lib/server.c

   1 /*
   2  * libwebsockets - small server side websockets and web server implementation
   3  *
   4  * Copyright (C) 2010-2013 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
  23 #include "private-libwebsockets.h"
  24
  25 #ifdef WIN32
  26 #include <tchar.h>
  27 #include <io.h>
  28 #else
  29 #ifdef LWS_BUILTIN_GETIFADDRS
  30 #include <getifaddrs.h>
  31 #else
  32 #include <ifaddrs.h>
  33 #endif
  34 #include <sys/un.h>
  35 #include <sys/socket.h>
  36 #include <netdb.h>
  37 #endif
  38
  39 #ifdef LWS_OPENSSL_SUPPORT
  40
  41 static void
  42 libwebsockets_decode_ssl_error(void)
  43 {
  44         char buf[256];
  45         u_long err;
  46
  47         while ((err = ERR_get_error()) != 0) {
  48                 ERR_error_string_n(err, buf, sizeof(buf));
  49                 lwsl_err("*** %lu %s\n", err, buf);
  50         }
  51 }
  52 #endif
  53
  54 int
  55 interface_to_sa(const char *ifname, struct sockaddr_in *addr, size_t addrlen)
  56 {
  57         int rc = -1;
  58 #ifdef WIN32
  59         /* TODO */
  60 #else
  61         struct ifaddrs *ifr;
  62         struct ifaddrs *ifc;
  63         struct sockaddr_in *sin;
  64
  65         getifaddrs(&ifr);
  66         for (ifc = ifr; ifc != NULL; ifc = ifc->ifa_next) {
  67                 if (strcmp(ifc->ifa_name, ifname))
  68                         continue;
  69                 if (ifc->ifa_addr == NULL)
  70                         continue;
  71                 sin = (struct sockaddr_in *)ifc->ifa_addr;
  72                 if (sin->sin_family != AF_INET)
  73                         continue;
  74                 memcpy(addr, sin, addrlen);
  75                 rc = 0;
  76         }
  77
  78         freeifaddrs(ifr);
  79 #endif
  80         return rc;
  81 }
  82
  83 struct libwebsocket *
  84 libwebsocket_create_new_server_wsi(struct libwebsocket_context *context)
  85 {
  86         struct libwebsocket *new_wsi;
  87
  88         new_wsi = (struct libwebsocket *)malloc(sizeof(struct libwebsocket));
  89         if (new_wsi == NULL) {
  90                 lwsl_err("Out of memory for new connection\n");
  91                 return NULL;
  92         }
  93
  94         memset(new_wsi, 0, sizeof(struct libwebsocket));
  95 #ifndef LWS_NO_EXTENSIONS
  96         new_wsi->count_active_extensions = 0;
  97 #endif
  98         new_wsi->pending_timeout = NO_PENDING_TIMEOUT;
  99
 100         /* intialize the instance struct */
 101
 102         new_wsi->state = WSI_STATE_HTTP;
 103         new_wsi->mode = LWS_CONNMODE_HTTP_SERVING;
 104         new_wsi->hdr_parsing_completed = 0;
 105
 106         if (lws_allocate_header_table(new_wsi)) {
 107                 free(new_wsi);
 108                 return NULL;
 109         }
 110
 111         /*
 112          * these can only be set once the protocol is known
 113          * we set an unestablished connection's protocol pointer
 114          * to the start of the supported list, so it can look
 115          * for matching ones during the handshake
 116          */
 117         new_wsi->protocol = context->protocols;
 118         new_wsi->user_space = NULL;
 119         new_wsi->ietf_spec_revision = 0;
 120
 121         return new_wsi;
 122 }
 123
 124 int lws_server_socket_service(struct libwebsocket_context *context,
 125                         struct libwebsocket *wsi, struct pollfd *pollfd)
 126 {
 127         struct libwebsocket *new_wsi;
 128         int accept_fd;
 129         unsigned int clilen;
 130         struct sockaddr_in cli_addr;
 131         int n;
 132         ssize_t len;
 133 #ifdef LWS_OPENSSL_SUPPORT
 134         int m;
 135 #ifndef USE_CYASSL
 136         BIO *bio;
 137 #endif
 138 #endif
 139
 140         switch (wsi->mode) {
 141
 142         case LWS_CONNMODE_HTTP_SERVING:
 143
 144                 /* handle http headers coming in */
 145
 146                 /* any incoming data ready? */
 147
 148                 if (pollfd->revents & POLLIN) {
 149
 150         #ifdef LWS_OPENSSL_SUPPORT
 151                         if (wsi->ssl)
 152                                 len = SSL_read(wsi->ssl,
 153                                         context->service_buffer,
 154                                                sizeof(context->service_buffer));
 155                         else
 156         #endif
 157                                 len = recv(pollfd->fd,
 158                                         context->service_buffer,
 159                                         sizeof(context->service_buffer), 0);
 160
 161                         if (len < 0) {
 162                                 lwsl_debug("Socket read returned %d\n", len);
 163                                 if (errno != EINTR && errno != EAGAIN)
 164                                         libwebsocket_close_and_free_session(
 165                                                 context, wsi,
 166                                                 LWS_CLOSE_STATUS_NOSTATUS);
 167                                 return 0;
 168                         }
 169                         if (!len) {
 170                                 lwsl_info("lws_server_skt_srv: read 0 len\n");
 171                                 /* lwsl_info("   state=%d\n", wsi->state); */
 172                                 if (!wsi->hdr_parsing_completed)
 173                                         free(wsi->u.hdr.ah);
 174                                 libwebsocket_close_and_free_session(
 175                                        context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
 176                                 return 0;
 177                         }
 178
 179                         n = libwebsocket_read(context, wsi,
 180                                                 context->service_buffer, len);
 181                         if (n < 0)
 182                                 /* we closed wsi */
 183                                 return 0;
 184                 }
 185
 186                 /* this handles POLLOUT for http serving fragments */
 187
 188                 if (!(pollfd->revents & POLLOUT))
 189                         break;
 190
 191                 /* one shot */
 192                 pollfd->events &= ~POLLOUT;
 193
 194                 if (wsi->state != WSI_STATE_HTTP_ISSUING_FILE) {
 195                         n = user_callback_handle_rxflow(
 196                                         wsi->protocol->callback,
 197                                         wsi->protocol->owning_server,
 198                                         wsi, LWS_CALLBACK_HTTP_WRITEABLE,
 199                                         wsi->user_space,
 200                                         NULL,
 201                                         0);
 202                         if (n < 0)
 203                                 libwebsocket_close_and_free_session(
 204                                        context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
 205                         break;
 206                 }
 207
 208                 /* nonzero for completion or error */
 209                 if (libwebsockets_serve_http_file_fragment(context, wsi))
 210                         libwebsocket_close_and_free_session(context, wsi,
 211                                                LWS_CLOSE_STATUS_NOSTATUS);
 212                 break;
 213
 214         case LWS_CONNMODE_SERVER_LISTENER:
 215
 216                 /* pollin means a client has connected to us then */
 217
 218                 if (!(pollfd->revents & POLLIN))
 219                         break;
 220
 221                 /* listen socket got an unencrypted connection... */
 222
 223                 clilen = sizeof(cli_addr);
 224                 lws_latency_pre(context, wsi);
 225                 accept_fd  = accept(pollfd->fd, (struct sockaddr *)&cli_addr,
 226                                                                        &clilen);
 227                 lws_latency(context, wsi,
 228                         "unencrypted accept LWS_CONNMODE_SERVER_LISTENER",
 229                                                      accept_fd, accept_fd >= 0);
 230                 if (accept_fd < 0) {
 231                         if (errno == EAGAIN || errno == EWOULDBLOCK) {
 232                                 lwsl_debug("accept asks to try again\n");
 233                                 break;
 234                         }
 235                         lwsl_warn("ERROR on accept: %s\n", strerror(errno));
 236                         break;
 237                 }
 238
 239                 lws_set_socket_options(context, accept_fd);
 240
 241                 /*
 242                  * look at who we connected to and give user code a chance
 243                  * to reject based on client IP.  There's no protocol selected
 244                  * yet so we issue this to protocols[0]
 245                  */
 246
 247                 if ((context->protocols[0].callback)(context, wsi,
 248                                 LWS_CALLBACK_FILTER_NETWORK_CONNECTION,
 249                                            NULL, (void *)(long)accept_fd, 0)) {
 250                         lwsl_debug("Callback denied network connection\n");
 251                         compatible_close(accept_fd);
 252                         break;
 253                 }
 254
 255                 new_wsi = libwebsocket_create_new_server_wsi(context);
 256                 if (new_wsi == NULL) {
 257                         compatible_close(accept_fd);
 258                         break;
 259                 }
 260
 261                 new_wsi->sock = accept_fd;
 262
 263 #ifdef LWS_OPENSSL_SUPPORT
 264                 new_wsi->ssl = NULL;
 265                 if (!context->use_ssl) {
 266 #endif
 267
 268                         lwsl_debug("accepted new conn  port %u on fd=%d\n",
 269                                           ntohs(cli_addr.sin_port), accept_fd);
 270
 271                         insert_wsi_socket_into_fds(context, new_wsi);
 272                         break;
 273 #ifdef LWS_OPENSSL_SUPPORT
 274                 }
 275
 276                 new_wsi->ssl = SSL_new(context->ssl_ctx);
 277                 if (new_wsi->ssl == NULL) {
 278                         lwsl_err("SSL_new failed: %s\n",
 279                             ERR_error_string(SSL_get_error(
 280                             new_wsi->ssl, 0), NULL));
 281                             libwebsockets_decode_ssl_error();
 282                         free(new_wsi);
 283                         compatible_close(accept_fd);
 284                         break;
 285                 }
 286
 287                 SSL_set_ex_data(new_wsi->ssl,
 288                         openssl_websocket_private_data_index, context);
 289
 290                 SSL_set_fd(new_wsi->ssl, accept_fd);
 291
 292                 #ifdef USE_CYASSL
 293                 CyaSSL_set_using_nonblock(new_wsi->ssl, 1);
 294                 #else
 295                 bio = SSL_get_rbio(new_wsi->ssl);
 296                 if (bio)
 297                         BIO_set_nbio(bio, 1); /* nonblocking */
 298                 else
 299                         lwsl_notice("NULL rbio\n");
 300                 bio = SSL_get_wbio(new_wsi->ssl);
 301                 if (bio)
 302                         BIO_set_nbio(bio, 1); /* nonblocking */
 303                 else
 304                         lwsl_notice("NULL rbio\n");
 305                 #endif
 306
 307                 /*
 308                  * we are not accepted yet, but we need to enter ourselves
 309                  * as a live connection.  That way we can retry when more
 310                  * pieces come if we're not sorted yet
 311                  */
 312
 313                 wsi = new_wsi;
 314                 wsi->mode = LWS_CONNMODE_SSL_ACK_PENDING;
 315                 insert_wsi_socket_into_fds(context, wsi);
 316
 317                 libwebsocket_set_timeout(wsi, PENDING_TIMEOUT_SSL_ACCEPT,
 318                                                         AWAITING_TIMEOUT);
 319
 320                 lwsl_info("inserted SSL accept into fds, trying SSL_accept\n");
 321
 322                 /* fallthru */
 323
 324         case LWS_CONNMODE_SSL_ACK_PENDING:
 325
 326                 pollfd->events &= ~POLLOUT;
 327
 328                 /* external POLL support via protocol 0 */
 329                 context->protocols[0].callback(context, wsi,
 330                         LWS_CALLBACK_CLEAR_MODE_POLL_FD,
 331                         wsi->user_space, (void *)(long)wsi->sock, POLLOUT);
 332
 333                 lws_latency_pre(context, wsi);
 334                 n = SSL_accept(wsi->ssl);
 335                 lws_latency(context, wsi,
 336                         "SSL_accept LWS_CONNMODE_SSL_ACK_PENDING\n", n, n == 1);
 337
 338                 if (n != 1) {
 339                         m = SSL_get_error(wsi->ssl, n);
 340                         lwsl_debug("SSL_accept failed %d / %s\n",
 341                                                   m, ERR_error_string(m, NULL));
 342
 343                         if (m == SSL_ERROR_WANT_READ) {
 344                                 context->fds[
 345                                    wsi->position_in_fds_table].events |= POLLIN;
 346
 347                                 /* external POLL support via protocol 0 */
 348                                 context->protocols[0].callback(context, wsi,
 349                                         LWS_CALLBACK_SET_MODE_POLL_FD,
 350                                         wsi->user_space,
 351                                         (void *)(long)wsi->sock, POLLIN);
 352                                 lwsl_info("SSL_ERROR_WANT_READ\n");
 353                                 break;
 354                         }
 355                         if (m == SSL_ERROR_WANT_WRITE) {
 356                                 context->fds[
 357                                   wsi->position_in_fds_table].events |= POLLOUT;
 358
 359                                 /* external POLL support via protocol 0 */
 360                                 context->protocols[0].callback(context, wsi,
 361                                         LWS_CALLBACK_SET_MODE_POLL_FD,
 362                                         wsi->user_space,
 363                                         (void *)(long)wsi->sock, POLLOUT);
 364                                 break;
 365                         }
 366                         lwsl_debug("SSL_accept failed skt %u: %s\n",
 367                               pollfd->fd,
 368                               ERR_error_string(m, NULL));
 369                         libwebsocket_close_and_free_session(context, wsi,
 370                                                      LWS_CLOSE_STATUS_NOSTATUS);
 371                         break;
 372                 }
 373
 374                 /* OK, we are accepted */
 375
 376                 libwebsocket_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
 377
 378                 wsi->mode = LWS_CONNMODE_HTTP_SERVING;
 379
 380                 lwsl_debug("accepted new SSL conn\n");
 381                 break;
 382 #endif
 383
 384         default:
 385                 break;
 386         }
 387         return 0;
 388 }
 389