2 * libwebsockets - small server side websockets and web server implementation
4 * Copyright (C) 2010 Andy Green <andy@warmcat.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation:
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 #include "private-libwebsockets.h"
25 libwebsocket_close_and_free_session(struct libwebsocket *wsi)
28 unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 2 +
29 LWS_SEND_BUFFER_POST_PADDING];
31 if ((unsigned long)wsi < LWS_MAX_PROTOCOLS)
36 if (n == WSI_STATE_DEAD_SOCKET)
40 * signal we are closing, libsocket_write will
41 * add any necessary version-specific stuff. If the write fails,
42 * no worries we are closing anyway. If we didn't initiate this
43 * close, then our state has been changed to
44 * WSI_STATE_RETURNED_CLOSE_ALREADY and we can skip this
47 if (n == WSI_STATE_ESTABLISHED)
48 libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], 0,
51 wsi->state = WSI_STATE_DEAD_SOCKET;
53 if (wsi->protocol->callback && n == WSI_STATE_ESTABLISHED)
54 wsi->protocol->callback(wsi, LWS_CALLBACK_CLOSED,
55 wsi->user_space, NULL, 0);
57 for (n = 0; n < WSI_TOKEN_COUNT; n++)
58 if (wsi->utf8_token[n].token)
59 free(wsi->utf8_token[n].token);
61 /* fprintf(stderr, "closing fd=%d\n", wsi->sock); */
63 #ifdef LWS_OPENSSL_SUPPORT
65 n = SSL_get_fd(wsi->ssl);
66 SSL_shutdown(wsi->ssl);
71 shutdown(wsi->sock, SHUT_RDWR);
73 #ifdef LWS_OPENSSL_SUPPORT
77 free(wsi->user_space);
83 libwebsocket_poll_connections(struct libwebsocket_context *this)
85 unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + MAX_BROADCAST_PAYLOAD +
86 LWS_SEND_BUFFER_POST_PADDING];
87 int client = this->count_protocols + 1;
88 struct libwebsocket *wsi;
92 /* check for activity on client sockets */
94 for (; client < this->fds_count; client++) {
96 /* handle session socket closed */
98 if (this->fds[client].revents & (POLLERR | POLLHUP)) {
100 debug("Session Socket %d %p (fd=%d) dead\n",
101 client, (void *)this->wsi[client],
102 this->fds[client].fd);
104 libwebsocket_close_and_free_session(this->wsi[client]);
108 /* the guy requested a callback when it was OK to write */
110 if ((unsigned long)this->wsi[client] > LWS_MAX_PROTOCOLS &&
111 this->fds[client].revents & POLLOUT) {
113 this->fds[client].events &= ~POLLOUT;
115 this->wsi[client]->protocol->callback(this->wsi[client],
116 LWS_CALLBACK_CLIENT_WRITEABLE,
117 this->wsi[client]->user_space,
121 /* any incoming data ready? */
123 if (!(this->fds[client].revents & POLLIN))
128 if ((unsigned long)this->wsi[client] < LWS_MAX_PROTOCOLS) {
130 /* get the issued broadcast payload from the socket */
132 len = read(this->fds[client].fd,
133 buf + LWS_SEND_BUFFER_PRE_PADDING,
134 MAX_BROADCAST_PAYLOAD);
138 "Error reading broadcast payload\n");
142 /* broadcast it to all guys with this protocol index */
144 for (n = this->count_protocols + 1;
145 n < this->fds_count; n++) {
149 if ((unsigned long)wsi < LWS_MAX_PROTOCOLS)
153 * never broadcast to non-established
157 if (wsi->state != WSI_STATE_ESTABLISHED)
160 /* only to clients connected to us */
162 if (wsi->mode != LWS_CONNMODE_WS_SERVING)
166 * only broadcast to connections using
167 * the requested protocol
170 if (wsi->protocol->protocol_index !=
171 (int)(unsigned long)this->wsi[client])
174 /* broadcast it to this connection */
176 wsi->protocol->callback(wsi,
177 LWS_CALLBACK_BROADCAST,
179 buf + LWS_SEND_BUFFER_PRE_PADDING, len);
185 #ifdef LWS_OPENSSL_SUPPORT
186 if (this->wsi[client]->ssl)
187 n = SSL_read(this->wsi[client]->ssl, buf, sizeof buf);
190 n = recv(this->fds[client].fd, buf, sizeof buf, 0);
193 fprintf(stderr, "Socket read returned %d\n", n);
197 libwebsocket_close_and_free_session(this->wsi[client]);
201 /* service incoming data */
203 n = libwebsocket_read(this->wsi[client], buf, n);
207 * it closed and nuked wsi[client], so remove the
208 * socket handle and wsi from our service list
212 debug("nuking wsi %p, fsd_count = %d\n",
213 (void *)this->wsi[client], this->fds_count - 1);
216 for (n = client; n < this->fds_count; n++) {
217 this->fds[n] = this->fds[n + 1];
218 this->wsi[n] = this->wsi[n + 1];
229 * libwebsocket_context_destroy() - Destroy the websocket context
230 * @this: Websocket context
232 * This function closes any active connections and then frees the
233 * context. After calling this, any further use of the context is
237 libwebsocket_context_destroy(struct libwebsocket_context *this)
241 /* close listening skt and per-protocol broadcast sockets */
242 for (client = this->count_protocols + 1; client < this->fds_count; client++)
243 switch (this->wsi[client]->mode) {
244 case LWS_CONNMODE_WS_SERVING:
245 libwebsocket_close_and_free_session(this->wsi[client]);
247 case LWS_CONNMODE_WS_CLIENT:
248 libwebsocket_client_close(this->wsi[client]);
252 close(this->fd_random);
254 #ifdef LWS_OPENSSL_SUPPORT
256 SSL_CTX_free(this->ssl_ctx);
257 if (this->ssl_client_ctx)
258 SSL_CTX_free(this->ssl_client_ctx);
265 * libwebsocket_service() - Service any pending websocket activity
266 * @this: Websocket context
267 * @timeout_ms: Timeout for poll; 0 means return immediately if nothing needed
268 * service otherwise block and service immediately, returning
269 * after the timeout if nothing needed service.
271 * This function deals with any pending websocket traffic, for three
272 * kinds of event. It handles these events on both server and client
273 * types of connection the same.
275 * 1) Accept new connections to our context's server
277 * 2) Perform pending broadcast writes initiated from other forked
278 * processes (effectively serializing asynchronous broadcasts)
280 * 3) Call the receive callback for incoming frame data received by
281 * server or client connections.
283 * You need to call this service function periodically to all the above
284 * functions to happen; if your application is single-threaded you can
285 * just call it in your main event loop.
287 * Alternatively you can fork a new process that asynchronously handles
288 * calling this service in a loop. In that case you are happy if this
289 * call blocks your thread until it needs to take care of something and
290 * would call it with a large nonzero timeout. Your loop then takes no
291 * CPU while there is nothing happening.
293 * If you are calling it in a single-threaded app, you don't want it to
294 * wait around blocking other things in your loop from happening, so you
295 * would call it with a timeout_ms of 0, so it returns immediately if
296 * nothing is pending, or as soon as it services whatever was pending.
301 libwebsocket_service(struct libwebsocket_context *this, int timeout_ms)
306 struct sockaddr_in cli_addr;
309 /* stay dead once we are dead */
314 /* don't check listen socket if we are not listening */
316 if (this->listen_port)
317 n = poll(this->fds, this->fds_count, timeout_ms);
319 n = poll(&this->fds[1], this->fds_count - 1, timeout_ms);
322 if (n < 0 || this->fds[0].revents & (POLLERR | POLLHUP)) {
324 fprintf(stderr, "Listen Socket dead\n");
328 if (n == 0) /* poll timeout */
331 /* handle accept on listening socket? */
333 for (client = 0; client < this->count_protocols + 1; client++) {
335 if (!this->fds[client].revents & POLLIN)
338 /* listen socket got an unencrypted connection... */
340 clilen = sizeof(cli_addr);
341 fd = accept(this->fds[client].fd,
342 (struct sockaddr *)&cli_addr, &clilen);
344 fprintf(stderr, "ERROR on accept");
348 if (this->fds_count >= MAX_CLIENTS) {
349 fprintf(stderr, "too busy");
356 * accepting a connection to broadcast socket
357 * set wsi to be protocol index not pointer
360 this->wsi[this->fds_count] =
361 (struct libwebsocket *)(long)(client - 1);
366 /* accepting connection to main listener */
368 this->wsi[this->fds_count] =
369 malloc(sizeof(struct libwebsocket));
370 if (!this->wsi[this->fds_count]) {
371 fprintf(stderr, "Out of memory for new connection\n");
375 #ifdef LWS_OPENSSL_SUPPORT
376 this->wsi[this->fds_count]->ssl = NULL;
377 this->ssl_ctx = NULL;
381 this->wsi[this->fds_count]->ssl =
382 SSL_new(this->ssl_ctx);
383 if (this->wsi[this->fds_count]->ssl == NULL) {
384 fprintf(stderr, "SSL_new failed: %s\n",
385 ERR_error_string(SSL_get_error(
386 this->wsi[this->fds_count]->ssl, 0),
388 free(this->wsi[this->fds_count]);
392 SSL_set_fd(this->wsi[this->fds_count]->ssl, fd);
394 n = SSL_accept(this->wsi[this->fds_count]->ssl);
397 * browsers seem to probe with various
398 * ssl params which fail then retry
401 debug("SSL_accept failed skt %u: %s\n",
403 ERR_error_string(SSL_get_error(
404 this->wsi[this->fds_count]->ssl,
407 this->wsi[this->fds_count]->ssl);
408 free(this->wsi[this->fds_count]);
411 debug("accepted new SSL conn "
412 "port %u on fd=%d SSL ver %s\n",
413 ntohs(cli_addr.sin_port), fd,
414 SSL_get_version(this->wsi[
415 this->fds_count]->ssl));
419 debug("accepted new conn port %u on fd=%d\n",
420 ntohs(cli_addr.sin_port), fd);
422 /* intialize the instance struct */
424 this->wsi[this->fds_count]->sock = fd;
425 this->wsi[this->fds_count]->state = WSI_STATE_HTTP;
426 this->wsi[this->fds_count]->name_buffer_pos = 0;
427 this->wsi[this->fds_count]->mode = LWS_CONNMODE_WS_SERVING;
429 for (n = 0; n < WSI_TOKEN_COUNT; n++) {
430 this->wsi[this->fds_count]->
431 utf8_token[n].token = NULL;
432 this->wsi[this->fds_count]->
433 utf8_token[n].token_len = 0;
437 * these can only be set once the protocol is known
438 * we set an unestablished connection's protocol pointer
439 * to the start of the supported list, so it can look
440 * for matching ones during the handshake
442 this->wsi[this->fds_count]->protocol = this->protocols;
443 this->wsi[this->fds_count]->user_space = NULL;
446 * Default protocol is 76 / 00
447 * After 76, there's a header specified to inform which
448 * draft the client wants, when that's seen we modify
449 * the individual connection's spec revision accordingly
451 this->wsi[this->fds_count]->ietf_spec_revision = 0;
456 * make sure NO events are seen yet on this new socket
457 * (otherwise we inherit old fds[client].revents from
458 * previous socket there and die mysteriously! )
460 this->fds[this->fds_count].revents = 0;
462 this->fds[this->fds_count].events = POLLIN;
463 this->fds[this->fds_count++].fd = fd;
467 /* service anything incoming on websocket connection */
469 libwebsocket_poll_connections(this);
471 /* this round is done */
477 /* inform caller we are dead */
483 * libwebsocket_callback_on_writable() - Request a callback when this socket
484 * becomes able to be written to without
487 * @wsi: Websocket connection instance to get callback for
491 libwebsocket_callback_on_writable(struct libwebsocket *wsi)
493 struct libwebsocket_context *this = wsi->protocol->owning_server;
496 for (n = this->count_protocols + 1; n < this->fds_count; n++)
497 if (this->wsi[n] == wsi) {
498 this->fds[n].events |= POLLOUT;
502 fprintf(stderr, "libwebsocket_callback_on_writable "
503 "didn't find socket\n");
508 * libwebsocket_callback_on_writable_all_protocol() - Request a callback for
509 * all connections using the given protocol when it
510 * becomes possible to write to each socket without
513 * @protocol: Protocol whose connections will get callbacks
517 libwebsocket_callback_on_writable_all_protocol(
518 const struct libwebsocket_protocols *protocol)
520 struct libwebsocket_context *this = protocol->owning_server;
523 for (n = this->count_protocols + 1; n < this->fds_count; n++)
524 if ((unsigned long)this->wsi[n] > LWS_MAX_PROTOCOLS)
525 if (this->wsi[n]->protocol == protocol)
526 this->fds[n].events |= POLLOUT;
533 * libwebsocket_get_socket_fd() - returns the socket file descriptor
535 * You will not need this unless you are doing something special
537 * @wsi: Websocket connection instance
541 libwebsocket_get_socket_fd(struct libwebsocket *wsi)
547 * libwebsocket_rx_flow_control() - Enable and disable socket servicing for
550 * If the output side of a server process becomes choked, this allows flow
551 * control for the input side.
553 * @wsi: Websocket connection instance to get callback for
554 * @enable: 0 = disable read servicing for this connection, 1 = enable
558 libwebsocket_rx_flow_control(struct libwebsocket *wsi, int enable)
560 struct libwebsocket_context *this = wsi->protocol->owning_server;
563 for (n = this->count_protocols + 1; n < this->fds_count; n++)
564 if (this->wsi[n] == wsi) {
566 this->fds[n].events |= POLLIN;
568 this->fds[n].events &= ~POLLIN;
573 fprintf(stderr, "libwebsocket_callback_on_writable "
574 "unable to find socket\n");
579 * libwebsocket_canonical_hostname() - returns this host's hostname
581 * This is typically used by client code to fill in the host parameter
582 * when making a client connection. You can only call it after the context
585 * @this: Websocket context
590 libwebsocket_canonical_hostname(struct libwebsocket_context *this)
592 return (const char *)this->canonical_hostname;
596 static void sigpipe_handler(int x)
602 * libwebsocket_create_context() - Create the websocket handler
603 * @port: Port to listen on... you can use 0 to suppress listening on
604 * any port, that's what you want if you are not running a
605 * websocket server at all but just using it as a client
606 * @protocols: Array of structures listing supported protocols and a protocol-
607 * specific callback for each one. The list is ended with an
608 * entry that has a NULL callback pointer.
609 * It's not const because we write the owning_server member
610 * @ssl_cert_filepath: If libwebsockets was compiled to use ssl, and you want
611 * to listen using SSL, set to the filepath to fetch the
612 * server cert from, otherwise NULL for unencrypted
613 * @ssl_private_key_filepath: filepath to private key if wanting SSL mode,
615 * @gid: group id to change to after setting listen socket, or -1.
616 * @uid: user id to change to after setting listen socket, or -1.
617 * @options: 0, or LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK
619 * This function creates the listening socket and takes care
620 * of all initialization in one step.
622 * After initialization, it returns a struct libwebsocket_context * that
623 * represents this server. After calling, user code needs to take care
624 * of calling libwebsocket_service() with the context pointer to get the
625 * server's sockets serviced. This can be done in the same process context
626 * or a forked process, or another thread,
628 * The protocol callback functions are called for a handful of events
629 * including http requests coming in, websocket connections becoming
630 * established, and data arriving; it's also called periodically to allow
631 * async transmission.
633 * HTTP requests are sent always to the FIRST protocol in @protocol, since
634 * at that time websocket protocol has not been negotiated. Other
635 * protocols after the first one never see any HTTP callack activity.
637 * The server created is a simple http server by default; part of the
638 * websocket standard is upgrading this http connection to a websocket one.
640 * This allows the same server to provide files like scripts and favicon /
641 * images or whatever over http and dynamic data over websockets all in
642 * one place; they're all handled in the user callback.
645 struct libwebsocket_context *
646 libwebsocket_create_context(int port,
647 struct libwebsocket_protocols *protocols,
648 const char *ssl_cert_filepath,
649 const char *ssl_private_key_filepath,
650 int gid, int uid, unsigned int options)
655 struct sockaddr_in serv_addr, cli_addr;
657 struct libwebsocket_context *this = NULL;
663 #ifdef LWS_OPENSSL_SUPPORT
665 char ssl_err_buf[512];
668 this = malloc(sizeof(struct libwebsocket_context));
670 fprintf(stderr, "No memory for websocket context\n");
673 this->protocols = protocols;
674 this->listen_port = port;
675 this->http_proxy_port = 0;
676 this->http_proxy_address[0] = '\0';
677 this->options = options;
679 this->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
680 if (this->fd_random < 0) {
681 fprintf(stderr, "Unable to open random device %s %d\n",
682 SYSTEM_RANDOM_FILEPATH, this->fd_random);
686 /* find canonical hostname */
688 hostname[(sizeof hostname) - 1] = '\0';
689 gethostname(hostname, (sizeof hostname) - 1);
690 he = gethostbyname(hostname);
691 strncpy(this->canonical_hostname, he->h_name,
692 sizeof this->canonical_hostname - 1);
693 this->canonical_hostname[sizeof this->canonical_hostname - 1] = '\0';
694 fprintf(stderr, " canonical hostname = '%s'\n",
695 this->canonical_hostname);
697 /* split the proxy ads:port if given */
699 p = getenv("http_proxy");
701 strncpy(this->http_proxy_address, p,
702 sizeof this->http_proxy_address - 1);
703 this->http_proxy_address[
704 sizeof this->http_proxy_address - 1] = '\0';
706 p = strchr(this->http_proxy_address, ':');
708 fprintf(stderr, "http_proxy needs to be ads:port\n");
712 this->http_proxy_port = atoi(p + 1);
714 fprintf(stderr, "Using proxy %s:%u\n",
715 this->http_proxy_address,
716 this->http_proxy_port);
721 #ifdef LWS_OPENSSL_SUPPORT
722 this->use_ssl = ssl_cert_filepath != NULL &&
723 ssl_private_key_filepath != NULL;
725 fprintf(stderr, " Compiled with SSL support, "
728 fprintf(stderr, " Compiled with SSL support, "
732 if (ssl_cert_filepath != NULL &&
733 ssl_private_key_filepath != NULL) {
734 fprintf(stderr, " Not compiled for OpenSSl support!\n");
737 fprintf(stderr, " Compiled without SSL support, "
738 "serving unencrypted\n");
744 signal(SIGPIPE, sigpipe_handler);
747 #ifdef LWS_OPENSSL_SUPPORT
749 /* basic openssl init */
753 OpenSSL_add_all_algorithms();
754 SSL_load_error_strings();
757 * Firefox insists on SSLv23 not SSLv3
758 * Konq disables SSLv2 by default now, SSLv23 works
761 method = (SSL_METHOD *)SSLv23_server_method();
763 fprintf(stderr, "problem creating ssl method: %s\n",
764 ERR_error_string(ERR_get_error(), ssl_err_buf));
767 this->ssl_ctx = SSL_CTX_new(method); /* create context */
768 if (!this->ssl_ctx) {
769 fprintf(stderr, "problem creating ssl context: %s\n",
770 ERR_error_string(ERR_get_error(), ssl_err_buf));
776 method = (SSL_METHOD *)SSLv23_client_method();
778 fprintf(stderr, "problem creating ssl method: %s\n",
779 ERR_error_string(ERR_get_error(), ssl_err_buf));
782 this->ssl_client_ctx = SSL_CTX_new(method); /* create context */
783 if (!this->ssl_client_ctx) {
784 fprintf(stderr, "problem creating ssl context: %s\n",
785 ERR_error_string(ERR_get_error(), ssl_err_buf));
790 /* openssl init for cert verification (used with client sockets) */
792 if (!SSL_CTX_load_verify_locations(this->ssl_client_ctx, NULL,
793 LWS_OPENSSL_CLIENT_CERTS)) {
794 fprintf(stderr, "Unable to load SSL Client certs from %s "
795 "(set by --with-client-cert-dir= in configure) -- "
796 " client ssl isn't going to work",
797 LWS_OPENSSL_CLIENT_CERTS);
802 /* openssl init for server sockets */
804 /* set the local certificate from CertFile */
805 n = SSL_CTX_use_certificate_file(this->ssl_ctx,
806 ssl_cert_filepath, SSL_FILETYPE_PEM);
808 fprintf(stderr, "problem getting cert '%s': %s\n",
810 ERR_error_string(ERR_get_error(), ssl_err_buf));
813 /* set the private key from KeyFile */
814 if (SSL_CTX_use_PrivateKey_file(this->ssl_ctx,
815 ssl_private_key_filepath,
816 SSL_FILETYPE_PEM) != 1) {
817 fprintf(stderr, "ssl problem getting key '%s': %s\n",
818 ssl_private_key_filepath,
819 ERR_error_string(ERR_get_error(), ssl_err_buf));
822 /* verify private key */
823 if (!SSL_CTX_check_private_key(this->ssl_ctx)) {
824 fprintf(stderr, "Private SSL key doesn't match cert\n");
828 /* SSL is happy and has a cert it's content with */
834 if (lws_b64_selftest())
837 /* set up our external listening socket we serve on */
841 sockfd = socket(AF_INET, SOCK_STREAM, 0);
843 fprintf(stderr, "ERROR opening socket");
847 /* allow us to restart even if old sockets in TIME_WAIT */
848 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
850 bzero((char *) &serv_addr, sizeof(serv_addr));
851 serv_addr.sin_family = AF_INET;
852 serv_addr.sin_addr.s_addr = INADDR_ANY;
853 serv_addr.sin_port = htons(port);
855 n = bind(sockfd, (struct sockaddr *) &serv_addr,
858 fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
864 /* drop any root privs for this process */
868 fprintf(stderr, "setgid: %s\n", strerror(errno));
871 fprintf(stderr, "setuid: %s\n", strerror(errno));
874 * prepare the poll() fd array... it's like this
876 * [0] = external listening socket
877 * [1 .. this->count_protocols] = per-protocol broadcast sockets
878 * [this->count_protocols + 1 ... this->fds_count-1] = connection skts
882 this->fds[0].fd = sockfd;
883 this->fds[0].events = POLLIN;
884 this->count_protocols = 0;
888 fprintf(stderr, " Listening on port %d\n", port);
891 /* set up our internal broadcast trigger sockets per-protocol */
893 for (; protocols[this->count_protocols].callback;
894 this->count_protocols++) {
895 protocols[this->count_protocols].owning_server = this;
896 protocols[this->count_protocols].protocol_index =
897 this->count_protocols;
899 fd = socket(AF_INET, SOCK_STREAM, 0);
901 fprintf(stderr, "ERROR opening socket");
905 /* allow us to restart even if old sockets in TIME_WAIT */
906 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
908 bzero((char *) &serv_addr, sizeof(serv_addr));
909 serv_addr.sin_family = AF_INET;
910 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
911 serv_addr.sin_port = 0; /* pick the port for us */
913 n = bind(fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
915 fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
920 slen = sizeof cli_addr;
921 n = getsockname(fd, (struct sockaddr *)&cli_addr, &slen);
923 fprintf(stderr, "getsockname failed\n");
926 protocols[this->count_protocols].broadcast_socket_port =
927 ntohs(cli_addr.sin_port);
930 debug(" Protocol %s broadcast socket %d\n",
931 protocols[this->count_protocols].name,
932 ntohs(cli_addr.sin_port));
934 this->fds[this->fds_count].fd = fd;
935 this->fds[this->fds_count].events = POLLIN;
936 /* wsi only exists for connections, not broadcast listener */
937 this->wsi[this->fds_count] = NULL;
948 * libwebsockets_fork_service_loop() - Optional helper function forks off
949 * a process for the websocket server loop.
950 * You don't have to use this but if not, you
951 * have to make sure you are calling
952 * libwebsocket_service periodically to service
953 * the websocket traffic
954 * @this: server context returned by creation function
958 libwebsockets_fork_service_loop(struct libwebsocket_context *this)
962 struct sockaddr_in cli_addr;
971 /* main process context */
973 for (client = 1; client < this->count_protocols + 1; client++) {
974 fd = socket(AF_INET, SOCK_STREAM, 0);
976 fprintf(stderr, "Unable to create socket\n");
979 cli_addr.sin_family = AF_INET;
980 cli_addr.sin_port = htons(
981 this->protocols[client - 1].broadcast_socket_port);
982 cli_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
983 n = connect(fd, (struct sockaddr *)&cli_addr,
986 fprintf(stderr, "Unable to connect to "
987 "broadcast socket %d, %s\n",
988 client, strerror(errno));
992 this->protocols[client - 1].broadcast_socket_user_fd =
1000 /* we want a SIGHUP when our parent goes down */
1001 prctl(PR_SET_PDEATHSIG, SIGHUP);
1003 /* in this forked process, sit and service websocket connections */
1006 if (libwebsocket_service(this, 1000))
1015 * libwebsockets_get_protocol() - Returns a protocol pointer from a websocket
1017 * @wsi: pointer to struct websocket you want to know the protocol of
1020 * This is useful to get the protocol to broadcast back to from inside
1024 const struct libwebsocket_protocols *
1025 libwebsockets_get_protocol(struct libwebsocket *wsi)
1027 return wsi->protocol;
1031 * libwebsockets_broadcast() - Sends a buffer to the callback for all active
1032 * connections of the given protocol.
1033 * @protocol: pointer to the protocol you will broadcast to all members of
1034 * @buf: buffer containing the data to be broadcase. NOTE: this has to be
1035 * allocated with LWS_SEND_BUFFER_PRE_PADDING valid bytes before
1036 * the pointer and LWS_SEND_BUFFER_POST_PADDING afterwards in the
1037 * case you are calling this function from callback context.
1038 * @len: length of payload data in buf, starting from buf.
1040 * This function allows bulk sending of a packet to every connection using
1041 * the given protocol. It does not send the data directly; instead it calls
1042 * the callback with a reason type of LWS_CALLBACK_BROADCAST. If the callback
1043 * wants to actually send the data for that connection, the callback itself
1044 * should call libwebsocket_write().
1046 * libwebsockets_broadcast() can be called from another fork context without
1047 * having to take any care about data visibility between the processes, it'll
1053 libwebsockets_broadcast(const struct libwebsocket_protocols *protocol,
1054 unsigned char *buf, size_t len)
1056 struct libwebsocket_context *this = protocol->owning_server;
1059 if (!protocol->broadcast_socket_user_fd) {
1061 * We are either running unforked / flat, or we are being
1062 * called from poll thread context
1063 * eg, from a callback. In that case don't use sockets for
1064 * broadcast IPC (since we can't open a socket connection to
1065 * a socket listening on our own thread) but directly do the
1068 * Locking is not needed because we are by definition being
1069 * called in the poll thread context and are serialized.
1072 for (n = this->count_protocols + 1; n < this->fds_count; n++) {
1074 if ((unsigned long)this->wsi[n] < LWS_MAX_PROTOCOLS)
1077 /* never broadcast to non-established connection */
1078 if (this->wsi[n]->state != WSI_STATE_ESTABLISHED)
1081 /* only broadcast to guys using requested protocol */
1082 if (this->wsi[n]->protocol != protocol)
1085 this->wsi[n]->protocol->callback(this->wsi[n],
1086 LWS_CALLBACK_BROADCAST,
1087 this->wsi[n]->user_space,
1095 * We're being called from a different process context than the server
1096 * loop. Instead of broadcasting directly, we send our
1097 * payload on a socket to do the IPC; the server process will serialize
1098 * the broadcast action in its main poll() loop.
1100 * There's one broadcast socket listening for each protocol supported
1101 * set up when the websocket server initializes
1104 n = send(protocol->broadcast_socket_user_fd, buf, len, MSG_NOSIGNAL);