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"
24 /* file descriptor hash management */
27 wsi_from_fd(struct libwebsocket_context *this, int fd)
29 int h = LWS_FD_HASH(fd);
32 for (n = 0; n < this->fd_hashtable[h].length; n++)
33 if (this->fd_hashtable[h].wsi[n]->sock == fd)
34 return this->fd_hashtable[h].wsi[n];
40 insert_wsi(struct libwebsocket_context *this, struct libwebsocket *wsi)
42 int h = LWS_FD_HASH(wsi->sock);
44 if (this->fd_hashtable[h].length == MAX_CLIENTS - 1) {
45 fprintf(stderr, "hash table overflow\n");
49 this->fd_hashtable[h].wsi[this->fd_hashtable[h].length++] = wsi;
55 delete_from_fd(struct libwebsocket_context *this, int fd)
57 int h = LWS_FD_HASH(fd);
60 for (n = 0; n < this->fd_hashtable[h].length; n++)
61 if (this->fd_hashtable[h].wsi[n]->sock == fd) {
62 while (n < this->fd_hashtable[h].length) {
63 this->fd_hashtable[h].wsi[n] =
64 this->fd_hashtable[h].wsi[n + 1];
67 this->fd_hashtable[h].length--;
72 fprintf(stderr, "Failed to find fd %d requested for "
73 "delete in hashtable\n", fd);
79 libwebsocket_close_and_free_session(struct libwebsocket *wsi)
82 unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 2 +
83 LWS_SEND_BUFFER_POST_PADDING];
85 if ((unsigned long)wsi < LWS_MAX_PROTOCOLS)
90 if (n == WSI_STATE_DEAD_SOCKET)
94 * signal we are closing, libsocket_write will
95 * add any necessary version-specific stuff. If the write fails,
96 * no worries we are closing anyway. If we didn't initiate this
97 * close, then our state has been changed to
98 * WSI_STATE_RETURNED_CLOSE_ALREADY and we can skip this
101 if (n == WSI_STATE_ESTABLISHED)
102 libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], 0,
105 wsi->state = WSI_STATE_DEAD_SOCKET;
107 if (wsi->protocol->callback && n == WSI_STATE_ESTABLISHED)
108 wsi->protocol->callback(wsi, LWS_CALLBACK_CLOSED,
109 wsi->user_space, NULL, 0);
111 for (n = 0; n < WSI_TOKEN_COUNT; n++)
112 if (wsi->utf8_token[n].token)
113 free(wsi->utf8_token[n].token);
115 /* fprintf(stderr, "closing fd=%d\n", wsi->sock); */
117 #ifdef LWS_OPENSSL_SUPPORT
119 n = SSL_get_fd(wsi->ssl);
120 SSL_shutdown(wsi->ssl);
125 shutdown(wsi->sock, SHUT_RDWR);
127 #ifdef LWS_OPENSSL_SUPPORT
131 free(wsi->user_space);
138 * libwebsocket_service_fd() - Service polled socket with something waiting
139 * @this: Websocket context
140 * @pollfd: The pollfd entry describing the socket fd and which events
143 * This function closes any active connections and then frees the
144 * context. After calling this, any further use of the context is
149 libwebsocket_service_fd(struct libwebsocket_context *this,
150 struct pollfd *pollfd)
152 unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + MAX_BROADCAST_PAYLOAD +
153 LWS_SEND_BUFFER_POST_PADDING];
154 struct libwebsocket *wsi = wsi_from_fd(this, pollfd->fd);
155 struct libwebsocket *new_wsi;
161 struct sockaddr_in cli_addr;
167 case LWS_CONNMODE_SERVER_LISTENER:
169 /* pollin means a client has connected to us then */
171 if (!pollfd->revents & POLLIN)
174 /* listen socket got an unencrypted connection... */
176 clilen = sizeof(cli_addr);
177 accept_fd = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
180 fprintf(stderr, "ERROR on accept");
184 if (this->fds_count >= MAX_CLIENTS) {
185 fprintf(stderr, "too busy to accept new client\n");
190 /* accepting connection to main listener */
192 new_wsi = malloc(sizeof(struct libwebsocket));
193 if (new_wsi == NULL) {
194 fprintf(stderr, "Out of memory for new connection\n");
198 memset(new_wsi, 0, sizeof (struct libwebsocket));
199 new_wsi->sock = accept_fd;
201 #ifdef LWS_OPENSSL_SUPPORT
203 this->ssl_ctx = NULL;
207 new_wsi->ssl = SSL_new(this->ssl_ctx);
208 if (new_wsi->ssl == NULL) {
209 fprintf(stderr, "SSL_new failed: %s\n",
210 ERR_error_string(SSL_get_error(
211 new_wsi->ssl, 0), NULL));
216 SSL_set_fd(new_wsi->ssl, accept_fd);
218 n = SSL_accept(new_wsi->ssl);
221 * browsers seem to probe with various
222 * ssl params which fail then retry
225 debug("SSL_accept failed skt %u: %s\n",
227 ERR_error_string(SSL_get_error(
228 new_wsi->ssl, n), NULL));
234 debug("accepted new SSL conn "
235 "port %u on fd=%d SSL ver %s\n",
236 ntohs(cli_addr.sin_port), accept_fd,
237 SSL_get_version(new_wsi->ssl));
241 debug("accepted new conn port %u on fd=%d\n",
242 ntohs(cli_addr.sin_port), accept_fd);
244 /* intialize the instance struct */
246 new_wsi->state = WSI_STATE_HTTP;
247 new_wsi->name_buffer_pos = 0;
248 new_wsi->mode = LWS_CONNMODE_WS_SERVING;
250 for (n = 0; n < WSI_TOKEN_COUNT; n++) {
251 new_wsi->utf8_token[n].token = NULL;
252 new_wsi->utf8_token[n].token_len = 0;
256 * these can only be set once the protocol is known
257 * we set an unestablished connection's protocol pointer
258 * to the start of the supported list, so it can look
259 * for matching ones during the handshake
261 new_wsi->protocol = this->protocols;
262 new_wsi->user_space = NULL;
265 * Default protocol is 76 / 00
266 * After 76, there's a header specified to inform which
267 * draft the client wants, when that's seen we modify
268 * the individual connection's spec revision accordingly
270 new_wsi->ietf_spec_revision = 0;
272 insert_wsi(this, new_wsi);
275 * make sure NO events are seen yet on this new socket
276 * (otherwise we inherit old fds[client].revents from
277 * previous socket there and die mysteriously! )
279 this->fds[this->fds_count].revents = 0;
281 this->fds[this->fds_count].events = POLLIN;
282 this->fds[this->fds_count++].fd = accept_fd;
284 /* external POLL support via protocol 0 */
285 this->protocols[0].callback(new_wsi,
286 LWS_CALLBACK_ADD_POLL_FD,
287 (void *)(long)accept_fd, NULL, POLLIN);
291 case LWS_CONNMODE_BROADCAST_PROXY_LISTENER:
293 /* as we are listening, POLLIN means accept() is needed */
295 if (!pollfd->revents & POLLIN)
298 /* listen socket got an unencrypted connection... */
300 clilen = sizeof(cli_addr);
301 accept_fd = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
304 fprintf(stderr, "ERROR on accept");
308 if (this->fds_count >= MAX_CLIENTS) {
309 fprintf(stderr, "too busy to accept new broadcast "
315 /* create a dummy wsi for the connection and add it */
317 new_wsi = malloc(sizeof(struct libwebsocket));
318 memset(new_wsi, 0, sizeof (struct libwebsocket));
319 new_wsi->sock = accept_fd;
320 new_wsi->mode = LWS_CONNMODE_BROADCAST_PROXY;
321 new_wsi->state = WSI_STATE_ESTABLISHED;
322 /* note which protocol we are proxying */
323 new_wsi->protocol_index_for_broadcast_proxy =
324 wsi->protocol_index_for_broadcast_proxy;
325 insert_wsi(this, new_wsi);
327 /* add connected socket to internal poll array */
329 this->fds[this->fds_count].revents = 0;
330 this->fds[this->fds_count].events = POLLIN;
331 this->fds[this->fds_count++].fd = accept_fd;
333 /* external POLL support via protocol 0 */
334 this->protocols[0].callback(new_wsi,
335 LWS_CALLBACK_ADD_POLL_FD,
336 (void *)(long)accept_fd, NULL, POLLIN);
340 case LWS_CONNMODE_BROADCAST_PROXY:
342 /* handle session socket closed */
344 if (pollfd->revents & (POLLERR | POLLHUP)) {
346 debug("Session Socket %p (fd=%d) dead\n",
347 (void *)wsi, accept_fd);
349 libwebsocket_close_and_free_session(wsi);
353 /* the guy requested a callback when it was OK to write */
355 if (pollfd->revents & POLLOUT) {
359 pollfd->events &= ~POLLOUT;
361 /* external POLL support via protocol 0 */
362 this->protocols[0].callback(wsi,
363 LWS_CALLBACK_CLEAR_MODE_POLL_FD,
364 (void *)(long)wsi->sock, NULL, POLLOUT);
366 wsi->protocol->callback(wsi,
367 LWS_CALLBACK_CLIENT_WRITEABLE,
372 /* any incoming data ready? */
374 if (!(pollfd->revents & POLLIN))
377 /* get the issued broadcast payload from the socket */
379 len = read(pollfd->fd, buf + LWS_SEND_BUFFER_PRE_PADDING,
380 MAX_BROADCAST_PAYLOAD);
382 fprintf(stderr, "Error reading broadcast payload\n");
386 /* broadcast it to all guys with this protocol index */
388 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
390 for (m = 0; m < this->fd_hashtable[n].length; m++) {
392 new_wsi = this->fd_hashtable[n].wsi[m];
394 /* only to clients we are serving to */
396 if (new_wsi->mode != LWS_CONNMODE_WS_SERVING)
400 * never broadcast to non-established
404 if (new_wsi->state != WSI_STATE_ESTABLISHED)
408 * only broadcast to connections using
409 * the requested protocol
412 if (new_wsi->protocol->protocol_index !=
413 wsi->protocol_index_for_broadcast_proxy)
416 /* broadcast it to this connection */
418 new_wsi->protocol->callback(new_wsi,
419 LWS_CALLBACK_BROADCAST,
421 buf + LWS_SEND_BUFFER_PRE_PADDING, len);
426 case LWS_CONNMODE_WS_SERVING:
427 case LWS_CONNMODE_WS_CLIENT:
429 /* handle session socket closed */
431 if (pollfd->revents & (POLLERR | POLLHUP)) {
433 debug("Session Socket %p (fd=%d) dead\n",
434 (void *)wsi, pollfd->fd);
436 libwebsocket_close_and_free_session(wsi);
440 /* the guy requested a callback when it was OK to write */
442 if (pollfd->revents & POLLOUT) {
444 pollfd->events &= ~POLLOUT;
446 /* external POLL support via protocol 0 */
447 this->protocols[0].callback(wsi,
448 LWS_CALLBACK_CLEAR_MODE_POLL_FD,
449 (void *)(long)wsi->sock, NULL, POLLOUT);
451 wsi->protocol->callback(wsi,
452 LWS_CALLBACK_CLIENT_WRITEABLE,
457 /* any incoming data ready? */
459 if (!(pollfd->revents & POLLIN))
462 #ifdef LWS_OPENSSL_SUPPORT
464 n = SSL_read(wsi->ssl, buf, sizeof buf);
467 n = recv(pollfd->fd, buf, sizeof buf, 0);
470 fprintf(stderr, "Socket read returned %d\n", n);
474 libwebsocket_close_and_free_session(wsi);
478 /* service incoming data */
480 n = libwebsocket_read(wsi, buf, n);
484 * it closed and nuked wsi[client], so remove the
485 * socket handle and wsi from our service list
489 debug("nuking wsi %p, fsd_count = %d\n",
490 (void *)wsi, this->fds_count - 1);
492 delete_from_fd(this, pollfd->fd);
495 for (n = 0; n < this->fds_count; n++)
496 if (this->fds[n].fd == pollfd->fd) {
497 while (n < this->fds_count) {
498 this->fds[n] = this->fds[n + 1];
504 /* external POLL support via protocol 0 */
505 this->protocols[0].callback(wsi,
506 LWS_CALLBACK_DEL_POLL_FD,
507 (void *)(long)pollfd->fd, NULL, 0);
518 * libwebsocket_context_destroy() - Destroy the websocket context
519 * @this: Websocket context
521 * This function closes any active connections and then frees the
522 * context. After calling this, any further use of the context is
526 libwebsocket_context_destroy(struct libwebsocket_context *this)
530 struct libwebsocket *wsi;
532 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
534 for (m = 0; m < this->fd_hashtable[n].length; m++) {
536 wsi = this->fd_hashtable[n].wsi[m];
539 case LWS_CONNMODE_WS_SERVING:
540 libwebsocket_close_and_free_session(wsi);
542 case LWS_CONNMODE_WS_CLIENT:
543 libwebsocket_client_close(wsi);
551 close(this->fd_random);
553 #ifdef LWS_OPENSSL_SUPPORT
555 SSL_CTX_free(this->ssl_ctx);
556 if (this->ssl_client_ctx)
557 SSL_CTX_free(this->ssl_client_ctx);
564 * libwebsocket_service() - Service any pending websocket activity
565 * @this: Websocket context
566 * @timeout_ms: Timeout for poll; 0 means return immediately if nothing needed
567 * service otherwise block and service immediately, returning
568 * after the timeout if nothing needed service.
570 * This function deals with any pending websocket traffic, for three
571 * kinds of event. It handles these events on both server and client
572 * types of connection the same.
574 * 1) Accept new connections to our context's server
576 * 2) Perform pending broadcast writes initiated from other forked
577 * processes (effectively serializing asynchronous broadcasts)
579 * 3) Call the receive callback for incoming frame data received by
580 * server or client connections.
582 * You need to call this service function periodically to all the above
583 * functions to happen; if your application is single-threaded you can
584 * just call it in your main event loop.
586 * Alternatively you can fork a new process that asynchronously handles
587 * calling this service in a loop. In that case you are happy if this
588 * call blocks your thread until it needs to take care of something and
589 * would call it with a large nonzero timeout. Your loop then takes no
590 * CPU while there is nothing happening.
592 * If you are calling it in a single-threaded app, you don't want it to
593 * wait around blocking other things in your loop from happening, so you
594 * would call it with a timeout_ms of 0, so it returns immediately if
595 * nothing is pending, or as soon as it services whatever was pending.
600 libwebsocket_service(struct libwebsocket_context *this, int timeout_ms)
604 /* stay dead once we are dead */
609 /* wait for something to need service */
611 n = poll(this->fds, this->fds_count, timeout_ms);
612 if (n == 0) /* poll timeout */
615 if (n < 0 || this->fds[0].revents & (POLLERR | POLLHUP)) {
617 fprintf(stderr, "Listen Socket dead\n");
622 /* handle accept on listening socket? */
624 for (n = 0; n < this->fds_count; n++)
625 if (this->fds[n].revents)
626 libwebsocket_service_fd(this, &this->fds[n]);
632 * libwebsocket_callback_on_writable() - Request a callback when this socket
633 * becomes able to be written to without
636 * @wsi: Websocket connection instance to get callback for
640 libwebsocket_callback_on_writable(struct libwebsocket *wsi)
642 struct libwebsocket_context *this = wsi->protocol->owning_server;
645 for (n = 0; n < this->fds_count; n++)
646 if (this->fds[n].fd == wsi->sock) {
647 this->fds[n].events |= POLLOUT;
651 /* external POLL support via protocol 0 */
652 this->protocols[0].callback(wsi,
653 LWS_CALLBACK_SET_MODE_POLL_FD,
654 (void *)(long)wsi->sock, NULL, POLLOUT);
660 * libwebsocket_callback_on_writable_all_protocol() - Request a callback for
661 * all connections using the given protocol when it
662 * becomes possible to write to each socket without
665 * @protocol: Protocol whose connections will get callbacks
669 libwebsocket_callback_on_writable_all_protocol(
670 const struct libwebsocket_protocols *protocol)
672 struct libwebsocket_context *this = protocol->owning_server;
675 struct libwebsocket *wsi;
677 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
679 for (m = 0; m < this->fd_hashtable[n].length; m++) {
681 wsi = this->fd_hashtable[n].wsi[m];
683 if (wsi->protocol == protocol)
684 libwebsocket_callback_on_writable(wsi);
693 * libwebsocket_get_socket_fd() - returns the socket file descriptor
695 * You will not need this unless you are doing something special
697 * @wsi: Websocket connection instance
701 libwebsocket_get_socket_fd(struct libwebsocket *wsi)
707 * libwebsocket_rx_flow_control() - Enable and disable socket servicing for
710 * If the output side of a server process becomes choked, this allows flow
711 * control for the input side.
713 * @wsi: Websocket connection instance to get callback for
714 * @enable: 0 = disable read servicing for this connection, 1 = enable
718 libwebsocket_rx_flow_control(struct libwebsocket *wsi, int enable)
720 struct libwebsocket_context *this = wsi->protocol->owning_server;
723 for (n = 0; n < this->fds_count; n++)
724 if (this->fds[n].fd == wsi->sock) {
726 this->fds[n].events |= POLLIN;
728 this->fds[n].events &= ~POLLIN;
734 /* external POLL support via protocol 0 */
735 this->protocols[0].callback(wsi,
736 LWS_CALLBACK_SET_MODE_POLL_FD,
737 (void *)(long)wsi->sock, NULL, POLLIN);
739 /* external POLL support via protocol 0 */
740 this->protocols[0].callback(wsi,
741 LWS_CALLBACK_CLEAR_MODE_POLL_FD,
742 (void *)(long)wsi->sock, NULL, POLLIN);
745 fprintf(stderr, "libwebsocket_callback_on_writable "
746 "unable to find socket\n");
751 * libwebsocket_canonical_hostname() - returns this host's hostname
753 * This is typically used by client code to fill in the host parameter
754 * when making a client connection. You can only call it after the context
757 * @this: Websocket context
762 libwebsocket_canonical_hostname(struct libwebsocket_context *this)
764 return (const char *)this->canonical_hostname;
768 static void sigpipe_handler(int x)
775 * libwebsocket_create_context() - Create the websocket handler
776 * @port: Port to listen on... you can use 0 to suppress listening on
777 * any port, that's what you want if you are not running a
778 * websocket server at all but just using it as a client
779 * @protocols: Array of structures listing supported protocols and a protocol-
780 * specific callback for each one. The list is ended with an
781 * entry that has a NULL callback pointer.
782 * It's not const because we write the owning_server member
783 * @ssl_cert_filepath: If libwebsockets was compiled to use ssl, and you want
784 * to listen using SSL, set to the filepath to fetch the
785 * server cert from, otherwise NULL for unencrypted
786 * @ssl_private_key_filepath: filepath to private key if wanting SSL mode,
788 * @gid: group id to change to after setting listen socket, or -1.
789 * @uid: user id to change to after setting listen socket, or -1.
790 * @options: 0, or LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK
792 * This function creates the listening socket and takes care
793 * of all initialization in one step.
795 * After initialization, it returns a struct libwebsocket_context * that
796 * represents this server. After calling, user code needs to take care
797 * of calling libwebsocket_service() with the context pointer to get the
798 * server's sockets serviced. This can be done in the same process context
799 * or a forked process, or another thread,
801 * The protocol callback functions are called for a handful of events
802 * including http requests coming in, websocket connections becoming
803 * established, and data arriving; it's also called periodically to allow
804 * async transmission.
806 * HTTP requests are sent always to the FIRST protocol in @protocol, since
807 * at that time websocket protocol has not been negotiated. Other
808 * protocols after the first one never see any HTTP callack activity.
810 * The server created is a simple http server by default; part of the
811 * websocket standard is upgrading this http connection to a websocket one.
813 * This allows the same server to provide files like scripts and favicon /
814 * images or whatever over http and dynamic data over websockets all in
815 * one place; they're all handled in the user callback.
818 struct libwebsocket_context *
819 libwebsocket_create_context(int port,
820 struct libwebsocket_protocols *protocols,
821 const char *ssl_cert_filepath,
822 const char *ssl_private_key_filepath,
823 int gid, int uid, unsigned int options)
828 struct sockaddr_in serv_addr, cli_addr;
830 struct libwebsocket_context *this = NULL;
835 struct libwebsocket *wsi;
837 #ifdef LWS_OPENSSL_SUPPORT
839 char ssl_err_buf[512];
842 this = malloc(sizeof(struct libwebsocket_context));
844 fprintf(stderr, "No memory for websocket context\n");
847 this->protocols = protocols;
848 this->listen_port = port;
849 this->http_proxy_port = 0;
850 this->http_proxy_address[0] = '\0';
851 this->options = options;
854 this->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
855 if (this->fd_random < 0) {
856 fprintf(stderr, "Unable to open random device %s %d\n",
857 SYSTEM_RANDOM_FILEPATH, this->fd_random);
861 /* find canonical hostname */
863 hostname[(sizeof hostname) - 1] = '\0';
864 gethostname(hostname, (sizeof hostname) - 1);
865 he = gethostbyname(hostname);
866 strncpy(this->canonical_hostname, he->h_name,
867 sizeof this->canonical_hostname - 1);
868 this->canonical_hostname[sizeof this->canonical_hostname - 1] = '\0';
869 fprintf(stderr, " canonical hostname = '%s'\n",
870 this->canonical_hostname);
872 /* split the proxy ads:port if given */
874 p = getenv("http_proxy");
876 strncpy(this->http_proxy_address, p,
877 sizeof this->http_proxy_address - 1);
878 this->http_proxy_address[
879 sizeof this->http_proxy_address - 1] = '\0';
881 p = strchr(this->http_proxy_address, ':');
883 fprintf(stderr, "http_proxy needs to be ads:port\n");
887 this->http_proxy_port = atoi(p + 1);
889 fprintf(stderr, "Using proxy %s:%u\n",
890 this->http_proxy_address,
891 this->http_proxy_port);
896 #ifdef LWS_OPENSSL_SUPPORT
897 this->use_ssl = ssl_cert_filepath != NULL &&
898 ssl_private_key_filepath != NULL;
900 fprintf(stderr, " Compiled with SSL support, "
903 fprintf(stderr, " Compiled with SSL support, "
907 if (ssl_cert_filepath != NULL &&
908 ssl_private_key_filepath != NULL) {
909 fprintf(stderr, " Not compiled for OpenSSl support!\n");
912 fprintf(stderr, " Compiled without SSL support, "
913 "serving unencrypted\n");
919 signal(SIGPIPE, sigpipe_handler);
922 #ifdef LWS_OPENSSL_SUPPORT
924 /* basic openssl init */
928 OpenSSL_add_all_algorithms();
929 SSL_load_error_strings();
932 * Firefox insists on SSLv23 not SSLv3
933 * Konq disables SSLv2 by default now, SSLv23 works
936 method = (SSL_METHOD *)SSLv23_server_method();
938 fprintf(stderr, "problem creating ssl method: %s\n",
939 ERR_error_string(ERR_get_error(), ssl_err_buf));
942 this->ssl_ctx = SSL_CTX_new(method); /* create context */
943 if (!this->ssl_ctx) {
944 fprintf(stderr, "problem creating ssl context: %s\n",
945 ERR_error_string(ERR_get_error(), ssl_err_buf));
951 method = (SSL_METHOD *)SSLv23_client_method();
953 fprintf(stderr, "problem creating ssl method: %s\n",
954 ERR_error_string(ERR_get_error(), ssl_err_buf));
957 this->ssl_client_ctx = SSL_CTX_new(method); /* create context */
958 if (!this->ssl_client_ctx) {
959 fprintf(stderr, "problem creating ssl context: %s\n",
960 ERR_error_string(ERR_get_error(), ssl_err_buf));
965 /* openssl init for cert verification (used with client sockets) */
967 if (!SSL_CTX_load_verify_locations(this->ssl_client_ctx, NULL,
968 LWS_OPENSSL_CLIENT_CERTS)) {
969 fprintf(stderr, "Unable to load SSL Client certs from %s "
970 "(set by --with-client-cert-dir= in configure) -- "
971 " client ssl isn't going to work",
972 LWS_OPENSSL_CLIENT_CERTS);
977 /* openssl init for server sockets */
979 /* set the local certificate from CertFile */
980 n = SSL_CTX_use_certificate_file(this->ssl_ctx,
981 ssl_cert_filepath, SSL_FILETYPE_PEM);
983 fprintf(stderr, "problem getting cert '%s': %s\n",
985 ERR_error_string(ERR_get_error(), ssl_err_buf));
988 /* set the private key from KeyFile */
989 if (SSL_CTX_use_PrivateKey_file(this->ssl_ctx,
990 ssl_private_key_filepath,
991 SSL_FILETYPE_PEM) != 1) {
992 fprintf(stderr, "ssl problem getting key '%s': %s\n",
993 ssl_private_key_filepath,
994 ERR_error_string(ERR_get_error(), ssl_err_buf));
997 /* verify private key */
998 if (!SSL_CTX_check_private_key(this->ssl_ctx)) {
999 fprintf(stderr, "Private SSL key doesn't match cert\n");
1003 /* SSL is happy and has a cert it's content with */
1009 if (lws_b64_selftest())
1012 /* fd hashtable init */
1014 for (n = 0; n < FD_HASHTABLE_MODULUS; n++)
1015 this->fd_hashtable[n].length = 0;
1017 /* set up our external listening socket we serve on */
1021 sockfd = socket(AF_INET, SOCK_STREAM, 0);
1023 fprintf(stderr, "ERROR opening socket");
1027 /* allow us to restart even if old sockets in TIME_WAIT */
1028 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
1030 bzero((char *) &serv_addr, sizeof(serv_addr));
1031 serv_addr.sin_family = AF_INET;
1032 serv_addr.sin_addr.s_addr = INADDR_ANY;
1033 serv_addr.sin_port = htons(port);
1035 n = bind(sockfd, (struct sockaddr *) &serv_addr,
1038 fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
1043 wsi = malloc(sizeof(struct libwebsocket));
1044 memset(wsi, 0, sizeof (struct libwebsocket));
1046 wsi->mode = LWS_CONNMODE_SERVER_LISTENER;
1047 insert_wsi(this, wsi);
1050 fprintf(stderr, " Listening on port %d\n", port);
1052 /* list in the internal poll array */
1054 this->fds[this->fds_count].fd = sockfd;
1055 this->fds[this->fds_count++].events = POLLIN;
1057 /* external POLL support via protocol 0 */
1058 this->protocols[0].callback(wsi,
1059 LWS_CALLBACK_ADD_POLL_FD,
1060 (void *)(long)sockfd, NULL, POLLIN);
1064 /* drop any root privs for this process */
1068 fprintf(stderr, "setgid: %s\n", strerror(errno));
1071 fprintf(stderr, "setuid: %s\n", strerror(errno));
1074 /* set up our internal broadcast trigger sockets per-protocol */
1076 for (this->count_protocols = 0;
1077 protocols[this->count_protocols].callback;
1078 this->count_protocols++) {
1079 protocols[this->count_protocols].owning_server = this;
1080 protocols[this->count_protocols].protocol_index =
1081 this->count_protocols;
1083 fd = socket(AF_INET, SOCK_STREAM, 0);
1085 fprintf(stderr, "ERROR opening socket");
1089 /* allow us to restart even if old sockets in TIME_WAIT */
1090 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
1092 bzero((char *) &serv_addr, sizeof(serv_addr));
1093 serv_addr.sin_family = AF_INET;
1094 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
1095 serv_addr.sin_port = 0; /* pick the port for us */
1097 n = bind(fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
1099 fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
1104 slen = sizeof cli_addr;
1105 n = getsockname(fd, (struct sockaddr *)&cli_addr, &slen);
1107 fprintf(stderr, "getsockname failed\n");
1110 protocols[this->count_protocols].broadcast_socket_port =
1111 ntohs(cli_addr.sin_port);
1114 debug(" Protocol %s broadcast socket %d\n",
1115 protocols[this->count_protocols].name,
1116 ntohs(cli_addr.sin_port));
1118 /* dummy wsi per broadcast proxy socket */
1120 wsi = malloc(sizeof(struct libwebsocket));
1121 memset(wsi, 0, sizeof (struct libwebsocket));
1123 wsi->mode = LWS_CONNMODE_BROADCAST_PROXY_LISTENER;
1124 /* note which protocol we are proxying */
1125 wsi->protocol_index_for_broadcast_proxy = this->count_protocols;
1126 insert_wsi(this, wsi);
1128 /* list in internal poll array */
1130 this->fds[this->fds_count].fd = fd;
1131 this->fds[this->fds_count].events = POLLIN;
1132 this->fds[this->fds_count].revents = 0;
1135 /* external POLL support via protocol 0 */
1136 this->protocols[0].callback(wsi,
1137 LWS_CALLBACK_ADD_POLL_FD,
1138 (void *)(long)fd, NULL, POLLIN);
1148 * libwebsockets_fork_service_loop() - Optional helper function forks off
1149 * a process for the websocket server loop.
1150 * You don't have to use this but if not, you
1151 * have to make sure you are calling
1152 * libwebsocket_service periodically to service
1153 * the websocket traffic
1154 * @this: server context returned by creation function
1158 libwebsockets_fork_service_loop(struct libwebsocket_context *this)
1161 struct sockaddr_in cli_addr;
1171 /* main process context */
1174 * set up the proxy sockets to allow broadcast from
1175 * service process context
1178 for (p = 0; p < this->count_protocols; p++) {
1179 fd = socket(AF_INET, SOCK_STREAM, 0);
1181 fprintf(stderr, "Unable to create socket\n");
1184 cli_addr.sin_family = AF_INET;
1185 cli_addr.sin_port = htons(
1186 this->protocols[p].broadcast_socket_port);
1187 cli_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
1188 n = connect(fd, (struct sockaddr *)&cli_addr,
1191 fprintf(stderr, "Unable to connect to "
1192 "broadcast socket %d, %s\n",
1193 n, strerror(errno));
1197 this->protocols[p].broadcast_socket_user_fd = fd;
1203 /* we want a SIGHUP when our parent goes down */
1204 prctl(PR_SET_PDEATHSIG, SIGHUP);
1206 /* in this forked process, sit and service websocket connections */
1209 if (libwebsocket_service(this, 1000))
1218 * libwebsockets_get_protocol() - Returns a protocol pointer from a websocket
1220 * @wsi: pointer to struct websocket you want to know the protocol of
1223 * This is useful to get the protocol to broadcast back to from inside
1227 const struct libwebsocket_protocols *
1228 libwebsockets_get_protocol(struct libwebsocket *wsi)
1230 return wsi->protocol;
1234 * libwebsockets_broadcast() - Sends a buffer to the callback for all active
1235 * connections of the given protocol.
1236 * @protocol: pointer to the protocol you will broadcast to all members of
1237 * @buf: buffer containing the data to be broadcase. NOTE: this has to be
1238 * allocated with LWS_SEND_BUFFER_PRE_PADDING valid bytes before
1239 * the pointer and LWS_SEND_BUFFER_POST_PADDING afterwards in the
1240 * case you are calling this function from callback context.
1241 * @len: length of payload data in buf, starting from buf.
1243 * This function allows bulk sending of a packet to every connection using
1244 * the given protocol. It does not send the data directly; instead it calls
1245 * the callback with a reason type of LWS_CALLBACK_BROADCAST. If the callback
1246 * wants to actually send the data for that connection, the callback itself
1247 * should call libwebsocket_write().
1249 * libwebsockets_broadcast() can be called from another fork context without
1250 * having to take any care about data visibility between the processes, it'll
1256 libwebsockets_broadcast(const struct libwebsocket_protocols *protocol,
1257 unsigned char *buf, size_t len)
1259 struct libwebsocket_context *this = protocol->owning_server;
1262 struct libwebsocket * wsi;
1264 if (!protocol->broadcast_socket_user_fd) {
1266 * We are either running unforked / flat, or we are being
1267 * called from poll thread context
1268 * eg, from a callback. In that case don't use sockets for
1269 * broadcast IPC (since we can't open a socket connection to
1270 * a socket listening on our own thread) but directly do the
1273 * Locking is not needed because we are by definition being
1274 * called in the poll thread context and are serialized.
1277 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
1279 for (m = 0; m < this->fd_hashtable[n].length; m++) {
1281 wsi = this->fd_hashtable[n].wsi[m];
1283 if (wsi->mode != LWS_CONNMODE_WS_SERVING)
1287 * never broadcast to
1288 * non-established connections
1290 if (wsi->state != WSI_STATE_ESTABLISHED)
1293 /* only broadcast to guys using
1294 * requested protocol
1296 if (wsi->protocol != protocol)
1299 wsi->protocol->callback(wsi,
1300 LWS_CALLBACK_BROADCAST,
1310 * We're being called from a different process context than the server
1311 * loop. Instead of broadcasting directly, we send our
1312 * payload on a socket to do the IPC; the server process will serialize
1313 * the broadcast action in its main poll() loop.
1315 * There's one broadcast socket listening for each protocol supported
1316 * set up when the websocket server initializes
1319 n = send(protocol->broadcast_socket_user_fd, buf, len, MSG_NOSIGNAL);