libwebsockets_hangup_on_client - Server calls to terminate client connection

void libwebsockets_hangup_on_client (struct libwebsocket_context * context, int fd)

Arguments

context
libwebsockets context
fd
Connection socket descriptor

libwebsockets_get_peer_addresses - Get client address information

void libwebsockets_get_peer_addresses (int fd, char * name, int name_len, char * rip, int rip_len)

Arguments

fd
Connection socket descriptor
name
Buffer to take client address name
name_len
Length of client address name buffer
rip
Buffer to take client address IP qotted quad
rip_len
Length of client address IP buffer

Description

This function fills in name and rip with the name and IP of the client connected with socket descriptor fd. Names may be truncated if there is not enough room. If either cannot be determined, they will be returned as valid zero-length strings.

libwebsocket_service_fd - Service polled socket with something waiting

int libwebsocket_service_fd (struct libwebsocket_context * context, struct pollfd * pollfd)

Arguments

context
Websocket context
pollfd
The pollfd entry describing the socket fd and which events happened.

Description

This function closes any active connections and then frees the context. After calling this, any further use of the context is undefined.

libwebsocket_context_destroy - Destroy the websocket context

void libwebsocket_context_destroy (struct libwebsocket_context * context)

Arguments

context
Websocket context

Description

This function closes any active connections and then frees the context. After calling this, any further use of the context is undefined.

libwebsocket_service - Service any pending websocket activity

int libwebsocket_service (struct libwebsocket_context * context, int timeout_ms)

Arguments

context
Websocket context
timeout_ms
Timeout for poll; 0 means return immediately if nothing needed service otherwise block and service immediately, returning after the timeout if nothing needed service.

Description

This function deals with any pending websocket traffic, for three kinds of event. It handles these events on both server and client types of connection the same.

1) Accept new connections to our context's server

2) Perform pending broadcast writes initiated from other forked processes (effectively serializing asynchronous broadcasts)

3) Call the receive callback for incoming frame data received by server or client connections.

You need to call this service function periodically to all the above functions to happen; if your application is single-threaded you can just call it in your main event loop.

Alternatively you can fork a new process that asynchronously handles calling this service in a loop. In that case you are happy if this call blocks your thread until it needs to take care of something and would call it with a large nonzero timeout. Your loop then takes no CPU while there is nothing happening.

If you are calling it in a single-threaded app, you don't want it to wait around blocking other things in your loop from happening, so you would call it with a timeout_ms of 0, so it returns immediately if nothing is pending, or as soon as it services whatever was pending.


libwebsocket_callback_on_writable - Request a callback when this socket becomes able to be written to without blocking

int libwebsocket_callback_on_writable (struct libwebsocket_context * context, struct libwebsocket * wsi)

Arguments

context
libwebsockets context
wsi
Websocket connection instance to get callback for

libwebsocket_callback_on_writable_all_protocol - Request a callback for all connections using the given protocol when it becomes possible to write to each socket without blocking in turn.

int libwebsocket_callback_on_writable_all_protocol (const struct libwebsocket_protocols * protocol)

Arguments

protocol
Protocol whose connections will get callbacks

libwebsocket_set_timeout - marks the wsi as subject to a timeout

void libwebsocket_set_timeout (struct libwebsocket * wsi, enum pending_timeout reason, int secs)

Arguments

wsi
Websocket connection instance
reason
timeout reason
secs
how many seconds

Description

You will not need this unless you are doing something special


libwebsocket_get_socket_fd - returns the socket file descriptor

int libwebsocket_get_socket_fd (struct libwebsocket * wsi)

Arguments

wsi
Websocket connection instance

Description

You will not need this unless you are doing something special


libwebsocket_rx_flow_control - Enable and disable socket servicing for receieved packets.

int libwebsocket_rx_flow_control (struct libwebsocket * wsi, int enable)

Arguments

