lib/parsers.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
  29 unsigned char lextable[] = {
  30         /* pos 0: state 0 */
  31         0x47 /* 'G' */, 0x07 /* to pos 14 state 1 */,
  32         0x48 /* 'H' */, 0x0A /* to pos 22 state 5 */,
  33         0x43 /* 'C' */, 0x0F /* to pos 34 state 10 */,
  34         0x53 /* 'S' */, 0x19 /* to pos 56 state 21 */,
  35         0x55 /* 'U' */, 0x3F /* to pos 134 state 51 */,
  36         0x4F /* 'O' */, 0x46 /* to pos 150 state 59 */,
  37         0x8D /* '.' */, 0x52 /* to pos 176 state 72 */,
  38         /* pos 14: state 1 */
  39         0xC5 /* 'E' */, 0x01 /* to pos 16 state 2 */,
  40         /* pos 16: state 2 */
  41         0xD4 /* 'T' */, 0x01 /* to pos 18 state 3 */,
  42         /* pos 18: state 3 */
  43         0xA0 /* ' ' */, 0x01 /* to pos 20 state 4 */,
  44         /* pos 20: state 4 */
  45         0x80, 0x00 /* terminal marker */,
  46         /* pos 22: state 5 */
  47         0x6F /* 'o' */, 0x02 /* to pos 26 state 6 */,
  48         0xD4 /* 'T' */, 0x76 /* to pos 260 state 114 */,
  49         /* pos 26: state 6 */
  50         0xF3 /* 's' */, 0x01 /* to pos 28 state 7 */,
  51         /* pos 28: state 7 */
  52         0xF4 /* 't' */, 0x01 /* to pos 30 state 8 */,
  53         /* pos 30: state 8 */
  54         0xBA /* ':' */, 0x01 /* to pos 32 state 9 */,
  55         /* pos 32: state 9 */
  56         0x81, 0x00 /* terminal marker */,
  57         /* pos 34: state 10 */
  58         0xEF /* 'o' */, 0x01 /* to pos 36 state 11 */,
  59         /* pos 36: state 11 */
  60         0xEE /* 'n' */, 0x01 /* to pos 38 state 12 */,
  61         /* pos 38: state 12 */
  62         0xEE /* 'n' */, 0x01 /* to pos 40 state 13 */,
  63         /* pos 40: state 13 */
  64         0xE5 /* 'e' */, 0x01 /* to pos 42 state 14 */,
  65         /* pos 42: state 14 */
  66         0xE3 /* 'c' */, 0x01 /* to pos 44 state 15 */,
  67         /* pos 44: state 15 */
  68         0xF4 /* 't' */, 0x01 /* to pos 46 state 16 */,
  69         /* pos 46: state 16 */
  70         0xE9 /* 'i' */, 0x01 /* to pos 48 state 17 */,
  71         /* pos 48: state 17 */
  72         0xEF /* 'o' */, 0x01 /* to pos 50 state 18 */,
  73         /* pos 50: state 18 */
  74         0xEE /* 'n' */, 0x01 /* to pos 52 state 19 */,
  75         /* pos 52: state 19 */
  76         0xBA /* ':' */, 0x01 /* to pos 54 state 20 */,
  77         /* pos 54: state 20 */
  78         0x82, 0x00 /* terminal marker */,
  79         /* pos 56: state 21 */
  80         0xE5 /* 'e' */, 0x01 /* to pos 58 state 22 */,
  81         /* pos 58: state 22 */
  82         0xE3 /* 'c' */, 0x01 /* to pos 60 state 23 */,
  83         /* pos 60: state 23 */
  84         0xAD /* '-' */, 0x01 /* to pos 62 state 24 */,
  85         /* pos 62: state 24 */
  86         0xD7 /* 'W' */, 0x01 /* to pos 64 state 25 */,
  87         /* pos 64: state 25 */
  88         0xE5 /* 'e' */, 0x01 /* to pos 66 state 26 */,
  89         /* pos 66: state 26 */
  90         0xE2 /* 'b' */, 0x01 /* to pos 68 state 27 */,
  91         /* pos 68: state 27 */
  92         0xD3 /* 'S' */, 0x01 /* to pos 70 state 28 */,
  93         /* pos 70: state 28 */
  94         0xEF /* 'o' */, 0x01 /* to pos 72 state 29 */,
  95         /* pos 72: state 29 */
  96         0xE3 /* 'c' */, 0x01 /* to pos 74 state 30 */,
  97         /* pos 74: state 30 */
  98         0xEB /* 'k' */, 0x01 /* to pos 76 state 31 */,
  99         /* pos 76: state 31 */
 100         0xE5 /* 'e' */, 0x01 /* to pos 78 state 32 */,
 101         /* pos 78: state 32 */
 102         0xF4 /* 't' */, 0x01 /* to pos 80 state 33 */,
 103         /* pos 80: state 33 */
 104         0xAD /* '-' */, 0x01 /* to pos 82 state 34 */,
 105         /* pos 82: state 34 */
 106         0x4B /* 'K' */, 0x08 /* to pos 98 state 35 */,
 107         0x50 /* 'P' */, 0x10 /* to pos 116 state 42 */,
 108         0x44 /* 'D' */, 0x27 /* to pos 164 state 66 */,
 109         0x56 /* 'V' */, 0x2F /* to pos 182 state 75 */,
 110         0x4F /* 'O' */, 0x36 /* to pos 198 state 83 */,
 111         0x45 /* 'E' */, 0x3C /* to pos 212 state 90 */,
 112         0x41 /* 'A' */, 0x46 /* to pos 234 state 101 */,
 113         0xCE /* 'N' */, 0x4C /* to pos 248 state 108 */,
 114         /* pos 98: state 35 */
 115         0xE5 /* 'e' */, 0x01 /* to pos 100 state 36 */,
 116         /* pos 100: state 36 */
 117         0xF9 /* 'y' */, 0x01 /* to pos 102 state 37 */,
 118         /* pos 102: state 37 */
 119         0x31 /* '1' */, 0x03 /* to pos 108 state 38 */,
 120         0x32 /* '2' */, 0x04 /* to pos 112 state 40 */,
 121         0xBA /* ':' */, 0x25 /* to pos 180 state 74 */,
 122         /* pos 108: state 38 */
 123         0xBA /* ':' */, 0x01 /* to pos 110 state 39 */,
 124         /* pos 110: state 39 */
 125         0x83, 0x00 /* terminal marker */,
 126         /* pos 112: state 40 */
 127         0xBA /* ':' */, 0x01 /* to pos 114 state 41 */,
 128         /* pos 114: state 41 */
 129         0x84, 0x00 /* terminal marker */,
 130         /* pos 116: state 42 */
 131         0xF2 /* 'r' */, 0x01 /* to pos 118 state 43 */,
 132         /* pos 118: state 43 */
 133         0xEF /* 'o' */, 0x01 /* to pos 120 state 44 */,
 134         /* pos 120: state 44 */
 135         0xF4 /* 't' */, 0x01 /* to pos 122 state 45 */,
 136         /* pos 122: state 45 */
 137         0xEF /* 'o' */, 0x01 /* to pos 124 state 46 */,
 138         /* pos 124: state 46 */
 139         0xE3 /* 'c' */, 0x01 /* to pos 126 state 47 */,
 140         /* pos 126: state 47 */
 141         0xEF /* 'o' */, 0x01 /* to pos 128 state 48 */,
 142         /* pos 128: state 48 */
 143         0xEC /* 'l' */, 0x01 /* to pos 130 state 49 */,
 144         /* pos 130: state 49 */
 145         0xBA /* ':' */, 0x01 /* to pos 132 state 50 */,
 146         /* pos 132: state 50 */
 147         0x85, 0x00 /* terminal marker */,
 148         /* pos 134: state 51 */
 149         0xF0 /* 'p' */, 0x01 /* to pos 136 state 52 */,
 150         /* pos 136: state 52 */
 151         0xE7 /* 'g' */, 0x01 /* to pos 138 state 53 */,
 152         /* pos 138: state 53 */
 153         0xF2 /* 'r' */, 0x01 /* to pos 140 state 54 */,
 154         /* pos 140: state 54 */
 155         0xE1 /* 'a' */, 0x01 /* to pos 142 state 55 */,
 156         /* pos 142: state 55 */
 157         0xE4 /* 'd' */, 0x01 /* to pos 144 state 56 */,
 158         /* pos 144: state 56 */
 159         0xE5 /* 'e' */, 0x01 /* to pos 146 state 57 */,
 160         /* pos 146: state 57 */
 161         0xBA /* ':' */, 0x01 /* to pos 148 state 58 */,
 162         /* pos 148: state 58 */
 163         0x86, 0x00 /* terminal marker */,
 164         /* pos 150: state 59 */
 165         0xF2 /* 'r' */, 0x01 /* to pos 152 state 60 */,
 166         /* pos 152: state 60 */
 167         0xE9 /* 'i' */, 0x01 /* to pos 154 state 61 */,
 168         /* pos 154: state 61 */
 169         0xE7 /* 'g' */, 0x01 /* to pos 156 state 62 */,
 170         /* pos 156: state 62 */
 171         0xE9 /* 'i' */, 0x01 /* to pos 158 state 63 */,
 172         /* pos 158: state 63 */
 173         0xEE /* 'n' */, 0x01 /* to pos 160 state 64 */,
 174         /* pos 160: state 64 */
 175         0xBA /* ':' */, 0x01 /* to pos 162 state 65 */,
 176         /* pos 162: state 65 */
 177         0x87, 0x00 /* terminal marker */,
 178         /* pos 164: state 66 */
 179         0xF2 /* 'r' */, 0x01 /* to pos 166 state 67 */,
 180         /* pos 166: state 67 */
 181         0xE1 /* 'a' */, 0x01 /* to pos 168 state 68 */,
 182         /* pos 168: state 68 */
 183         0xE6 /* 'f' */, 0x01 /* to pos 170 state 69 */,
 184         /* pos 170: state 69 */
 185         0xF4 /* 't' */, 0x01 /* to pos 172 state 70 */,
 186         /* pos 172: state 70 */
 187         0xBA /* ':' */, 0x01 /* to pos 174 state 71 */,
 188         /* pos 174: state 71 */
 189         0x88, 0x00 /* terminal marker */,
 190         /* pos 176: state 72 */
 191         0x8A /* '.' */, 0x01 /* to pos 178 state 73 */,
 192         /* pos 178: state 73 */
 193         0x89, 0x00 /* terminal marker */,
 194         /* pos 180: state 74 */
 195         0x8A, 0x00 /* terminal marker */,
 196         /* pos 182: state 75 */
 197         0xE5 /* 'e' */, 0x01 /* to pos 184 state 76 */,
 198         /* pos 184: state 76 */
 199         0xF2 /* 'r' */, 0x01 /* to pos 186 state 77 */,
 200         /* pos 186: state 77 */
 201         0xF3 /* 's' */, 0x01 /* to pos 188 state 78 */,
 202         /* pos 188: state 78 */
 203         0xE9 /* 'i' */, 0x01 /* to pos 190 state 79 */,
 204         /* pos 190: state 79 */
 205         0xEF /* 'o' */, 0x01 /* to pos 192 state 80 */,
 206         /* pos 192: state 80 */
 207         0xEE /* 'n' */, 0x01 /* to pos 194 state 81 */,
 208         /* pos 194: state 81 */
 209         0xBA /* ':' */, 0x01 /* to pos 196 state 82 */,
 210         /* pos 196: state 82 */
 211         0x8B, 0x00 /* terminal marker */,
 212         /* pos 198: state 83 */
 213         0xF2 /* 'r' */, 0x01 /* to pos 200 state 84 */,
 214         /* pos 200: state 84 */
 215         0xE9 /* 'i' */, 0x01 /* to pos 202 state 85 */,
 216         /* pos 202: state 85 */
 217         0xE7 /* 'g' */, 0x01 /* to pos 204 state 86 */,
 218         /* pos 204: state 86 */
 219         0xE9 /* 'i' */, 0x01 /* to pos 206 state 87 */,
 220         /* pos 206: state 87 */
 221         0xEE /* 'n' */, 0x01 /* to pos 208 state 88 */,
 222         /* pos 208: state 88 */
 223         0xBA /* ':' */, 0x01 /* to pos 210 state 89 */,
 224         /* pos 210: state 89 */
 225         0x8C, 0x00 /* terminal marker */,
 226         /* pos 212: state 90 */
 227         0xF8 /* 'x' */, 0x01 /* to pos 214 state 91 */,
 228         /* pos 214: state 91 */
 229         0xF4 /* 't' */, 0x01 /* to pos 216 state 92 */,
 230         /* pos 216: state 92 */
 231         0xE5 /* 'e' */, 0x01 /* to pos 218 state 93 */,
 232         /* pos 218: state 93 */
 233         0xEE /* 'n' */, 0x01 /* to pos 220 state 94 */,
 234         /* pos 220: state 94 */
 235         0xF3 /* 's' */, 0x01 /* to pos 222 state 95 */,
 236         /* pos 222: state 95 */
 237         0xE9 /* 'i' */, 0x01 /* to pos 224 state 96 */,
 238         /* pos 224: state 96 */
 239         0xEF /* 'o' */, 0x01 /* to pos 226 state 97 */,
 240         /* pos 226: state 97 */
 241         0xEE /* 'n' */, 0x01 /* to pos 228 state 98 */,
 242         /* pos 228: state 98 */
 243         0xF3 /* 's' */, 0x01 /* to pos 230 state 99 */,
 244         /* pos 230: state 99 */
 245         0xBA /* ':' */, 0x01 /* to pos 232 state 100 */,
 246         /* pos 232: state 100 */
 247         0x8D, 0x00 /* terminal marker */,
 248         /* pos 234: state 101 */
 249         0xE3 /* 'c' */, 0x01 /* to pos 236 state 102 */,
 250         /* pos 236: state 102 */
 251         0xE3 /* 'c' */, 0x01 /* to pos 238 state 103 */,
 252         /* pos 238: state 103 */
 253         0xE5 /* 'e' */, 0x01 /* to pos 240 state 104 */,
 254         /* pos 240: state 104 */
 255         0xF0 /* 'p' */, 0x01 /* to pos 242 state 105 */,
 256         /* pos 242: state 105 */
 257         0xF4 /* 't' */, 0x01 /* to pos 244 state 106 */,
 258         /* pos 244: state 106 */
 259         0xBA /* ':' */, 0x01 /* to pos 246 state 107 */,
 260         /* pos 246: state 107 */
 261         0x8E, 0x00 /* terminal marker */,
 262         /* pos 248: state 108 */
 263         0xEF /* 'o' */, 0x01 /* to pos 250 state 109 */,
 264         /* pos 250: state 109 */
 265         0xEE /* 'n' */, 0x01 /* to pos 252 state 110 */,
 266         /* pos 252: state 110 */
 267         0xE3 /* 'c' */, 0x01 /* to pos 254 state 111 */,
 268         /* pos 254: state 111 */
 269         0xE5 /* 'e' */, 0x01 /* to pos 256 state 112 */,
 270         /* pos 256: state 112 */
 271         0xBA /* ':' */, 0x01 /* to pos 258 state 113 */,
 272         /* pos 258: state 113 */
 273         0x8F, 0x00 /* terminal marker */,
 274         /* pos 260: state 114 */
 275         0xD4 /* 'T' */, 0x01 /* to pos 262 state 115 */,
 276         /* pos 262: state 115 */
 277         0xD0 /* 'P' */, 0x01 /* to pos 264 state 116 */,
 278         /* pos 264: state 116 */
 279         0xAF /* '/' */, 0x01 /* to pos 266 state 117 */,
 280         /* pos 266: state 117 */
 281         0xB1 /* '1' */, 0x01 /* to pos 268 state 118 */,
 282         /* pos 268: state 118 */
 283         0xAE /* '.' */, 0x01 /* to pos 270 state 119 */,
 284         /* pos 270: state 119 */
 285         0xB1 /* '1' */, 0x01 /* to pos 272 state 120 */,
 286         /* pos 272: state 120 */
 287         0xA0 /* ' ' */, 0x01 /* to pos 274 state 121 */,
 288         /* pos 274: state 121 */
 289         0x90, 0x00 /* terminal marker */,
 290         /* total size 276 bytes */
 291 };
 292
 293 int lextable_decode(int pos, char c)
 294 {
 295         while (pos >= 0) {
 296                 if (lextable[pos + 1] == 0) /* terminal marker */
 297                         return pos;
 298
 299                 if ((lextable[pos] & 0x7f) == c)
 300                         return pos + (lextable[pos + 1] << 1);
 301
 302                 if (lextable[pos] & 0x80)
 303                         return -1;
 304
 305                 pos += 2;
 306         }
 307         return pos;
 308 }
 309
 310 int lws_allocate_header_table(struct libwebsocket *wsi)
 311 {
 312         wsi->u.hdr.ah = malloc(sizeof(*wsi->u.hdr.ah));
 313         if (wsi->u.hdr.ah == NULL) {
 314                 lwsl_err("Out of memory\n");
 315                 return -1;
 316         }
 317         memset(wsi->u.hdr.ah->frag_index, 0, sizeof(wsi->u.hdr.ah->frag_index));
 318         wsi->u.hdr.ah->next_frag_index = 0;
 319         wsi->u.hdr.ah->pos = 0;
 320
 321         return 0;
 322 }
 323
 324 int lws_hdr_total_length(struct libwebsocket *wsi, enum lws_token_indexes h)
 325 {
 326         int n;
 327         int len = 0;
 328
 329         n = wsi->u.hdr.ah->frag_index[h];
 330         if (n == 0)
 331                 return 0;
 332
 333         do {
 334                 len += wsi->u.hdr.ah->frags[n].len;
 335                 n = wsi->u.hdr.ah->frags[n].next_frag_index;
 336         } while (n);
 337
 338         return len;
 339 }
 340
 341 int lws_hdr_copy(struct libwebsocket *wsi, char *dest, int len,
 342                                                 enum lws_token_indexes h)
 343 {
 344         int toklen = lws_hdr_total_length(wsi, h);
 345         int n;
 346
 347         if (toklen >= len)
 348                 return -1;
 349
 350         n = wsi->u.hdr.ah->frag_index[h];
 351         if (n == 0)
 352                 return 0;
 353
 354         do {
 355                 strcpy(dest,
 356                         &wsi->u.hdr.ah->data[wsi->u.hdr.ah->frags[n].offset]);
 357                 dest += wsi->u.hdr.ah->frags[n].len;
 358                 n = wsi->u.hdr.ah->frags[n].next_frag_index;
 359         } while (n);
 360
 361         return toklen;
 362 }
 363
 364 char *lws_hdr_simple_ptr(struct libwebsocket *wsi, enum lws_token_indexes h)
 365 {
 366         int n;
 367
 368         n = wsi->u.hdr.ah->frag_index[h];
 369         if (!n)
 370                 return NULL;
 371
 372         return &wsi->u.hdr.ah->data[wsi->u.hdr.ah->frags[n].offset];
 373 }
 374
 375 int lws_hdr_simple_create(struct libwebsocket *wsi,
 376                                 enum lws_token_indexes h, const char *s)
 377 {
 378         wsi->u.hdr.ah->next_frag_index++;
 379         if (wsi->u.hdr.ah->next_frag_index ==
 380                sizeof(wsi->u.hdr.ah->frags) / sizeof(wsi->u.hdr.ah->frags[0])) {
 381                 lwsl_warn("More hdr frags than we can deal with, dropping\n");
 382                 return -1;
 383         }
 384
 385         wsi->u.hdr.ah->frag_index[h] = wsi->u.hdr.ah->next_frag_index;
 386
 387         wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].offset =
 388                                                              wsi->u.hdr.ah->pos;
 389         wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len = 0;
 390         wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].next_frag_index =
 391                                                                               0;
 392
 393         do {
 394                 if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
 395                         lwsl_err("Ran out of header data space\n");
 396                         return -1;
 397                 }
 398                 wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = *s;
 399                 if (*s)
 400                         wsi->u.hdr.ah->frags[
 401                                         wsi->u.hdr.ah->next_frag_index].len++;
 402         } while (*s++);
 403
 404         return 0;
 405 }
 406
 407 int libwebsocket_parse(struct libwebsocket *wsi, unsigned char c)
 408 {
 409         int n;
 410
 411         switch (wsi->u.hdr.parser_state) {
 412         case WSI_TOKEN_GET_URI:
 413         case WSI_TOKEN_HOST:
 414         case WSI_TOKEN_CONNECTION:
 415         case WSI_TOKEN_KEY1:
 416         case WSI_TOKEN_KEY2:
 417         case WSI_TOKEN_PROTOCOL:
 418         case WSI_TOKEN_UPGRADE:
 419         case WSI_TOKEN_ORIGIN:
 420         case WSI_TOKEN_SWORIGIN:
 421         case WSI_TOKEN_DRAFT:
 422         case WSI_TOKEN_CHALLENGE:
 423         case WSI_TOKEN_KEY:
 424         case WSI_TOKEN_VERSION:
 425         case WSI_TOKEN_ACCEPT:
 426         case WSI_TOKEN_NONCE:
 427         case WSI_TOKEN_EXTENSIONS:
 428         case WSI_TOKEN_HTTP:
 429
 430                 lwsl_parser("WSI_TOK_(%d) '%c'\n", wsi->u.hdr.parser_state, c);
 431
 432                 /* collect into malloc'd buffers */
 433                 /* optional initial space swallow */
 434                 if (!wsi->u.hdr.ah->frags[wsi->u.hdr.ah->frag_index[
 435                                       wsi->u.hdr.parser_state]].len && c == ' ')
 436                         break;
 437
 438                 /* special case space terminator for get-uri */
 439                 if (wsi->u.hdr.parser_state == WSI_TOKEN_GET_URI && c == ' ') {
 440                         c = '\0';
 441                         wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
 442                 }
 443
 444                 /* bail at EOL */
 445                 if (wsi->u.hdr.parser_state != WSI_TOKEN_CHALLENGE &&
 446                                                                   c == '\x0d') {
 447                         c = '\0';
 448                         wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
 449                         lwsl_parser("*\n");
 450                 }
 451
 452                 if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
 453                         lwsl_warn("excessive header content\n");
 454                         return -1;
 455                 }
 456                 wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = c;
 457                 if (c)
 458                         wsi->u.hdr.ah->frags[
 459                                         wsi->u.hdr.ah->next_frag_index].len++;
 460
 461                 /* per-protocol end of headers management */
 462
 463                 if (wsi->u.hdr.parser_state == WSI_TOKEN_CHALLENGE)
 464                         goto set_parsing_complete;
 465                 break;
 466
 467                 /* collecting and checking a name part */
 468         case WSI_TOKEN_NAME_PART:
 469                 lwsl_parser("WSI_TOKEN_NAME_PART '%c'\n", c);
 470
 471                 wsi->u.hdr.lextable_pos =
 472                                 lextable_decode(wsi->u.hdr.lextable_pos, c);
 473
 474                 if (wsi->u.hdr.lextable_pos < 0) {
 475                         /* this is not a header we know about */
 476                         if (wsi->u.hdr.ah->frag_index[WSI_TOKEN_GET_URI]) {
 477                                 /*
 478                                  * altready had the method, no idea what
 479                                  * this crap is, ignore
 480                                  */
 481                                 wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
 482                                 break;
 483                         }
 484                         /*
 485                          * hm it's an unknown http method in fact,
 486                          * treat as dangerous
 487                          */
 488
 489                         lwsl_info("Unknown method - dropping\n");
 490                         return -1;
 491                 }
 492                 if (lextable[wsi->u.hdr.lextable_pos + 1] == 0) {
 493
 494                         /* terminal state */
 495
 496                         n = lextable[wsi->u.hdr.lextable_pos] & 0x7f;
 497
 498                         lwsl_parser("known hdr %d\n", n);
 499
 500                         if (n == WSI_TOKEN_GET_URI &&
 501                                 wsi->u.hdr.ah->frag_index[WSI_TOKEN_GET_URI]) {
 502                                 lwsl_warn("Duplicated GET\n");
 503                                 return -1;
 504                         }
 505
 506                         /*
 507                          * WSORIGIN is protocol equiv to ORIGIN,
 508                          * JWebSocket likes to send it, map to ORIGIN
 509                          */
 510                         if (n == WSI_TOKEN_SWORIGIN)
 511                                 n = WSI_TOKEN_ORIGIN;
 512
 513                         wsi->u.hdr.parser_state = (enum lws_token_indexes)
 514                                                         (WSI_TOKEN_GET_URI + n);
 515                         if (wsi->u.hdr.parser_state == WSI_TOKEN_CHALLENGE)
 516                                 goto set_parsing_complete;
 517
 518                         goto start_fragment;
 519                 }
 520                 break;
 521
 522 start_fragment:
 523                 wsi->u.hdr.ah->next_frag_index++;
 524                 if (wsi->u.hdr.ah->next_frag_index ==
 525                                 sizeof(wsi->u.hdr.ah->frags) /
 526                                               sizeof(wsi->u.hdr.ah->frags[0])) {
 527                         lwsl_warn("More hdr frags than we can deal with\n");
 528                         return -1;
 529                 }
 530
 531                 wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].offset =
 532                                                              wsi->u.hdr.ah->pos;
 533                 wsi->u.hdr.ah->frags[wsi->u.hdr.ah->next_frag_index].len = 0;
 534                 wsi->u.hdr.ah->frags[
 535                             wsi->u.hdr.ah->next_frag_index].next_frag_index = 0;
 536
 537                 n = wsi->u.hdr.ah->frag_index[wsi->u.hdr.parser_state];
 538                 if (!n) { /* first fragment */
 539                         wsi->u.hdr.ah->frag_index[wsi->u.hdr.parser_state] =
 540                                                  wsi->u.hdr.ah->next_frag_index;
 541                 } else { /* continuation */
 542                         while (wsi->u.hdr.ah->frags[n].next_frag_index)
 543                                 n = wsi->u.hdr.ah->frags[n].next_frag_index;
 544                         wsi->u.hdr.ah->frags[n].next_frag_index =
 545                                                  wsi->u.hdr.ah->next_frag_index;
 546
 547                         if (wsi->u.hdr.ah->pos == sizeof(wsi->u.hdr.ah->data)) {
 548                                 lwsl_warn("excessive header content\n");
 549                                 return -1;
 550                         }
 551
 552                         wsi->u.hdr.ah->data[wsi->u.hdr.ah->pos++] = ' ';
 553                         wsi->u.hdr.ah->frags[
 554                                           wsi->u.hdr.ah->next_frag_index].len++;
 555                 }
 556
 557                 break;
 558
 559
 560                 /* skipping arg part of a name we didn't recognize */
 561         case WSI_TOKEN_SKIPPING:
 562                 lwsl_parser("WSI_TOKEN_SKIPPING '%c'\n", c);
 563                 if (c == '\x0d')
 564                         wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING_SAW_CR;
 565                 break;
 566
 567         case WSI_TOKEN_SKIPPING_SAW_CR:
 568                 lwsl_parser("WSI_TOKEN_SKIPPING_SAW_CR '%c'\n", c);
 569                 if (c == '\x0a') {
 570                         wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
 571                         wsi->u.hdr.lextable_pos = 0;
 572                 } else
 573                         wsi->u.hdr.parser_state = WSI_TOKEN_SKIPPING;
 574                 break;
 575                 /* we're done, ignore anything else */
 576         case WSI_PARSING_COMPLETE:
 577                 lwsl_parser("WSI_PARSING_COMPLETE '%c'\n", c);
 578                 break;
 579
 580         default:        /* keep gcc happy */
 581                 break;
 582         }
 583
 584         return 0;
 585
 586 set_parsing_complete:
 587
 588         if (lws_hdr_total_length(wsi, WSI_TOKEN_UPGRADE)) {
 589                 if (lws_hdr_total_length(wsi, WSI_TOKEN_VERSION))
 590                         wsi->ietf_spec_revision =
 591                                atoi(lws_hdr_simple_ptr(wsi, WSI_TOKEN_VERSION));
 592
 593                 lwsl_parser("v%02d hdrs completed\n", wsi->ietf_spec_revision);
 594         }
 595         wsi->u.hdr.parser_state = WSI_PARSING_COMPLETE;
 596         wsi->hdr_parsing_completed = 1;
 597
 598         return 0;
 599 }
 600
 601
 602 /**
 603  * lws_frame_is_binary: true if the current frame was sent in binary mode
 604  *
 605  * @wsi: the connection we are inquiring about
 606  *
 607  * This is intended to be called from the LWS_CALLBACK_RECEIVE callback if
 608  * it's interested to see if the frame it's dealing with was sent in binary
 609  * mode.
 610  */
 611
 612 int lws_frame_is_binary(struct libwebsocket *wsi)
 613 {
 614         return wsi->u.ws.frame_is_binary;
 615 }
 616
 617 int
 618 libwebsocket_rx_sm(struct libwebsocket *wsi, unsigned char c)
 619 {
 620         int n;
 621         struct lws_tokens eff_buf;
 622         int ret = 0;
 623 #ifndef LWS_NO_EXTENSIONS
 624         int handled;
 625         int m;
 626 #endif
 627
 628 #if 0
 629         lwsl_debug("RX: %02X ", c);
 630 #endif
 631
 632         switch (wsi->lws_rx_parse_state) {
 633         case LWS_RXPS_NEW:
 634
 635                 switch (wsi->ietf_spec_revision) {
 636                 case 13:
 637                         /*
 638                          * no prepended frame key any more
 639                          */
 640                         wsi->u.ws.all_zero_nonce = 1;
 641                         goto handle_first;
 642
 643                 default:
 644                         lwsl_warn("lws_rx_sm: unknown spec version %d\n",
 645                                                        wsi->ietf_spec_revision);
 646                         break;
 647                 }
 648                 break;
 649         case LWS_RXPS_04_MASK_NONCE_1:
 650                 wsi->u.ws.frame_masking_nonce_04[1] = c;
 651                 if (c)
 652                         wsi->u.ws.all_zero_nonce = 0;
 653                 wsi->lws_rx_parse_state = LWS_RXPS_04_MASK_NONCE_2;
 654                 break;
 655         case LWS_RXPS_04_MASK_NONCE_2:
 656                 wsi->u.ws.frame_masking_nonce_04[2] = c;
 657                 if (c)
 658                         wsi->u.ws.all_zero_nonce = 0;
 659                 wsi->lws_rx_parse_state = LWS_RXPS_04_MASK_NONCE_3;
 660                 break;
 661         case LWS_RXPS_04_MASK_NONCE_3:
 662                 wsi->u.ws.frame_masking_nonce_04[3] = c;
 663                 if (c)
 664                         wsi->u.ws.all_zero_nonce = 0;
 665
 666                 /*
 667                  * start from the zero'th byte in the XOR key buffer since
 668                  * this is the start of a frame with a new key
 669                  */
 670
 671                 wsi->u.ws.frame_mask_index = 0;
 672
 673                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_1;
 674                 break;
 675
 676         /*
 677          *  04 logical framing from the spec (all this is masked when incoming
 678          *  and has to be unmasked)
 679          *
 680          * We ignore the possibility of extension data because we don't
 681          * negotiate any extensions at the moment.
 682          *
 683          *    0                   1                   2                   3
 684          *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 685          *   +-+-+-+-+-------+-+-------------+-------------------------------+
 686          *   |F|R|R|R| opcode|R| Payload len |    Extended payload length    |
 687          *   |I|S|S|S|  (4)  |S|     (7)     |             (16/63)           |
 688          *   |N|V|V|V|       |V|             |   (if payload len==126/127)   |
 689          *   | |1|2|3|       |4|             |                               |
 690          *   +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
 691          *   |     Extended payload length continued, if payload len == 127  |
 692          *   + - - - - - - - - - - - - - - - +-------------------------------+
 693          *   |                               |         Extension data        |
 694          *   +-------------------------------+ - - - - - - - - - - - - - - - +
 695          *   :                                                               :
 696          *   +---------------------------------------------------------------+
 697          *   :                       Application data                        :
 698          *   +---------------------------------------------------------------+
 699          *
 700          *  We pass payload through to userland as soon as we get it, ignoring
 701          *  FIN.  It's up to userland to buffer it up if it wants to see a
 702          *  whole unfragmented block of the original size (which may be up to
 703          *  2^63 long!)
 704          */
 705
 706         case LWS_RXPS_04_FRAME_HDR_1:
 707 handle_first:
 708
 709                 wsi->u.ws.opcode = c & 0xf;
 710                 wsi->u.ws.rsv = c & 0x70;
 711                 wsi->u.ws.final = !!((c >> 7) & 1);
 712
 713                 switch (wsi->u.ws.opcode) {
 714                 case LWS_WS_OPCODE_07__TEXT_FRAME:
 715                 case LWS_WS_OPCODE_07__BINARY_FRAME:
 716                         wsi->u.ws.frame_is_binary =
 717                              wsi->u.ws.opcode == LWS_WS_OPCODE_07__BINARY_FRAME;
 718                         break;
 719                 }
 720                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN;
 721                 break;
 722
 723         case LWS_RXPS_04_FRAME_HDR_LEN:
 724
 725                 wsi->u.ws.this_frame_masked = !!(c & 0x80);
 726
 727                 switch (c & 0x7f) {
 728                 case 126:
 729                         /* control frames are not allowed to have big lengths */
 730                         if (wsi->u.ws.opcode & 8)
 731                                 goto illegal_ctl_length;
 732
 733                         wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN16_2;
 734                         break;
 735                 case 127:
 736                         /* control frames are not allowed to have big lengths */
 737                         if (wsi->u.ws.opcode & 8)
 738                                 goto illegal_ctl_length;
 739
 740                         wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_8;
 741                         break;
 742                 default:
 743                         wsi->u.ws.rx_packet_length = c & 0x7f;
 744                         if (wsi->u.ws.this_frame_masked)
 745                                 wsi->lws_rx_parse_state =
 746                                                 LWS_RXPS_07_COLLECT_FRAME_KEY_1;
 747                         else
 748                                 wsi->lws_rx_parse_state =
 749                                         LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
 750                         break;
 751                 }
 752                 break;
 753
 754         case LWS_RXPS_04_FRAME_HDR_LEN16_2:
 755                 wsi->u.ws.rx_packet_length = c << 8;
 756                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN16_1;
 757                 break;
 758
 759         case LWS_RXPS_04_FRAME_HDR_LEN16_1:
 760                 wsi->u.ws.rx_packet_length |= c;
 761                 if (wsi->u.ws.this_frame_masked)
 762                         wsi->lws_rx_parse_state =
 763                                         LWS_RXPS_07_COLLECT_FRAME_KEY_1;
 764                 else
 765                         wsi->lws_rx_parse_state =
 766                                 LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
 767                 break;
 768
 769         case LWS_RXPS_04_FRAME_HDR_LEN64_8:
 770                 if (c & 0x80) {
 771                         lwsl_warn("b63 of length must be zero\n");
 772                         /* kill the connection */
 773                         return -1;
 774                 }
 775 #if defined __LP64__
 776                 wsi->u.ws.rx_packet_length = ((size_t)c) << 56;
 777 #else
 778                 wsi->u.ws.rx_packet_length = 0;
 779 #endif
 780                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_7;
 781                 break;
 782
 783         case LWS_RXPS_04_FRAME_HDR_LEN64_7:
 784 #if defined __LP64__
 785                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 48;
 786 #endif
 787                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_6;
 788                 break;
 789
 790         case LWS_RXPS_04_FRAME_HDR_LEN64_6:
 791 #if defined __LP64__
 792                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 40;
 793 #endif
 794                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_5;
 795                 break;
 796
 797         case LWS_RXPS_04_FRAME_HDR_LEN64_5:
 798 #if defined __LP64__
 799                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 32;
 800 #endif
 801                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_4;
 802                 break;
 803
 804         case LWS_RXPS_04_FRAME_HDR_LEN64_4:
 805                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 24;
 806                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_3;
 807                 break;
 808
 809         case LWS_RXPS_04_FRAME_HDR_LEN64_3:
 810                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 16;
 811                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_2;
 812                 break;
 813
 814         case LWS_RXPS_04_FRAME_HDR_LEN64_2:
 815                 wsi->u.ws.rx_packet_length |= ((size_t)c) << 8;
 816                 wsi->lws_rx_parse_state = LWS_RXPS_04_FRAME_HDR_LEN64_1;
 817                 break;
 818
 819         case LWS_RXPS_04_FRAME_HDR_LEN64_1:
 820                 wsi->u.ws.rx_packet_length |= ((size_t)c);
 821                 if (wsi->u.ws.this_frame_masked)
 822                         wsi->lws_rx_parse_state =
 823                                         LWS_RXPS_07_COLLECT_FRAME_KEY_1;
 824                 else
 825                         wsi->lws_rx_parse_state =
 826                                 LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
 827                 break;
 828
 829         case LWS_RXPS_07_COLLECT_FRAME_KEY_1:
 830                 wsi->u.ws.frame_masking_nonce_04[0] = c;
 831                 if (c)
 832                         wsi->u.ws.all_zero_nonce = 0;
 833                 wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_2;
 834                 break;
 835
 836         case LWS_RXPS_07_COLLECT_FRAME_KEY_2:
 837                 wsi->u.ws.frame_masking_nonce_04[1] = c;
 838                 if (c)
 839                         wsi->u.ws.all_zero_nonce = 0;
 840                 wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_3;
 841                 break;
 842
 843         case LWS_RXPS_07_COLLECT_FRAME_KEY_3:
 844                 wsi->u.ws.frame_masking_nonce_04[2] = c;
 845                 if (c)
 846                         wsi->u.ws.all_zero_nonce = 0;
 847                 wsi->lws_rx_parse_state = LWS_RXPS_07_COLLECT_FRAME_KEY_4;
 848                 break;
 849
 850         case LWS_RXPS_07_COLLECT_FRAME_KEY_4:
 851                 wsi->u.ws.frame_masking_nonce_04[3] = c;
 852                 if (c)
 853                         wsi->u.ws.all_zero_nonce = 0;
 854                 wsi->lws_rx_parse_state =
 855                                         LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED;
 856                 wsi->u.ws.frame_mask_index = 0;
 857                 if (wsi->u.ws.rx_packet_length == 0)
 858                         goto spill;
 859                 break;
 860
 861
 862         case LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED:
 863
 864                 if (!wsi->u.ws.rx_user_buffer)
 865                         lwsl_err("NULL user buffer...\n");
 866
 867                 if (wsi->u.ws.all_zero_nonce)
 868                         wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING +
 869                                (wsi->u.ws.rx_user_buffer_head++)] = c;
 870                 else
 871                         wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING +
 872                                (wsi->u.ws.rx_user_buffer_head++)] =
 873                                    c ^ wsi->u.ws.frame_masking_nonce_04[
 874                                             (wsi->u.ws.frame_mask_index++) & 3];
 875
 876                 if (--wsi->u.ws.rx_packet_length == 0) {
 877                         /* spill because we have the whole frame */
 878                         wsi->lws_rx_parse_state = LWS_RXPS_NEW;
 879                         goto spill;
 880                 }
 881
 882                 /*
 883                  * if there's no protocol max frame size given, we are
 884                  * supposed to default to LWS_MAX_SOCKET_IO_BUF
 885                  */
 886
 887                 if (!wsi->protocol->rx_buffer_size &&
 888                                         wsi->u.ws.rx_user_buffer_head !=
 889                                                           LWS_MAX_SOCKET_IO_BUF)
 890                         break;
 891                 else
 892                         if (wsi->protocol->rx_buffer_size &&
 893                                         wsi->u.ws.rx_user_buffer_head !=
 894                                                   wsi->protocol->rx_buffer_size)
 895                         break;
 896
 897                 /* spill because we filled our rx buffer */
 898 spill:
 899                 /*
 900                  * is this frame a control packet we should take care of at this
 901                  * layer?  If so service it and hide it from the user callback
 902                  */
 903
 904                 lwsl_parser("spill on %s\n", wsi->protocol->name);
 905
 906                 switch (wsi->u.ws.opcode) {
 907                 case LWS_WS_OPCODE_07__CLOSE:
 908                         /* is this an acknowledgement of our close? */
 909                         if (wsi->state == WSI_STATE_AWAITING_CLOSE_ACK) {
 910                                 /*
 911                                  * fine he has told us he is closing too, let's
 912                                  * finish our close
 913                                  */
 914                                 lwsl_parser("seen client close ack\n");
 915                                 return -1;
 916                         }
 917                         lwsl_parser("server sees client close packet\n");
 918                         /* parrot the close packet payload back */
 919                         n = libwebsocket_write(wsi, (unsigned char *)
 920                                 &wsi->u.ws.rx_user_buffer[
 921                                         LWS_SEND_BUFFER_PRE_PADDING],
 922                                         wsi->u.ws.rx_user_buffer_head,
 923                                                                LWS_WRITE_CLOSE);
 924                         if (n < 0)
 925                                 lwsl_info("write of close ack failed %d\n", n);
 926                         wsi->state = WSI_STATE_RETURNED_CLOSE_ALREADY;
 927                         /* close the connection */
 928                         return -1;
 929
 930                 case LWS_WS_OPCODE_07__PING:
 931                         lwsl_info("received %d byte ping, sending pong\n",
 932                                                  wsi->u.ws.rx_user_buffer_head);
 933                         lwsl_hexdump(&wsi->u.ws.rx_user_buffer[
 934                                         LWS_SEND_BUFFER_PRE_PADDING],
 935                                                  wsi->u.ws.rx_user_buffer_head);
 936                         /* parrot the ping packet payload back as a pong */
 937                         n = libwebsocket_write(wsi, (unsigned char *)
 938                         &wsi->u.ws.rx_user_buffer[LWS_SEND_BUFFER_PRE_PADDING],
 939                                  wsi->u.ws.rx_user_buffer_head, LWS_WRITE_PONG);
 940                         if (n < 0)
 941                                 return -1;
 942                         /* ... then just drop it */
 943                         wsi->u.ws.rx_user_buffer_head = 0;
 944                         return 0;
 945
 946                 case LWS_WS_OPCODE_07__PONG:
 947                         /* ... then just drop it */
 948                         wsi->u.ws.rx_user_buffer_head = 0;
 949                         return 0;
 950
 951                 case LWS_WS_OPCODE_07__TEXT_FRAME:
 952                 case LWS_WS_OPCODE_07__BINARY_FRAME:
 953                 case LWS_WS_OPCODE_07__CONTINUATION:
 954                         break;
 955
 956                 default:
 957 #ifndef LWS_NO_EXTENSIONS
 958                         lwsl_parser("passing opc %x up to exts\n",
 959                                                         wsi->u.ws.opcode);
 960
 961                         /*
 962                          * It's something special we can't understand here.
 963                          * Pass the payload up to the extension's parsing
 964                          * state machine.
 965                          */
 966
 967                         eff_buf.token = &wsi->u.ws.rx_user_buffer[
 968                                                    LWS_SEND_BUFFER_PRE_PADDING];
 969                         eff_buf.token_len = wsi->u.ws.rx_user_buffer_head;
 970
 971                         handled = 0;
 972                         for (n = 0; n < wsi->count_active_extensions; n++) {
 973                                 m = wsi->active_extensions[n]->callback(
 974                                         wsi->protocol->owning_server,
 975                                         wsi->active_extensions[n], wsi,
 976                                         LWS_EXT_CALLBACK_EXTENDED_PAYLOAD_RX,
 977                                             wsi->active_extensions_user[n],
 978                                                                    &eff_buf, 0);
 979                                 if (m)
 980                                         handled = 1;
 981                         }
 982
 983                         if (!handled)
 984 #endif
 985                                 lwsl_ext("ext opc opcode 0x%x unknown\n",
 986                                                               wsi->u.ws.opcode);
 987
 988                         wsi->u.ws.rx_user_buffer_head = 0;
 989                         return 0;
 990                 }
 991
 992                 /*
 993                  * No it's real payload, pass it up to the user callback.
 994                  * It's nicely buffered with the pre-padding taken care of
 995                  * so it can be sent straight out again using libwebsocket_write
 996                  */
 997
 998                 eff_buf.token = &wsi->u.ws.rx_user_buffer[
 999                                                 LWS_SEND_BUFFER_PRE_PADDING];
