HTTP/2サンプル実装 (共通ルーチン)

HTTP/2 を理解するために, 簡単に実装してみました。

ここでは, 次の2種類のサンプルの, 共通ルーチンを実装します。HTTP/2プロトコルの説明も行います。

HTTP/2

ストリーム, フレーム

HTTP/2 は,「ストリーム」と「フレーム」という単位で, メッセージをやりとりします。

Connection はソケット接続です。基本的なコンセプトとして, 一つのソケット接続のなかで、並列で, リソースのリクエストとレスポンスをやり取りします. 一つ一つの論理的なデータのやり取りが「ストリーム」です。


図の出典: https://developers.google.com/web/fundamentals/performance/http2/

実際には, ある程度細切れにした「フレーム」を並べることで, 多重化します。各ストリームを一つのソケットに畳み込むために, 各フレームにストリームIDを付け, どのストリームのデータなのかを区別します。

一つ一つのフレームは, 9バイトのヘッダと, 内容のペイロードからなります。

フレームは, 次のいずれかの frame type を持ちます.

0x0 DATA リクエストボディや、レスポンスボディ.
0x1 HEADERS 非圧縮または圧縮されたHTTPヘッダ
0x2 PRIORITY ストリームの優先度を変更. RFC 9113 (June 2022) で非推奨になった. 互換性のために送信することはできるが、単に無視される.
0x3 RST_STREAM ストリームの終了を通知
0x4 SETTINGS 接続に関する設定
0x5 PUSH_PROMISE サーバからのリソースのプッシュ通知
0x6 PING 接続状況を確認する
0x7 GOAWAY 接続の終了を通知
0x8 WINDOW_UPDATE フロー制御ウィンドウを更新する
0x9 CONTINUATION HEADERSフレームやPUSH_PROMISEフレームの続きのデータ

HTTP/1.1 のリクエストとレスポンスはそれぞれ, HTTP/2 では HEADERSフレームと DATA フレームに分かれます。GETメソッドなら, HEADERSフレームだけを送信します。

ヘッダやリソースが一つのフレームに入りきらない場合, HEADERS も DATA も、複数のフレームに跨ることがあります。HEADERS が長いときは CONTINUATIONフレーム, DATA のほうは、このフレーム自体に継続フラグがあります。

双方向

HTTP/1.1 と同様に, クライアントからリクエストを出し、サーバからレスポンスとしてデータを返す方法が一つ。HTTP/2 では, サーバからデータを push することもできます。そのため, ストリームは, クライアントからも, サーバからも開始できます。

クライアントがリソースを要求した場合, サーバのほうから関連するリソースもついでに送信できます。サーバから, PUSH_PROMISE フレームを開始します。

[2020.12] サーバpush には, すでにクライアント側でキャッシュされていれば無駄になる、などの問題があり、Google Chrome では廃止予定。デフォルトではこの設定は有効のため, SETTINGS_ENABLE_PUSH = 0 (無効化) をすべての接続の冒頭に送信する。See Intent to Remove: HTTP/2 and gQUIC server push

ヘッダ

TLS版と非TLS (平文) 版で共通化できるように, Http2Reader クラスを用意します。

実際の通信は, std::streambuf を拡張した, SocketStreamBuf クラスで行います; streambuf を拡張し, ソケット対応 [C++]

http2_common.h ファイル:

C++
[RAW]
  1. // HTTP/2 フレーム単位での読み込み.
  2. class Http2Reader
  3. {
  4. typedef void (*Func)(const char* buf, int payload_length);
  6. std::streambuf* m_conn;
  8. char* m_framebuf;
  9. int m_bufsize;
  11. Func m_func;
  13. public:
  14. Http2Reader() : m_conn(nullptr), m_framebuf(nullptr), m_bufsize(0) { }
  16. virtual ~Http2Reader()
  17. {
  18. if (m_framebuf) {
  19. free(m_framebuf);
  20. m_framebuf = nullptr;
  21. m_bufsize = 0;
  22. }
  23. }
  25. void add_listener( Func func );
  27. void attach(std::streambuf* conn);
  29. // フレーム (バイナリデータ)
  30. char* read_frame();
  32. // 行
  33. std::string getline();
  34. };

実装

ヘッダの解析, ヘッダの送信

HTTP/2 のヘッダ (HEADERSフレーム) は, HPACK という方法で圧縮されます。これが地味に難しい。