wsi
Websocket connection instance to get callback for
enable
0 = disable read servicing for this connection, 1 = enable

Description

If the output side of a server process becomes choked, this allows flow control for the input side.


libwebsocket_canonical_hostname - returns this host's hostname

const char * libwebsocket_canonical_hostname (struct libwebsocket_context * context)

Arguments

context
Websocket context

Description

This is typically used by client code to fill in the host parameter when making a client connection. You can only call it after the context has been created.


libwebsocket_create_context - Create the websocket handler

struct libwebsocket_context * libwebsocket_create_context (int port, const char * interf, struct libwebsocket_protocols * protocols, struct libwebsocket_extension * extensions, const char * ssl_cert_filepath, const char * ssl_private_key_filepath, int gid, int uid, unsigned int options)

Arguments

port
Port to listen on... you can use 0 to suppress listening on any port, that's what you want if you are not running a websocket server at all but just using it as a client
interf
NULL to bind the listen socket to all interfaces, or the interface name, eg, "eth2"
protocols
Array of structures listing supported protocols and a protocol- specific callback for each one. The list is ended with an entry that has a NULL callback pointer. It's not const because we write the owning_server member
extensions
NULL or array of libwebsocket_extension structs listing the extensions this context supports
ssl_cert_filepath
If libwebsockets was compiled to use ssl, and you want to listen using SSL, set to the filepath to fetch the server cert from, otherwise NULL for unencrypted
ssl_private_key_filepath
filepath to private key if wanting SSL mode, else ignored
gid
group id to change to after setting listen socket, or -1.
uid
user id to change to after setting listen socket, or -1.
options
0, or LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK

Description

This function creates the listening socket and takes care of all initialization in one step.

After initialization, it returns a struct libwebsocket_context * that represents this server. After calling, user code needs to take care of calling libwebsocket_service with the context pointer to get the server's sockets serviced. This can be done in the same process context or a forked process, or another thread,

The protocol callback functions are called for a handful of events including http requests coming in, websocket connections becoming established, and data arriving; it's also called periodically to allow async transmission.

HTTP requests are sent always to the FIRST protocol in protocol, since at that time websocket protocol has not been negotiated. Other protocols after the first one never see any HTTP callack activity.

The server created is a simple http server by default; part of the websocket standard is upgrading this http connection to a websocket one.

This allows the same server to provide files like scripts and favicon / images or whatever over http and dynamic data over websockets all in one place; they're all handled in the user callback.


libwebsockets_fork_service_loop - Optional helper function forks off a process for the websocket server loop. You don't have to use this but if not, you have to make sure you are calling libwebsocket_service periodically to service the websocket traffic

int libwebsockets_fork_service_loop (struct libwebsocket_context * context)

Arguments

context
server context returned by creation function

libwebsockets_get_protocol - Returns a protocol pointer from a websocket connection.

const struct libwebsocket_protocols * libwebsockets_get_protocol (struct libwebsocket * wsi)

Arguments

wsi
pointer to struct websocket you want to know the protocol of

Description

This is useful to get the protocol to broadcast back to from inside the callback.


libwebsockets_broadcast - Sends a buffer to the callback for all active connections of the given protocol.

int libwebsockets_broadcast (const struct libwebsocket_protocols * protocol, unsigned char * buf, size_t len)

Arguments

protocol
pointer to the protocol you will broadcast to all members of
buf
buffer containing the data to be broadcase. NOTE: this has to be allocated with LWS_SEND_BUFFER_PRE_PADDING valid bytes before the pointer and LWS_SEND_BUFFER_POST_PADDING afterwards in the case you are calling this function from callback context.
len
length of payload data in buf, starting from buf.

Description

This function allows bulk sending of a packet to every connection using the given protocol. It does not send the data directly; instead it calls the callback with a reason type of LWS_CALLBACK_BROADCAST. If the callback wants to actually send the data for that connection, the callback itself should call libwebsocket_write.

