lib/libwebsockets.c

   1 /*
   2  * libwebsockets - small server side websockets and web server implementation
   3  *
   4  * Copyright (C) 2010 Andy Green <andy@warmcat.com>
   5  *
   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.
  10  *
  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.
  15  *
  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,
  19  *  MA  02110-1301  USA
  20  */
  21
  22 #include "private-libwebsockets.h"
  23
  24 #ifdef WIN32
  25
  26 #else
  27 #include <ifaddrs.h>
  28 #include <sys/un.h>
  29 #endif
  30
  31 #ifdef LWS_OPENSSL_SUPPORT
  32 int openssl_websocket_private_data_index;
  33 #endif
  34
  35 /*
  36  * In-place str to lower case
  37  */
  38
  39 static void
  40 strtolower(char *s)
  41 {
  42         while (*s) {
  43                 *s = tolower(*s);
  44                 s++;
  45         }
  46 }
  47
  48 /* file descriptor hash management */
  49
  50 struct libwebsocket *
  51 wsi_from_fd(struct libwebsocket_context *context, int fd)
  52 {
  53         int h = LWS_FD_HASH(fd);
  54         int n = 0;
  55
  56         for (n = 0; n < context->fd_hashtable[h].length; n++)
  57                 if (context->fd_hashtable[h].wsi[n]->sock == fd)
  58                         return context->fd_hashtable[h].wsi[n];
  59
  60         return NULL;
  61 }
  62
  63 int
  64 insert_wsi(struct libwebsocket_context *context, struct libwebsocket *wsi)
  65 {
  66         int h = LWS_FD_HASH(wsi->sock);
  67
  68         if (context->fd_hashtable[h].length == MAX_CLIENTS - 1) {
  69                 fprintf(stderr, "hash table overflow\n");
  70                 return 1;
  71         }
  72
  73         context->fd_hashtable[h].wsi[context->fd_hashtable[h].length++] = wsi;
  74
  75         return 0;
  76 }
  77
  78 int
  79 delete_from_fd(struct libwebsocket_context *context, int fd)
  80 {
  81         int h = LWS_FD_HASH(fd);
  82         int n = 0;
  83
  84         for (n = 0; n < context->fd_hashtable[h].length; n++)
  85                 if (context->fd_hashtable[h].wsi[n]->sock == fd) {
  86                         while (n < context->fd_hashtable[h].length) {
  87                                 context->fd_hashtable[h].wsi[n] =
  88                                             context->fd_hashtable[h].wsi[n + 1];
  89                                 n++;
  90                         }
  91                         context->fd_hashtable[h].length--;
  92
  93                         return 0;
  94                 }
  95
  96         fprintf(stderr, "Failed to find fd %d requested for "
  97                                                    "delete in hashtable\n", fd);
  98         return 1;
  99 }
 100
 101 #ifdef LWS_OPENSSL_SUPPORT
 102 static void
 103 libwebsockets_decode_ssl_error(void)
 104 {
 105         char buf[256];
 106         u_long err;
 107
 108         while ((err = ERR_get_error()) != 0) {
 109                 ERR_error_string_n(err, buf, sizeof(buf));
 110                 fprintf(stderr, "*** %s\n", buf);
 111         }
 112 }
 113 #endif
 114
 115
 116 static int
 117 interface_to_sa(const char* ifname, struct sockaddr_in *addr, size_t addrlen)
 118 {
 119         int rc = -1;
 120 #ifdef WIN32
 121         // TODO
 122 #else
 123         struct ifaddrs *ifr;
 124         struct ifaddrs *ifc;
 125         struct sockaddr_in *sin;
 126
 127         getifaddrs(&ifr);
 128         for (ifc = ifr; ifc != NULL; ifc = ifc->ifa_next) {
 129                 if (strcmp(ifc->ifa_name, ifname))
 130                         continue;
 131                 if (ifc->ifa_addr == NULL)
 132                         continue;
 133                 sin = (struct sockaddr_in *)ifc->ifa_addr;
 134                 if (sin->sin_family != AF_INET)
 135                         continue;
 136                 memcpy(addr, sin, addrlen);
 137                 rc = 0;
 138         }
 139
 140         freeifaddrs(ifr);
 141 #endif
 142         return rc;
 143 }
 144
 145 void
 146 libwebsocket_close_and_free_session(struct libwebsocket_context *context,
 147                          struct libwebsocket *wsi, enum lws_close_status reason)
 148 {
 149         int n;
 150         int old_state;
 151         unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 2 +
 152                                                   LWS_SEND_BUFFER_POST_PADDING];
 153         int ret;
 154         int m;
 155         struct lws_tokens eff_buf;
 156
 157         if (!wsi)
 158                 return;
 159
 160         old_state = wsi->state;
 161
 162         if (old_state == WSI_STATE_DEAD_SOCKET)
 163                 return;
 164
 165         wsi->close_reason = reason;
 166
 167         /*
 168          * flush any tx pending from extensions, since we may send close packet
 169          * if there are problems with send, just nuke the connection
 170          */
 171
 172         ret = 1;
 173         while (ret == 1) {
 174
 175                 /* default to nobody has more to spill */
 176
 177                 ret = 0;
 178                 eff_buf.token = NULL;
 179                 eff_buf.token_len = 0;
 180
 181                 /* show every extension the new incoming data */
 182
 183                 for (n = 0; n < wsi->count_active_extensions; n++) {
 184                         m = wsi->active_extensions[n]->callback(
 185                                 wsi->protocol->owning_server, wsi,
 186                                         LWS_EXT_CALLBACK_FLUSH_PENDING_TX,
 187                                    wsi->active_extensions_user[n], &eff_buf, 0);
 188                         if (m < 0) {
 189                                 fprintf(stderr, "Extension reports "
 190                                                                "fatal error\n");
 191                                 goto just_kill_connection;
 192                         }
 193                         if (m)
 194                                 /*
 195                                  * at least one extension told us he has more
 196                                  * to spill, so we will go around again after
 197                                  */
 198                                 ret = 1;
 199                 }
 200
 201                 /* assuming they left us something to send, send it */
 202
 203                 if (eff_buf.token_len)
 204                         if (lws_issue_raw(wsi, (unsigned char *)eff_buf.token,
 205                                                              eff_buf.token_len))
 206                                 goto just_kill_connection;
 207         }
 208
 209         /*
 210          * signal we are closing, libsocket_write will
 211          * add any necessary version-specific stuff.  If the write fails,
 212          * no worries we are closing anyway.  If we didn't initiate this
 213          * close, then our state has been changed to
 214          * WSI_STATE_RETURNED_CLOSE_ALREADY and we will skip this.
 215          *
 216          * Likewise if it's a second call to close this connection after we
 217          * sent the close indication to the peer already, we are in state
 218          * WSI_STATE_AWAITING_CLOSE_ACK and will skip doing this a second time.
 219          */
 220
 221         if (old_state == WSI_STATE_ESTABLISHED &&
 222                                           reason != LWS_CLOSE_STATUS_NOSTATUS) {
 223                 n = libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING],
 224                                                             0, LWS_WRITE_CLOSE);
 225                 if (!n) {
 226                         /*
 227                          * we have sent a nice protocol level indication we
 228                          * now wish to close, we should not send anything more
 229                          */
 230
 231                         wsi->state = WSI_STATE_AWAITING_CLOSE_ACK;
 232
 233                         /* and we should wait for a reply for a bit */
 234
 235                         libwebsocket_set_timeout(wsi,
 236                                                   PENDING_TIMEOUT_CLOSE_ACK, 5);
 237
 238                         fprintf(stderr, "sent close indication, awaiting ack\n");
 239
 240                         return;
 241                 }
 242
 243                 /* else, the send failed and we should just hang up */
 244         }
 245
 246 just_kill_connection:
 247         /*
 248          * we won't be servicing or receiving anything further from this guy
 249          * remove this fd from wsi mapping hashtable
 250          */
 251
 252         delete_from_fd(context, wsi->sock);
 253
 254         /* delete it from the internal poll list if still present */
 255
 256         for (n = 0; n < context->fds_count; n++) {
 257                 if (context->fds[n].fd != wsi->sock)
 258                         continue;
 259                 while (n < context->fds_count - 1) {
 260                         context->fds[n] = context->fds[n + 1];
 261                         n++;
 262                 }
 263                 context->fds_count--;
 264                 /* we only have to deal with one */
 265                 n = context->fds_count;
 266         }
 267
 268         /* remove also from external POLL support via protocol 0 */
 269
 270         context->protocols[0].callback(context, wsi,
 271                     LWS_CALLBACK_DEL_POLL_FD, (void *)(long)wsi->sock, NULL, 0);
 272
 273         wsi->state = WSI_STATE_DEAD_SOCKET;
 274
 275         /* tell the user it's all over for this guy */
 276
 277         if (wsi->protocol && wsi->protocol->callback &&
 278                                              old_state == WSI_STATE_ESTABLISHED)
 279                 wsi->protocol->callback(context, wsi, LWS_CALLBACK_CLOSED,
 280                                                       wsi->user_space, NULL, 0);
 281
 282         /* deallocate any active extension contexts */
 283
 284         for (n = 0; n < wsi->count_active_extensions; n++) {
 285                 if (!wsi->active_extensions[n]->callback)
 286                         continue;
 287
 288                 wsi->active_extensions[n]->callback(context, wsi,
 289                         LWS_EXT_CALLBACK_DESTROY,
 290                         wsi->active_extensions_user[n], NULL, 0);
 291
 292                 free(wsi->active_extensions_user[n]);
 293         }
 294
 295         /* free up his parsing allocations */
 296
 297         for (n = 0; n < WSI_TOKEN_COUNT; n++)
 298                 if (wsi->utf8_token[n].token)
 299                         free(wsi->utf8_token[n].token);
 300
 301 /*      fprintf(stderr, "closing fd=%d\n", wsi->sock); */
 302
 303 #ifdef LWS_OPENSSL_SUPPORT
 304         if (wsi->ssl) {
 305                 n = SSL_get_fd(wsi->ssl);
 306                 SSL_shutdown(wsi->ssl);
 307 #ifdef WIN32
 308                 closesocket(n);
 309 #else
 310                 close(n);
 311 #endif
 312                 SSL_free(wsi->ssl);
 313         } else {
 314 #endif
 315                 shutdown(wsi->sock, SHUT_RDWR);
 316 #ifdef WIN32
 317                 closesocket(wsi->sock);
 318 #else
 319                 close(wsi->sock);
 320 #endif
 321 #ifdef LWS_OPENSSL_SUPPORT
 322         }
 323 #endif
 324         if (wsi->user_space)
 325                 free(wsi->user_space);
 326
 327         free(wsi);
 328 }
 329
 330 /**
 331  * libwebsockets_hangup_on_client() - Server calls to terminate client
 332  *                                      connection
 333  * @context:    libwebsockets context
 334  * @fd:         Connection socket descriptor
 335  */
 336
 337 void
 338 libwebsockets_hangup_on_client(struct libwebsocket_context *context, int fd)
 339 {
 340         struct libwebsocket *wsi = wsi_from_fd(context, fd);
 341
 342         if (wsi == NULL)
 343                 return;
 344
 345         libwebsocket_close_and_free_session(context, wsi,
 346                                                      LWS_CLOSE_STATUS_NOSTATUS);
 347 }
 348
 349
 350 /**
 351  * libwebsockets_get_peer_addresses() - Get client address information
 352  * @fd:         Connection socket descriptor
 353  * @name:       Buffer to take client address name
 354  * @name_len:   Length of client address name buffer
 355  * @rip:        Buffer to take client address IP qotted quad
 356  * @rip_len:    Length of client address IP buffer
 357  *
 358  *      This function fills in @name and @rip with the name and IP of
 359  *      the client connected with socket descriptor @fd.  Names may be
 360  *      truncated if there is not enough room.  If either cannot be
 361  *      determined, they will be returned as valid zero-length strings.
 362  */
 363
 364 void
 365 libwebsockets_get_peer_addresses(int fd, char *name, int name_len,
 366                                         char *rip, int rip_len)
 367 {
 368         unsigned int len;
 369         struct sockaddr_in sin;
 370         struct hostent *host;
 371         struct hostent *host1;
 372         char ip[128];
 373         unsigned char *p;
 374         int n;
 375         struct sockaddr_un *un;
 376
 377         rip[0] = '\0';
 378         name[0] = '\0';
 379
 380         len = sizeof sin;
 381         if (getpeername(fd, (struct sockaddr *) &sin, &len) < 0) {
 382                 perror("getpeername");
 383                 return;
 384         }
 385
 386         host = gethostbyaddr((char *) &sin.sin_addr, sizeof sin.sin_addr,
 387                                                                        AF_INET);
 388         if (host == NULL) {
 389                 perror("gethostbyaddr");
 390                 return;
 391         }
 392
 393         strncpy(name, host->h_name, name_len);
 394         name[name_len - 1] = '\0';
 395
 396         host1 = gethostbyname(host->h_name);
 397         if (host1 == NULL)
 398                 return;
 399         p = (unsigned char *)host1;
 400         n = 0;
 401         while (p != NULL) {
 402                 p = (unsigned char *)host1->h_addr_list[n++];
 403                 if (p == NULL)
 404                         continue;
 405                 if ((host1->h_addrtype != AF_INET) &&
 406                                                 (host1->h_addrtype != AF_LOCAL))
 407                         continue;
 408
 409                 if (host1->h_addrtype == AF_INET)
 410                         sprintf(ip, "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
 411                 else {
 412                         un = (struct sockaddr_un *)p;
 413                         strncpy(ip, un->sun_path, sizeof(ip) -1);
 414                         ip[sizeof(ip) - 1] = '\0';
 415                 }
 416                 p = NULL;
 417                 strncpy(rip, ip, rip_len);
 418                 rip[rip_len - 1] = '\0';
 419         }
 420 }
 421
 422 int libwebsockets_get_random(struct libwebsocket_context *context,
 423                                                              void *buf, int len)
 424 {
 425         int n;
 426         char *p = buf;
 427
 428 #ifdef WIN32
 429         for (n = 0; n < len; n++)
 430                 p[n] = (unsigned char)rand();
 431 #else
 432         n = read(context->fd_random, p, len);
 433 #endif
 434
 435         return n;
 436 }
 437
 438 unsigned char *
 439 libwebsockets_SHA1(const unsigned char *d, size_t n, unsigned char *md)
 440 {
 441         return SHA1(d, n, md);
 442 }
 443
 444 void libwebsockets_00_spaceout(char *key, int spaces, int seed)
 445 {
 446         char *p;
 447
 448         key++;
 449         while (spaces--) {
 450                 if (*key && (seed & 1))
 451                         key++;
 452                 seed >>= 1;
 453
 454                 p = key + strlen(key);
 455                 while (p >= key) {
 456                         p[1] = p[0];
 457                         p--;
 458                 }
 459                 *key++ = ' ';
 460         }
 461 }
 462
 463 void libwebsockets_00_spam(char *key, int count, int seed)
 464 {
 465         char *p;
 466
 467         key++;
 468         while (count--) {
 469
 470                 if (*key && (seed & 1))
 471                         key++;
 472                 seed >>= 1;
 473
 474                 p = key + strlen(key);
 475                 while (p >= key) {
 476                         p[1] = p[0];
 477                         p--;
 478                 }
 479                 *key++ = 0x21 + ((seed & 0xffff) % 15);
 480                 /* 4 would use it up too fast.. not like it matters */
 481                 seed >>= 1;
 482         }
 483 }
 484
 485 int lws_send_pipe_choked(struct libwebsocket *wsi)
 486 {
 487         struct pollfd fds;
 488
 489         fds.fd = wsi->sock;
 490         fds.events = POLLOUT;
 491         fds.revents = 0;
 492
 493         if (poll(&fds, 1, 0) != 1)
 494                 return 1;
 495
 496         if ((fds.revents & POLLOUT) == 0)
 497                 return 1;
 498
 499         /* okay to send another packet without blocking */
 500
 501         return 0;
 502 }
 503
 504 static int
 505 lws_handle_POLLOUT_event(struct libwebsocket_context *context,
 506                                 struct libwebsocket *wsi, struct pollfd *pollfd)
 507 {
 508         struct lws_tokens eff_buf;
 509         int n;
 510         int ret;
 511         int m;
 512
 513         if (!wsi->extension_data_pending)
 514                 goto user_service;
 515
 516         /*
 517          * check in on the active extensions, see if they
 518          * had pending stuff to spill... they need to get the
 519          * first look-in otherwise sequence will be disordered
 520          *
 521          * NULL, zero-length eff_buf means just spill pending
 522          */
 523
 524         ret = 1;
 525         while (ret == 1) {
 526
 527                 /* default to nobody has more to spill */
 528
 529                 ret = 0;
 530                 eff_buf.token = NULL;
 531                 eff_buf.token_len = 0;
 532
 533                 /* give every extension a chance to spill */
 534
 535                 for (n = 0; n < wsi->count_active_extensions; n++) {
 536                         m = wsi->active_extensions[n]->callback(
 537                                 wsi->protocol->owning_server, wsi,
 538                                         LWS_EXT_CALLBACK_PACKET_TX_PRESEND,
 539                                    wsi->active_extensions_user[n], &eff_buf, 0);
 540                         if (m < 0) {
 541                                 fprintf(stderr, "extension reports fatal error\n");
 542                                 return -1;
 543                         }
 544                         if (m)
 545                                 /*
 546                                  * at least one extension told us he has more
 547                                  * to spill, so we will go around again after
 548                                  */
 549                                 ret = 1;
 550                 }
 551
 552                 /* assuming they gave us something to send, send it */
 553
 554                 if (eff_buf.token_len) {
 555                         if (lws_issue_raw(wsi, (unsigned char *)eff_buf.token,
 556                                                              eff_buf.token_len))
 557                                 return -1;
 558                 } else
 559                         continue;
 560
 561                 /* no extension has more to spill */
 562
 563                 if (!ret)
 564                         continue;
 565
 566                 /*
 567                  * There's more to spill from an extension, but we just sent
 568                  * something... did that leave the pipe choked?
 569                  */
 570
 571                 if (!lws_send_pipe_choked(wsi))
 572                         /* no we could add more */
 573                         continue;
 574
 575                 fprintf(stderr, "choked in POLLOUT service\n");
 576
 577                 /*
 578                  * Yes, he's choked.  Leave the POLLOUT masked on so we will
 579                  * come back here when he is unchoked.  Don't call the user
 580                  * callback to enforce ordering of spilling, he'll get called
 581                  * when we come back here and there's nothing more to spill.
 582                  */
 583
 584                 return 0;
 585         }
 586
 587         wsi->extension_data_pending = 0;
 588
 589 user_service:
 590         /* one shot */
 591
 592         pollfd->events &= ~POLLOUT;
 593
 594         /* external POLL support via protocol 0 */
 595         context->protocols[0].callback(context, wsi,
 596                 LWS_CALLBACK_CLEAR_MODE_POLL_FD,
 597                 (void *)(long)wsi->sock, NULL, POLLOUT);
 598
 599         if (wsi->mode == LWS_CONNMODE_WS_CLIENT)
 600                 n = LWS_CALLBACK_CLIENT_WRITEABLE;
 601         else
 602                 n = LWS_CALLBACK_SERVER_WRITEABLE;
 603
 604         wsi->protocol->callback(context, wsi, n, wsi->user_space, NULL, 0);
 605
 606         return 0;
 607 }
 608
 609
 610
 611 /**
 612  * libwebsocket_service_fd() - Service polled socket with something waiting
 613  * @context:    Websocket context
 614  * @pollfd:     The pollfd entry describing the socket fd and which events
 615  *              happened.
 616  *
 617  *      This function closes any active connections and then frees the
 618  *      context.  After calling this, any further use of the context is
 619  *      undefined.
 620  */
 621
 622 int
 623 libwebsocket_service_fd(struct libwebsocket_context *context,
 624                                                           struct pollfd *pollfd)
 625 {
 626         unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 1 + MAX_BROADCAST_PAYLOAD +
 627                                                   LWS_SEND_BUFFER_POST_PADDING];
 628         struct libwebsocket *wsi;
 629         struct libwebsocket *new_wsi;
 630         int n;
 631         int m;
 632         size_t len;
 633         int accept_fd;
 634         unsigned int clilen;
 635         struct sockaddr_in cli_addr;
 636         struct timeval tv;
 637         static const char magic_websocket_guid[] =
 638                                          "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 639         static const char magic_websocket_04_masking_guid[] =
 640                                          "61AC5F19-FBBA-4540-B96F-6561F1AB40A8";
 641         char hash[20];
 642         char pkt[1024];
 643         char *p = &pkt[0];
 644         const char *pc;
 645         const char *c;
 646         int more = 1;
 647         int okay = 0;
 648         char ext_name[128];
 649         struct lws_tokens eff_buf;
 650         int ext_count = 0;
 651         struct libwebsocket_extension *ext;
 652         int opt = 1;
 653
 654 #ifdef LWS_OPENSSL_SUPPORT
 655         char ssl_err_buf[512];
 656 #endif
 657         /*
 658          * you can call us with pollfd = NULL to just allow the once-per-second
 659          * global timeout checks; if less than a second since the last check
 660          * it returns immediately then.
 661          */
 662
 663         gettimeofday(&tv, NULL);
 664
 665         if (context->last_timeout_check_s != tv.tv_sec) {
 666                 context->last_timeout_check_s = tv.tv_sec;
 667
 668                 /* global timeout check once per second */
 669
 670                 for (n = 0; n < context->fds_count; n++) {
 671                         wsi = wsi_from_fd(context, context->fds[n].fd);
 672                         if (!wsi->pending_timeout)
 673                                 continue;
 674
 675                         /*
 676                          * if we went beyond the allowed time, kill the
 677                          * connection
 678                          */
 679
 680                         if (tv.tv_sec > wsi->pending_timeout_limit) {
 681                                 fprintf(stderr, "TIMEDOUT WAITING\n");
 682                                 libwebsocket_close_and_free_session(context,
 683                                                 wsi, LWS_CLOSE_STATUS_NOSTATUS);
 684                         }
 685                 }
 686         }
 687
 688         /* just here for timeout management? */
 689
 690         if (pollfd == NULL)
 691                 return 0;
 692
 693         /* no, here to service a socket descriptor */
 694
 695         wsi = wsi_from_fd(context, pollfd->fd);
 696
 697         if (wsi == NULL)
 698                 return 1;
 699
 700         switch (wsi->mode) {
 701         case LWS_CONNMODE_SERVER_LISTENER:
 702
 703                 /* pollin means a client has connected to us then */
 704
 705                 if (!pollfd->revents & POLLIN)
 706                         break;
 707
 708                 /* listen socket got an unencrypted connection... */
 709
 710                 clilen = sizeof(cli_addr);
 711                 accept_fd  = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
 712                                                                        &clilen);
 713                 if (accept_fd < 0) {
 714                         fprintf(stderr, "ERROR on accept");
 715                         break;
 716                 }
 717
 718                 /* Disable Nagle */
 719                 opt = 1;
 720                 setsockopt(accept_fd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
 721
 722                 if (context->fds_count >= MAX_CLIENTS) {
 723                         fprintf(stderr, "too busy to accept new client\n");
 724 #ifdef WIN32
 725                         closesocket(accept_fd);
 726 #else
 727                         close(accept_fd);
 728 #endif
 729                         break;
 730                 }
 731
 732                 /*
 733                  * look at who we connected to and give user code a chance
 734                  * to reject based on client IP.  There's no protocol selected
 735                  * yet so we issue this to protocols[0]
 736                  */
 737
 738                 if ((context->protocols[0].callback)(context, wsi,
 739                                 LWS_CALLBACK_FILTER_NETWORK_CONNECTION,
 740                                              (void*)(long)accept_fd, NULL, 0)) {
 741                         fprintf(stderr, "Callback denied network connection\n");
 742 #ifdef WIN32
 743                         closesocket(accept_fd);
 744 #else
 745                         close(accept_fd);
 746 #endif
 747                         break;
 748                 }
 749
 750                 /* accepting connection to main listener */
 751
 752                 new_wsi = malloc(sizeof(struct libwebsocket));
 753                 if (new_wsi == NULL) {
 754                         fprintf(stderr, "Out of memory for new connection\n");
 755                         break;
 756                 }
 757
 758                 memset(new_wsi, 0, sizeof (struct libwebsocket));
 759                 new_wsi->sock = accept_fd;
 760                 new_wsi->count_active_extensions = 0;
 761                 new_wsi->pending_timeout = NO_PENDING_TIMEOUT;
 762
 763 #ifdef LWS_OPENSSL_SUPPORT
 764                 new_wsi->ssl = NULL;
 765
 766                 if (context->use_ssl) {
 767
 768                         new_wsi->ssl = SSL_new(context->ssl_ctx);
 769                         if (new_wsi->ssl == NULL) {
 770                                 fprintf(stderr, "SSL_new failed: %s\n",
 771                                     ERR_error_string(SSL_get_error(
 772                                     new_wsi->ssl, 0), NULL));
 773                                     libwebsockets_decode_ssl_error();
 774                                 free(new_wsi);
 775                                 break;
 776                         }
 777
 778                         SSL_set_fd(new_wsi->ssl, accept_fd);
 779
 780                         n = SSL_accept(new_wsi->ssl);
 781                         if (n != 1) {
 782                                 /*
 783                                  * browsers seem to probe with various
 784                                  * ssl params which fail then retry
 785                                  * and succeed
 786                                  */
 787                                 debug("SSL_accept failed skt %u: %s\n",
 788                                       pollfd->fd,
 789                                       ERR_error_string(SSL_get_error(
 790                                       new_wsi->ssl, n), NULL));
 791                                 SSL_free(
 792                                        new_wsi->ssl);
 793                                 free(new_wsi);
 794                                 break;
 795                         }
 796
 797                         debug("accepted new SSL conn  "
 798                               "port %u on fd=%d SSL ver %s\n",
 799                                 ntohs(cli_addr.sin_port), accept_fd,
 800                                   SSL_get_version(new_wsi->ssl));
 801
 802                 } else
 803 #endif
 804                         debug("accepted new conn  port %u on fd=%d\n",
 805                                           ntohs(cli_addr.sin_port), accept_fd);
 806
 807                 /* intialize the instance struct */
 808
 809                 new_wsi->state = WSI_STATE_HTTP;
 810                 new_wsi->name_buffer_pos = 0;
 811                 new_wsi->mode = LWS_CONNMODE_WS_SERVING;
 812
 813                 for (n = 0; n < WSI_TOKEN_COUNT; n++) {
 814                         new_wsi->utf8_token[n].token = NULL;
 815                         new_wsi->utf8_token[n].token_len = 0;
 816                 }
 817
 818                 /*
 819                  * these can only be set once the protocol is known
 820                  * we set an unestablished connection's protocol pointer
 821                  * to the start of the supported list, so it can look
 822                  * for matching ones during the handshake
 823                  */
 824                 new_wsi->protocol = context->protocols;
 825                 new_wsi->user_space = NULL;
 826
 827                 /*
 828                  * Default protocol is 76 / 00
 829                  * After 76, there's a header specified to inform which
 830                  * draft the client wants, when that's seen we modify
 831                  * the individual connection's spec revision accordingly
 832                  */
 833                 new_wsi->ietf_spec_revision = 0;
 834
 835                 insert_wsi(context, new_wsi);
 836
 837                 /*
 838                  * make sure NO events are seen yet on this new socket
 839                  * (otherwise we inherit old fds[client].revents from
 840                  * previous socket there and die mysteriously! )
 841                  */
 842                 context->fds[context->fds_count].revents = 0;
 843
 844                 context->fds[context->fds_count].events = POLLIN;
 845                 context->fds[context->fds_count++].fd = accept_fd;
 846
 847                 /* external POLL support via protocol 0 */
 848                 context->protocols[0].callback(context, new_wsi,
 849                         LWS_CALLBACK_ADD_POLL_FD,
 850                         (void *)(long)accept_fd, NULL, POLLIN);
 851
 852                 break;
 853
 854         case LWS_CONNMODE_BROADCAST_PROXY_LISTENER:
 855
 856                 /* as we are listening, POLLIN means accept() is needed */
 857
 858                 if (!pollfd->revents & POLLIN)
 859                         break;
 860
 861                 /* listen socket got an unencrypted connection... */
 862
 863                 clilen = sizeof(cli_addr);
 864                 accept_fd  = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
 865                                                                        &clilen);
 866                 if (accept_fd < 0) {
 867                         fprintf(stderr, "ERROR on accept");
 868                         break;
 869                 }
 870
 871                 if (context->fds_count >= MAX_CLIENTS) {
 872                         fprintf(stderr, "too busy to accept new broadcast "
 873                                                               "proxy client\n");
 874 #ifdef WIN32
 875                         closesocket(accept_fd);
 876 #else
 877                         close(accept_fd);
 878 #endif
 879                         break;
 880                 }
 881
 882                 /* create a dummy wsi for the connection and add it */
 883
 884                 new_wsi = malloc(sizeof(struct libwebsocket));
 885                 memset(new_wsi, 0, sizeof (struct libwebsocket));
 886                 new_wsi->sock = accept_fd;
 887                 new_wsi->mode = LWS_CONNMODE_BROADCAST_PROXY;
 888                 new_wsi->state = WSI_STATE_ESTABLISHED;
 889                 new_wsi->count_active_extensions = 0;
 890                 /* note which protocol we are proxying */
 891                 new_wsi->protocol_index_for_broadcast_proxy =
 892                                         wsi->protocol_index_for_broadcast_proxy;
 893                 insert_wsi(context, new_wsi);
 894
 895                 /* add connected socket to internal poll array */
 896
 897                 context->fds[context->fds_count].revents = 0;
 898                 context->fds[context->fds_count].events = POLLIN;
 899                 context->fds[context->fds_count++].fd = accept_fd;
 900
 901                 /* external POLL support via protocol 0 */
 902                 context->protocols[0].callback(context, new_wsi,
 903                         LWS_CALLBACK_ADD_POLL_FD,
 904                         (void *)(long)accept_fd, NULL, POLLIN);
 905
 906                 break;
 907
 908         case LWS_CONNMODE_BROADCAST_PROXY:
 909
 910                 /* handle session socket closed */
 911
 912                 if (pollfd->revents & (POLLERR | POLLHUP)) {
 913
 914                         debug("Session Socket %p (fd=%d) dead\n",
 915                                 (void *)wsi, pollfd->fd);
 916
 917                         libwebsocket_close_and_free_session(context, wsi,
 918                                                        LWS_CLOSE_STATUS_NORMAL);
 919                         return 1;
 920                 }
 921
 922                 /*
 923                  * either extension code with stuff to spill, or the user code,
 924                  * requested a callback when it was OK to write
 925                  */
 926
 927                 if (pollfd->revents & POLLOUT)
 928                         if (lws_handle_POLLOUT_event(context, wsi, pollfd) < 0) {
 929                                 libwebsocket_close_and_free_session(context, wsi,
 930                                                        LWS_CLOSE_STATUS_NORMAL);
 931                                 return 1;
 932                         }
 933
 934                 /* any incoming data ready? */
 935
 936                 if (!(pollfd->revents & POLLIN))
 937                         break;
 938
 939                 /* get the issued broadcast payload from the socket */
 940
 941                 len = read(pollfd->fd, buf + LWS_SEND_BUFFER_PRE_PADDING,
 942                                                          MAX_BROADCAST_PAYLOAD);
 943                 if (len < 0) {
 944                         fprintf(stderr, "Error reading broadcast payload\n");
 945                         break;
 946                 }
 947
 948                 /* broadcast it to all guys with this protocol index */
 949
 950                 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
 951
 952                         for (m = 0; m < context->fd_hashtable[n].length; m++) {
 953
 954                                 new_wsi = context->fd_hashtable[n].wsi[m];
 955
 956                                 /* only to clients we are serving to */
 957
 958                                 if (new_wsi->mode != LWS_CONNMODE_WS_SERVING)
 959                                         continue;
 960
 961                                 /*
 962                                  * never broadcast to non-established
 963                                  * connection
 964                                  */
 965
 966                                 if (new_wsi->state != WSI_STATE_ESTABLISHED)
 967                                         continue;
 968
 969                                 /*
 970                                  * only broadcast to connections using
 971                                  * the requested protocol
 972                                  */
 973
 974                                 if (new_wsi->protocol->protocol_index !=
 975                                         wsi->protocol_index_for_broadcast_proxy)
 976                                         continue;
 977
 978                                 /* broadcast it to this connection */
 979
 980                                 new_wsi->protocol->callback(context, new_wsi,
 981                                         LWS_CALLBACK_BROADCAST,
 982                                         new_wsi->user_space,
 983                                         buf + LWS_SEND_BUFFER_PRE_PADDING, len);
 984                         }
 985                 }
 986                 break;
 987
 988         case LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY:
 989
 990                 /* handle proxy hung up on us */
 991
 992                 if (pollfd->revents & (POLLERR | POLLHUP)) {
 993
 994                         fprintf(stderr, "Proxy connection %p (fd=%d) dead\n",
 995                                 (void *)wsi, pollfd->fd);
 996
 997                         libwebsocket_close_and_free_session(context, wsi,
 998                                                      LWS_CLOSE_STATUS_NOSTATUS);
 999                         return 1;
1000                 }
1001
1002                 n = recv(wsi->sock, pkt, sizeof pkt, 0);
1003                 if (n < 0) {
1004                         libwebsocket_close_and_free_session(context, wsi,
1005                                                      LWS_CLOSE_STATUS_NOSTATUS);
1006                         fprintf(stderr, "ERROR reading from proxy socket\n");
1007                         return 1;
1008                 }
1009
1010                 pkt[13] = '\0';
1011                 if (strcmp(pkt, "HTTP/1.0 200 ") != 0) {
1012                         libwebsocket_close_and_free_session(context, wsi,
1013                                                      LWS_CLOSE_STATUS_NOSTATUS);
1014                         fprintf(stderr, "ERROR from proxy: %s\n", pkt);
1015                         return 1;
1016                 }
1017
1018                 /* clear his proxy connection timeout */
1019
1020                 libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
1021
1022                 /* fallthru */
1023
1024         case LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE:
1025
1026         #ifdef LWS_OPENSSL_SUPPORT
1027                 if (wsi->use_ssl) {
1028
1029                         wsi->ssl = SSL_new(context->ssl_client_ctx);
1030                         wsi->client_bio = BIO_new_socket(wsi->sock,
1031                                                                    BIO_NOCLOSE);
1032                         SSL_set_bio(wsi->ssl, wsi->client_bio, wsi->client_bio);
1033
1034                         SSL_set_ex_data(wsi->ssl,
1035                                         openssl_websocket_private_data_index,
1036                                                                        context);
1037
1038                         if (SSL_connect(wsi->ssl) <= 0) {
1039                                 fprintf(stderr, "SSL connect error %s\n",
1040                                         ERR_error_string(ERR_get_error(),
1041                                                                   ssl_err_buf));
1042                                 libwebsocket_close_and_free_session(context, wsi,
1043                                                      LWS_CLOSE_STATUS_NOSTATUS);
1044                                 return 1;
1045                         }
1046
1047                         n = SSL_get_verify_result(wsi->ssl);
1048                         if ((n != X509_V_OK) && (
1049                                 n != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT ||
1050                                                            wsi->use_ssl != 2)) {
1051
1052                                 fprintf(stderr, "server's cert didn't "
1053                                                            "look good %d\n", n);
1054                                 libwebsocket_close_and_free_session(context,
1055                                                 wsi, LWS_CLOSE_STATUS_NOSTATUS);
1056                                 return 1;
1057                         }
1058                 } else {
1059                         wsi->ssl = NULL;
1060         #endif
1061
1062
1063         #ifdef LWS_OPENSSL_SUPPORT
1064                 }
1065         #endif
1066
1067                 /*
1068                  * create the random key
1069                  */
1070
1071                 n = libwebsockets_get_random(context, hash, 16);
1072                 if (n != 16) {
1073                         fprintf(stderr, "Unable to read from random dev %s\n",
1074                                                         SYSTEM_RANDOM_FILEPATH);
1075                         free(wsi->c_path);
1076                         free(wsi->c_host);
1077                         if (wsi->c_origin)
1078                                 free(wsi->c_origin);
1079                         if (wsi->c_protocol)
1080                                 free(wsi->c_protocol);
1081                         libwebsocket_close_and_free_session(context, wsi,
1082                                                      LWS_CLOSE_STATUS_NOSTATUS);
1083                         return 1;
1084                 }
1085
1086                 lws_b64_encode_string(hash, 16, wsi->key_b64,
1087                                                            sizeof wsi->key_b64);
1088
1089                 /*
1090                  * 00 example client handshake
1091                  *
1092                  * GET /socket.io/websocket HTTP/1.1
1093                  * Upgrade: WebSocket
1094                  * Connection: Upgrade
1095                  * Host: 127.0.0.1:9999
1096                  * Origin: http://127.0.0.1
1097                  * Sec-WebSocket-Key1: 1 0 2#0W 9 89 7  92 ^
1098                  * Sec-WebSocket-Key2: 7 7Y 4328 B2v[8(z1
1099                  * Cookie: socketio=websocket
1100                  *
1101                  * (Á®Ä0¶†≥
1102                  *
1103                  * 04 example client handshake
1104                  *
1105                  * GET /chat HTTP/1.1
1106                  * Host: server.example.com
1107                  * Upgrade: websocket
1108                  * Connection: Upgrade
1109                  * Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
1110                  * Sec-WebSocket-Origin: http://example.com
1111                  * Sec-WebSocket-Protocol: chat, superchat
1112                  * Sec-WebSocket-Version: 4
1113                  */
1114
1115                 p += sprintf(p, "GET %s HTTP/1.1\x0d\x0a", wsi->c_path);
1116
1117                 if (wsi->ietf_spec_revision == 0) {
1118                         unsigned char spaces_1, spaces_2;
1119                         unsigned int max_1, max_2;
1120                         unsigned int num_1, num_2;
1121                         unsigned long product_1, product_2;
1122                         char key_1[40];
1123                         char key_2[40];
1124                         unsigned int seed;
1125                         unsigned int count;
1126                         char challenge[16];
1127
1128                         libwebsockets_get_random(context, &spaces_1,
1129                                                                   sizeof(char));
1130                         libwebsockets_get_random(context, &spaces_2,
1131                                                                   sizeof(char));
1132
1133                         spaces_1 = (spaces_1 % 12) + 1;
1134                         spaces_2 = (spaces_2 % 12) + 1;
1135
1136                         max_1 = 4294967295 / spaces_1;
1137                         max_2 = 4294967295 / spaces_2;
1138
1139                         libwebsockets_get_random(context, &num_1, sizeof(int));
1140                         libwebsockets_get_random(context, &num_2, sizeof(int));
1141
1142                         num_1 = (num_1 % max_1);
1143                         num_2 = (num_2 % max_2);
1144
1145                         challenge[0] = num_1 >> 24;
1146                         challenge[1] = num_1 >> 16;
1147                         challenge[2] = num_1 >> 8;
1148                         challenge[3] = num_1;
1149                         challenge[4] = num_2 >> 24;
1150                         challenge[5] = num_2 >> 16;
1151                         challenge[6] = num_2 >> 8;
1152                         challenge[7] = num_2;
1153
1154                         product_1 = num_1 * spaces_1;
1155                         product_2 = num_2 * spaces_2;
1156
1157                         sprintf(key_1, "%lu", product_1);
1158                         sprintf(key_2, "%lu", product_2);
1159
1160                         libwebsockets_get_random(context, &seed, sizeof(int));
1161                         libwebsockets_get_random(context, &count, sizeof(int));
1162
1163                         libwebsockets_00_spam(key_1, (count % 12) + 1, seed);
1164
1165                         libwebsockets_get_random(context, &seed, sizeof(int));
1166                         libwebsockets_get_random(context, &count, sizeof(int));
1167
1168                         libwebsockets_00_spam(key_2, (count % 12) + 1, seed);
1169
1170                         libwebsockets_get_random(context, &seed, sizeof(int));
1171
1172                         libwebsockets_00_spaceout(key_1, spaces_1, seed);
1173                         libwebsockets_00_spaceout(key_2, spaces_2, seed >> 16);
1174
1175                         p += sprintf(p, "Upgrade: websocket\x0d\x0a"
1176                                 "Connection: Upgrade\x0d\x0aHost: %s\x0d\x0a",
1177                                 wsi->c_host);
1178                         if (wsi->c_origin)
1179                                 p += sprintf(p, "Origin: %s\x0d\x0a",
1180                                 wsi->c_origin);
1181
1182                         if (wsi->c_protocol)
1183                                 p += sprintf(p, "Sec-WebSocket-Protocol: %s"
1184                                                  "\x0d\x0a", wsi->c_protocol);
1185
1186                         p += sprintf(p, "Sec-WebSocket-Key1: %s\x0d\x0a",
1187                                 key_1);
1188                         p += sprintf(p, "Sec-WebSocket-Key2: %s\x0d\x0a",
1189                                 key_2);
1190
1191                         /* give userland a chance to append, eg, cookies */
1192
1193                         context->protocols[0].callback(context, wsi,
1194                                 LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
1195                                         NULL, &p, (pkt + sizeof(pkt)) - p - 12);
1196
1197                         p += sprintf(p, "\x0d\x0a");
1198
1199                         if (libwebsockets_get_random(context, p, 8) != 8)
1200                                 return -1;
1201                         memcpy(&challenge[8], p, 8);
1202                         p += 8;
1203
1204                         /* precompute what we want to see from the server */
1205
1206                         MD5((unsigned char *)challenge, 16,
1207                            (unsigned char *)wsi->initial_handshake_hash_base64);
1208
1209                         goto issue_hdr;
1210                 }
1211
1212                 p += sprintf(p, "Host: %s\x0d\x0a", wsi->c_host);
1213                 p += sprintf(p, "Upgrade: websocket\x0d\x0a");
1214                 p += sprintf(p, "Connection: Upgrade\x0d\x0a"
1215                                         "Sec-WebSocket-Key: ");
1216                 strcpy(p, wsi->key_b64);
1217                 p += strlen(wsi->key_b64);
1218                 p += sprintf(p, "\x0d\x0a");
1219                 if (wsi->c_origin)
1220                         p += sprintf(p, "Sec-WebSocket-Origin: %s\x0d\x0a",
1221                                                                  wsi->c_origin);
1222                 if (wsi->c_protocol)
1223                         p += sprintf(p, "Sec-WebSocket-Protocol: %s\x0d\x0a",
1224                                                                wsi->c_protocol);
1225
1226                 /* tell the server what extensions we could support */
1227
1228                 p += sprintf(p, "Sec-WebSocket-Extensions: ");
1229
1230                 ext =context->extensions;
1231                 while (ext && ext->callback) {
1232
1233                         n = 0;
1234                         n = context->protocols[0].callback(context, wsi,
1235                                 LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED,
1236                                         wsi->user_space, (char *)ext->name, 0);
1237
1238                         /*
1239                          * zero return from callback means
1240                          * go ahead and allow the extension,
1241                          * it's what we get if the callback is
1242                          * unhandled
1243                          */
1244
1245                         if (n) {
1246                                 ext++;
1247                                 continue;
1248                         }
1249
1250                         /* apply it */
1251
1252                         if (ext_count)
1253                                 *p++ = ',';
1254                         p += sprintf(p, "%s", ext->name);
1255                         ext_count++;
1256
1257                         ext++;
1258                 }
1259
1260                 p += sprintf(p, "\x0d\x0a");
1261
1262                 if (wsi->ietf_spec_revision)
1263                         p += sprintf(p, "Sec-WebSocket-Version: %d\x0d\x0a",
1264                                                        wsi->ietf_spec_revision);
1265
1266                 /* give userland a chance to append, eg, cookies */
1267
1268                 context->protocols[0].callback(context, wsi,
1269                         LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
1270                         NULL, &p, (pkt + sizeof(pkt)) - p - 12);
1271
1272                 p += sprintf(p, "\x0d\x0a");
1273
1274                 /* prepare the expected server accept response */
1275
1276                 strcpy((char *)buf, wsi->key_b64);
1277                 strcpy((char *)&buf[strlen((char *)buf)], magic_websocket_guid);
1278
1279                 SHA1(buf, strlen((char *)buf), (unsigned char *)hash);
1280
1281                 lws_b64_encode_string(hash, 20,
1282                                 wsi->initial_handshake_hash_base64,
1283                                      sizeof wsi->initial_handshake_hash_base64);
1284
1285 issue_hdr:
1286
1287                 /* done with these now */
1288
1289                 free(wsi->c_path);
1290                 free(wsi->c_host);
1291                 if (wsi->c_origin)
1292                         free(wsi->c_origin);
1293
1294                 /* send our request to the server */
1295
1296         #ifdef LWS_OPENSSL_SUPPORT
1297                 if (wsi->use_ssl)
1298                         n = SSL_write(wsi->ssl, pkt, p - pkt);
1299                 else
1300         #endif
1301                         n = send(wsi->sock, pkt, p - pkt, 0);
1302
1303                 if (n < 0) {
1304                         fprintf(stderr, "ERROR writing to client socket\n");
1305                         libwebsocket_close_and_free_session(context, wsi,
1306                                                      LWS_CLOSE_STATUS_NOSTATUS);
1307                         return 1;
1308                 }
1309
1310                 wsi->parser_state = WSI_TOKEN_NAME_PART;
1311                 wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY;
1312                 libwebsocket_set_timeout(wsi,
1313                                 PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE, 5);
1314
1315                 break;
1316
1317         case LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY:
1318
1319                 /* handle server hung up on us */
1320
1321                 if (pollfd->revents & (POLLERR | POLLHUP)) {
1322
1323                         fprintf(stderr, "Server connection %p (fd=%d) dead\n",
1324                                 (void *)wsi, pollfd->fd);
1325
1326                         goto bail3;
1327                 }
1328
1329
1330                 /* interpret the server response */
1331
1332                 /*
1333                  *  HTTP/1.1 101 Switching Protocols
1334                  *  Upgrade: websocket
1335                  *  Connection: Upgrade
1336                  *  Sec-WebSocket-Accept: me89jWimTRKTWwrS3aRrL53YZSo=
1337                  *  Sec-WebSocket-Nonce: AQIDBAUGBwgJCgsMDQ4PEC==
1338                  *  Sec-WebSocket-Protocol: chat
1339                  */
1340
1341         #ifdef LWS_OPENSSL_SUPPORT
1342                 if (wsi->use_ssl)
1343                         len = SSL_read(wsi->ssl, pkt, sizeof pkt);
1344                 else
1345         #endif
1346                         len = recv(wsi->sock, pkt, sizeof pkt, 0);
1347
1348                 if (len < 0) {
1349                         fprintf(stderr,
1350                                   "libwebsocket_client_handshake read error\n");
1351                         goto bail3;
1352                 }
1353
1354                 p = pkt;
1355                 for (n = 0; n < len; n++)
1356                         libwebsocket_parse(wsi, *p++);
1357
1358                 if (wsi->parser_state != WSI_PARSING_COMPLETE) {
1359                         fprintf(stderr, "libwebsocket_client_handshake "
1360                                         "server response failed parsing\n");
1361                         goto bail3;
1362                 }
1363
1364                 /*
1365                  * 00 / 76 -->
1366                  *
1367                  * HTTP/1.1 101 WebSocket Protocol Handshake
1368                  * Upgrade: WebSocket
1369                  * Connection: Upgrade
1370                  * Sec-WebSocket-Origin: http://127.0.0.1
1371                  * Sec-WebSocket-Location: ws://127.0.0.1:9999/socket.io/websocket
1372                  *
1373                  * xxxxxxxxxxxxxxxx
1374                  */
1375
1376                 if (wsi->ietf_spec_revision == 0) {
1377                         if (!wsi->utf8_token[WSI_TOKEN_HTTP].token_len ||
1378                             !wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len ||
1379                             !wsi->utf8_token[WSI_TOKEN_CHALLENGE].token_len ||
1380                             !wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len ||
1381                             (!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len &&
1382                             wsi->c_protocol != NULL)) {
1383                                 fprintf(stderr, "libwebsocket_client_handshake "
1384                                                 "missing required header(s)\n");
1385                                 pkt[len] = '\0';
1386                                 fprintf(stderr, "%s", pkt);
1387                                 goto bail3;
1388                         }
1389
1390                         strtolower(wsi->utf8_token[WSI_TOKEN_HTTP].token);
1391                         if (strcmp(wsi->utf8_token[WSI_TOKEN_HTTP].token,
1392                                 "101 websocket protocol handshake")) {
1393                                 fprintf(stderr, "libwebsocket_client_handshake "
1394                                         "server sent bad HTTP response '%s'\n",
1395                                         wsi->utf8_token[WSI_TOKEN_HTTP].token);
1396                                 goto bail3;
1397                         }
1398
1399                         if (wsi->utf8_token[WSI_TOKEN_CHALLENGE].token_len <
1400                                                                            16) {
1401                                 fprintf(stderr, "libwebsocket_client_handshake "
1402                                         "challenge reply too short %d\n",
1403                                         wsi->utf8_token[
1404                                                 WSI_TOKEN_CHALLENGE].token_len);
1405                                 pkt[len] = '\0';
1406                                 fprintf(stderr, "%s", pkt);
1407                                 goto bail3;
1408
1409                         }
1410
1411                         goto select_protocol;
1412                 }
1413
1414                 /*
1415                  * well, what the server sent looked reasonable for syntax.
1416                  * Now let's confirm it sent all the necessary headers
1417                  */
1418
1419                  if (!wsi->utf8_token[WSI_TOKEN_HTTP].token_len ||
1420                         !wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len ||
1421                         !wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len ||
1422                         !wsi->utf8_token[WSI_TOKEN_ACCEPT].token_len ||
1423                         (!wsi->utf8_token[WSI_TOKEN_NONCE].token_len &&
1424                                            wsi->ietf_spec_revision == 4) ||
1425                         (!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len &&
1426                                                      wsi->c_protocol != NULL)) {
1427                         fprintf(stderr, "libwebsocket_client_handshake "
1428                                                 "missing required header(s)\n");
1429                         pkt[len] = '\0';
1430                         fprintf(stderr, "%s", pkt);
1431                         goto bail3;
1432                 }
1433
1434                 /*
1435                  * Everything seems to be there, now take a closer look at what
1436                  * is in each header
1437                  */
1438
1439                 strtolower(wsi->utf8_token[WSI_TOKEN_HTTP].token);
1440                 if (strcmp(wsi->utf8_token[WSI_TOKEN_HTTP].token,
1441                                                    "101 switching protocols")) {
1442                         fprintf(stderr, "libwebsocket_client_handshake "
1443                                         "server sent bad HTTP response '%s'\n",
1444                                          wsi->utf8_token[WSI_TOKEN_HTTP].token);
1445                         goto bail3;
1446                 }
1447
1448                 strtolower(wsi->utf8_token[WSI_TOKEN_UPGRADE].token);
1449                 if (strcmp(wsi->utf8_token[WSI_TOKEN_UPGRADE].token,
1450                                                                  "websocket")) {
1451                         fprintf(stderr, "libwebsocket_client_handshake server "
1452                                         "sent bad Upgrade header '%s'\n",
1453                                       wsi->utf8_token[WSI_TOKEN_UPGRADE].token);
1454                         goto bail3;
1455                 }
1456
1457                 strtolower(wsi->utf8_token[WSI_TOKEN_CONNECTION].token);
1458                 if (strcmp(wsi->utf8_token[WSI_TOKEN_CONNECTION].token,
1459                                                                    "upgrade")) {
1460                         fprintf(stderr, "libwebsocket_client_handshake server "
1461                                         "sent bad Connection hdr '%s'\n",
1462                                    wsi->utf8_token[WSI_TOKEN_CONNECTION].token);
1463                         goto bail3;
1464                 }
1465
1466 select_protocol:
1467                 pc = wsi->c_protocol;
1468
1469                 /*
1470                  * confirm the protocol the server wants to talk was in the list
1471                  * of protocols we offered
1472                  */
1473
1474                 if (!wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len) {
1475
1476                         /*
1477                          * no protocol name to work from,
1478                          * default to first protocol
1479                          */
1480                         wsi->protocol = &context->protocols[0];
1481
1482                         free(wsi->c_protocol);
1483
1484                         goto check_accept;
1485                 }
1486
1487                 while (*pc && !okay) {
1488                         if ((!strncmp(pc,
1489                                 wsi->utf8_token[WSI_TOKEN_PROTOCOL].token,
1490                            wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len)) &&
1491                  (pc[wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len] == ',' ||
1492                    pc[wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len] == '\0')) {
1493                                 okay = 1;
1494                                 continue;
1495                         }
1496                         while (*pc && *pc != ',')
1497                                 pc++;
1498                         while (*pc && *pc != ' ')
1499                                 pc++;
1500                 }
1501
1502                 /* done with him now */
1503
1504                 if (wsi->c_protocol)
1505                         free(wsi->c_protocol);
1506
1507
1508                 if (!okay) {
1509                         fprintf(stderr, "libwebsocket_client_handshake server "
1510                                                 "sent bad protocol '%s'\n",
1511                                      wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
1512                         goto bail2;
1513                 }
1514
1515                 /*
1516                  * identify the selected protocol struct and set it
1517                  */
1518                 n = 0;
1519                 wsi->protocol = NULL;
1520                 while (context->protocols[n].callback) {
1521                         if (strcmp(wsi->utf8_token[WSI_TOKEN_PROTOCOL].token,
1522                                                context->protocols[n].name) == 0)
1523                                 wsi->protocol = &context->protocols[n];
1524                         n++;
1525                 }
1526
1527                 if (wsi->protocol == NULL) {
1528                         fprintf(stderr, "libwebsocket_client_handshake server "
1529                                         "requested protocol '%s', which we "
1530                                         "said we supported but we don't!\n",
1531                                      wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
1532                         goto bail2;
1533                 }
1534
1535
1536                 /* instantiate the accepted extensions */
1537
1538                 if (!wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len)
1539                         goto check_accept;
1540
1541                 /*
1542                  * break down the list of server accepted extensions
1543                  * and go through matching them or identifying bogons
1544                  */
1545
1546                 c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token;
1547                 n = 0;
1548                 while (more) {
1549
1550                         if (*c && *c != ',') {
1551                                 ext_name[n] = *c++;
1552                                 if (n < sizeof(ext_name) - 1)
1553                                         n++;
1554                                 continue;
1555                         }
1556                         ext_name[n] = '\0';
1557                         if (!*c)
1558                                 more = 0;
1559
1560                         /* check we actually support it */
1561
1562                         n = 0;
1563                         ext = wsi->protocol->owning_server->extensions;
1564                         while (ext && ext->callback) {
1565
1566                                 if (strcmp(ext_name, ext->name)) {
1567                                         ext++;
1568                                         continue;
1569                                 }
1570
1571                                 n = 1;
1572
1573                                 /* instantiate the extension on this conn */
1574
1575                                 wsi->active_extensions_user[
1576                                         wsi->count_active_extensions] =
1577                                              malloc(ext->per_session_data_size);
1578                                 wsi->active_extensions[
1579                                           wsi->count_active_extensions] = ext;
1580
1581                                 /* allow him to construct his context */
1582
1583                                 ext->callback(wsi->protocol->owning_server,
1584                                         wsi, LWS_EXT_CALLBACK_CLIENT_CONSTRUCT,
1585                                                 wsi->active_extensions_user[
1586                                         wsi->count_active_extensions], NULL, 0);
1587
1588                                 wsi->count_active_extensions++;
1589
1590                                 ext++;
1591                         }
1592
1593                         if (n == 0) {
1594                                 fprintf(stderr, "Server said we should use"
1595                                       "an unknown extension '%s'!\n", ext_name);
1596                                 goto bail2;
1597                         }
1598
1599                         n = 0;
1600                 }
1601
1602
1603         check_accept:
1604
1605                 if (wsi->ietf_spec_revision == 0) {
1606
1607                         if (memcmp(wsi->initial_handshake_hash_base64,
1608                               wsi->utf8_token[WSI_TOKEN_CHALLENGE].token, 16)) {
1609                                 fprintf(stderr, "libwebsocket_client_handshake "
1610                                                "failed 00 challenge compare\n");
1611                                         pkt[len] = '\0';
1612                                         fprintf(stderr, "%s", pkt);
1613                                         goto bail2;
1614                         }
1615
1616                         goto accept_ok;
1617                 }
1618
1619                 /*
1620                  * Confirm his accept token is the one we precomputed
1621                  */
1622
1623                 if (strcmp(wsi->utf8_token[WSI_TOKEN_ACCEPT].token,
1624                                           wsi->initial_handshake_hash_base64)) {
1625                         fprintf(stderr, "libwebsocket_client_handshake server "
1626                                 "sent bad ACCEPT '%s' vs computed '%s'\n",
1627                                 wsi->utf8_token[WSI_TOKEN_ACCEPT].token,
1628                                             wsi->initial_handshake_hash_base64);
1629                         goto bail2;
1630                 }
1631
1632                 if (wsi->ietf_spec_revision == 4) {
1633                         /*
1634                          * Calculate the 04 masking key to use when
1635                          * sending data to server
1636                          */
1637
1638                         strcpy((char *)buf, wsi->key_b64);
1639                         p = (char *)buf + strlen(wsi->key_b64);
1640                         strcpy(p, wsi->utf8_token[WSI_TOKEN_NONCE].token);
1641                         p += wsi->utf8_token[WSI_TOKEN_NONCE].token_len;
1642                         strcpy(p, magic_websocket_04_masking_guid);
1643                         SHA1(buf, strlen((char *)buf), wsi->masking_key_04);
1644                 }
1645 accept_ok:
1646
1647                 /* allocate the per-connection user memory (if any) */
1648
1649                 if (wsi->protocol->per_session_data_size) {
1650                         wsi->user_space = malloc(
1651                                           wsi->protocol->per_session_data_size);
1652                         if (wsi->user_space  == NULL) {
1653                                 fprintf(stderr, "Out of memory for "
1654                                                            "conn user space\n");
1655                                 goto bail2;
1656                         }
1657                 } else
1658                         wsi->user_space = NULL;
1659
1660                 /* clear his proxy connection timeout */
1661
1662                 libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
1663
1664                 /* mark him as being alive */
1665
1666                 wsi->state = WSI_STATE_ESTABLISHED;
1667                 wsi->mode = LWS_CONNMODE_WS_CLIENT;
1668
1669                 fprintf(stderr, "handshake OK for protocol %s\n",
1670                                                            wsi->protocol->name);
1671
1672                 /* call him back to inform him he is up */
1673
1674                 wsi->protocol->callback(context, wsi,
1675                                  LWS_CALLBACK_CLIENT_ESTABLISHED,
1676                                  wsi->user_space,
1677                                  NULL, 0);
1678
1679                 break;
1680
1681 bail3:
1682                 if (wsi->c_protocol)
1683                         free(wsi->c_protocol);
1684
1685 bail2:
1686                 libwebsocket_close_and_free_session(context, wsi,
1687                                                      LWS_CLOSE_STATUS_NOSTATUS);
1688                 return 1;
1689
1690
1691         case LWS_CONNMODE_WS_SERVING:
1692         case LWS_CONNMODE_WS_CLIENT:
1693
1694                 /* handle session socket closed */
1695
1696                 if (pollfd->revents & (POLLERR | POLLHUP)) {
1697
1698                         fprintf(stderr, "Session Socket %p (fd=%d) dead\n",
1699                                 (void *)wsi, pollfd->fd);
1700
1701                         libwebsocket_close_and_free_session(context, wsi,
1702                                                      LWS_CLOSE_STATUS_NOSTATUS);
1703                         return 1;
1704                 }
1705
1706                 /* the guy requested a callback when it was OK to write */
1707
1708                 if ((pollfd->revents & POLLOUT) &&
1709                                             wsi->state == WSI_STATE_ESTABLISHED)
1710                         if (lws_handle_POLLOUT_event(context, wsi,
1711                                                                   pollfd) < 0) {
1712                                 libwebsocket_close_and_free_session(
1713                                          context, wsi, LWS_CLOSE_STATUS_NORMAL);
1714                                 return 1;
1715                         }
1716
1717
1718                 /* any incoming data ready? */
1719
1720                 if (!(pollfd->revents & POLLIN))
1721                         break;
1722
1723 #ifdef LWS_OPENSSL_SUPPORT
1724                 if (wsi->ssl)
1725                         eff_buf.token_len = SSL_read(wsi->ssl, buf, sizeof buf);
1726                 else
1727 #endif
1728                         eff_buf.token_len =
1729                                            recv(pollfd->fd, buf, sizeof buf, 0);
1730
1731                 if (eff_buf.token_len < 0) {
1732                         fprintf(stderr, "Socket read returned %d\n",
1733                                                             eff_buf.token_len);
1734                         break;
1735                 }
1736                 if (!eff_buf.token_len) {
1737                         libwebsocket_close_and_free_session(context, wsi,
1738                                                      LWS_CLOSE_STATUS_NOSTATUS);
1739                         return 1;
1740                 }
1741
1742                 /*
1743                  * give any active extensions a chance to munge the buffer
1744                  * before parse.  We pass in a pointer to an lws_tokens struct
1745                  * prepared with the default buffer and content length that's in
1746                  * there.  Rather than rewrite the default buffer, extensions
1747                  * that expect to grow the buffer can adapt .token to
1748                  * point to their own per-connection buffer in the extension
1749                  * user allocation.  By default with no extensions or no
1750                  * extension callback handling, just the normal input buffer is
1751                  * used then so it is efficient.
1752                  */
1753
1754                 eff_buf.token = (char *)buf;
1755
1756                 more = 1;
1757                 while (more) {
1758
1759                         more = 0;
1760
1761                         for (n = 0; n < wsi->count_active_extensions; n++) {
1762                                 m = wsi->active_extensions[n]->callback(context, wsi,
1763                                         LWS_EXT_CALLBACK_PACKET_RX_PREPARSE,
1764                                      wsi->active_extensions_user[n], &eff_buf, 0);
1765                                 if (m < 0) {
1766                                         fprintf(stderr, "Extension reports fatal error\n");
1767                                         libwebsocket_close_and_free_session(context, wsi,
1768                                                              LWS_CLOSE_STATUS_NOSTATUS);
1769                                         return 1;
1770                                 }
1771                                 if (m)
1772                                         more = 1;
1773                         }
1774
1775                         /* service incoming data */
1776
1777                         if (eff_buf.token_len) {
1778                                 n = libwebsocket_read(context, wsi,
1779                                      (unsigned char *)eff_buf.token, eff_buf.token_len);
1780                                 if (n < 0)
1781                                         /* we closed wsi */
1782                                         return 1;
1783                         }
1784
1785                         eff_buf.token = NULL;
1786                         eff_buf.token_len = 0;
1787                 }
1788                 break;
1789         }
1790
1791         return 0;
1792 }
1793
1794
1795 /**
1796  * libwebsocket_context_destroy() - Destroy the websocket context
1797  * @context:    Websocket context
1798  *
1799  *      This function closes any active connections and then frees the
1800  *      context.  After calling this, any further use of the context is
1801  *      undefined.
1802  */
1803 void
1804 libwebsocket_context_destroy(struct libwebsocket_context *context)
1805 {
1806         int n;
1807         int m;
1808         struct libwebsocket *wsi;
1809
1810         for (n = 0; n < FD_HASHTABLE_MODULUS; n++)
1811                 for (m = 0; m < context->fd_hashtable[n].length; m++) {
1812                         wsi = context->fd_hashtable[n].wsi[m];
1813                         libwebsocket_close_and_free_session(context, wsi,
1814                                                     LWS_CLOSE_STATUS_GOINGAWAY);
1815                 }
1816
1817 #ifdef WIN32
1818 #else
1819         close(context->fd_random);
1820 #endif
1821
1822 #ifdef LWS_OPENSSL_SUPPORT
1823         if (context->ssl_ctx)
1824                 SSL_CTX_free(context->ssl_ctx);
1825         if (context->ssl_client_ctx)
1826                 SSL_CTX_free(context->ssl_client_ctx);
1827 #endif
1828
1829         free(context);
1830
1831 #ifdef WIN32
1832         WSACleanup();
1833 #endif
1834 }
1835
1836 /**
1837  * libwebsocket_service() - Service any pending websocket activity
1838  * @context:    Websocket context
1839  * @timeout_ms: Timeout for poll; 0 means return immediately if nothing needed
1840  *              service otherwise block and service immediately, returning
1841  *              after the timeout if nothing needed service.
1842  *
1843  *      This function deals with any pending websocket traffic, for three
1844  *      kinds of event.  It handles these events on both server and client
1845  *      types of connection the same.
1846  *
1847  *      1) Accept new connections to our context's server
1848  *
1849  *      2) Perform pending broadcast writes initiated from other forked
1850  *         processes (effectively serializing asynchronous broadcasts)
1851  *
1852  *      3) Call the receive callback for incoming frame data received by
1853  *          server or client connections.
1854  *
1855  *      You need to call this service function periodically to all the above
1856  *      functions to happen; if your application is single-threaded you can
1857  *      just call it in your main event loop.
1858  *
1859  *      Alternatively you can fork a new process that asynchronously handles
1860  *      calling this service in a loop.  In that case you are happy if this
1861  *      call blocks your thread until it needs to take care of something and
1862  *      would call it with a large nonzero timeout.  Your loop then takes no
1863  *      CPU while there is nothing happening.
1864  *
1865  *      If you are calling it in a single-threaded app, you don't want it to
1866  *      wait around blocking other things in your loop from happening, so you
1867  *      would call it with a timeout_ms of 0, so it returns immediately if
1868  *      nothing is pending, or as soon as it services whatever was pending.
1869  */
1870
1871
1872 int
1873 libwebsocket_service(struct libwebsocket_context *context, int timeout_ms)
1874 {
1875         int n;
1876
1877         /* stay dead once we are dead */
1878
1879         if (context == NULL)
1880                 return 1;
1881
1882         /* wait for something to need service */
1883
1884         n = poll(context->fds, context->fds_count, timeout_ms);
1885         if (n == 0) /* poll timeout */
1886                 return 0;
1887
1888         if (n < 0) {
1889                 /*
1890                 fprintf(stderr, "Listen Socket dead\n");
1891                 */
1892                 return 1;
1893         }
1894
1895         /* handle accept on listening socket? */
1896
1897         for (n = 0; n < context->fds_count; n++)
1898                 if (context->fds[n].revents)
1899                         libwebsocket_service_fd(context, &context->fds[n]);
1900
1901         return 0;
1902 }
1903
1904 /**
1905  * libwebsocket_callback_on_writable() - Request a callback when this socket
1906  *                                       becomes able to be written to without
1907  *                                       blocking
1908  *
1909  * @context:    libwebsockets context
1910  * @wsi:        Websocket connection instance to get callback for
1911  */
1912
1913 int
1914 libwebsocket_callback_on_writable(struct libwebsocket_context *context,
1915                                                        struct libwebsocket *wsi)
1916 {
1917         int n;
1918
1919         for (n = 0; n < context->fds_count; n++)
1920                 if (context->fds[n].fd == wsi->sock) {
1921                         context->fds[n].events |= POLLOUT;
1922                         n = context->fds_count;
1923                 }
1924
1925         /* external POLL support via protocol 0 */
1926         context->protocols[0].callback(context, wsi,
1927                 LWS_CALLBACK_SET_MODE_POLL_FD,
1928                 (void *)(long)wsi->sock, NULL, POLLOUT);
1929
1930         return 1;
1931 }
1932
1933 /**
1934  * libwebsocket_callback_on_writable_all_protocol() - Request a callback for
1935  *                      all connections using the given protocol when it
1936  *                      becomes possible to write to each socket without
1937  *                      blocking in turn.
1938  *
1939  * @protocol:   Protocol whose connections will get callbacks
1940  */
1941
1942 int
1943 libwebsocket_callback_on_writable_all_protocol(
1944                                   const struct libwebsocket_protocols *protocol)
1945 {
1946         struct libwebsocket_context *context = protocol->owning_server;
1947         int n;
1948         int m;
1949         struct libwebsocket *wsi;
1950
1951         for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
1952
1953                 for (m = 0; m < context->fd_hashtable[n].length; m++) {
1954
1955                         wsi = context->fd_hashtable[n].wsi[m];
1956
1957                         if (wsi->protocol == protocol)
1958                                 libwebsocket_callback_on_writable(context, wsi);
1959                 }
1960         }
1961
1962         return 0;
1963 }
1964
1965 /**
1966  * libwebsocket_set_timeout() - marks the wsi as subject to a timeout
1967  *
1968  * You will not need this unless you are doing something special
1969  *
1970  * @wsi:        Websocket connection instance
1971  * @reason:     timeout reason
1972  * @secs:       how many seconds
1973  */
1974
1975 void
1976 libwebsocket_set_timeout(struct libwebsocket *wsi,
1977                                           enum pending_timeout reason, int secs)
1978 {
1979         struct timeval tv;
1980
1981         gettimeofday(&tv, NULL);
1982
1983         wsi->pending_timeout_limit = tv.tv_sec + secs;
1984         wsi->pending_timeout = reason;
1985 }
1986
1987
1988 /**
1989  * libwebsocket_get_socket_fd() - returns the socket file descriptor
1990  *
1991  * You will not need this unless you are doing something special
1992  *
1993  * @wsi:        Websocket connection instance
1994  */
1995
1996 int
1997 libwebsocket_get_socket_fd(struct libwebsocket *wsi)
1998 {
1999         return wsi->sock;
2000 }
2001
2002 /**
2003  * libwebsocket_rx_flow_control() - Enable and disable socket servicing for
2004  *                              receieved packets.
2005  *
2006  * If the output side of a server process becomes choked, this allows flow
2007  * control for the input side.
2008  *
2009  * @wsi:        Websocket connection instance to get callback for
2010  * @enable:     0 = disable read servicing for this connection, 1 = enable
2011  */
2012
2013 int
2014 libwebsocket_rx_flow_control(struct libwebsocket *wsi, int enable)
2015 {
2016         struct libwebsocket_context *context = wsi->protocol->owning_server;
2017         int n;
2018
2019         for (n = 0; n < context->fds_count; n++)
2020                 if (context->fds[n].fd == wsi->sock) {
2021                         if (enable)
2022                                 context->fds[n].events |= POLLIN;
2023                         else
2024                                 context->fds[n].events &= ~POLLIN;
2025
2026                         return 0;
2027                 }
2028
2029         if (enable)
2030                 /* external POLL support via protocol 0 */
2031                 context->protocols[0].callback(context, wsi,
2032                         LWS_CALLBACK_SET_MODE_POLL_FD,
2033                         (void *)(long)wsi->sock, NULL, POLLIN);
2034         else
2035                 /* external POLL support via protocol 0 */
2036                 context->protocols[0].callback(context, wsi,
2037                         LWS_CALLBACK_CLEAR_MODE_POLL_FD,
2038                         (void *)(long)wsi->sock, NULL, POLLIN);
2039
2040
2041         fprintf(stderr, "libwebsocket_callback_on_writable "
2042                                                      "unable to find socket\n");
2043         return 1;
2044 }
2045
2046 /**
2047  * libwebsocket_canonical_hostname() - returns this host's hostname
2048  *
2049  * This is typically used by client code to fill in the host parameter
2050  * when making a client connection.  You can only call it after the context
2051  * has been created.
2052  *
2053  * @context:    Websocket context
2054  */
2055
2056
2057 extern const char *
2058 libwebsocket_canonical_hostname(struct libwebsocket_context *context)
2059 {
2060         return (const char *)context->canonical_hostname;
2061 }
2062
2063
2064 static void sigpipe_handler(int x)
2065 {
2066 }
2067
2068 #ifdef LWS_OPENSSL_SUPPORT
2069 static int
2070 OpenSSL_verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx)
2071 {
2072
2073         SSL *ssl;
2074         int n;
2075         struct libwebsocket_context *context;
2076
2077         ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
2078                 SSL_get_ex_data_X509_STORE_CTX_idx());
2079
2080         /*
2081          * !!! nasty openssl requires the index to come as a library-scope
2082          * static
2083          */
2084         context = SSL_get_ex_data(ssl, openssl_websocket_private_data_index);
2085
2086         n = context->protocols[0].callback(NULL, NULL,
2087                 LWS_CALLBACK_OPENSSL_PERFORM_CLIENT_CERT_VERIFICATION,
2088                                                    x509_ctx, ssl, preverify_ok);
2089
2090         /* convert return code from 0 = OK to 1 = OK */
2091
2092         if (!n)
2093                 n = 1;
2094         else
2095                 n = 0;
2096
2097         return n;
2098 }
2099 #endif
2100
2101
2102 /**
2103  * libwebsocket_create_context() - Create the websocket handler
2104  * @port:       Port to listen on... you can use 0 to suppress listening on
2105  *              any port, that's what you want if you are not running a
2106  *              websocket server at all but just using it as a client
2107  * @interf:  NULL to bind the listen socket to all interfaces, or the
2108  *              interface name, eg, "eth2"
2109  * @protocols:  Array of structures listing supported protocols and a protocol-
2110  *              specific callback for each one.  The list is ended with an
2111  *              entry that has a NULL callback pointer.
2112  *              It's not const because we write the owning_server member
2113  * @extensions: NULL or array of libwebsocket_extension structs listing the
2114  *              extensions this context supports
2115  * @ssl_cert_filepath:  If libwebsockets was compiled to use ssl, and you want
2116  *                      to listen using SSL, set to the filepath to fetch the
2117  *                      server cert from, otherwise NULL for unencrypted
2118  * @ssl_private_key_filepath: filepath to private key if wanting SSL mode,
2119  *                      else ignored
2120  * @gid:        group id to change to after setting listen socket, or -1.
2121  * @uid:        user id to change to after setting listen socket, or -1.
2122  * @options:    0, or LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK
2123  *
2124  *      This function creates the listening socket and takes care
2125  *      of all initialization in one step.
2126  *
2127  *      After initialization, it returns a struct libwebsocket_context * that
2128  *      represents this server.  After calling, user code needs to take care
2129  *      of calling libwebsocket_service() with the context pointer to get the
2130  *      server's sockets serviced.  This can be done in the same process context
2131  *      or a forked process, or another thread,
2132  *
2133  *      The protocol callback functions are called for a handful of events
2134  *      including http requests coming in, websocket connections becoming
2135  *      established, and data arriving; it's also called periodically to allow
2136  *      async transmission.
2137  *
2138  *      HTTP requests are sent always to the FIRST protocol in @protocol, since
2139  *      at that time websocket protocol has not been negotiated.  Other
2140  *      protocols after the first one never see any HTTP callack activity.
2141  *
2142  *      The server created is a simple http server by default; part of the
2143  *      websocket standard is upgrading this http connection to a websocket one.
2144  *
2145  *      This allows the same server to provide files like scripts and favicon /
2146  *      images or whatever over http and dynamic data over websockets all in
2147  *      one place; they're all handled in the user callback.
2148  */
2149
2150 struct libwebsocket_context *
2151 libwebsocket_create_context(int port, const char *interf,
2152                                struct libwebsocket_protocols *protocols,
2153                                struct libwebsocket_extension *extensions,
2154                                const char *ssl_cert_filepath,
2155                                const char *ssl_private_key_filepath,
2156                                int gid, int uid, unsigned int options)
2157 {
2158         int n;
2159         int sockfd = 0;
2160         int fd;
2161         struct sockaddr_in serv_addr, cli_addr;
2162         int opt = 1;
2163         struct libwebsocket_context *context = NULL;
2164         unsigned int slen;
2165         char *p;
2166         char hostname[1024];
2167         struct hostent *he;
2168         struct libwebsocket *wsi;
2169
2170 #ifdef LWS_OPENSSL_SUPPORT
2171         SSL_METHOD *method;
2172         char ssl_err_buf[512];
2173 #endif
2174
2175 #ifdef _WIN32
2176         {
2177                 WORD wVersionRequested;
2178                 WSADATA wsaData;
2179                 int err;
2180
2181                 /* Use the MAKEWORD(lowbyte, highbyte) macro from Windef.h */
2182                 wVersionRequested = MAKEWORD(2, 2);
2183
2184                 err = WSAStartup(wVersionRequested, &wsaData);
2185                 if (err != 0) {
2186                         /* Tell the user that we could not find a usable */
2187                         /* Winsock DLL.                                  */
2188                         fprintf(stderr, "WSAStartup failed with error: %d\n",
2189                                                                            err);
2190                         return NULL;
2191                 }
2192         }
2193 #endif
2194
2195
2196         context = malloc(sizeof(struct libwebsocket_context));
2197         if (!context) {
2198                 fprintf(stderr, "No memory for websocket context\n");
2199                 return NULL;
2200         }
2201         context->protocols = protocols;
2202         context->listen_port = port;
2203         context->http_proxy_port = 0;
2204         context->http_proxy_address[0] = '\0';
2205         context->options = options;
2206         context->fds_count = 0;
2207         context->extensions = extensions;
2208
2209 #ifdef WIN32
2210         context->fd_random = 0;
2211 #else
2212         context->fd_random = open(SYSTEM_RANDOM_FILEPATH, O_RDONLY);
2213         if (context->fd_random < 0) {
2214                 fprintf(stderr, "Unable to open random device %s %d\n",
2215                                     SYSTEM_RANDOM_FILEPATH, context->fd_random);
2216                 return NULL;
2217         }
2218 #endif
2219
2220 #ifdef LWS_OPENSSL_SUPPORT
2221         context->use_ssl = 0;
2222         context->ssl_ctx = NULL;
2223         context->ssl_client_ctx = NULL;
2224         openssl_websocket_private_data_index = 0;
2225 #endif
2226         /* find canonical hostname */
2227
2228         hostname[(sizeof hostname) - 1] = '\0';
2229         gethostname(hostname, (sizeof hostname) - 1);
2230         he = gethostbyname(hostname);
2231         if (he) {
2232                 strncpy(context->canonical_hostname, he->h_name,
2233                                         sizeof context->canonical_hostname - 1);
2234                 context->canonical_hostname[
2235                                 sizeof context->canonical_hostname - 1] = '\0';
2236         } else
2237                 strncpy(context->canonical_hostname, hostname,
2238                                         sizeof context->canonical_hostname - 1);
2239
2240         /* split the proxy ads:port if given */
2241
2242         p = getenv("http_proxy");
2243         if (p) {
2244                 strncpy(context->http_proxy_address, p,
2245                                         sizeof context->http_proxy_address - 1);
2246                 context->http_proxy_address[
2247                                  sizeof context->http_proxy_address - 1] = '\0';
2248
2249                 p = strchr(context->http_proxy_address, ':');
2250                 if (p == NULL) {
2251                         fprintf(stderr, "http_proxy needs to be ads:port\n");
2252                         return NULL;
2253                 }
2254                 *p = '\0';
2255                 context->http_proxy_port = atoi(p + 1);
2256
2257                 fprintf(stderr, "Using proxy %s:%u\n",
2258                                 context->http_proxy_address,
2259                                                       context->http_proxy_port);
2260         }
2261
2262         if (port) {
2263
2264 #ifdef LWS_OPENSSL_SUPPORT
2265                 context->use_ssl = ssl_cert_filepath != NULL &&
2266                                                ssl_private_key_filepath != NULL;
2267                 if (context->use_ssl)
2268                         fprintf(stderr, " Compiled with SSL support, "
2269                                                                   "using it\n");
2270                 else
2271                         fprintf(stderr, " Compiled with SSL support, "
2272                                                               "not using it\n");
2273
2274 #else
2275                 if (ssl_cert_filepath != NULL &&
2276                                              ssl_private_key_filepath != NULL) {
2277                         fprintf(stderr, " Not compiled for OpenSSl support!\n");
2278                         return NULL;
2279                 }
2280                 fprintf(stderr, " Compiled without SSL support, "
2281                                                        "serving unencrypted\n");
2282 #endif
2283         }
2284
2285         /* ignore SIGPIPE */
2286 #ifdef WIN32
2287 #else
2288         signal(SIGPIPE, sigpipe_handler);
2289 #endif
2290
2291
2292 #ifdef LWS_OPENSSL_SUPPORT
2293
2294         /* basic openssl init */
2295
2296         SSL_library_init();
2297
2298         OpenSSL_add_all_algorithms();
2299         SSL_load_error_strings();
2300
2301         openssl_websocket_private_data_index =
2302                 SSL_get_ex_new_index(0, "libwebsockets", NULL, NULL, NULL);
2303
2304         /*
2305          * Firefox insists on SSLv23 not SSLv3
2306          * Konq disables SSLv2 by default now, SSLv23 works
2307          */
2308
2309         method = (SSL_METHOD *)SSLv23_server_method();
2310         if (!method) {
2311                 fprintf(stderr, "problem creating ssl method: %s\n",
2312                         ERR_error_string(ERR_get_error(), ssl_err_buf));
2313                 return NULL;
2314         }
2315         context->ssl_ctx = SSL_CTX_new(method); /* create context */
2316         if (!context->ssl_ctx) {
2317                 fprintf(stderr, "problem creating ssl context: %s\n",
2318                         ERR_error_string(ERR_get_error(), ssl_err_buf));
2319                 return NULL;
2320         }
2321
2322         /* client context */
2323         if (port == CONTEXT_PORT_NO_LISTEN)
2324         {
2325                 method = (SSL_METHOD *)SSLv23_client_method();
2326                 if (!method) {
2327                         fprintf(stderr, "problem creating ssl method: %s\n",
2328                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
2329                         return NULL;
2330                 }
2331                 /* create context */
2332                 context->ssl_client_ctx = SSL_CTX_new(method);
2333                 if (!context->ssl_client_ctx) {
2334                         fprintf(stderr, "problem creating ssl context: %s\n",
2335                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
2336                         return NULL;
2337                 }
2338
2339                 /* openssl init for cert verification (for client sockets) */
2340
2341                 if (!SSL_CTX_load_verify_locations(
2342                                         context->ssl_client_ctx, NULL,
2343                                                       LWS_OPENSSL_CLIENT_CERTS))
2344                         fprintf(stderr,
2345                             "Unable to load SSL Client certs from %s "
2346                             "(set by --with-client-cert-dir= in configure) -- "
2347                                 " client ssl isn't going to work",
2348                                                       LWS_OPENSSL_CLIENT_CERTS);
2349
2350                 /*
2351                  * callback allowing user code to load extra verification certs
2352                  * helping the client to verify server identity
2353                  */
2354
2355                 context->protocols[0].callback(context, NULL,
2356                         LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS,
2357                         context->ssl_client_ctx, NULL, 0);
2358         }
2359         /* as a server, are we requiring clients to identify themselves? */
2360
2361         if (options & LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT) {
2362
2363                 /* absolutely require the client cert */
2364
2365                 SSL_CTX_set_verify(context->ssl_ctx,
2366                        SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2367                                                        OpenSSL_verify_callback);
2368
2369                 /*
2370                  * give user code a chance to load certs into the server
2371                  * allowing it to verify incoming client certs
2372                  */
2373
2374                 context->protocols[0].callback(context, NULL,
2375                         LWS_CALLBACK_OPENSSL_LOAD_EXTRA_SERVER_VERIFY_CERTS,
2376                                                      context->ssl_ctx, NULL, 0);
2377         }
2378
2379         if (context->use_ssl) {
2380
2381                 /* openssl init for server sockets */
2382
2383                 /* set the local certificate from CertFile */
2384                 n = SSL_CTX_use_certificate_file(context->ssl_ctx,
2385                                         ssl_cert_filepath, SSL_FILETYPE_PEM);
2386                 if (n != 1) {
2387                         fprintf(stderr, "problem getting cert '%s': %s\n",
2388                                 ssl_cert_filepath,
2389                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
2390                         return NULL;
2391                 }
2392                 /* set the private key from KeyFile */
2393                 if (SSL_CTX_use_PrivateKey_file(context->ssl_ctx,
2394                              ssl_private_key_filepath, SSL_FILETYPE_PEM) != 1) {
2395                         fprintf(stderr, "ssl problem getting key '%s': %s\n",
2396                                                 ssl_private_key_filepath,
2397                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
2398                         return NULL;
2399                 }
2400                 /* verify private key */
2401                 if (!SSL_CTX_check_private_key(context->ssl_ctx)) {
2402                         fprintf(stderr, "Private SSL key doesn't match cert\n");
2403                         return NULL;
2404                 }
2405
2406                 /* SSL is happy and has a cert it's content with */
2407         }
2408 #endif
2409
2410         /* selftest */
2411
2412         if (lws_b64_selftest())
2413                 return NULL;
2414
2415         /* fd hashtable init */
2416
2417         for (n = 0; n < FD_HASHTABLE_MODULUS; n++)
2418                 context->fd_hashtable[n].length = 0;
2419
2420         /* set up our external listening socket we serve on */
2421
2422         if (port) {
2423
2424                 sockfd = socket(AF_INET, SOCK_STREAM, 0);
2425                 if (sockfd < 0) {
2426                         fprintf(stderr, "ERROR opening socket");
2427                         return NULL;
2428                 }
2429
2430                 /* allow us to restart even if old sockets in TIME_WAIT */
2431                 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
2432
2433
2434                 /* Disable Nagle */
2435                 opt = 1;
2436                 setsockopt(sockfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
2437
2438                 bzero((char *) &serv_addr, sizeof(serv_addr));
2439                 serv_addr.sin_family = AF_INET;
2440                 if (interf == NULL)
2441                         serv_addr.sin_addr.s_addr = INADDR_ANY;
2442                 else
2443                         interface_to_sa(interf, &serv_addr,
2444                                                 sizeof(serv_addr));
2445                 serv_addr.sin_port = htons(port);
2446
2447                 n = bind(sockfd, (struct sockaddr *) &serv_addr,
2448                                                              sizeof(serv_addr));
2449                 if (n < 0) {
2450                         fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
2451                                                                 port, n, errno);
2452                         return NULL;
2453                 }
2454
2455                 wsi = malloc(sizeof(struct libwebsocket));
2456                 memset(wsi, 0, sizeof (struct libwebsocket));
2457                 wsi->sock = sockfd;
2458                 wsi->count_active_extensions = 0;
2459                 wsi->mode = LWS_CONNMODE_SERVER_LISTENER;
2460                 insert_wsi(context, wsi);
2461
2462                 listen(sockfd, 5);
2463                 fprintf(stderr, " Listening on port %d\n", port);
2464
2465                 /* list in the internal poll array */
2466
2467                 context->fds[context->fds_count].fd = sockfd;
2468                 context->fds[context->fds_count++].events = POLLIN;
2469
2470                 /* external POLL support via protocol 0 */
2471                 context->protocols[0].callback(context, wsi,
2472                         LWS_CALLBACK_ADD_POLL_FD,
2473                         (void *)(long)sockfd, NULL, POLLIN);
2474
2475         }
2476
2477         /* drop any root privs for this process */
2478 #ifdef WIN32
2479 #else
2480         if (gid != -1)
2481                 if (setgid(gid))
2482                         fprintf(stderr, "setgid: %s\n", strerror(errno));
2483         if (uid != -1)
2484                 if (setuid(uid))
2485                         fprintf(stderr, "setuid: %s\n", strerror(errno));
2486 #endif
2487
2488         /* set up our internal broadcast trigger sockets per-protocol */
2489
2490         for (context->count_protocols = 0;
2491                         protocols[context->count_protocols].callback;
2492                                                    context->count_protocols++) {
2493                 protocols[context->count_protocols].owning_server = context;
2494                 protocols[context->count_protocols].protocol_index =
2495                                                        context->count_protocols;
2496
2497                 fd = socket(AF_INET, SOCK_STREAM, 0);
2498                 if (fd < 0) {
2499                         fprintf(stderr, "ERROR opening socket");
2500                         return NULL;
2501                 }
2502
2503                 /* allow us to restart even if old sockets in TIME_WAIT */
2504                 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
2505
2506                 bzero((char *) &serv_addr, sizeof(serv_addr));
2507                 serv_addr.sin_family = AF_INET;
2508                 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2509                 serv_addr.sin_port = 0; /* pick the port for us */
2510
2511                 n = bind(fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
2512                 if (n < 0) {
2513                         fprintf(stderr, "ERROR on binding to port %d (%d %d)\n",
2514                                                                 port, n, errno);
2515                         return NULL;
2516                 }
2517
2518                 slen = sizeof cli_addr;
2519                 n = getsockname(fd, (struct sockaddr *)&cli_addr, &slen);
2520                 if (n < 0) {
2521                         fprintf(stderr, "getsockname failed\n");
2522                         return NULL;
2523                 }
2524                 protocols[context->count_protocols].broadcast_socket_port =
2525                                                        ntohs(cli_addr.sin_port);
2526                 listen(fd, 5);
2527
2528                 debug("  Protocol %s broadcast socket %d\n",
2529                                 protocols[context->count_protocols].name,
2530                                                       ntohs(cli_addr.sin_port));
2531
2532                 /* dummy wsi per broadcast proxy socket */
2533
2534                 wsi = malloc(sizeof(struct libwebsocket));
2535                 memset(wsi, 0, sizeof (struct libwebsocket));
2536                 wsi->sock = fd;
2537                 wsi->mode = LWS_CONNMODE_BROADCAST_PROXY_LISTENER;
2538                 wsi->count_active_extensions = 0;
2539                 /* note which protocol we are proxying */
2540                 wsi->protocol_index_for_broadcast_proxy =
2541                                                        context->count_protocols;
2542                 insert_wsi(context, wsi);
2543
2544                 /* list in internal poll array */
2545
2546                 context->fds[context->fds_count].fd = fd;
2547                 context->fds[context->fds_count].events = POLLIN;
2548                 context->fds[context->fds_count].revents = 0;
2549                 context->fds_count++;
2550
2551                 /* external POLL support via protocol 0 */
2552                 context->protocols[0].callback(context, wsi,
2553                         LWS_CALLBACK_ADD_POLL_FD,
2554                         (void *)(long)fd, NULL, POLLIN);
2555         }
2556
2557         return context;
2558 }
2559
2560
2561 #ifndef LWS_NO_FORK
2562
2563 /**
2564  * libwebsockets_fork_service_loop() - Optional helper function forks off
2565  *                                a process for the websocket server loop.
2566  *                              You don't have to use this but if not, you
2567  *                              have to make sure you are calling
2568  *                              libwebsocket_service periodically to service
2569  *                              the websocket traffic
2570  * @context:    server context returned by creation function
2571  */
2572
2573 int
2574 libwebsockets_fork_service_loop(struct libwebsocket_context *context)
2575 {
2576         int fd;
2577         struct sockaddr_in cli_addr;
2578         int n;
2579         int p;
2580
2581         n = fork();
2582         if (n < 0)
2583                 return n;
2584
2585         if (!n) {
2586
2587                 /* main process context */
2588
2589                 /*
2590                  * set up the proxy sockets to allow broadcast from
2591                  * service process context
2592                  */
2593
2594                 for (p = 0; p < context->count_protocols; p++) {
2595                         fd = socket(AF_INET, SOCK_STREAM, 0);
2596                         if (fd < 0) {
2597                                 fprintf(stderr, "Unable to create socket\n");
2598                                 return -1;
2599                         }
2600                         cli_addr.sin_family = AF_INET;
2601                         cli_addr.sin_port = htons(
2602                              context->protocols[p].broadcast_socket_port);
2603                         cli_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2604                         n = connect(fd, (struct sockaddr *)&cli_addr,
2605                                                                sizeof cli_addr);
2606                         if (n < 0) {
2607                                 fprintf(stderr, "Unable to connect to "
2608                                                 "broadcast socket %d, %s\n",
2609                                                 n, strerror(errno));
2610                                 return -1;
2611                         }
2612
2613                         context->protocols[p].broadcast_socket_user_fd = fd;
2614                 }
2615
2616                 return 0;
2617         }
2618
2619         /* we want a SIGHUP when our parent goes down */
2620         prctl(PR_SET_PDEATHSIG, SIGHUP);
2621
2622         /* in this forked process, sit and service websocket connections */
2623
2624         while (1)
2625                 if (libwebsocket_service(context, 1000))
2626                         return -1;
2627
2628         return 0;
2629 }
2630
2631 #endif
2632
2633 /**
2634  * libwebsockets_get_protocol() - Returns a protocol pointer from a websocket
2635  *                                connection.
2636  * @wsi:        pointer to struct websocket you want to know the protocol of
2637  *
2638  *
2639  *      This is useful to get the protocol to broadcast back to from inside
2640  * the callback.
2641  */
2642
2643 const struct libwebsocket_protocols *
2644 libwebsockets_get_protocol(struct libwebsocket *wsi)
2645 {
2646         return wsi->protocol;
2647 }
2648
2649 /**
2650  * libwebsockets_broadcast() - Sends a buffer to the callback for all active
2651  *                                connections of the given protocol.
2652  * @protocol:   pointer to the protocol you will broadcast to all members of
2653  * @buf:  buffer containing the data to be broadcase.  NOTE: this has to be
2654  *              allocated with LWS_SEND_BUFFER_PRE_PADDING valid bytes before
2655  *              the pointer and LWS_SEND_BUFFER_POST_PADDING afterwards in the
2656  *              case you are calling this function from callback context.
2657  * @len:        length of payload data in buf, starting from buf.
2658  *
2659  *      This function allows bulk sending of a packet to every connection using
2660  * the given protocol.  It does not send the data directly; instead it calls
2661  * the callback with a reason type of LWS_CALLBACK_BROADCAST.  If the callback
2662  * wants to actually send the data for that connection, the callback itself
2663  * should call libwebsocket_write().
2664  *
2665  * libwebsockets_broadcast() can be called from another fork context without
2666  * having to take any care about data visibility between the processes, it'll
2667  * "just work".
2668  */
2669
2670
2671 int
2672 libwebsockets_broadcast(const struct libwebsocket_protocols *protocol,
2673                                                  unsigned char *buf, size_t len)
2674 {
2675         struct libwebsocket_context *context = protocol->owning_server;
2676         int n;
2677         int m;
2678         struct libwebsocket * wsi;
2679
2680         if (!protocol->broadcast_socket_user_fd) {
2681                 /*
2682                  * We are either running unforked / flat, or we are being
2683                  * called from poll thread context
2684                  * eg, from a callback.  In that case don't use sockets for
2685                  * broadcast IPC (since we can't open a socket connection to
2686                  * a socket listening on our own thread) but directly do the
2687                  * send action.
2688                  *
2689                  * Locking is not needed because we are by definition being
2690                  * called in the poll thread context and are serialized.
2691                  */
2692
2693                 for (n = 0; n < FD_HASHTABLE_MODULUS; n++) {
2694
2695                         for (m = 0; m < context->fd_hashtable[n].length; m++) {
2696
2697                                 wsi = context->fd_hashtable[n].wsi[m];
2698
2699                                 if (wsi->mode != LWS_CONNMODE_WS_SERVING)
2700                                         continue;
2701
2702                                 /*
2703                                  * never broadcast to
2704                                  * non-established connections
2705                                  */
2706                                 if (wsi->state != WSI_STATE_ESTABLISHED)
2707                                         continue;
2708
2709                                 /* only broadcast to guys using
2710                                  * requested protocol
2711                                  */
2712                                 if (wsi->protocol != protocol)
2713                                         continue;
2714
2715                                 wsi->protocol->callback(context, wsi,
2716                                          LWS_CALLBACK_BROADCAST,
2717                                          wsi->user_space,
2718                                          buf, len);
2719                         }
2720                 }
2721
2722                 return 0;
2723         }
2724
2725         /*
2726          * We're being called from a different process context than the server
2727          * loop.  Instead of broadcasting directly, we send our
2728          * payload on a socket to do the IPC; the server process will serialize
2729          * the broadcast action in its main poll() loop.
2730          *
2731          * There's one broadcast socket listening for each protocol supported
2732          * set up when the websocket server initializes
2733          */
2734
2735         n = send(protocol->broadcast_socket_user_fd, buf, len, MSG_NOSIGNAL);
2736
2737         return n;
2738 }
2739
2740 int
2741 libwebsocket_is_final_fragment(struct libwebsocket *wsi)
2742 {
2743         return wsi->final;
2744 }