1 <h2>libwebsocket_client_connect - Connect to another websocket server</h2>
2 <i>struct libwebsocket *</i>
3 <b>libwebsocket_client_connect</b>
4 (<i>struct libwebsocket_context *</i> <b>context</b>,
5 <i>const char *</i> <b>address</b>,
6 <i>int</i> <b>port</b>,
7 <i>int</i> <b>ssl_connection</b>,
8 <i>const char *</i> <b>path</b>,
9 <i>const char *</i> <b>host</b>,
10 <i>const char *</i> <b>origin</b>,
11 <i>const char *</i> <b>protocol</b>,
12 <i>int</i> <b>ietf_version_or_minus_one</b>)
18 <dd>Remote server address, eg, "myserver.com"
20 <dd>Port to connect to on the remote server, eg, 80
21 <dt><b>ssl_connection</b>
22 <dd>0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self
25 <dd>Websocket path on server
27 <dd>Hostname on server
29 <dd>Socket origin name
31 <dd>Comma-separated list of protocols being asked for from
32 the server, or just one. The server will pick the one it
34 <dt><b>ietf_version_or_minus_one</b>
35 <dd>-1 to ask to connect using the default, latest
36 protocol supported, or the specific protocol ordinal
40 This function creates a connection to a remote server
43 <h2>libwebsocket_client_connect_extended - Connect to another websocket server</h2>
44 <i>struct libwebsocket *</i>
45 <b>libwebsocket_client_connect_extended</b>
46 (<i>struct libwebsocket_context *</i> <b>context</b>,
47 <i>const char *</i> <b>address</b>,
48 <i>int</i> <b>port</b>,
49 <i>int</i> <b>ssl_connection</b>,
50 <i>const char *</i> <b>path</b>,
51 <i>const char *</i> <b>host</b>,
52 <i>const char *</i> <b>origin</b>,
53 <i>const char *</i> <b>protocol</b>,
54 <i>int</i> <b>ietf_version_or_minus_one</b>,
55 <i>void *</i> <b>userdata</b>)
61 <dd>Remote server address, eg, "myserver.com"
63 <dd>Port to connect to on the remote server, eg, 80
64 <dt><b>ssl_connection</b>
65 <dd>0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self
68 <dd>Websocket path on server
70 <dd>Hostname on server
72 <dd>Socket origin name
74 <dd>Comma-separated list of protocols being asked for from
75 the server, or just one. The server will pick the one it
77 <dt><b>ietf_version_or_minus_one</b>
78 <dd>-1 to ask to connect using the default, latest
79 protocol supported, or the specific protocol ordinal
81 <dd>Pre-allocated user data
85 This function creates a connection to a remote server
88 <h2>lws_get_library_version - </h2>
90 <b>lws_get_library_version</b>
100 returns a const char * to a string like "1.1 178d78c"
101 representing the library version followed by the git head hash it
105 <h2>libwebsockets_get_peer_addresses - Get client address information</h2>
107 <b>libwebsockets_get_peer_addresses</b>
108 (<i>struct libwebsocket_context *</i> <b>context</b>,
109 <i>struct libwebsocket *</i> <b>wsi</b>,
110 <i>int</i> <b>fd</b>,
111 <i>char *</i> <b>name</b>,
112 <i>int</i> <b>name_len</b>,
113 <i>char *</i> <b>rip</b>,
114 <i>int</i> <b>rip_len</b>)
118 <dd>Libwebsockets context
120 <dd>Local struct libwebsocket associated with
122 <dd>Connection socket descriptor
124 <dd>Buffer to take client address name
126 <dd>Length of client address name buffer
128 <dd>Buffer to take client address IP qotted quad
130 <dd>Length of client address IP buffer
134 This function fills in <tt><b>name</b></tt> and <tt><b>rip</b></tt> with the name and IP of
135 the client connected with socket descriptor <tt><b>fd</b></tt>. Names may be
136 truncated if there is not enough room. If either cannot be
137 determined, they will be returned as valid zero-length strings.
140 <h2>libwebsocket_service_fd - Service polled socket with something waiting</h2>
142 <b>libwebsocket_service_fd</b>
143 (<i>struct libwebsocket_context *</i> <b>context</b>,
144 <i>struct pollfd *</i> <b>pollfd</b>)
148 <dd>Websocket context
150 <dd>The pollfd entry describing the socket fd and which events
155 This function takes a pollfd that has POLLIN or POLLOUT activity and
156 services it according to the state of the associated
159 The one call deals with all "service" that might happen on a socket
160 including listen accepts, http files as well as websocket protocol.
163 <h2>libwebsocket_context_destroy - Destroy the websocket context</h2>
165 <b>libwebsocket_context_destroy</b>
166 (<i>struct libwebsocket_context *</i> <b>context</b>)
170 <dd>Websocket context
174 This function closes any active connections and then frees the
175 context. After calling this, any further use of the context is
179 <h2>libwebsocket_context_user - get the user data associated with the context</h2>
180 <i>LWS_EXTERN void *</i>
181 <b>libwebsocket_context_user</b>
182 (<i>struct libwebsocket_context *</i> <b>context</b>)
186 <dd>Websocket context
190 This returns the optional user allocation that can be attached to
191 the context the sockets live in at context_create time. It's a way
192 to let all sockets serviced in the same context share data without
193 using globals statics in the user code.
196 <h2>libwebsocket_service - Service any pending websocket activity</h2>
198 <b>libwebsocket_service</b>
199 (<i>struct libwebsocket_context *</i> <b>context</b>,
200 <i>int</i> <b>timeout_ms</b>)
204 <dd>Websocket context
205 <dt><b>timeout_ms</b>
206 <dd>Timeout for poll; 0 means return immediately if nothing needed
207 service otherwise block and service immediately, returning
208 after the timeout if nothing needed service.
212 This function deals with any pending websocket traffic, for three
213 kinds of event. It handles these events on both server and client
214 types of connection the same.
216 1) Accept new connections to our context's server
218 2) Call the receive callback for incoming frame data received by
219 server or client connections.
221 You need to call this service function periodically to all the above
222 functions to happen; if your application is single-threaded you can
223 just call it in your main event loop.
225 Alternatively you can fork a new process that asynchronously handles
226 calling this service in a loop. In that case you are happy if this
227 call blocks your thread until it needs to take care of something and
228 would call it with a large nonzero timeout. Your loop then takes no
229 CPU while there is nothing happening.
231 If you are calling it in a single-threaded app, you don't want it to
232 wait around blocking other things in your loop from happening, so you
233 would call it with a timeout_ms of 0, so it returns immediately if
234 nothing is pending, or as soon as it services whatever was pending.
237 <h2>libwebsocket_callback_on_writable - Request a callback when this socket becomes able to be written to without blocking</h2>
239 <b>libwebsocket_callback_on_writable</b>
240 (<i>struct libwebsocket_context *</i> <b>context</b>,
241 <i>struct libwebsocket *</i> <b>wsi</b>)
245 <dd>libwebsockets context
247 <dd>Websocket connection instance to get callback for
250 <h2>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.</h2>
252 <b>libwebsocket_callback_on_writable_all_protocol</b>
253 (<i>const struct libwebsocket_protocols *</i> <b>protocol</b>)
257 <dd>Protocol whose connections will get callbacks
260 <h2>libwebsocket_set_timeout - marks the wsi as subject to a timeout</h2>
262 <b>libwebsocket_set_timeout</b>
263 (<i>struct libwebsocket *</i> <b>wsi</b>,
264 <i>enum pending_timeout</i> <b>reason</b>,
265 <i>int</i> <b>secs</b>)
269 <dd>Websocket connection instance
278 You will not need this unless you are doing something special
281 <h2>libwebsocket_get_socket_fd - returns the socket file descriptor</h2>
283 <b>libwebsocket_get_socket_fd</b>
284 (<i>struct libwebsocket *</i> <b>wsi</b>)
288 <dd>Websocket connection instance
293 You will not need this unless you are doing something special
296 <h2>libwebsocket_rx_flow_control - Enable and disable socket servicing for receieved packets.</h2>
298 <b>libwebsocket_rx_flow_control</b>
299 (<i>struct libwebsocket *</i> <b>wsi</b>,
300 <i>int</i> <b>enable</b>)
304 <dd>Websocket connection instance to get callback for
306 <dd>0 = disable read servicing for this connection, 1 = enable
311 If the output side of a server process becomes choked, this allows flow
312 control for the input side.
315 <h2>libwebsocket_canonical_hostname - returns this host's hostname</h2>
317 <b>libwebsocket_canonical_hostname</b>
318 (<i>struct libwebsocket_context *</i> <b>context</b>)
322 <dd>Websocket context
327 This is typically used by client code to fill in the host parameter
328 when making a client connection. You can only call it after the context
332 <h2>libwebsocket_create_context - Create the websocket handler</h2>
333 <i>struct libwebsocket_context *</i>
334 <b>libwebsocket_create_context</b>
335 (<i>struct lws_context_creation_info *</i> <b>info</b>)
339 <dd>pointer to struct with parameters
343 This function creates the listening socket (if serving) and takes care
344 of all initialization in one step.
346 After initialization, it returns a struct libwebsocket_context * that
347 represents this server. After calling, user code needs to take care
348 of calling <b>libwebsocket_service</b> with the context pointer to get the
349 server's sockets serviced. This can be done in the same process context
350 or a forked process, or another thread,
352 The protocol callback functions are called for a handful of events
353 including http requests coming in, websocket connections becoming
354 established, and data arriving; it's also called periodically to allow
357 HTTP requests are sent always to the FIRST protocol in <tt><b>protocol</b></tt>, since
358 at that time websocket protocol has not been negotiated. Other
359 protocols after the first one never see any HTTP callack activity.
361 The server created is a simple http server by default; part of the
362 websocket standard is upgrading this http connection to a websocket one.
364 This allows the same server to provide files like scripts and favicon /
365 images or whatever over http and dynamic data over websockets all in
366 one place; they're all handled in the user callback.
369 <h2>libwebsockets_get_protocol - Returns a protocol pointer from a websocket connection.</h2>
370 <i>const struct libwebsocket_protocols *</i>
371 <b>libwebsockets_get_protocol</b>
372 (<i>struct libwebsocket *</i> <b>wsi</b>)
376 <dd>pointer to struct websocket you want to know the protocol of
381 Some apis can act on all live connections of a given protocol,
382 this is how you can get a pointer to the active protocol if needed.
385 <h2>lws_set_log_level - Set the logging bitfield</h2>
387 <b>lws_set_log_level</b>
388 (<i>int</i> <b>level</b>,
389 <i>void (*</i><b>log_emit_function</b>) <i>(int level, const char *line)</i>)
393 <dd>OR together the LLL_ debug contexts you want output from
394 <dt><b>log_emit_function</b>
395 <dd>NULL to leave it as it is, or a user-supplied
396 function to perform log string emission instead of
397 the default stderr one.
401 log level defaults to "err", "warn" and "notice" contexts enabled and
405 <h2>libwebsocket_write - Apply protocol then write data to client</h2>
407 <b>libwebsocket_write</b>
408 (<i>struct libwebsocket *</i> <b>wsi</b>,
409 <i>unsigned char *</i> <b>buf</b>,
410 <i>size_t</i> <b>len</b>,
411 <i>enum libwebsocket_write_protocol</i> <b>protocol</b>)
415 <dd>Websocket instance (available from user callback)
417 <dd>The data to send. For data being sent on a websocket
418 connection (ie, not default http), this buffer MUST have
419 LWS_SEND_BUFFER_PRE_PADDING bytes valid BEFORE the pointer
420 and an additional LWS_SEND_BUFFER_POST_PADDING bytes valid
421 in the buffer after (buf + len). This is so the protocol
422 header and trailer data can be added in-situ.
424 <dd>Count of the data bytes in the payload starting from buf
426 <dd>Use LWS_WRITE_HTTP to reply to an http connection, and one
427 of LWS_WRITE_BINARY or LWS_WRITE_TEXT to send appropriate
428 data on a websockets connection. Remember to allow the extra
429 bytes before and after buf if LWS_WRITE_BINARY or LWS_WRITE_TEXT
434 This function provides the way to issue data back to the client
435 for both http and websocket protocols.
437 In the case of sending using websocket protocol, be sure to allocate
438 valid storage before and after buf as explained above. This scheme
439 allows maximum efficiency of sending data and protocol in a single
440 packet while not burdening the user code with any protocol knowledge.
442 Return may be -1 for a fatal error needing connection close, or a
443 positive number reflecting the amount of bytes actually sent. This
444 can be less than the requested number of bytes due to OS memory
445 pressure at any given time.
448 <h2>libwebsockets_serve_http_file - Send a file back to the client using http</h2>
450 <b>libwebsockets_serve_http_file</b>
451 (<i>struct libwebsocket_context *</i> <b>context</b>,
452 <i>struct libwebsocket *</i> <b>wsi</b>,
453 <i>const char *</i> <b>file</b>,
454 <i>const char *</i> <b>content_type</b>)
458 <dd>libwebsockets context
460 <dd>Websocket instance (available from user callback)
462 <dd>The file to issue over http
463 <dt><b>content_type</b>
464 <dd>The http content type, eg, text/html
468 This function is intended to be called from the callback in response
469 to http requests from the client. It allows the callback to issue
470 local files down the http link in a single step.
472 Returning <0 indicates error and the wsi should be closed. Returning
473 >0 indicates the file was completely sent and the wsi should be closed.
474 ==0 indicates the file transfer is started and needs more service later,
475 the wsi should be left alone.
478 <h2>lws_frame_is_binary - </h2>
480 <b>lws_frame_is_binary</b>
481 (<i>struct libwebsocket *</i> <b>wsi</b>)
485 <dd>the connection we are inquiring about
489 This is intended to be called from the LWS_CALLBACK_RECEIVE callback if
490 it's interested to see if the frame it's dealing with was sent in binary
494 <h2>libwebsockets_remaining_packet_payload - Bytes to come before "overall" rx packet is complete</h2>
496 <b>libwebsockets_remaining_packet_payload</b>
497 (<i>struct libwebsocket *</i> <b>wsi</b>)
501 <dd>Websocket instance (available from user callback)
505 This function is intended to be called from the callback if the
506 user code is interested in "complete packets" from the client.
507 libwebsockets just passes through payload as it comes and issues a buffer
508 additionally when it hits a built-in limit. The LWS_CALLBACK_RECEIVE
509 callback handler can use this API to find out if the buffer it has just
510 been given is the last piece of a "complete packet" from the client --
511 when that is the case <b>libwebsockets_remaining_packet_payload</b> will return
514 Many protocols won't care becuse their packets are always small.
517 <h2>callback - User server actions</h2>
518 <i>LWS_EXTERN int</i>
520 (<i>struct libwebsocket_context *</i> <b>context</b>,
521 <i>struct libwebsocket *</i> <b>wsi</b>,
522 <i>enum libwebsocket_callback_reasons</i> <b>reason</b>,
523 <i>void *</i> <b>user</b>,
524 <i>void *</i> <b>in</b>,
525 <i>size_t</i> <b>len</b>)
529 <dd>Websockets context
531 <dd>Opaque websocket instance pointer
533 <dd>The reason for the call
535 <dd>Pointer to per-session user data allocated by library
537 <dd>Pointer used for some callback reasons
539 <dd>Length set for some callback reasons
543 This callback is the way the user controls what is served. All the
544 protocol detail is hidden and handled by the library.
546 For each connection / session there is user data allocated that is
547 pointed to by "user". You set the size of this user data area when
548 the library is initialized with libwebsocket_create_server.
550 You get an opportunity to initialize user data when called back with
551 LWS_CALLBACK_ESTABLISHED reason.
553 <h3>LWS_CALLBACK_ESTABLISHED</h3>
555 after the server completes a handshake with
558 <h3>LWS_CALLBACK_CLIENT_CONNECTION_ERROR</h3>
560 the request client connection has
561 been unable to complete a handshake with the remote server
563 <h3>LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH</h3>
565 this is the last chance for the
566 client user code to examine the http headers
567 and decide to reject the connection. If the
568 content in the headers is interesting to the
569 client (url, etc) it needs to copy it out at
570 this point since it will be destroyed before
571 the CLIENT_ESTABLISHED call
573 <h3>LWS_CALLBACK_CLIENT_ESTABLISHED</h3>
575 after your client connection completed
576 a handshake with the remote server
578 <h3>LWS_CALLBACK_CLOSED</h3>
580 when the websocket session ends
582 <h3>LWS_CALLBACK_RECEIVE</h3>
584 data has appeared for this server endpoint from a
585 remote client, it can be found at *in and is
588 <h3>LWS_CALLBACK_CLIENT_RECEIVE_PONG</h3>
590 if you elected to see PONG packets,
591 they appear with this callback reason. PONG
592 packets only exist in 04+ protocol
594 <h3>LWS_CALLBACK_CLIENT_RECEIVE</h3>
596 data has appeared from the server for the
597 client connection, it can be found at *in and
600 <h3>LWS_CALLBACK_HTTP</h3>
602 an http request has come from a client that is not
603 asking to upgrade the connection to a websocket
604 one. This is a chance to serve http content,
605 for example, to send a script to the client
606 which will then open the websockets connection.
607 <tt><b>in</b></tt> points to the URI path requested and
608 <b>libwebsockets_serve_http_file</b> makes it very
609 simple to send back a file to the client.
610 Normally after sending the file you are done
611 with the http connection, since the rest of the
612 activity will come by websockets from the script
613 that was delivered by http, so you will want to
614 return 1; to close and free up the connection.
615 That's important because it uses a slot in the
616 total number of client connections allowed set
619 <h3>LWS_CALLBACK_HTTP_WRITEABLE</h3>
621 you can write more down the http protocol
624 <h3>LWS_CALLBACK_HTTP_FILE_COMPLETION</h3>
626 a file requested to be send down
627 http link has completed.
629 <h3>LWS_CALLBACK_SERVER_WRITEABLE</h3>
632 <b>libwebsocket_callback_on_writable</b> on a connection, you will
633 get one of these callbacks coming when the connection socket
634 is able to accept another write packet without blocking.
635 If it already was able to take another packet without blocking,
636 you'll get this callback at the next call to the service loop
637 function. Notice that CLIENTs get LWS_CALLBACK_CLIENT_WRITEABLE
638 and servers get LWS_CALLBACK_SERVER_WRITEABLE.
640 <h3>LWS_CALLBACK_FILTER_NETWORK_CONNECTION</h3>
642 called when a client connects to
643 the server at network level; the connection is accepted but then
644 passed to this callback to decide whether to hang up immediately
645 or not, based on the client IP. <tt><b>in</b></tt> contains the connection
646 socket's descriptor. Return non-zero to terminate
647 the connection before sending or receiving anything.
648 Because this happens immediately after the network connection
649 from the client, there's no websocket protocol selected yet so
650 this callback is issued only to protocol 0.
652 <h3>LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION</h3>
654 called when the handshake has
655 been received and parsed from the client, but the response is
656 not sent yet. Return non-zero to disallow the connection.
657 <tt><b>user</b></tt> is a pointer to an array of struct lws_tokens, you can
658 use the header enums lws_token_indexes from libwebsockets.h
659 to check for and read the supported header presence and
660 content before deciding to allow the handshake to proceed or
661 to kill the connection.
663 <h3>LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS</h3>
666 including OpenSSL support, this callback allows your user code
667 to perform extra <b>SSL_CTX_load_verify_locations</b> or similar
668 calls to direct OpenSSL where to find certificates the client
669 can use to confirm the remote server identity. <tt><b>user</b></tt> is the
672 <h3>LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS</h3>
675 including OpenSSL support, this callback allows your user code
676 to load extra certifcates into the server which allow it to
677 verify the validity of certificates returned by clients. <tt><b>user</b></tt>
678 is the server's OpenSSL SSL_CTX*
680 <h3>LWS_CALLBACK_OPENSSL_PERFORM_CLIENT_CERT_VERIFICATION</h3>
683 libwebsockets context was created with the option
684 LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT, then this
685 callback is generated during OpenSSL verification of the cert
686 sent from the client. It is sent to protocol[0] callback as
687 no protocol has been negotiated on the connection yet.
688 Notice that the libwebsockets context and wsi are both NULL
689 during this callback. See
693 //www.openssl.org/docs/ssl/SSL_CTX_set_verify.html
694 to understand more detail about the OpenSSL callback that
695 generates this libwebsockets callback and the meanings of the
696 arguments passed. In this callback, <tt><b>user</b></tt> is the x509_ctx,
697 <tt><b>in</b></tt> is the ssl pointer and <tt><b>len</b></tt> is preverify_ok
698 Notice that this callback maintains libwebsocket return
699 conventions, return 0 to mean the cert is OK or 1 to fail it.
700 This also means that if you don't handle this callback then
701 the default callback action of returning 0 allows the client
704 <h3>LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER</h3>
706 this callback happens
707 when a client handshake is being compiled. <tt><b>user</b></tt> is NULL,
708 <tt><b>in</b></tt> is a char **, it's pointing to a char * which holds the
709 next location in the header buffer where you can add
710 headers, and <tt><b>len</b></tt> is the remaining space in the header buffer,
711 which is typically some hundreds of bytes. So, to add a canned
712 cookie, your handler code might look similar to:
714 char **p = (char **)in;
719 *p += sprintf(*p, "Cookie: a=b\x0d\x0a");
723 Notice if you add anything, you just have to take care about
724 the CRLF on the line you added. Obviously this callback is
725 optional, if you don't handle it everything is fine.
727 Notice the callback is coming to protocols[0] all the time,
728 because there is no specific protocol handshook yet.
730 <h3>LWS_CALLBACK_CONFIRM_EXTENSION_OKAY</h3>
732 When the server handshake code
733 sees that it does support a requested extension, before
734 accepting the extension by additing to the list sent back to
735 the client it gives this callback just to check that it's okay
736 to use that extension. It calls back to the requested protocol
737 and with <tt><b>in</b></tt> being the extension name, <tt><b>len</b></tt> is 0 and <tt><b>user</b></tt> is
738 valid. Note though at this time the ESTABLISHED callback hasn't
739 happened yet so if you initialize <tt><b>user</b></tt> content there, <tt><b>user</b></tt>
740 content during this callback might not be useful for anything.
741 Notice this callback comes to protocols[0].
743 <h3>LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED</h3>
746 connection is being prepared to start a handshake to a server,
747 each supported extension is checked with protocols[0] callback
748 with this reason, giving the user code a chance to suppress the
749 claim to support that extension by returning non-zero. If
750 unhandled, by default 0 will be returned and the extension
751 support included in the header to the server. Notice this
752 callback comes to protocols[0].
754 <h3>LWS_CALLBACK_PROTOCOL_INIT</h3>
756 One-time call per protocol so it can
757 do initial setup / allocations etc
759 <h3>LWS_CALLBACK_PROTOCOL_DESTROY</h3>
761 One-time call per protocol indicating
762 this protocol won't get used at all after this callback, the
763 context is getting destroyed. Take the opportunity to
764 deallocate everything that was allocated by the protocol.
766 The next four reasons are optional and only need taking care of if you
767 will be integrating libwebsockets sockets into an external polling
770 <h3>LWS_CALLBACK_ADD_POLL_FD</h3>
772 libwebsocket deals with its <b>poll</b> loop
773 internally, but in the case you are integrating with another
774 server you will need to have libwebsocket sockets share a
775 polling array with the other server. This and the other
776 POLL_FD related callbacks let you put your specialized
777 poll array interface code in the callback for protocol 0, the
778 first protocol you support, usually the HTTP protocol in the
779 serving case. This callback happens when a socket needs to be
781 <h3>added to the polling loop</h3>
783 <tt><b>in</b></tt> contains the fd, and
784 <tt><b>len</b></tt> is the events bitmap (like, POLLIN). If you are using the
785 internal polling loop (the "service" callback), you can just
786 ignore these callbacks.
788 <h3>LWS_CALLBACK_DEL_POLL_FD</h3>
790 This callback happens when a socket descriptor
791 needs to be removed from an external polling array. <tt><b>in</b></tt> is
792 the socket desricptor. If you are using the internal polling
793 loop, you can just ignore it.
795 <h3>LWS_CALLBACK_SET_MODE_POLL_FD</h3>
797 This callback happens when libwebsockets
798 wants to modify the events for the socket descriptor in <tt><b>in</b></tt>.
799 The handler should OR <tt><b>len</b></tt> on to the events member of the pollfd
800 struct for this socket descriptor. If you are using the
801 internal polling loop, you can just ignore it.
803 <h3>LWS_CALLBACK_CLEAR_MODE_POLL_FD</h3>
805 This callback occurs when libwebsockets
806 wants to modify the events for the socket descriptor in <tt><b>in</b></tt>.
807 The handler should AND ~<tt><b>len</b></tt> on to the events member of the
808 pollfd struct for this socket descriptor. If you are using the
809 internal polling loop, you can just ignore it.
812 <h2>extension_callback - Hooks to allow extensions to operate</h2>
813 <i>LWS_EXTERN int</i>
814 <b>extension_callback</b>
815 (<i>struct libwebsocket_context *</i> <b>context</b>,
816 <i>struct libwebsocket_extension *</i> <b>ext</b>,
817 <i>struct libwebsocket *</i> <b>wsi</b>,
818 <i>enum libwebsocket_extension_callback_reasons</i> <b>reason</b>,
819 <i>void *</i> <b>user</b>,
820 <i>void *</i> <b>in</b>,
821 <i>size_t</i> <b>len</b>)
825 <dd>Websockets context
829 <dd>Opaque websocket instance pointer
831 <dd>The reason for the call
833 <dd>Pointer to per-session user data allocated by library
835 <dd>Pointer used for some callback reasons
837 <dd>Length set for some callback reasons
841 Each extension that is active on a particular connection receives
842 callbacks during the connection lifetime to allow the extension to
843 operate on websocket data and manage itself.
845 Libwebsockets takes care of allocating and freeing "user" memory for
846 each active extension on each connection. That is what is pointed to
847 by the <tt><b>user</b></tt> parameter.
849 <h3>LWS_EXT_CALLBACK_CONSTRUCT</h3>
851 called when the server has decided to
852 select this extension from the list provided by the client,
853 just before the server will send back the handshake accepting
854 the connection with this extension active. This gives the
855 extension a chance to initialize its connection context found
856 in <tt><b>user</b></tt>.
858 <h3>LWS_EXT_CALLBACK_CLIENT_CONSTRUCT</h3>
860 same as LWS_EXT_CALLBACK_CONSTRUCT
861 but called when client is instantiating this extension. Some
862 extensions will work the same on client and server side and then
863 you can just merge handlers for both CONSTRUCTS.
865 <h3>LWS_EXT_CALLBACK_DESTROY</h3>
867 called when the connection the extension was
868 being used on is about to be closed and deallocated. It's the
869 last chance for the extension to deallocate anything it has
870 allocated in the user data (pointed to by <tt><b>user</b></tt>) before the
871 user data is deleted. This same callback is used whether you
872 are in client or server instantiation context.
874 <h3>LWS_EXT_CALLBACK_PACKET_RX_PREPARSE</h3>
876 when this extension was active on
877 a connection, and a packet of data arrived at the connection,
878 it is passed to this callback to give the extension a chance to
879 change the data, eg, decompress it. <tt><b>user</b></tt> is pointing to the
880 extension's private connection context data, <tt><b>in</b></tt> is pointing
881 to an lws_tokens struct, it consists of a char * pointer called
882 token, and an int called token_len. At entry, these are
883 set to point to the received buffer and set to the content
884 length. If the extension will grow the content, it should use
885 a new buffer allocated in its private user context data and
886 set the pointed-to lws_tokens members to point to its buffer.
888 <h3>LWS_EXT_CALLBACK_PACKET_TX_PRESEND</h3>
890 this works the same way as
891 LWS_EXT_CALLBACK_PACKET_RX_PREPARSE above, except it gives the
892 extension a chance to change websocket data just before it will
893 be sent out. Using the same lws_token pointer scheme in <tt><b>in</b></tt>,
894 the extension can change the buffer and the length to be
895 transmitted how it likes. Again if it wants to grow the
896 buffer safely, it should copy the data into its own buffer and
897 set the lws_tokens token pointer to it.
900 <h2>struct libwebsocket_protocols - List of protocols and handlers server supports.</h2>
901 <b>struct libwebsocket_protocols</b> {<br>
902 <i>const char *</i> <b>name</b>;<br>
903 <i>callback_function *</i> <b>callback</b>;<br>
904 <i>size_t</i> <b>per_session_data_size</b>;<br>
905 <i>size_t</i> <b>rx_buffer_size</b>;<br>
906 <i>struct libwebsocket_context *</i> <b>owning_server</b>;<br>
907 <i>int</i> <b>protocol_index</b>;<br>
912 <dd>Protocol name that must match the one given in the client
913 Javascript new WebSocket(url, 'protocol') name
915 <dd>The service callback used for this protocol. It allows the
916 service action for an entire protocol to be encapsulated in
917 the protocol-specific callback
918 <dt><b>per_session_data_size</b>
919 <dd>Each new connection using this protocol gets
920 this much memory allocated on connection establishment and
921 freed on connection takedown. A pointer to this per-connection
922 allocation is passed into the callback in the 'user' parameter
923 <dt><b>rx_buffer_size</b>
924 <dd>if you want atomic frames delivered to the callback, you
925 should set this to the size of the biggest legal frame that
926 you support. If the frame size is exceeded, there is no
927 error, but the buffer will spill to the user callback when
928 full, which you can detect by using
929 <b>libwebsockets_remaining_packet_payload</b>. Notice that you
930 just talk about frame size here, the LWS_SEND_BUFFER_PRE_PADDING
931 and post-padding are automatically also allocated on top.
932 <dt><b>owning_server</b>
933 <dd>the server init call fills in this opaque pointer when
934 registering this protocol with the server.
935 <dt><b>protocol_index</b>
936 <dd>which protocol we are starting from zero
940 This structure represents one protocol supported by the server. An
941 array of these structures is passed to <b>libwebsocket_create_server</b>
942 allows as many protocols as you like to be handled by one server.
945 <h2>struct libwebsocket_extension - An extension we know how to cope with</h2>
946 <b>struct libwebsocket_extension</b> {<br>
947 <i>const char *</i> <b>name</b>;<br>
948 <i>extension_callback_function *</i> <b>callback</b>;<br>
949 <i>size_t</i> <b>per_session_data_size</b>;<br>
950 <i>void *</i> <b>per_context_private_data</b>;<br>
955 <dd>Formal extension name, eg, "deflate-stream"
958 <dt><b>per_session_data_size</b>
959 <dd>Libwebsockets will auto-malloc this much
960 memory for the use of the extension, a pointer
961 to it comes in the <tt><b>user</b></tt> callback parameter
962 <dt><b>per_context_private_data</b>
963 <dd>Optional storage for this extension that
964 is per-context, so it can track stuff across
965 all sessions, etc, if it wants
968 <h2>struct lws_context_creation_info - </h2>
969 <b>struct lws_context_creation_info</b> {<br>
970 <i>int</i> <b>port</b>;<br>
971 <i>const char *</i> <b>iface</b>;<br>
972 <i>struct libwebsocket_protocols *</i> <b>protocols</b>;<br>
973 <i>struct libwebsocket_extension *</i> <b>extensions</b>;<br>
974 <i>const char *</i> <b>ssl_cert_filepath</b>;<br>
975 <i>const char *</i> <b>ssl_private_key_filepath</b>;<br>
976 <i>const char *</i> <b>ssl_ca_filepath</b>;<br>
977 <i>const char *</i> <b>ssl_cipher_list</b>;<br>
978 <i>int</i> <b>gid</b>;<br>
979 <i>int</i> <b>uid</b>;<br>
980 <i>unsigned int</i> <b>options</b>;<br>
981 <i>void *</i> <b>user</b>;<br>
982 <i>int</i> <b>ka_time</b>;<br>
983 <i>int</i> <b>ka_probes</b>;<br>
984 <i>int</i> <b>ka_interval</b>;<br>
989 <dd>Port to listen on... you can use 0 to suppress listening on
990 any port, that's what you want if you are not running a
991 websocket server at all but just using it as a client
993 <dd>NULL to bind the listen socket to all interfaces, or the
994 interface name, eg, "eth2"
996 <dd>Array of structures listing supported protocols and a protocol-
997 specific callback for each one. The list is ended with an
998 entry that has a NULL callback pointer.
999 It's not const because we write the owning_server member
1000 <dt><b>extensions</b>
1001 <dd>NULL or array of libwebsocket_extension structs listing the
1002 extensions this context supports. If you configured with
1003 --without-extensions, you should give NULL here.
1004 <dt><b>ssl_cert_filepath</b>
1005 <dd>If libwebsockets was compiled to use ssl, and you want
1006 to listen using SSL, set to the filepath to fetch the
1007 server cert from, otherwise NULL for unencrypted
1008 <dt><b>ssl_private_key_filepath</b>
1009 <dd>filepath to private key if wanting SSL mode,
1011 <dt><b>ssl_ca_filepath</b>
1012 <dd>CA certificate filepath or NULL
1013 <dt><b>ssl_cipher_list</b>
1014 <dd>List of valid ciphers to use (eg,
1015 "RC4-MD5:RC4-SHA:AES128-SHA:AES256-SHA:HIGH:!DSS:!aNULL"
1016 or you can leave it as NULL to get "DEFAULT"
1018 <dd>group id to change to after setting listen socket, or -1.
1020 <dd>user id to change to after setting listen socket, or -1.
1022 <dd>0, or LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK
1024 <dd>optional user pointer that can be recovered via the context
1025 pointer using libwebsocket_context_user
1027 <dd>0 for no keepalive, otherwise apply this keepalive timeout to
1028 all libwebsocket sockets, client or server
1029 <dt><b>ka_probes</b>
1030 <dd>if ka_time was nonzero, after the timeout expires how many
1031 times to try to get a response from the peer before giving up
1032 and killing the connection
1033 <dt><b>ka_interval</b>
1034 <dd>if ka_time was nonzero, how long to wait before each ka_probes
projects / profile / ivi / libwebsockets.git / blob