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.
Return may be -1 for a fatal error needing connection close, or a positive number reflecting the amount of bytes actually sent. This can be less than the requested number of bytes due to OS memory pressure at any given time.
Returns 1 if the HTTP connection must close now Returns 0 and resets connection to wait for new HTTP header / transaction if possible
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.Returning <0 indicates error and the wsi should be closed. Returning >0 indicates the file was completely sent and lws_http_transaction_completed called on the wsi (and close if != 0) ==0 indicates the file transfer is started and needs more service later, the wsi should be left alone.
Helper to report HTTP errors back to the client cleanly and consistently
This function creates a connection to a remote server
This function creates a connection to a remote server
This function takes a pollfd that has POLLIN or POLLOUT activity and services it according to the state of the associated struct lws.The one call deals with all "service" that might happen on a socket including listen accepts, http files as well as websocket protocol.
If a pollfd says it has something, you can just pass it to lws_service_fd whether it is a socket handled by lws or not. If it sees it is a lws socket, the traffic will be handled and pollfd->revents will be zeroed now.
If the socket is foreign to lws, it leaves revents alone. So you can see if you should service yourself by checking the pollfd revents after letting lws try to service it.
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) 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.
This is intended to be called from the LWS_CALLBACK_RECEIVE callback if it's interested to see if the frame it's dealing with was sent in binary mode.
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 lws_remaining_packet_payload will return 0.Many protocols won't care becuse their packets are always small.
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.
This returns the optional user allocation that can be attached to the context the sockets live in at context_create time. It's a way to let all sockets serviced in the same context share data without using globals statics in the user code.
You will not need this unless you are doing something special
You will not need this unless you are doing something special
If the output side of a server process becomes choked, this allows flow control for the input side.
When the user server code realizes it can accept more input, it can call this to have the RX flow restriction removed from all connections using the given protocol.
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.
Returns 0 if proxy string was parsed and proxy was setup. Returns -1 if proxy is NULL or has incorrect format.This is only required if your OS does not provide the http_proxy environment variable (eg, OSX)
IMPORTANT! You should call this function right after creation of the lws_context and before call to connect. If you call this function after connect behavior is undefined. This function will override proxy settings made on lws_context creation with genenv call.
Some apis can act on all live connections of a given protocol, this is how you can get a pointer to the active protocol if needed.
log level defaults to "err", "warn" and "notice" contexts enabled and emission on stderr.
Returns 0 if the connection is not using SSL, 1 if using SSL and using verified cert, and 2 if using SSL but the cert was not checked (appears for client wsi told to skip check on connection)
Returns 1 if you cannot use lws_write because the last write on this connection is still buffered, and can't be cleared without returning to the service loop and waiting for the connection to be writeable again.If you will try to do >1 lws_write call inside a single WRITEABLE callback, you must check this after every write and bail if set, ask for a new writeable callback and continue writing from there.
This is never set at the start of a writeable callback, but any write may set it.
returns a const char * to a string like "1.1 178d78c" representing the library version followed by the git head hash it was built from
This function creates the listening socket (if serving) and takes care of all initialization in one step.After initialization, it returns a struct lws_context * that represents this server. After calling, user code needs to take care of calling lws_service with the context pointer to get the server's sockets serviced. This must be done in the same process context as the initialization call.
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.
This function closes any active connections and then frees the context. After calling this, any further use of the context is undefined.
This function let a call to lws_service waiting for a timeout immediately return.
This function let a call to lws_service waiting for a timeout immediately return.
This function let a call to lws_service waiting for a timeout immediately return.There is no poll in MBED3, he will fire callbacks when he feels like it.
These provide platform-agnostic ways to deal with filesystem access in the library and in the user code.
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 lws_create_server.
You get an opportunity to initialize user data when called back with LWS_CALLBACK_ESTABLISHED reason.
after the server completes a handshake with an incoming client. If you built the library with ssl support, in is a pointer to the ssl struct associated with the connection or NULL.
the request client connection has been unable to complete a handshake with the remote server. If in is non-NULL, you can find an error string of length len where it points to.
this is the last chance for the client user code to examine the http headers and decide to reject the connection. If the content in the headers is interesting to the client (url, etc) it needs to copy it out at this point since it will be destroyed before the CLIENT_ESTABLISHED call
after your client connection completed a handshake with the remote server
when the websocket session ends
when a HTTP (non-websocket) session ends
data has appeared for this server endpoint from a remote client, it can be found at *in and is len bytes long
if you elected to see PONG packets, they appear with this callback reason. PONG packets only exist in 04+ protocol
data has appeared from the server for the client connection, it can be found at *in and is len bytes long
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 lws_serve_http_file makes it very simple to send back a file to the client. Normally after sending the file you are done with the http connection, since the rest of the activity will come by websockets from the script that was delivered by http, so you will want to return 1; to close and free up the connection. That's important because it uses a slot in the total number of client connections allowed set by MAX_CLIENTS.
the next len bytes data from the http request body HTTP connection is now available in in.
the expected amount of http request body has been delivered
you can write more down the http protocol link now.
a file requested to be send down http link has completed.
If you call lws_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.
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. in contains the connection socket's descriptor. Since the client connection information is not available yet, wsi still pointing to the main server socket. 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.
A new client just had been connected, accepted, and instantiated into the pool. This callback allows setting any relevant property to it. Because this happens immediately after the instantiation of a new client, there's no websocket protocol selected yet so this callback is issued only to protocol 0. Only wsi is defined, pointing to the new client, and the return value is ignored.
called when the request 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 the connection user space allocation, in is the URI, eg, "/" In your handler you can use the public APIs lws_hdr_total_length / lws_hdr_copy to access all of the headers using 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 http connection to proceed or to kill the 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 the connection user space allocation, in is the requested protocol name In your handler you can use the public APIs lws_hdr_total_length / lws_hdr_copy to access all of the headers using 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.
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*
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*
if configured for including OpenSSL support but no private key file has been specified (ssl_private_key_filepath is NULL), this callback is called to allow the user to set the private key directly via libopenssl and perform further operations if required; this might be useful in situations where the private key is not directly accessible by the OS, for example if it is stored on a smartcard user is the server's OpenSSL SSL_CTX*
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
//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.
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.
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].
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].
One-time call per protocol so it can do initial setup / allocations etc
One-time call per protocol indicating this protocol won't get used at all after this callback, the context is getting destroyed. Take the opportunity to deallocate everything that was allocated by the protocol.
outermost (earliest) wsi create notification
outermost (latest) wsi destroy notificationThe next five reasons are optional and only need taking care of if you will be integrating libwebsockets sockets into an external polling array.
For these calls, in points to a struct lws_pollargs that contains fd, events and prev_events members
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
in points to a struct lws_pollargs; the fd member of the struct is the file descriptor, and events contains the active events.If you are using the internal polling loop (the "service" callback), you can just ignore these callbacks.
This callback happens when a socket descriptor needs to be removed from an external polling array. in is again the struct lws_pollargs containing the fd member to be removed. If you are using the internal polling loop, you can just ignore it.
This callback happens when libwebsockets wants to modify the events for a connectiion. in is the struct lws_pollargs with the fd to change. The new event mask is in events member and the old mask is in the prev_events member. If you are using the internal polling loop, you can just ignore it.
These allow the external poll changes driven by libwebsockets to participate in an external thread locking scheme around the changes, so the whole thing is threadsafe. These are called around three activities in the library, - inserting a new wsi in the wsi / fd table (len=1) - deleting a wsi from the wsi / fd table (len=1) - changing a wsi's POLLIN/OUT state (len=0) Locking and unlocking external synchronization objects when len == 1 allows external threads to be synchronized against wsi lifecycle changes if it acquires the same lock for the duration of wsi dereference from the other thread context.
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.
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.
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.
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.
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.
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.
This structure represents one protocol supported by the server. An array of these structures is passed to lws_create_server allows as many protocols as you like to be handled by one server.The first protocol given has its callback used for user callbacks when there is no agreed protocol name, that's true during HTTP part of the
header.