Class: Raptor::Http2Parser

Inherits:
Object
  • Object
show all
Defined in:
ext/raptor_http2/raptor_http2.c

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.connection_preface ⇒ Object 



666
667
668
669
 
# File 'ext/raptor_http2/raptor_http2.c', line 666

static VALUE h2_connection_preface(VALUE self) {
  (void)self;
  return rb_str_new(HTTP2_CONNECTION_PREFACE, HTTP2_CONNECTION_PREFACE_LEN);
}

Instance Method Details

#build_frame(type, flags, stream_id, payload) ⇒ Object 



626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
 
# File 'ext/raptor_http2/raptor_http2.c', line 626

static VALUE h2_build_frame(VALUE self, VALUE type, VALUE flags, VALUE stream_id, VALUE payload) {
  (void)self;

  uint8_t frame_type;
  ID type_id = SYM2ID(type);

  if (type_id == rb_intern("data"))               frame_type = FRAME_DATA;
  else if (type_id == rb_intern("headers"))        frame_type = FRAME_HEADERS;
  else if (type_id == rb_intern("priority"))       frame_type = FRAME_PRIORITY;
  else if (type_id == rb_intern("rst_stream"))     frame_type = FRAME_RST_STREAM;
  else if (type_id == rb_intern("settings"))       frame_type = FRAME_SETTINGS;
  else if (type_id == rb_intern("push_promise"))   frame_type = FRAME_PUSH_PROMISE;
  else if (type_id == rb_intern("ping"))           frame_type = FRAME_PING;
  else if (type_id == rb_intern("goaway"))         frame_type = FRAME_GOAWAY;
  else if (type_id == rb_intern("window_update"))  frame_type = FRAME_WINDOW_UPDATE;
  else if (type_id == rb_intern("continuation"))   frame_type = FRAME_CONTINUATION;
  else rb_raise(rb_eArgError, "unknown frame type");

  uint8_t frame_flags = (uint8_t)NUM2UINT(flags);
  uint32_t sid = NUM2UINT(stream_id);

  const char *payload_ptr = NIL_P(payload) ? "" : RSTRING_PTR(payload);
  size_t payload_len = NIL_P(payload) ? 0 : RSTRING_LEN(payload);

  uint8_t header[HTTP2_FRAME_HEADER_SIZE];
  header[0] = (payload_len >> 16) & 0xff;
  header[1] = (payload_len >> 8) & 0xff;
  header[2] = payload_len & 0xff;
  header[3] = frame_type;
  header[4] = frame_flags;
  header[5] = (sid >> 24) & 0x7f;
  header[6] = (sid >> 16) & 0xff;
  header[7] = (sid >> 8) & 0xff;
  header[8] = sid & 0xff;

  VALUE result = rb_str_new((const char *)header, HTTP2_FRAME_HEADER_SIZE);
  rb_str_buf_cat(result, payload_ptr, payload_len);
  return result;
}

#build_settings(settings) ⇒ Object 



707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
 
# File 'ext/raptor_http2/raptor_http2.c', line 707

static VALUE h2_build_settings(VALUE self, VALUE settings) {
  (void)self;
  Check_Type(settings, T_HASH);

  VALUE buf = rb_str_buf_new(36);
  VALUE keys = rb_funcall(settings, rb_intern("keys"), 0);

  for (long i = 0; i < RARRAY_LEN(keys); i++) {
    VALUE key = rb_ary_entry(keys, i);
    VALUE val = rb_hash_aref(settings, key);
    ID key_id = SYM2ID(key);

    uint16_t id;
    if (key_id == rb_intern("header_table_size"))           id = SETTINGS_HEADER_TABLE_SIZE;
    else if (key_id == rb_intern("enable_push"))            id = SETTINGS_ENABLE_PUSH;
    else if (key_id == rb_intern("max_concurrent_streams")) id = SETTINGS_MAX_CONCURRENT_STREAMS;
    else if (key_id == rb_intern("initial_window_size"))    id = SETTINGS_INITIAL_WINDOW_SIZE;
    else if (key_id == rb_intern("max_frame_size"))         id = SETTINGS_MAX_FRAME_SIZE;
    else if (key_id == rb_intern("max_header_list_size"))   id = SETTINGS_MAX_HEADER_LIST_SIZE;
    else continue;

    uint32_t v = NUM2UINT(val);
    uint8_t entry[6];
    entry[0] = (id >> 8) & 0xff;
    entry[1] = id & 0xff;
    entry[2] = (v >> 24) & 0xff;
    entry[3] = (v >> 16) & 0xff;
    entry[4] = (v >> 8) & 0xff;
    entry[5] = v & 0xff;
    rb_str_buf_cat(buf, (const char *)entry, 6);
  }

  return buf;
}

#encode_headers(headers) ⇒ Object 



595
596
597
598
599
 
# File 'ext/raptor_http2/raptor_http2.c', line 595

static VALUE h2_encode_headers(VALUE self, VALUE headers) {
  (void)self;
  Check_Type(headers, T_ARRAY);
  return hpack_encode_header_block(headers);
}

#parse_frame(buffer) ⇒ Object 



601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
 
# File 'ext/raptor_http2/raptor_http2.c', line 601