次のようなバイト列の繰り返しです。最初のバイトで, フィールド名を省略するのかどうか, インデックスをどうするのか, などを選択し, それによって後続のバイト列が決まります。 

     0   1   2   3   4   5   6   7
   +---+---+---+---+---+---+---+---+
   | 0 | 0 | 0 | 0 |       0       | このオクテットの上位ビットで、後続が変わる。
   +---+---+-----------------------+
   | H |     Name Length (7+)      |
   +---+---------------------------+
   |  Name String (Length octets)  |
   +---+---------------------------+
   | H |     Value Length (7+)     |
   +---+---------------------------+
   | Value String (Length octets)  |
   +-------------------------------+

バイト列を短くするために, 仕様で事前定義された主なヘッダフィールド名があります。インデックスによる既出のヘッダフィールドの省略も可能です。

実装では, インデックスのデコード, フィールド値のデコードが必要です。文字列は, ハフマン符号化によって圧縮されています。

(2018.7 update) 全部を実装するのは大変で、ギブアップしました。ここでは、既存のライブラリを使います。

HPACK の実装としては, ほかにも例えば, こちらがあります; jnferguson/hpack-rfc7541: header-only c++ implementation of a HTTPv2 HPACK/RFC7541 encoder /decoder. ヘッダ1ファイルで実装しています。これを見ると, 複雑さが分かります。

C++
[RAW]
  1. /*
  2. * RFC 7541 HPACK: Header Compression for HTTP/2
  3. */
  4. int dump_HEADERS_payload( const char* payload, int payload_length )
  5. {
  6. int isfinal = 1; // TODO:
  7. int rv;
  9. const char* in;
  10. for ( in = payload; in < payload + payload_length; ) {
  11. nghttp2_nv nv;
  12. int inflate_flags = 0; // ret
  13. rv = nghttp2_hd_inflate_hd2(m_inflater, &nv, &inflate_flags,
  14. (unsigned char*) in, payload_length - (in - payload),
  15. isfinal);
  16. if (rv < 0) {
  17. fprintf(stderr, "inflate failed: %d\n", rv);
  18. return -1;
  19. }
  20. if ( (inflate_flags & NGHTTP2_HD_INFLATE_EMIT) != 0 ) {
  21. string name, value;
  22. name.assign((char*) nv.name, nv.namelen);
  23. value.assign((char*) nv.value, nv.valuelen);
  24. printf("%s: %s\n", name.c_str(), value.c_str());
  25. }
  27. in += rv;
  28. }
  30. return 0;
  31. }

一方, HEADERS フレームの送信は, 無圧縮と決め打ちすれば, それほど難しくありません。

C++
[RAW]
  1. int send_HEADERS_frame( streambuf* conn, int stream_id,
  2. const map<string, string>& m )
  3. {
  4. assert(conn);
  6. char buf[1000];
  7. char* p = buf;
  9. // ヘッダ (9バイト)
  10. *p++ = 0; *p++ = 0; *p++ = 0;
  11. *p++ = 0x01; // HEADERS
  12. *p++ = 0x04;
  13. uint32_t nid = htonl(stream_id);
  14. memcpy(p, &nid, 4); p+= 4;
  16. // payload
  17. for ( auto& req : m ) {
  18. *p++ = 0x00; // 圧縮情報
  19. int len = req.first.size();
  20. assert(len <= 255);
  21. *p++ = len;
  22. memcpy(p, req.first.c_str(), len); p += len;
  23. len = req.second.size();
  24. assert(len <= 255);
  25. *p++ = len;
  26. memcpy(p, req.second.c_str(), len); p += len;
  27. }
  29. uint32_t n3 = htonl(p - buf - FRAME_HDR_LENGTH); // ヘッダの長さは含まない
  30. memcpy(buf, ((char*) &n3) + 1, 3);
  32. dump_frame_header('S', buf);
  33. dump_HEADERS_payload( buf + FRAME_HDR_LENGTH, p - buf - FRAME_HDR_LENGTH );
  34. ssize_t r = conn->sputn( buf, p - buf );
  35. if ( r < 0 ) {
  36. //int error = get_error();
  37. //conn->close();
  38. return r;
  39. }
  41. return r;
  42. }

ソケットを読む

HTTP/2 は, ソケットを読むとき, 行指向の部分と, フレーム単位のバイナリ列の部分があります。どちらの形でも読めるようにしなければなりません。

まずはフレーム単位。ストリームの長さは非常に巨大になることがありますが、フレームは, メモリに載る大きさと仮定して大丈夫です。