libwebsockets_broadcast can be called from another fork context without having to take any care about data visibility between the processes, it'll "just work".


libwebsocket_write - Apply protocol then write data to client

int libwebsocket_write (struct libwebsocket * wsi, unsigned char * buf, size_t len, enum libwebsocket_write_protocol protocol)

Arguments

wsi
Websocket instance (available from user callback)
buf
The data to send. For data being sent on a websocket connection (ie, not default http), this buffer MUST have LWS_SEND_BUFFER_PRE_PADDING bytes valid BEFORE the pointer and an additional LWS_SEND_BUFFER_POST_PADDING bytes valid in the buffer after (buf + len). This is so the protocol header and trailer data can be added in-situ.
len
Count of the data bytes in the payload starting from buf
protocol
Use LWS_WRITE_HTTP to reply to an http connection, and one of LWS_WRITE_BINARY or LWS_WRITE_TEXT to send appropriate data on a websockets connection. Remember to allow the extra bytes before and after buf if LWS_WRITE_BINARY or LWS_WRITE_TEXT are used.

Description

This function provides the way to issue data back to the client for both http and websocket protocols.

In the case of sending using websocket protocol, be sure to allocate valid storage before and after buf as explained above. This scheme allows maximum efficiency of sending data and protocol in a single packet while not burdening the user code with any protocol knowledge.


libwebsockets_serve_http_file - Send a file back to the client using http

int libwebsockets_serve_http_file (struct libwebsocket * wsi, const char * file, const char * content_type)

Arguments

wsi
Websocket instance (available from user callback)
file
The file to issue over http
content_type
The http content type, eg, text/html

Description

This function is intended to be called from the callback in response to http requests from the client. It allows the callback to issue local files down the http link in a single step.

libwebsockets_remaining_packet_payload - Bytes to come before "overall" rx packet is complete

size_t libwebsockets_remaining_packet_payload (struct libwebsocket * wsi)

Arguments

wsi
Websocket instance (available from user callback)

Description

This function is intended to be called from the callback if the user code is interested in "complete packets" from the client. libwebsockets just passes through payload as it comes and issues a buffer additionally when it hits a built-in limit. The LWS_CALLBACK_RECEIVE callback handler can use this API to find out if the buffer it has just been given is the last piece of a "complete packet" from the client -- when that is the case libwebsockets_remaining_packet_payload will return 0.

Many protocols won't care becuse their packets are always small.


libwebsocket_client_connect - Connect to another websocket server

struct libwebsocket * libwebsocket_client_connect (struct libwebsocket_context * context, const char * address, int port, int ssl_connection, const char * path, const char * host, const char * origin, const char * protocol, int ietf_version_or_minus_one)

Arguments

context
Websocket context
address
Remote server address, eg, "myserver.com"
port
Port to connect to on the remote server, eg, 80
ssl_connection
0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self signed certs
path
Websocket path on server
host
Hostname on server
origin
Socket origin name
protocol
Comma-separated list of protocols being asked for from the server, or just one. The server will pick the one it likes best.
ietf_version_or_minus_one
-1 to ask to connect using the default, latest protocol supported, or the specific protocol ordinal

Description

This function creates a connection to a remote server

libwebsocket_client_connect_extended - Connect to another websocket server

struct libwebsocket * libwebsocket_client_connect_extended (struct libwebsocket_context * context, const char * address, int port, int ssl_connection, const char * path, const char * host, const char * origin, const char * protocol, int ietf_version_or_minus_one, void * userdata)

Arguments

context
Websocket context
address
Remote server address, eg, "myserver.com"
port
Port to connect to on the remote server, eg, 80
ssl_connection
0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self signed certs
path
Websocket path on server
host
Hostname on server
origin
Socket origin name
protocol
Comma-separated list of protocols being asked for from the server, or just one. The server will pick the one it likes best.
ietf_version_or_minus_one
-1 to ask to connect using the default, latest protocol supported, or the specific protocol ordinal
userdata
Pre-allocated user data

