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 LWS_OPENSSL_SUPPORT
  25 SSL_CTX *ssl_ctx;
  26 int use_ssl;
  27 #endif
  28
  29
  30 extern int
  31 libwebsocket_read(struct libwebsocket *wsi, unsigned char * buf, size_t len);
  32
  33
  34 /* document the generic callback (it's a fake prototype under this) */
  35 /**
  36  * callback() - User server actions
  37  * @wsi:        Opaque websocket instance pointer
  38  * @reason:     The reason for the call
  39  * @user:       Pointer to per-session user data allocated by library
  40  * @in:         Pointer used for some callback reasons
  41  * @len:        Length set for some callback reasons
  42  *
  43  *      This callback is the way the user controls what is served.  All the
  44  *      protocol detail is hidden and handled by the library.
  45  *
  46  *      For each connection / session there is user data allocated that is
  47  *      pointed to by "user".  You set the size of this user data area when
  48  *      the library is initialized with libwebsocket_create_server.
  49  *
  50  *      You get an opportunity to initialize user data when called back with
  51  *      LWS_CALLBACK_ESTABLISHED reason.
  52  *
  53  *      LWS_CALLBACK_ESTABLISHED:  after successful websocket handshake
  54  *
  55  *      LWS_CALLBACK_CLOSED: when the websocket session ends
  56  *
  57  *      LWS_CALLBACK_SEND: opportunity to send to client (you would use
  58  *                              libwebsocket_write() taking care about the
  59  *                              special buffer requirements
  60  *      LWS_CALLBACK_RECEIVE: data has appeared for the server, it can be
  61  *                              found at *in and is len bytes long
  62  *
  63  *      LWS_CALLBACK_HTTP: an http request has come from a client that is not
  64  *                              asking to upgrade the connection to a websocket
  65  *                              one.  This is a chance to serve http content,
  66  *                              for example, to send a script to the client
  67  *                              which will then open the websockets connection.
  68  *                              @in points to the URI path requested and
  69  *                              libwebsockets_serve_http_file() makes it very
  70  *                              simple to send back a file to the client.
  71  */
  72 extern int callback(struct libwebsocket * wsi,
  73                          enum libwebsocket_callback_reasons reason, void * user,
  74                                                           void *in, size_t len);
  75
  76
  77 void
  78 libwebsocket_close_and_free_session(struct libwebsocket *wsi)
  79 {
  80         int n = wsi->state;
  81
  82         wsi->state = WSI_STATE_DEAD_SOCKET;
  83
  84         if (wsi->protocol->callback && n == WSI_STATE_ESTABLISHED)
  85                 wsi->protocol->callback(wsi, LWS_CALLBACK_CLOSED, wsi->user_space,
  86                                                                        NULL, 0);
  87
  88         for (n = 0; n < WSI_TOKEN_COUNT; n++)
  89                 if (wsi->utf8_token[n].token)
  90                         free(wsi->utf8_token[n].token);
  91
  92 //      fprintf(stderr, "closing fd=%d\n", wsi->sock);
  93
  94 #ifdef LWS_OPENSSL_SUPPORT
  95         if (use_ssl) {
  96                 n = SSL_get_fd(wsi->ssl);
  97                 SSL_shutdown(wsi->ssl);
  98                 close(n);
  99                 SSL_free(wsi->ssl);
 100         } else {
 101 #endif
 102                 shutdown(wsi->sock, SHUT_RDWR);
 103                 close(wsi->sock);
 104 #ifdef LWS_OPENSSL_SUPPORT
 105         }
 106 #endif
 107         if (wsi->user_space)
 108                 free(wsi->user_space);
 109
 110         free(wsi);
 111 }
 112
 113 /**
 114  * libwebsocket_create_server() - Create the listening websockets server
 115  * @port:       Port to listen on
 116  * @protocols:  Array of structures listing supported protocols and a protocol-
 117  *              specific callback for each one.  The list is ended with an
 118  *              entry that has a NULL callback pointer.
 119  * @ssl_cert_filepath:  If libwebsockets was compiled to use ssl, and you want
 120  *                      to listen using SSL, set to the filepath to fetch the
 121  *                      server cert from, otherwise NULL for unencrypted
 122  * @ssl_private_key_filepath: filepath to private key if wanting SSL mode,
 123  *                      else ignored
 124  * @gid:        group id to change to after setting listen socket, or -1.
 125  * @uid:        user id to change to after setting listen socket, or -1.
 126  *
 127  *      This function creates the listening socket and takes care
 128  *      of all initialization in one step.
 129  *
 130  *      It does not return since it sits in a service loop and operates via the
 131  *      callbacks given in @protocol.  User code should fork before calling
 132  *      libwebsocket_create_server() if it wants to do other things in
 133  *      parallel other than serve websockets.
 134  *
 135  *      The protocol callback functions are called for a handful of events
 136  *      including http requests coming in, websocket connections becoming
 137  *      established, and data arriving; it's also called periodically to allow
 138  *      async transmission.
 139  *
 140  *      HTTP requests are sent always to the FIRST protocol in @protocol, since
 141  *      at that time websocket protocol has not been negotiated.  Other
 142  *      protocols after the first one never see any HTTP callack activity.
 143  *
 144  *      The server created is a simple http server by default; part of the
 145  *      websocket standard is upgrading this http connection to a websocket one.
 146  *
 147  *      This allows the same server to provide files like scripts and favicon /
 148  *      images or whatever over http and dynamic data over websockets all in
 149  *      one place; they're all handled in the user callback.
 150  */
 151
 152 int libwebsocket_create_server(int port,
 153                                const struct libwebsocket_protocols *protocols,
 154                                const char * ssl_cert_filepath,
 155                                const char * ssl_private_key_filepath,
 156                                int gid, int uid)
 157 {
 158         int n;
 159         int client;
 160         int sockfd;
 161         int fd;
 162         unsigned int clilen;
 163         struct sockaddr_in serv_addr, cli_addr;
 164         struct libwebsocket *wsi[MAX_CLIENTS + 1];
 165         struct pollfd fds[MAX_CLIENTS + 1];
 166         int fds_count = 0;
 167         unsigned char buf[1024];
 168         int opt = 1;
 169
 170 #ifdef LWS_OPENSSL_SUPPORT
 171         const SSL_METHOD *method;
 172         char ssl_err_buf[512];
 173
 174         use_ssl = ssl_cert_filepath != NULL && ssl_private_key_filepath != NULL;
 175         if (use_ssl)
 176                 fprintf(stderr, " Compiled with SSL support, using it\n");
 177         else
 178                 fprintf(stderr, " Compiled with SSL support, not using it\n");
 179
 180 #else
 181         if (ssl_cert_filepath != NULL && ssl_private_key_filepath != NULL) {
 182                 fprintf(stderr, " Not compiled for OpenSSl support!\n");
 183                 return -1;
 184         }
 185         fprintf(stderr, " Compiled without SSL support, serving unencrypted\n");
 186 #endif
 187
 188 #ifdef LWS_OPENSSL_SUPPORT
 189         if (use_ssl) {
 190                 SSL_library_init();
 191
 192                 OpenSSL_add_all_algorithms();
 193                 SSL_load_error_strings();
 194
 195                         // Firefox insists on SSLv23 not SSLv3
 196                         // Konq disables SSLv2 by default now, SSLv23 works
 197
 198                 method = SSLv23_server_method();   // create server instance
 199                 if (!method) {
 200                         fprintf(stderr, "problem creating ssl method: %s\n",
 201                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
 202                         return -1;
 203                 }
 204                 ssl_ctx = SSL_CTX_new(method);  /* create context */
 205                 if (!ssl_ctx) {
 206                         printf("problem creating ssl context: %s\n",
 207                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
 208                         return -1;
 209                 }
 210                 /* set the local certificate from CertFile */
 211                 n = SSL_CTX_use_certificate_file(ssl_ctx,
 212                                         ssl_cert_filepath, SSL_FILETYPE_PEM);
 213                 if (n != 1) {
 214                         fprintf(stderr, "problem getting cert '%s': %s\n",
 215                                 ssl_cert_filepath,
 216                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
 217                         return -1;
 218                 }
 219                 /* set the private key from KeyFile */
 220                 if (SSL_CTX_use_PrivateKey_file(ssl_ctx,
 221                                                 ssl_private_key_filepath,
 222                                                 SSL_FILETYPE_PEM) != 1) {
 223                         fprintf(stderr, "ssl problem getting key '%s': %s\n",
 224                                                 ssl_private_key_filepath,
 225                                 ERR_error_string(ERR_get_error(), ssl_err_buf));
 226                         return (-1);
 227                 }
 228                 /* verify private key */
 229                 if (!SSL_CTX_check_private_key(ssl_ctx)) {
 230                         fprintf(stderr, "Private SSL key doesn't match cert\n");
 231                         return (-1);
 232                 }
 233
 234                 /* SSL is happy and has a cert it's content with */
 235         }
 236 #endif
 237
 238         sockfd = socket(AF_INET, SOCK_STREAM, 0);
 239         if (sockfd < 0) {
 240                 fprintf(stderr, "ERROR opening socket");
 241                 return -1;
 242         }
 243
 244         /* allow us to restart even if old sockets in TIME_WAIT */
 245         setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 246
 247         bzero((char *) &serv_addr, sizeof(serv_addr));
 248         serv_addr.sin_family = AF_INET;
 249         serv_addr.sin_addr.s_addr = INADDR_ANY;
 250         serv_addr.sin_port = htons(port);
 251         n = bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
 252         if (n < 0) {
 253               fprintf(stderr, "ERROR on binding to port %d (%d %d)\n", port, n,
 254                                                                          errno);
 255               return -1;
 256         }
 257
 258         /* drop any root privs for this thread */
 259
 260         if (gid != -1)
 261                 if (setgid(gid))
 262                         fprintf(stderr, "setgid: %s\n", strerror(errno));
 263         if (uid != -1)
 264                 if (setuid(uid))
 265                         fprintf(stderr, "setuid: %s\n", strerror(errno));
 266
 267         /*
 268          * sit there listening for connects, accept and service connections
 269          * in a poll loop, without any forking
 270          */
 271
 272         listen(sockfd, 5);
 273         fprintf(stderr, " Listening on port %d\n", port);
 274
 275         fds[0].fd = sockfd;
 276         fds_count = 1;
 277         fds[0].events = POLLIN;
 278
 279         while (1) {
 280
 281                 n = poll(fds, fds_count, 50);
 282                 if (n < 0 || fds[0].revents & (POLLERR | POLLHUP)) {
 283 //                      fprintf(stderr, "Listen Socket dead\n");
 284                         goto fatal;
 285                 }
 286                 if (n == 0) /* poll timeout */
 287                         goto poll_out;
 288
 289                 if (fds[0].revents & POLLIN) {
 290
 291                         /* listen socket got an unencrypted connection... */
 292
 293                         clilen = sizeof(cli_addr);
 294                         fd  = accept(sockfd,
 295                                      (struct sockaddr *)&cli_addr,
 296                                                                &clilen);
 297                         if (fd < 0) {
 298                                 fprintf(stderr, "ERROR on accept");
 299                                 continue;
 300                         }
 301
 302                         if (fds_count >= MAX_CLIENTS) {
 303                                 fprintf(stderr, "too busy");
 304                                 close(fd);
 305                                 continue;
 306                         }
 307
 308                         wsi[fds_count] = malloc(sizeof(struct libwebsocket));
 309                         if (!wsi[fds_count])
 310                                 return -1;
 311
 312
 313 #ifdef LWS_OPENSSL_SUPPORT
 314                         if (use_ssl) {
 315
 316                                 wsi[fds_count]->ssl = SSL_new(ssl_ctx);
 317                                 if (wsi[fds_count]->ssl == NULL) {
 318                                         fprintf(stderr, "SSL_new failed: %s\n",
 319                                             ERR_error_string(SSL_get_error(
 320                                                 wsi[fds_count]->ssl, 0), NULL));
 321                                         free(wsi[fds_count]);
 322                                         continue;
 323                                 }
 324
 325                                 SSL_set_fd(wsi[fds_count]->ssl, fd);
 326
 327                                 n = SSL_accept(wsi[fds_count]->ssl);
 328                                 if (n != 1) {
 329                                         /*
 330                                          * browsers seem to probe with various
 331                                          * ssl params which fail then retry
 332                                          * and succeed
 333                                          */
 334                                         debug("SSL_accept failed skt %u: %s\n",
 335                                                 fd,
 336                                                 ERR_error_string(SSL_get_error(
 337                                                 wsi[fds_count]->ssl, n), NULL));
 338                                         SSL_free(wsi[fds_count]->ssl);
 339                                         free(wsi[fds_count]);
 340                                         continue;
 341                                 }
 342                                 debug("accepted new SSL conn  "
 343                                       "port %u on fd=%d SSL ver %s\n",
 344                                         ntohs(cli_addr.sin_port), fd,
 345                                           SSL_get_version(wsi[fds_count]->ssl));
 346
 347                         } else
 348 #endif
 349                                 debug("accepted new conn  port %u on fd=%d\n",
 350                                                   ntohs(cli_addr.sin_port), fd);
 351
 352                         /* intialize the instance struct */
 353
 354                         wsi[fds_count]->sock = fd;
 355                         wsi[fds_count]->state = WSI_STATE_HTTP;
 356                         wsi[fds_count]->name_buffer_pos = 0;
 357
 358                         for (n = 0; n < WSI_TOKEN_COUNT; n++) {
 359                                 wsi[fds_count]->utf8_token[n].token = NULL;
 360                                 wsi[fds_count]->utf8_token[n].token_len = 0;
 361                         }
 362
 363                         /*
 364                          * these can only be set once the protocol is known
 365                          * we set an unestablished connection's protocol pointer
 366                          * to the start of the supported list, so it can look
 367                          * for matching ones during the handshake
 368                          */
 369                         wsi[fds_count]->protocol = protocols;
 370                         wsi[fds_count]->user_space = NULL;
 371
 372                         /*
 373                          * Default protocol is 76
 374                          * After 76, there's a header specified to inform which
 375                          * draft the client wants, when that's seen we modify
 376                          * the individual connection's spec revision accordingly
 377                          */
 378                         wsi[fds_count]->ietf_spec_revision = 76;
 379
 380                         fds[fds_count].events = POLLIN;
 381                         fds[fds_count++].fd = fd;
 382                 }
 383
 384                 /* check for activity on client sockets */
 385
 386                 for (client = 1; client < fds_count; client++) {
 387
 388                         /* handle session socket closed */
 389
 390                         if (fds[client].revents & (POLLERR | POLLHUP)) {
 391
 392                                 fprintf(stderr, "Session Socket dead\n");
 393
 394                                 libwebsocket_close_and_free_session(
 395                                                                    wsi[client]);
 396                                 goto nuke_this;
 397                         }
 398
 399                         /* any incoming data ready? */
 400
 401                         if (!(fds[client].revents & POLLIN))
 402                                 continue;
 403
 404 #ifdef LWS_OPENSSL_SUPPORT
 405                         if (use_ssl)
 406                                 n = SSL_read(wsi[client]->ssl, buf, sizeof buf);
 407                         else
 408 #endif
 409                                 n = recv(fds[client].fd, buf, sizeof(buf), 0);
 410
 411                         if (n < 0) {
 412                                 fprintf(stderr, "Socket read returned %d\n", n);
 413                                 continue;
 414                         }
 415                         if (!n) {
 416 //                              fprintf(stderr, "POLLIN with 0 len waiting\n");
 417                                 libwebsocket_close_and_free_session(
 418                                                                    wsi[client]);
 419                                 goto nuke_this;
 420                         }
 421
 422                         /* service incoming data */
 423
 424                         if (libwebsocket_read(wsi[client], buf, n) >= 0)
 425                                 continue;
 426
 427                         /*
 428                          * it closed and nuked wsi[client], so remove the
 429                          * socket handle and wsi from our service list
 430                          */
 431 nuke_this:
 432                         for (n = client; n < fds_count - 1; n++) {
 433                                 fds[n] = fds[n + 1];
 434                                 wsi[n] = wsi[n + 1];
 435                         }
 436                         fds_count--;
 437                         client--;
 438                 }
 439
 440 poll_out:
 441                 for (client = 1; client < fds_count; client++) {
 442
 443                         if (wsi[client]->state != WSI_STATE_ESTABLISHED)
 444                                 continue;
 445
 446                         wsi[client]->protocol->callback(wsi[client], LWS_CALLBACK_SEND,
 447                                           wsi[client]->user_space, NULL, 0);
 448                 }
 449
 450                 continue;
 451         }
 452
 453 fatal:
 454         /* listening socket */
 455         close(fds[0].fd);
 456         for (client = 1; client < fds_count; client++)
 457                 libwebsocket_close_and_free_session(wsi[client]);
 458
 459 #ifdef LWS_OPENSSL_SUPPORT
 460         SSL_CTX_free(ssl_ctx);
 461 #endif
 462         kill(0, SIGTERM);
 463
 464         return 0;
 465 }
 466
 467