| … | |
… | |
| 200 | { |
200 | { |
| 201 | return (!(pkt->flags & PF_PLAYER) || pl) |
201 | return (!(pkt->flags & PF_PLAYER) || pl) |
| 202 | && (!(pkt->flags & PF_PLAYING) || state == ST_PLAYING); |
202 | && (!(pkt->flags & PF_PLAYING) || state == ST_PLAYING); |
| 203 | } |
203 | } |
| 204 | |
204 | |
| 205 | // HACK: some commands currently should be executed |
205 | // HACK: some commands currently should be executed |
| 206 | // even when the player is frozen. this hack detects |
206 | // even when the player is frozen. this hack detects |
| 207 | // those commands. it should be folded into may_execute, |
207 | // those commands. it should be folded into may_execute, |
| 208 | // but kept seperate to emphasise the hack aspect, i.e. |
208 | // but kept seperate to emphasise the hack aspect, i.e. |
| 209 | // do it better, then remove. |
209 | // do it better, then remove. |
| 210 | static bool |
210 | static bool |
| … | |
… | |
| 350 | int amount = sizeof (inbuf) - inbuf_len; |
350 | int amount = sizeof (inbuf) - inbuf_len; |
| 351 | |
351 | |
| 352 | if (!amount) |
352 | if (!amount) |
| 353 | { |
353 | { |
| 354 | // input buffer full |
354 | // input buffer full |
| 355 | socket_ev.poll (socket_ev.poll () & ~EV_READ); |
355 | LOG (llevError, "input buffer overflow."); |
|
|
356 | destroy (); |
| 356 | return; |
357 | return; |
| 357 | } |
358 | } |
| 358 | |
359 | |
|
|
360 | if (ws_version) |
|
|
361 | { |
|
|
362 | if (ws_inbuf_len + 2048 > ws_inbuf_alloc) |
|
|
363 | ws_inbuf = (uint8 *)realloc (ws_inbuf, ws_inbuf_alloc += 4096); |
|
|
364 | |
|
|
365 | int len = read (fd, ws_inbuf + ws_inbuf_len, ws_inbuf_alloc - ws_inbuf_len); |
|
|
366 | |
|
|
367 | if (len > 0) |
|
|
368 | { |
|
|
369 | ws_inbuf_len += len; |
|
|
370 | |
|
|
371 | if (ws_inbuf_len < 2 + 4) // 6 is minimum length: op, len, mask |
|
|
372 | return; |
|
|
373 | |
|
|
374 | int d = 2; |
|
|
375 | int o = ws_inbuf [0] & 15; |
|
|
376 | int l = ws_inbuf [1] & 127; |
|
|
377 | |
|
|
378 | if (l == 126) |
|
|
379 | { |
|
|
380 | l = (ws_inbuf [2] << 8) | ws_inbuf [3]; |
|
|
381 | d += 2; |
|
|
382 | } |
|
|
383 | else if (l == 127) |
|
|
384 | { |
|
|
385 | if (ws_inbuf_len < 2 + 8) |
|
|
386 | return; |
|
|
387 | |
|
|
388 | // we don't do extra long frames, if a browser wants to send >2**32 bytes, |
|
|
389 | // there are bigger issues to fix. |
|
|
390 | l = (ws_inbuf [6] << 24) |
|
|
391 | | (ws_inbuf [7] << 16) |
|
|
392 | | (ws_inbuf [8] << 8) |
|
|
393 | | ws_inbuf [9]; |
|
|
394 | d += 8; |
|
|
395 | } |
|
|
396 | |
|
|
397 | // we only continue if we have a complete frame |
|
|
398 | if (ws_inbuf_len < d + 4 + l) |
|
|
399 | return; |
|
|
400 | |
|
|
401 | switch (o) |
|
|
402 | { |
|
|
403 | case 0: o = ws_inbuf_type; break; // continuation |
|
|
404 | case 1: ws_inbuf_type = 1; break; // utf-8 |
|
|
405 | case 2: ws_inbuf_type = 2; break; // binary |
|
|
406 | } |
|
|
407 | |
|
|
408 | if (l > amount) |
|
|
409 | { |
|
|
410 | // input buffer full |
|
|
411 | LOG (llevError, "input buffer overflow (ws)."); |
|
|
412 | destroy (); |
|
|
413 | return; |
|
|
414 | } |
|
|
415 | |
|
|
416 | for (int i = 0; i < l; ++i) |
|
|
417 | inbuf [inbuf_len + i] = ws_inbuf [d + 4 + i] ^ ws_inbuf [d + (i & 3)]; |
|
|
418 | |
|
|
419 | // remove frame |
|
|
420 | ws_inbuf_len -= d + 4 + l; |
|
|
421 | memmove (ws_inbuf, ws_inbuf + d + 4 + l, ws_inbuf_len); |
|
|
422 | |
|
|
423 | switch (o) |
|
|
424 | { |
|
|
425 | case 1: // utf-8 |
|
|
426 | { |
|
|
427 | uint8 *a = inbuf + inbuf_len; |
|
|
428 | uint8 *b = a; |
|
|
429 | uint8 *c = a + l; |
|
|
430 | |
|
|
431 | for (; a < c; ++a, ++b) |
|
|
432 | { |
|
|
433 | *b = *a; |
|
|
434 | |
|
|
435 | if (*a >= 0x80) |
|
|
436 | *b = (a [0] & 0x1f) << 6 | (a [1] & 0x3f), ++a; |
|
|
437 | } |
|
|
438 | |
|
|
439 | l -= a - b; |
|
|
440 | } |
|
|
441 | break; |
|
|
442 | case 2: // binary |
|
|
443 | break; |
|
|
444 | |
|
|
445 | case 9: // ping |
|
|
446 | { |
|
|
447 | // send pong - we assume ping messages are <64k |
|
|
448 | // as we can't handle >10k at the moment anyway. |
|
|
449 | uint8 hdr [] = { 0x8a, 126, l >> 8, l }; |
|
|
450 | send (hdr, sizeof (hdr)); |
|
|
451 | send (inbuf + inbuf_len, l); |
|
|
452 | } |
|
|
453 | return; |
|
|
454 | |
|
|
455 | case 10: // pong |
|
|
456 | return; |
|
|
457 | |
|
|
458 | case 8: // close |
|
|
459 | default: |
|
|
460 | destroy (); |
|
|
461 | return; |
|
|
462 | } |
|
|
463 | |
|
|
464 | amount = l; |
|
|
465 | } |
|
|
466 | else |
|
|
467 | amount = -1; |
|
|
468 | } |
|
|
469 | else |
| 359 | amount = read (fd, inbuf + inbuf_len, amount); |
470 | amount = read (fd, inbuf + inbuf_len, amount); |
| 360 | |
471 | |
| 361 | if (!amount) |
472 | if (!amount) |
| 362 | { |
473 | { |
| 363 | destroy (); |
474 | destroy (); |
| 364 | return; |
475 | return; |
| … | |
… | |
| 455 | } |
566 | } |
| 456 | |
567 | |
| 457 | if (!sl.length ()) |
568 | if (!sl.length ()) |
| 458 | return; |
569 | return; |
| 459 | |
570 | |
|
|
571 | if (ws_version == 8) |
|
|
572 | { |
|
|
573 | static uint8 buf [MAXSOCKBUF * 2 + 4]; |
|
|
574 | |
|
|
575 | uint8 *b = buf + 4; |
|
|
576 | for (uint8 *a = sl.buf_ + sl.hdrlen; a < sl.cur; ++a) |
|
|
577 | { |
|
|
578 | if (*a < 0x80) |
|
|
579 | *b++ = *a; |
|
|
580 | else |
|
|
581 | { |
|
|
582 | *b++ = 0xc0 | ((*a >> 6) & 0x1f); |
|
|
583 | *b++ = 0x80 | ( *a & 0x3f); |
|
|
584 | } |
|
|
585 | } |
|
|
586 | |
|
|
587 | assert (b - buf < sizeof (buf)); |
|
|
588 | |
|
|
589 | int l = b - (buf + 4); |
|
|
590 | |
|
|
591 | if (l < 126) |
|
|
592 | { |
|
|
593 | buf [2] = 0x81; |
|
|
594 | buf [3] = l; |
|
|
595 | |
|
|
596 | send (buf + 2, l + 2); |
|
|
597 | } |
|
|
598 | else |
|
|
599 | { |
|
|
600 | buf [0] = 0x81; |
|
|
601 | buf [1] = 126; |
|
|
602 | buf [2] = l >> 8; |
|
|
603 | buf [3] = l; |
|
|
604 | |
|
|
605 | send (buf, l + 4); |
|
|
606 | } |
|
|
607 | } |
|
|
608 | else if (ws_version == 13) |
|
|
609 | { |
|
|
610 | int l = sl.length (); |
|
|
611 | |
|
|
612 | if (l < 126) |
|
|
613 | { |
|
|
614 | uint8 hdr [] = { 0x82, l }; |
|
|
615 | send (hdr, sizeof (hdr)); |
|
|
616 | } |
|
|
617 | else |
|
|
618 | { |
|
|
619 | uint8 hdr [] = { 0x82, 126, l >> 8, l }; |
|
|
620 | send (hdr, sizeof (hdr)); |
|
|
621 | } |
|
|
622 | |
|
|
623 | send (sl.buf_ + sl.hdrlen, l); |
|
|
624 | } |
|
|
625 | else |
|
|
626 | { |
| 460 | assert (sl.hdrlen == 2); |
627 | assert (sl.hdrlen == 2); |
| 461 | |
628 | |
| 462 | sl.buf_ [0] = sl.length () >> 8; |
629 | sl.buf_ [0] = sl.length () >> 8; |
| 463 | sl.buf_ [1] = sl.length () ; |
630 | sl.buf_ [1] = sl.length () ; |
| 464 | |
631 | |
| 465 | send (sl.buf_, sl.length () + sl.hdrlen); |
632 | send (sl.buf_, sl.length () + sl.hdrlen); |
|
|
633 | } |
| 466 | } |
634 | } |
| 467 | |
635 | |
| 468 | void |
636 | void |
| 469 | client::send_packet (const char *buf, int len) |
637 | client::send_packet (const char *buf, int len) |
| 470 | { |
638 | { |