1000                 eff_buf.token_len = wsi->u.ws.rx_user_buffer_head;
1001 #ifndef LWS_NO_EXTENSIONS
1002                 for (n = 0; n < wsi->count_active_extensions; n++) {
1003                         m = wsi->active_extensions[n]->callback(
1004                                 wsi->protocol->owning_server,
1005                                 wsi->active_extensions[n], wsi,
1006                                 LWS_EXT_CALLBACK_PAYLOAD_RX,
1007                                 wsi->active_extensions_user[n],
1008                                 &eff_buf, 0);
1009                         if (m < 0) {
1010                                 lwsl_ext(
1011                                  "Extension '%s' failed to handle payload!\n",
1012                                               wsi->active_extensions[n]->name);
1013                                 return -1;
1014                         }
1015                 }
1016 #endif
1017                 if (eff_buf.token_len > 0) {
1018                         eff_buf.token[eff_buf.token_len] = '\0';
1019
1020                         if (wsi->protocol->callback)
1021                                 ret = user_callback_handle_rxflow(
1022                                                 wsi->protocol->callback,
1023                                                 wsi->protocol->owning_server,
1024                                                 wsi, LWS_CALLBACK_RECEIVE,
1025                                                 wsi->user_space,
1026                                                 eff_buf.token,
1027                                                 eff_buf.token_len);
1028                     else
1029                             lwsl_err("No callback on payload spill!\n");
1030                 }
1031
1032                 wsi->u.ws.rx_user_buffer_head = 0;
1033                 break;
1034         }
1035
1036         return ret;
1037
1038 illegal_ctl_length:
1039
1040         lwsl_warn("Control frame with xtended length is illegal\n");
1041         /* kill the connection */
1042         return -1;
1043 }
1044
1045
1046 int libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
1047                                                  unsigned char *buf, size_t len)
1048 {
1049         size_t n;
1050         int m;
1051         int clear_rxflow = !!wsi->u.ws.rxflow_buffer;
1052         struct libwebsocket_context *context = wsi->protocol->owning_server;
1053
1054 #if 0
1055         lwsl_parser("received %d byte packet\n", (int)len);
1056         lwsl_hexdump(buf, len);
1057 #endif
1058
1059         if (buf && wsi->u.ws.rxflow_buffer)
1060                 lwsl_err("!!!! pending rxflow data loss\n");
1061
1062         /* let the rx protocol state machine have as much as it needs */
1063
1064         n = 0;
1065         if (!buf) {
1066                 lwsl_info("dumping stored rxflow buffer len %d pos=%d\n",
1067                                     wsi->u.ws.rxflow_len, wsi->u.ws.rxflow_pos);
1068                 buf = wsi->u.ws.rxflow_buffer;
1069                 n = wsi->u.ws.rxflow_pos;
1070                 len = wsi->u.ws.rxflow_len;
1071                 /* let's pretend he's already allowing input */
1072                 context->fds[wsi->position_in_fds_table].events |= POLLIN;
1073         }
1074
1075         while (n < len) {
1076                 if (!(context->fds[wsi->position_in_fds_table].events &
1077                                                                       POLLIN)) {
1078                         /* his RX is flowcontrolled */
1079                         if (!wsi->u.ws.rxflow_buffer) {
1080                                 /* a new rxflow, buffer it and warn caller */
1081                                 lwsl_info("new rxflow input buffer len %d\n",
1082                                                                        len - n);
1083                                 wsi->u.ws.rxflow_buffer =
1084                                                (unsigned char *)malloc(len - n);
1085                                 wsi->u.ws.rxflow_len = len - n;
1086                                 wsi->u.ws.rxflow_pos = 0;
1087                                 memcpy(wsi->u.ws.rxflow_buffer,
1088                                                         buf + n, len - n);
1089                         } else {
1090                                 lwsl_info("re-using rxflow input buffer\n");
1091                                 /* rxflow while we were spilling prev rxflow */
1092                                 wsi->u.ws.rxflow_pos = n;
1093                         }
1094                         return 1;
1095                 }
1096                 m = libwebsocket_rx_sm(wsi, buf[n]);
1097                 if (m < 0)
1098                         return -1;
1099                 n++;
1100         }
1101
1102         if (clear_rxflow) {
1103                 lwsl_info("flow: clearing it\n");
1104                 free(wsi->u.ws.rxflow_buffer);
1105                 wsi->u.ws.rxflow_buffer = NULL;
1106                 context->fds[wsi->position_in_fds_table].events &= ~POLLIN;
1107         }
1108
1109         return 0;
1110 }
1111
1112
1113 /**
1114  * libwebsockets_remaining_packet_payload() - Bytes to come before "overall"
1115  *                                            rx packet is complete
1116  * @wsi:                Websocket instance (available from user callback)
1117  *
1118  *      This function is intended to be called from the callback if the
1119  *  user code is interested in "complete packets" from the client.
1120  *  libwebsockets just passes through payload as it comes and issues a buffer
1121  *  additionally when it hits a built-in limit.  The LWS_CALLBACK_RECEIVE
1122  *  callback handler can use this API to find out if the buffer it has just
1123  *  been given is the last piece of a "complete packet" from the client --
1124  *  when that is the case libwebsockets_remaining_packet_payload() will return
1125  *  0.
1126  *
1127  *  Many protocols won't care becuse their packets are always small.
1128  */
1129
1130 size_t
1131 libwebsockets_remaining_packet_payload(struct libwebsocket *wsi)
1132 {
1133         return wsi->u.ws.rx_packet_length;
1134 }