The Trickles server API is replacement for Berkeley sockets. It is an event-based API that is optimized for implementing stateless services, and does not require any persistent per-connection state. This event-based API is programmed in the standard interrupt-driven method. Trickles events are generated in response to packets received from the client. Each event is a minisocket. A minisocket is like a socket in that it identifies a particular client, and supports socket-like endpoint operations like sending data and closing the connection. Unlike a socket, a minisocket is deallocated immediately after processing the event.
Minisockets provide the application with a simple, narrow interface. Trickles supports the following operations on minisockets. The file descriptor refers to the listening socket bound to the server port.
msk_send(int fd, minisock *, char *, size_t); msk_sendv(int fd, minisock *, tiovec *, int); msk_sendfilev(int fd, minisock *, fiovec *, int); msk_setucont(int fd, minisock *, int pkt, char* buf, size_t); msk_sendbulk(int fd, mskdesc *, int len); msk_drop(int fd, minisock *); msk_detach(int fd, minisock *); msk_extract_events(int fd, extract_mskdesc_in *, int inlen, msk_collection *, int *outlen); msk_install_events(int fd, msk_collection *, int); msk_request(int fd, char *req, int reqlen, int reservelen);
The figure below demonstrates how a Trickles web server uses the Trickles server API. Upon receiving the HTTP request from the client, the server kernel generates msk0 within a queue that is mapped in both the kernel and application. The server is unblocked, and performs operations on the new minisocket: it sets the inode continuation and sends data. Upon sending the data and updated continuation, msk0 is destroyed.