lib/output.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 #include "private-libwebsockets.h"
  23
  24 #ifdef WIN32
  25 #include <io.h>
  26 #endif
  27
  28 static int
  29 libwebsocket_0405_frame_mask_generate(struct libwebsocket *wsi)
  30 {
  31         int n;
  32
  33         /* fetch the per-frame nonce */
  34
  35         n = libwebsockets_get_random(wsi->protocol->owning_server,
  36                                                 wsi->u.ws.frame_masking_nonce_04, 4);
  37         if (n != 4) {
  38                 lwsl_parser("Unable to read from random device %s %d\n",
  39                                                      SYSTEM_RANDOM_FILEPATH, n);
  40                 return 1;
  41         }
  42
  43         /* start masking from first byte of masking key buffer */
  44         wsi->u.ws.frame_mask_index = 0;
  45
  46         return 0;
  47 }
  48
  49 #ifdef _DEBUG
  50
  51 void lwsl_hexdump(void *vbuf, size_t len)
  52 {
  53         int n;
  54         int m;
  55         int start;
  56         unsigned char *buf = (unsigned char *)vbuf;
  57         char line[80];
  58         char *p;
  59
  60         lwsl_parser("\n");
  61
  62         for (n = 0; n < len;) {
  63                 start = n;
  64                 p = line;
  65
  66                 p += sprintf(p, "%04X: ", start);
  67
  68                 for (m = 0; m < 16 && n < len; m++)
  69                         p += sprintf(p, "%02X ", buf[n++]);
  70                 while (m++ < 16)
  71                         p += sprintf(p, "   ");
  72
  73                 p += sprintf(p, "   ");
  74
  75                 for (m = 0; m < 16 && (start + m) < len; m++) {
  76                         if (buf[start + m] >= ' ' && buf[start + m] < 127)
  77                                 *p++ = buf[start + m];
  78                         else
  79                                 *p++ = '.';
  80                 }
  81                 while (m++ < 16)
  82                         *p++ = ' ';
  83
  84                 *p++ = '\n';
  85                 *p = '\0';
  86                 lwsl_debug("%s", line);
  87         }
  88         lwsl_debug("\n");
  89 }
  90
  91 #endif
  92
  93 int lws_issue_raw(struct libwebsocket *wsi, unsigned char *buf, size_t len)
  94 {
  95         struct libwebsocket_context *context = wsi->protocol->owning_server;
  96         int n;
  97 #ifndef LWS_NO_EXTENSIONS
  98         int m;
  99
 100         /*
 101          * one of the extensions is carrying our data itself?  Like mux?
 102          */
 103
 104         for (n = 0; n < wsi->count_active_extensions; n++) {
 105                 /*
 106                  * there can only be active extensions after handshake completed
 107                  * so we can rely on protocol being set already in here
 108                  */
 109                 m = wsi->active_extensions[n]->callback(
 110                                 wsi->protocol->owning_server,
 111                                 wsi->active_extensions[n], wsi,
 112                                 LWS_EXT_CALLBACK_PACKET_TX_DO_SEND,
 113                                      wsi->active_extensions_user[n], &buf, len);
 114                 if (m < 0) {
 115                         lwsl_ext("Extension reports fatal error\n");
 116                         return -1;
 117                 }
 118                 if (m) /* handled */ {
 119 /*                      lwsl_ext("ext sent it\n"); */
 120                         return 0;
 121                 }
 122         }
 123 #endif
 124         if (!wsi->sock)
 125                 lwsl_warn("** error 0 sock but expected to send\n");
 126
 127         /*
 128          * nope, send it on the socket directly
 129          */
 130
 131 #if 0
 132         lwsl_debug("  TX: ");
 133         lws_hexdump(buf, len);
 134 #endif
 135
 136         lws_latency_pre(context, wsi);
 137 #ifdef LWS_OPENSSL_SUPPORT
 138         if (wsi->ssl) {
 139                 n = SSL_write(wsi->ssl, buf, len);
 140                 lws_latency(context, wsi, "SSL_write lws_issue_raw", n, n >= 0);
 141                 if (n < 0) {
 142                         lwsl_debug("ERROR writing to socket\n");
 143                         return -1;
 144                 }
 145         } else {
 146 #endif
 147                 n = send(wsi->sock, buf, len, MSG_NOSIGNAL);
 148                 lws_latency(context, wsi, "send lws_issue_raw", n, n == len);
 149                 if (n != len) {
 150                         lwsl_debug("ERROR writing len %d to socket %d\n", len, n);
 151                         return -1;
 152                 }
 153 #ifdef LWS_OPENSSL_SUPPORT
 154         }
 155 #endif
 156         return 0;
 157 }
 158
 159 #ifdef LWS_NO_EXTENSIONS
 160 int
 161 lws_issue_raw_ext_access(struct libwebsocket *wsi,
 162                                                  unsigned char *buf, size_t len)
 163 {
 164         return lws_issue_raw(wsi, buf, len);
 165 }
 166 #else
 167 int
 168 lws_issue_raw_ext_access(struct libwebsocket *wsi,
 169                                                  unsigned char *buf, size_t len)
 170 {
 171         int ret;
 172         struct lws_tokens eff_buf;
 173         int m;
 174         int n;
 175
 176         eff_buf.token = (char *)buf;
 177         eff_buf.token_len = len;
 178
 179         /*
 180          * while we have original buf to spill ourselves, or extensions report
 181          * more in their pipeline
 182          */
 183
 184         ret = 1;
 185         while (ret == 1) {
 186
 187                 /* default to nobody has more to spill */
 188
 189                 ret = 0;
 190
 191                 /* show every extension the new incoming data */
 192
 193                 for (n = 0; n < wsi->count_active_extensions; n++) {
 194                         m = wsi->active_extensions[n]->callback(
 195                                         wsi->protocol->owning_server,
 196                                         wsi->active_extensions[n], wsi,
 197                                         LWS_EXT_CALLBACK_PACKET_TX_PRESEND,
 198                                    wsi->active_extensions_user[n], &eff_buf, 0);
 199                         if (m < 0) {
 200                                 lwsl_ext("Extension: fatal error\n");
 201                                 return -1;
 202                         }
 203                         if (m)
 204                                 /*
 205                                  * at least one extension told us he has more
 206                                  * to spill, so we will go around again after
 207                                  */
 208                                 ret = 1;
 209                 }
 210
 211                 /* assuming they left us something to send, send it */
 212
 213                 if (eff_buf.token_len)
 214                         if (lws_issue_raw(wsi, (unsigned char *)eff_buf.token,
 215                                                             eff_buf.token_len))
 216                                 return -1;
 217
 218                 lwsl_parser("written %d bytes to client\n", eff_buf.token_len);
 219
 220                 /* no extension has more to spill */
 221
 222                 if (!ret)
 223                         break;
 224
 225                 /* we used up what we had */
 226
 227                 eff_buf.token = NULL;
 228                 eff_buf.token_len = 0;
 229
 230                 /*
 231                  * Did that leave the pipe choked?
 232                  */
 233
 234                 if (!lws_send_pipe_choked(wsi))
 235                         /* no we could add more */
 236                         continue;
 237
 238                 lwsl_debug("choked\n");
 239
 240                 /*
 241                  * Yes, he's choked.  Don't spill the rest now get a callback
 242                  * when he is ready to send and take care of it there
 243                  */
 244                 libwebsocket_callback_on_writable(
 245                                              wsi->protocol->owning_server, wsi);
 246                 wsi->extension_data_pending = 1;
 247                 ret = 0;
 248         }
 249
 250         return 0;
 251 }
 252 #endif
 253
 254 /**
 255  * libwebsocket_write() - Apply protocol then write data to client
 256  * @wsi:        Websocket instance (available from user callback)
 257  * @buf:        The data to send.  For data being sent on a websocket
 258  *              connection (ie, not default http), this buffer MUST have
 259  *              LWS_SEND_BUFFER_PRE_PADDING bytes valid BEFORE the pointer
 260  *              and an additional LWS_SEND_BUFFER_POST_PADDING bytes valid
 261  *              in the buffer after (buf + len).  This is so the protocol
 262  *              header and trailer data can be added in-situ.
 263  * @len:        Count of the data bytes in the payload starting from buf
 264  * @protocol:   Use LWS_WRITE_HTTP to reply to an http connection, and one
 265  *              of LWS_WRITE_BINARY or LWS_WRITE_TEXT to send appropriate
 266  *              data on a websockets connection.  Remember to allow the extra
 267  *              bytes before and after buf if LWS_WRITE_BINARY or LWS_WRITE_TEXT
 268  *              are used.
 269  *
 270  *      This function provides the way to issue data back to the client
 271  *      for both http and websocket protocols.
 272  *
 273  *      In the case of sending using websocket protocol, be sure to allocate
 274  *      valid storage before and after buf as explained above.  This scheme
 275  *      allows maximum efficiency of sending data and protocol in a single
 276  *      packet while not burdening the user code with any protocol knowledge.
 277  */
 278
 279 int libwebsocket_write(struct libwebsocket *wsi, unsigned char *buf,
 280                           size_t len, enum libwebsocket_write_protocol protocol)
 281 {
 282         int n;
 283         int pre = 0;
 284         int post = 0;
 285         int masked7 = wsi->mode == LWS_CONNMODE_WS_CLIENT;
 286         unsigned char *dropmask = NULL;
 287         unsigned char is_masked_bit = 0;
 288 #ifndef LWS_NO_EXTENSIONS
 289         struct lws_tokens eff_buf;
 290         int m;
 291 #endif
 292
 293         if (len == 0 && protocol != LWS_WRITE_CLOSE) {
 294                 lwsl_warn("zero length libwebsocket_write attempt\n");
 295                 return 0;
 296         }
 297
 298         if (protocol == LWS_WRITE_HTTP)
 299                 goto send_raw;
 300
 301         /* websocket protocol, either binary or text */
 302
 303         if (wsi->state != WSI_STATE_ESTABLISHED)
 304                 return -1;
 305
 306 #ifndef LWS_NO_EXTENSIONS
 307         /* give a change to the extensions to modify payload */
 308         eff_buf.token = (char *)buf;
 309         eff_buf.token_len = len;
 310
 311         switch (protocol) {
 312         case LWS_WRITE_PING:
 313         case LWS_WRITE_PONG:
 314         case LWS_WRITE_CLOSE:
 315                 break;
 316         default:
 317
 318                 for (n = 0; n < wsi->count_active_extensions; n++) {
 319                         m = wsi->active_extensions[n]->callback(
 320                                 wsi->protocol->owning_server,
 321                                 wsi->active_extensions[n], wsi,
 322                                 LWS_EXT_CALLBACK_PAYLOAD_TX,
 323                                 wsi->active_extensions_user[n], &eff_buf, 0);
 324                         if (m < 0)
 325                                 return -1;
 326                 }
 327         }
 328
 329         buf = (unsigned char *)eff_buf.token;
 330         len = eff_buf.token_len;
 331 #endif
 332
 333         switch (wsi->ietf_spec_revision) {
 334         case 13:
 335                 if (masked7) {
 336                         pre += 4;
 337                         dropmask = &buf[0 - pre];
 338                         is_masked_bit = 0x80;
 339                 }
 340
 341                 switch (protocol & 0xf) {
 342                 case LWS_WRITE_TEXT:
 343                         n = LWS_WS_OPCODE_07__TEXT_FRAME;
 344                         break;
 345                 case LWS_WRITE_BINARY:
 346                         n = LWS_WS_OPCODE_07__BINARY_FRAME;
 347                         break;
 348                 case LWS_WRITE_CONTINUATION:
 349                         n = LWS_WS_OPCODE_07__CONTINUATION;
 350                         break;
 351
 352                 case LWS_WRITE_CLOSE:
 353                         n = LWS_WS_OPCODE_07__CLOSE;
 354
 355                         /*
 356                          * 06+ has a 2-byte status code in network order
 357                          * we can do this because we demand post-buf
 358                          */
 359
 360                         if (wsi->u.ws.close_reason) {
 361                                 /* reason codes count as data bytes */
 362                                 buf -= 2;
 363                                 buf[0] = wsi->u.ws.close_reason >> 8;
 364                                 buf[1] = wsi->u.ws.close_reason;
 365                                 len += 2;
 366                         }
 367                         break;
 368                 case LWS_WRITE_PING:
 369                         n = LWS_WS_OPCODE_07__PING;
 370                         wsi->u.ws.pings_vs_pongs++;
 371                         break;
 372                 case LWS_WRITE_PONG:
 373                         n = LWS_WS_OPCODE_07__PONG;
 374                         break;
 375                 default:
 376                         lwsl_warn("libwebsocket_write: unknown write "
 377                                                          "opcode / protocol\n");
 378                         return -1;
 379                 }
 380
 381                 if (!(protocol & LWS_WRITE_NO_FIN))
 382                         n |= 1 << 7;
 383
 384                 if (len < 126) {
 385                         pre += 2;
 386                         buf[-pre] = n;
 387                         buf[-pre + 1] = len | is_masked_bit;
 388                 } else {
 389                         if (len < 65536) {
 390                                 pre += 4;
 391                                 buf[-pre] = n;
 392                                 buf[-pre + 1] = 126 | is_masked_bit;
 393                                 buf[-pre + 2] = len >> 8;
 394                                 buf[-pre + 3] = len;
 395                         } else {
 396                                 pre += 10;
 397                                 buf[-pre] = n;
 398                                 buf[-pre + 1] = 127 | is_masked_bit;
 399 #if defined __LP64__
 400                                         buf[-pre + 2] = (len >> 56) & 0x7f;
 401                                         buf[-pre + 3] = len >> 48;
 402                                         buf[-pre + 4] = len >> 40;
 403                                         buf[-pre + 5] = len >> 32;
 404 #else
 405                                         buf[-pre + 2] = 0;
 406                                         buf[-pre + 3] = 0;
 407                                         buf[-pre + 4] = 0;
 408                                         buf[-pre + 5] = 0;
 409 #endif
 410                                 buf[-pre + 6] = len >> 24;
 411                                 buf[-pre + 7] = len >> 16;
 412                                 buf[-pre + 8] = len >> 8;
 413                                 buf[-pre + 9] = len;
 414                         }
 415                 }
 416                 break;
 417         }
 418
 419         /*
 420          * Deal with masking if we are in client -> server direction and
 421          * the protocol demands it
 422          */
 423
 424         if (wsi->mode == LWS_CONNMODE_WS_CLIENT) {
 425
 426                 if (libwebsocket_0405_frame_mask_generate(wsi)) {
 427                         lwsl_err("libwebsocket_write: "
 428                                       "frame mask generation failed\n");
 429                         return 1;
 430                 }
 431
 432                 /*
 433                  * in v7, just mask the payload
 434                  */
 435                 for (n = 4; n < (int)len + 4; n++)
 436                         dropmask[n] = dropmask[n] ^ wsi->u.ws.frame_masking_nonce_04[(wsi->u.ws.frame_mask_index++) & 3];
 437
 438                 if (dropmask)
 439                         /* copy the frame nonce into place */
 440                         memcpy(dropmask,
 441                                        wsi->u.ws.frame_masking_nonce_04, 4);
 442         }
 443
 444 send_raw:
 445
 446 #if 0
 447         lwsl_debug("send %ld: ", len + post);
 448         lwsl_hexdump(&buf[-pre], len + post);
 449 #endif
 450
 451         switch (protocol) {
 452         case LWS_WRITE_CLOSE:
 453 //              lwsl_hexdump(&buf[-pre], len + post);
 454         case LWS_WRITE_HTTP:
 455         case LWS_WRITE_PONG:
 456         case LWS_WRITE_PING:
 457                 if (lws_issue_raw(wsi, (unsigned char *)buf - pre,
 458                                                               len + pre + post))
 459                         return -1;
 460
 461                 return 0;
 462         default:
 463                 break;
 464         }
 465
 466         /*
 467          * give any active extensions a chance to munge the buffer
 468          * before send.  We pass in a pointer to an lws_tokens struct
 469          * prepared with the default buffer and content length that's in
 470          * there.  Rather than rewrite the default buffer, extensions
 471          * that expect to grow the buffer can adapt .token to
 472          * point to their own per-connection buffer in the extension
 473          * user allocation.  By default with no extensions or no
 474          * extension callback handling, just the normal input buffer is
 475          * used then so it is efficient.
 476          *
 477          * callback returns 1 in case it wants to spill more buffers
 478          */
 479
 480         return lws_issue_raw_ext_access(wsi, buf - pre, len + pre + post);
 481 }
 482
 483 int libwebsockets_serve_http_file_fragment(struct libwebsocket_context *context,
 484                                                         struct libwebsocket *wsi)
 485 {
 486         int ret = 0;
 487         int n;
 488
 489         while (!lws_send_pipe_choked(wsi)) {
 490                 n = read(wsi->u.http.fd, context->service_buffer, sizeof(context->service_buffer));
 491                 if (n > 0) {
 492                         libwebsocket_write(wsi, context->service_buffer, n, LWS_WRITE_HTTP);
 493                         wsi->u.http.filepos += n;
 494                 }
 495
 496                 if (n < 0) {
 497                         libwebsocket_close_and_free_session(context, wsi, LWS_CLOSE_STATUS_NOSTATUS);
 498                         return 1;
 499                 }
 500
 501                 if (n < sizeof(context->service_buffer) || wsi->u.http.filepos == wsi->u.http.filelen) {
 502                         wsi->state = WSI_STATE_HTTP;
 503
 504                         if (wsi->protocol->callback)
 505                                 ret = user_callback_handle_rxflow(wsi->protocol->callback, context, wsi, LWS_CALLBACK_HTTP_FILE_COMPLETION, wsi->user_space,
 506                                         NULL, 0);
 507                         return ret;
 508                 }
 509         }
 510
 511         lwsl_notice("choked before able to send whole file (post)\n");
 512         libwebsocket_callback_on_writable(context, wsi);
 513
 514         return ret;
 515 }
 516
 517 /**
 518  * libwebsockets_serve_http_file() - Send a file back to the client using http
 519  * @context:            libwebsockets context
 520  * @wsi:                Websocket instance (available from user callback)
 521  * @file:               The file to issue over http
 522  * @content_type:       The http content type, eg, text/html
 523  *
 524  *      This function is intended to be called from the callback in response
 525  *      to http requests from the client.  It allows the callback to issue
 526  *      local files down the http link in a single step.
 527  *
 528  *      Returning <0 indicates error and the wsi should be closed.  Returning
 529  *      >0 indicates the file was completely sent and the wsi should be closed.
 530  *      ==0 indicates the file transfer is started and needs more service later,
 531  *      the wsi should be left alone.
 532  */
 533
 534 int libwebsockets_serve_http_file(struct libwebsocket_context *context,
 535                         struct libwebsocket *wsi, const char *file,
 536                                                        const char *content_type)
 537 {
 538         struct stat stat_buf;
 539         unsigned char *p = context->service_buffer;
 540         int ret = 0;
 541
 542         wsi->u.http.fd = open(file, O_RDONLY
 543 #ifdef WIN32
 544                          | _O_BINARY
 545 #endif
 546         );
 547
 548         if (wsi->u.http.fd < 1) {
 549                 p += sprintf((char *)p, "HTTP/1.0 400 Bad\x0d\x0a"
 550                         "Server: libwebsockets\x0d\x0a"
 551                         "\x0d\x0a"
 552                 );
 553                 wsi->u.http.fd = 0;
 554                 libwebsocket_write(wsi, context->service_buffer,
 555                                 p - context->service_buffer, LWS_WRITE_HTTP);
 556
 557                 return -1;
 558         }
 559
 560         fstat(wsi->u.http.fd, &stat_buf);
 561         wsi->u.http.filelen = stat_buf.st_size;
 562         p += sprintf((char *)p, "HTTP/1.0 200 OK\x0d\x0a"
 563                         "Server: libwebsockets\x0d\x0a"
 564                         "Content-Type: %s\x0d\x0a"
 565                         "Content-Length: %u\x0d\x0a"
 566                         "\x0d\x0a", content_type,
 567                                         (unsigned int)stat_buf.st_size);
 568
 569         ret = libwebsocket_write(wsi, context->service_buffer,
 570                                    p - context->service_buffer, LWS_WRITE_HTTP);
 571         if (ret)
 572                 return -1;
 573
 574         wsi->u.http.filepos = 0;
 575         wsi->state = WSI_STATE_HTTP_ISSUING_FILE;
 576
 577         return libwebsockets_serve_http_file_fragment(context, wsi);
 578 }
 579