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 



726
727
728
729
 
# File 'ext/raptor_http2/raptor_http2.c', line 726

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 



686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
 
# File 'ext/raptor_http2/raptor_http2.c', line 686

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 



767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
 
# File 'ext/raptor_http2/raptor_http2.c', line 767

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 



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

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

#encode_response_headers(status, headers) ⇒ Object 



650
651
652
653
654
655
656
657
658
659
 
# File 'ext/raptor_http2/raptor_http2.c', line 650

static VALUE h2_encode_response_headers(VALUE self, VALUE status, VALUE headers) {
  (void)self;
  Check_Type(headers, T_HASH);

  VALUE pairs = rb_ary_new();
  rb_ary_push(pairs, rb_ary_new_from_args(2, rb_str_new_lit(":status"), rb_obj_as_string(status)));
  rb_hash_foreach(headers, response_headers_iter, pairs);

  return hpack_encode_header_block(pairs);
}

#parse_frame(buffer) ⇒ Object 



661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
 
# File 'ext/raptor_http2/raptor_http2.c', line 661

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 



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

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 



731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'ext/raptor_http2/raptor_http2.c', line 731

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 



802
803
804
805
806
807
808
809
810
811
812
813
814
 
# File 'ext/raptor_http2/raptor_http2.c', line 802

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);
}