static VALUE h2_parse_frame(VALUE self, VALUE buffer) {
  (void)self;
  Check_Type(buffer, T_STRING);

  const uint8_t *buf = (const uint8_t *)RSTRING_PTR(buffer);
  size_t len = RSTRING_LEN(buffer);

  if (len < HTTP2_FRAME_HEADER_SIZE) return Qnil;

  frame_header fh;
  parse_frame_header(buf, &fh);

  size_t total = HTTP2_FRAME_HEADER_SIZE + fh.length;
  if (len < total) return Qnil;

  VALUE frame = rb_hash_new();
  rb_hash_aset(frame, ID2SYM(rb_intern("type")),      frame_type_sym(fh.type));
  rb_hash_aset(frame, ID2SYM(rb_intern("length")),     UINT2NUM(fh.length));
  rb_hash_aset(frame, ID2SYM(rb_intern("flags")),      UINT2NUM(fh.flags));
  rb_hash_aset(frame, ID2SYM(rb_intern("stream_id")),  UINT2NUM(fh.stream_id));
  rb_hash_aset(frame, ID2SYM(rb_intern("payload")),    rb_str_new((const char *)(buf + HTTP2_FRAME_HEADER_SIZE), fh.length));

  return rb_ary_new_from_args(2, frame, SIZET2NUM(total));
}

#parse_headers(header_block, dyn_table) ⇒ Object 



574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
 
# File 'ext/raptor_http2/raptor_http2.c', line 574

static VALUE h2_parse_headers(VALUE self, VALUE header_block, VALUE dyn_table) {
  raptor_h2_parser *parser;
  TypedData_Get_Struct(self, raptor_h2_parser, &h2_parser_type, parser);

  Check_Type(header_block, T_STRING);
  Check_Type(dyn_table, T_ARRAY);

  const uint8_t *buf = (const uint8_t *)RSTRING_PTR(header_block);
  size_t len = RSTRING_LEN(header_block);

  VALUE headers = rb_ary_new();
  VALUE table = rb_ary_dup(dyn_table);
  long max_size = parser->max_table_size;

  if (hpack_decode_header_block(buf, len, headers, &table, &max_size) < 0)
    rb_raise(eHttp2ParserError, "HPACK header block decode error");

  parser->max_table_size = max_size;
  return rb_ary_new_from_args(2, headers, table);
}

#parse_settings(payload) ⇒ Object 



671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
 
# File 'ext/raptor_http2/raptor_http2.c', line 671

static VALUE h2_parse_settings(VALUE self, VALUE payload) {
  (void)self;
  Check_Type(payload, T_STRING);

  const uint8_t *buf = (const uint8_t *)RSTRING_PTR(payload);
  size_t len = RSTRING_LEN(payload);

  if (len % 6 != 0)
    rb_raise(eHttp2ParserError, "invalid SETTINGS payload length");

  VALUE settings = rb_hash_new();

  for (size_t i = 0; i < len; i += 6) {
    uint16_t id = ((uint16_t)buf[i] << 8) | buf[i + 1];
    uint32_t val = ((uint32_t)buf[i + 2] << 24) | ((uint32_t)buf[i + 3] << 16) |
                   ((uint32_t)buf[i + 4] << 8) | buf[i + 5];

    switch (id) {
      case SETTINGS_HEADER_TABLE_SIZE:
        rb_hash_aset(settings, ID2SYM(rb_intern("header_table_size")), UINT2NUM(val));       break;
      case SETTINGS_ENABLE_PUSH:
        rb_hash_aset(settings, ID2SYM(rb_intern("enable_push")), UINT2NUM(val));              break;
      case SETTINGS_MAX_CONCURRENT_STREAMS:
        rb_hash_aset(settings, ID2SYM(rb_intern("max_concurrent_streams")), UINT2NUM(val));   break;
      case SETTINGS_INITIAL_WINDOW_SIZE:
        rb_hash_aset(settings, ID2SYM(rb_intern("initial_window_size")), UINT2NUM(val));      break;
      case SETTINGS_MAX_FRAME_SIZE:
        rb_hash_aset(settings, ID2SYM(rb_intern("max_frame_size")), UINT2NUM(val));           break;
      case SETTINGS_MAX_HEADER_LIST_SIZE:
        rb_hash_aset(settings, ID2SYM(rb_intern("max_header_list_size")), UINT2NUM(val));     break;
    }
  }

  return settings;
}

#parse_window_update(payload) ⇒ Object 



742
743
744
745
746
747
748
749
750
751
752
753
754
 
# File 'ext/raptor_http2/raptor_http2.c', line 742

static VALUE h2_parse_window_update(VALUE self, VALUE payload) {
  (void)self;
  Check_Type(payload, T_STRING);

  if (RSTRING_LEN(payload) != 4)
    rb_raise(eHttp2ParserError, "invalid WINDOW_UPDATE payload length");

  const uint8_t *buf = (const uint8_t *)RSTRING_PTR(payload);
  uint32_t increment = ((uint32_t)(buf[0] & 0x7f) << 24) | ((uint32_t)buf[1] << 16) |
                       ((uint32_t)buf[2] << 8) | buf[3];

  return UINT2NUM(increment);
}