Description

This function creates a connection to a remote server

callback - User server actions

LWS_EXTERN int callback (struct libwebsocket_context * context, struct libwebsocket * wsi, enum libwebsocket_callback_reasons reason, void * user, void * in, size_t len)

Arguments

context
Websockets context
wsi
Opaque websocket instance pointer
reason
The reason for the call
user
Pointer to per-session user data allocated by library
in
Pointer used for some callback reasons
len
Length set for some callback reasons

Description

This callback is the way the user controls what is served. All the protocol detail is hidden and handled by the library.

For each connection / session there is user data allocated that is pointed to by "user". You set the size of this user data area when the library is initialized with libwebsocket_create_server.

You get an opportunity to initialize user data when called back with LWS_CALLBACK_ESTABLISHED reason.

LWS_CALLBACK_ESTABLISHED

after the server completes a handshake with an incoming client

LWS_CALLBACK_CLIENT_CONNECTION_ERROR

the request client connection has been unable to complete a handshake with the remote server

LWS_CALLBACK_CLIENT_ESTABLISHED

after your client connection completed a handshake with the remote server

LWS_CALLBACK_CLOSED

when the websocket session ends

LWS_CALLBACK_BROADCAST

signal to send to client (you would use libwebsocket_write taking care about the special buffer requirements

LWS_CALLBACK_RECEIVE

data has appeared for this server endpoint from a remote client, it can be found at *in and is len bytes long

LWS_CALLBACK_CLIENT_RECEIVE_PONG

if you elected to see PONG packets, they appear with this callback reason. PONG packets only exist in 04+ protocol

LWS_CALLBACK_CLIENT_RECEIVE

data has appeared from the server for the client connection, it can be found at *in and is len bytes long

LWS_CALLBACK_HTTP

an http request has come from a client that is not asking to upgrade the connection to a websocket one. This is a chance to serve http content, for example, to send a script to the client which will then open the websockets connection. in points to the URI path requested and libwebsockets_serve_http_file makes it very simple to send back a file to the client.

LWS_CALLBACK_SERVER_WRITEABLE

If you call libwebsocket_callback_on_writable on a connection, you will get one of these callbacks coming when the connection socket is able to accept another write packet without blocking. If it already was able to take another packet without blocking, you'll get this callback at the next call to the service loop function. Notice that CLIENTs get LWS_CALLBACK_CLIENT_WRITEABLE and servers get LWS_CALLBACK_SERVER_WRITEABLE.

LWS_CALLBACK_FILTER_NETWORK_CONNECTION

called when a client connects to the server at network level; the connection is accepted but then passed to this callback to decide whether to hang up immediately or not, based on the client IP. user contains the connection socket's descriptor. Return non-zero to terminate the connection before sending or receiving anything. Because this happens immediately after the network connection from the client, there's no websocket protocol selected yet so this callback is issued only to protocol 0.

LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION

called when the handshake has been received and parsed from the client, but the response is not sent yet. Return non-zero to disallow the connection. user is a pointer to an array of struct lws_tokens, you can use the header enums lws_token_indexes from libwebsockets.h to check for and read the supported header presence and content before deciding to allow the handshake to proceed or to kill the connection.

LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS

if configured for including OpenSSL support, this callback allows your user code to perform extra SSL_CTX_load_verify_locations or similar calls to direct OpenSSL where to find certificates the client can use to confirm the remote server identity. user is the OpenSSL SSL_CTX*

LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS

if configured for including OpenSSL support, this callback allows your user code to load extra certifcates into the server which allow it to verify the validity of certificates returned by clients. user is the server's OpenSSL SSL_CTX*

LWS_CALLBACK_OPENSSL_PERFORM_CLIENT_CERT_VERIFICATION

if the libwebsockets context was created with the option LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT, then this callback is generated during OpenSSL verification of the cert sent from the client. It is sent to protocol[0] callback as no protocol has been negotiated on the connection yet. Notice that the libwebsockets context and wsi are both NULL during this callback. See

http

//www.openssl.org/docs/ssl/SSL_CTX_set_verify.html to understand more detail about the OpenSSL callback that generates this libwebsockets callback and the meanings of the arguments passed. In this callback, user is the x509_ctx, in is the ssl pointer and len is preverify_ok Notice that this callback maintains libwebsocket return conventions, return 0 to mean the cert is OK or 1 to fail it. This also means that if you don't handle this callback then the default callback action of returning 0 allows the client certificates.

LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER

this callback happens when a client handshake is being compiled. user is NULL, in is a char **, it's pointing to a char * which holds the next location in the header buffer where you can add headers, and len is the remaining space in the header buffer, which is typically some hundreds of bytes. So, to add a canned cookie, your handler code might look similar to:

char **p = (char **)in;

if (len < 100) return 1;

*p += sprintf(*p, "Cookie: a=b\x0d\x0a");

return 0;

Notice if you add anything, you just have to take care about the CRLF on the line you added. Obviously this callback is optional, if you don't handle it everything is fine.

Notice the callback is coming to protocols[0] all the time, because there is no specific protocol handshook yet.

LWS_CALLBACK_CONFIRM_EXTENSION_OKAY

When the server handshake code sees that it does support a requested extension, before accepting the extension by additing to the list sent back to the client it gives this callback just to check that it's okay to use that extension. It calls back to the requested protocol and with in being the extension name, len is 0 and user is valid. Note though at this time the ESTABLISHED callback hasn't happened yet so if you initialize user content there, user content during this callback might not be useful for anything. Notice this callback comes to protocols[0].

LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED

When a client connection is being prepared to start a handshake to a server, each supported extension is checked with protocols[0] callback with this reason, giving the user code a chance to suppress the claim to support that extension by returning non-zero. If unhandled, by default 0 will be returned and the extension support included in the header to the server. Notice this callback comes to protocols[0].

The next four reasons are optional and only need taking care of if you will be integrating libwebsockets sockets into an external polling array.

LWS_CALLBACK_ADD_POLL_FD

libwebsocket deals with its poll loop internally, but in the case you are integrating with another server you will need to have libwebsocket sockets share a polling array with the other server. This and the other POLL_FD related callbacks let you put your specialized poll array interface code in the callback for protocol 0, the first protocol you support, usually the HTTP protocol in the serving case. This callback happens when a socket needs to be

added to the polling loop

user contains the fd, and len is the events bitmap (like, POLLIN). If you are using the internal polling loop (the "service" callback), you can just ignore these callbacks.

LWS_CALLBACK_DEL_POLL_FD

This callback happens when a socket descriptor needs to be removed from an external polling array. user is the socket desricptor. If you are using the internal polling loop, you can just ignore it.

LWS_CALLBACK_SET_MODE_POLL_FD

This callback happens when libwebsockets wants to modify the events for the socket descriptor in user. The handler should OR len on to the events member of the pollfd struct for this socket descriptor. If you are using the internal polling loop, you can just ignore it.

LWS_CALLBACK_CLEAR_MODE_POLL_FD

This callback occurs when libwebsockets wants to modify the events for the socket descriptor in user. The handler should AND ~len on to the events member of the pollfd struct for this socket descriptor. If you are using the internal polling loop, you can just ignore it.

extension_callback - Hooks to allow extensions to operate

LWS_EXTERN int extension_callback (struct libwebsocket_context * context, struct libwebsocket_extension * ext, struct libwebsocket * wsi, enum libwebsocket_extension_callback_reasons reason, void * user, void * in, size_t len)

Arguments

context
Websockets context
ext
This extension
wsi
Opaque websocket instance pointer
reason
The reason for the call
user
Pointer to per-session user data allocated by library
in
Pointer used for some callback reasons
len
Length set for some callback reasons

Description

Each extension that is active on a particular connection receives callbacks during the connection lifetime to allow the extension to operate on websocket data and manage itself.

Libwebsockets takes care of allocating and freeing "user" memory for each active extension on each connection. That is what is pointed to by the user parameter.

LWS_EXT_CALLBACK_CONSTRUCT

called when the server has decided to select this extension from the list provided by the client, just before the server will send back the handshake accepting the connection with this extension active. This gives the extension a chance to initialize its connection context found in user.

LWS_EXT_CALLBACK_CLIENT_CONSTRUCT

same as LWS_EXT_CALLBACK_CONSTRUCT but called when client is instantiating this extension. Some extensions will work the same on client and server side and then you can just merge handlers for both CONSTRUCTS.

LWS_EXT_CALLBACK_DESTROY

called when the connection the extension was being used on is about to be closed and deallocated. It's the last chance for the extension to deallocate anything it has allocated in the user data (pointed to by user) before the user data is deleted. This same callback is used whether you are in client or server instantiation context.

LWS_EXT_CALLBACK_PACKET_RX_PREPARSE

when this extension was active on a connection, and a packet of data arrived at the connection, it is passed to this callback to give the extension a chance to change the data, eg, decompress it. user is pointing to the extension's private connection context data, in is pointing to an lws_tokens struct, it consists of a char * pointer called token, and an int called token_len. At entry, these are set to point to the received buffer and set to the content length. If the extension will grow the content, it should use a new buffer allocated in its private user context data and set the pointed-to lws_tokens members to point to its buffer.

LWS_EXT_CALLBACK_PACKET_TX_PRESEND

this works the same way as LWS_EXT_CALLBACK_PACKET_RX_PREPARSE above, except it gives the extension a chance to change websocket data just before it will be sent out. Using the same lws_token pointer scheme in in, the extension can change the buffer and the length to be transmitted how it likes. Again if it wants to grow the buffer safely, it should copy the data into its own buffer and set the lws_tokens token pointer to it.

struct libwebsocket_protocols - List of protocols and handlers server supports.

struct libwebsocket_protocols {
    const char * name;
    callback_function * callback;
    size_t per_session_data_size;
    struct libwebsocket_context * owning_server;
    int broadcast_socket_port;
    int broadcast_socket_user_fd;
    int protocol_index;
};

Members

name
Protocol name that must match the one given in the client Javascript new WebSocket(url, 'protocol') name
callback
The service callback used for this protocol. It allows the service action for an entire protocol to be encapsulated in the protocol-specific callback
per_session_data_size
Each new connection using this protocol gets this much memory allocated on connection establishment and freed on connection takedown. A pointer to this per-connection allocation is passed into the callback in the 'user' parameter
owning_server
the server init call fills in this opaque pointer when registering this protocol with the server.
broadcast_socket_port
the server init call fills this in with the localhost port number used to forward broadcasts for this protocol
broadcast_socket_user_fd
the server init call fills this in ... the main process context can write to this socket to perform broadcasts (use the libwebsockets_broadcast api to do this instead, it works from any process context)
protocol_index
which protocol we are starting from zero

Description

This structure represents one protocol supported by the server. An array of these structures is passed to libwebsocket_create_server allows as many protocols as you like to be handled by one server.

struct libwebsocket_extension - An extension we know how to cope with

struct libwebsocket_extension {
    const char * name;
    extension_callback_function * callback;
    size_t per_session_data_size;
    void * per_context_private_data;
};

Members

name
Formal extension name, eg, "deflate-stream"
callback
Service callback
per_session_data_size
Libwebsockets will auto-malloc this much memory for the use of the extension, a pointer to it comes in the user callback parameter
per_context_private_data
Optional storage for this externsion that is per-context, so it can track stuff across all sessions, etc, if it wants