C++
[RAW]
  1. // 1フレーム分を読む.
  2. char* Http2Reader::read_frame()
  3. {
  4. assert(m_conn);
  5. assert(m_bufsize >= FRAME_HDR_LENGTH);
  7. // ヘッダ (9バイト)
  8. m_conn->sgetn(m_framebuf, FRAME_HDR_LENGTH);
  10. int payload_length = 0;
  11. ntoh3(m_framebuf, &payload_length);
  13. if (FRAME_HDR_LENGTH + payload_length > m_bufsize) {
  14. m_bufsize = FRAME_HDR_LENGTH + payload_length;
  15. m_framebuf = (char*) realloc(m_framebuf, m_bufsize);
  16. }
  18. // payload
  19. m_conn->sgetn(m_framebuf + FRAME_HDR_LENGTH, payload_length);
  21. return m_framebuf;
  22. }

行として読む場合。streambuf がバッファリングの難しい部分をやってくれるので、非常に簡単です。

C++
[RAW]
  1. // @return 改行文字 (CRLF or LF) を含めない, 文字列.
  2. string Http2Reader::getline()
  3. {
  4. assert(m_conn);
  6. string ret;
  8. // sgetc() は位置を進めない. 罠か.
  9. int ch;
  10. while ( ch = m_conn->sbumpc(), (ch != EOF && ch != '\r' && ch != '\n') )
  11. ret.append(1, ch);
  13. if (ch == EOF)
  14. return ret;
  16. if (ch == '\r') {
  17. ch = m_conn->sgetc();
  18. if (ch == '\n')
  19. m_conn->sbumpc();
  20. }
  22. return ret;
  23. }

フレームの受信

いよいよフレームを受信し, DATAフレームを待ち構えます. frame type の解析がうまく実装できておらず, だいぶ手抜いています。

また, 別のストリームのフレームが交互に届く可能性を考慮できていません。

C++
[RAW]
  1. // 複数のストリームが、多重化されて送られてくる.
  2. // TODO: フレームをストリームに割り振る.
  3. void recv_streams(Http2Reader& reader)
  4. {
  5. int frame_type = 0;
  6. char* frame = nullptr;
  8. // HEADERS フレームを受信して, リソースの長さを取得する。
  9. while (true) {
  10. frame = reader.read_frame();
  11. dump_frame_header('R', frame);
  12. if (!frame)
  13. return;
  15. // payloadの長さ, frame typeを取得する。
  16. int payload_length = 0;
  17. ntoh3(frame, &payload_length);
  18. memcpy(&frame_type, frame + 3, 1);
  20. // ACKが返ってくる場合があるのでACKなら無視して次を読む。
  21. // TODO: listener を呼び出すようにする.
  22. if (memcmp(frame, settingframeAck, FRAME_HDR_LENGTH) == 0) {
  23. // 読みとばす
  24. continue;
  25. }
  27. if (frame_type == 0x3) { // RST_STREAM
  28. printf("error code = %x\n", *((int*) (frame + 9)));
  29. continue;
  30. }
  32. if (frame_type == 0x1) { // HEADERS
  33. // TODO: リソースの長さ
  34. int payload_length = 0;
  35. ntoh3(frame, &payload_length);
  36. dump_HEADERS_payload(frame + 9, payload_length);
  37. continue;
  38. }
  40. if (frame_type == 0x5) { // PUSH_PROMISE
  41. int payload_length = 0;
  42. ntoh3(frame, &payload_length);
  43. int stream_id = ntohl( *(int*) (frame + 9) );
  44. printf("promised stream-id: %d\n", stream_id);
  45. dump_HEADERS_payload(frame + 13, payload_length - 4);
  46. continue;
  47. }
  48. if (frame_type == 0x7) { // GOAWAY
  49. printf("last stream-id = %d; ", ntohl(*(int*) (frame + 9)));
  50. printf("error code = 0x%x\n", ntohl(*(int*) (frame + 13)));
  51. return;
  52. }
  53. if (frame_type == 0 ) // DATA
  54. break;
  55. }
  57. //------------------------------------------------------------
  58. // DATAフレームの受信.
  59. //------------------------------------------------------------
  60. int payload_length = 0;
  61. ntoh3(frame, &payload_length);
  63. frame[FRAME_HDR_LENGTH + 100 /*payload_length*/] = '\0'; // 手抜き
  64. printf("====DATA====\n");
  65. printf("%s", frame + FRAME_HDR_LENGTH);
  66. printf("====/DATA====\n");
  67. }