lsqpack 0.1.0

data/ls-qpack/test/test_read_enc_stream.c

@@ -0,0 +1,256 @@
+/*
+ * Read encoder stream
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lsqpack.h"
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+/* Dynamic table entry: */
+struct lsqpack_dec_table_entry
+{
+    unsigned    dte_name_len;
+    unsigned    dte_val_len;
+    unsigned    dte_refcnt;
+    char        dte_buf[0];     /* Contains both name and value */
+};
+
+#define DTE_NAME(dte) ((dte)->dte_buf)
+#define DTE_VALUE(dte) (&(dte)->dte_buf[(dte)->dte_name_len])
+
+
+struct test_read_encoder_stream
+{
+    int             lineno;
+
+    /* Input */
+    unsigned char   input[0x100];
+    size_t          input_sz;
+
+    /* Output */
+    unsigned        n_entries;
+    struct {
+        const char *name, *value;
+    }               dyn_table[10];
+};
+
+
+static const struct test_read_encoder_stream tests[] =
+{
+
+    {   __LINE__,
+        "\xc0\x8b\xf1\xe3\xc2\xf5\x15\x31\xa2\x45\xcf\x64\xdf",
+        13,
+        1,
+        {
+            { ":authority", "www.netbsd.org", },
+        },
+    },
+
+    {   __LINE__,
+        "\xc0\x00",
+        2,
+        1,
+        {
+            { ":authority", "", },
+        },
+    },
+
+    {   __LINE__,
+        "\xc0\x8b\xf1\xe3\xc2\xf5\x15\x31\xa2\x45\xcf\x64\xdf\x00",
+        14,
+        2,
+        {
+            { ":authority", "www.netbsd.org", },
+            { ":authority", "www.netbsd.org", },
+        },
+    },
+
+    {   __LINE__,
+        "\xc0\x8b\xf1\xe3\xc2\xf5\x15\x31\xa2\x45\xcf\x64\xdf\x00\x20",
+        15,
+        0,
+        {
+            { NULL, NULL, },
+        },
+    },
+
+    {   __LINE__,
+        "\xc0\x15" "Respect my authorata!",
+        2 + sizeof("Respect my authorata!") - 1,
+        1,
+        {
+            { ":authority", "Respect my authorata!", },
+        },
+    },
+
+    {   __LINE__,
+        "\x63\x92\xd9\x0b\x8c\xe5\x39\x6c\x2a\x86\x42\x94\xfa\x50\x83\xb3"
+        "\xfc",
+        17,
+        1,
+        {
+            { "dude", "Where is my car?", },
+        },
+    },
+
+    {   __LINE__,
+        "\x63\x92\xd9\x0b\x03\x61\x61\x7a",
+        8,
+        1,
+        {
+            { "dude", "aaz", },
+        },
+    },
+
+    {   __LINE__,
+        "\x43\x7a\x7a\x7a\x88\xcc\x6a\x0d\x48\xea\xe8\x3b\x0f",
+        13,
+        1,
+        {
+            { "zzz", "Kilimanjaro", },
+        },
+    },
+
+    {   __LINE__,
+        "\x43\x7a\x7a\x7a\x03\x61\x61\x7a",
+        8,
+        1,
+        {
+            { "zzz", "aaz", },
+        },
+    },
+
+    {   __LINE__,
+        "\x43\x7a\x7a\x7a\x03\x61\x61\x61\x80\x03\x61\x61\x7a",
+        13,
+        2,
+        {
+            { "zzz", "aaa", },
+            { "zzz", "aaz", },
+        },
+    },
+
+    {   __LINE__,
+        "\x40\x88\xcc\x6a\x0d\x48\xea\xe8\x3b\x0f",
+        10,
+        1,
+        {
+            { "", "Kilimanjaro", },
+        },
+    },
+
+    {   __LINE__,
+        "\x43\x7a\x7a\x7a\x00",
+        5,
+        1,
+        {
+            { "zzz", "", },
+        },
+    },
+
+    {   __LINE__,
+        "\x40\x00",
+        2,
+        1,
+        {
+            { "", "", },
+        },
+    },
+
+};
+
+
+struct ringbuf_iter
+{
+    const struct lsqpack_ringbuf *rbuf;
+    unsigned next, end;
+};
+
+
+#if LSQPACK_DEVEL_MODE
+unsigned
+ringbuf_count (const struct lsqpack_ringbuf *rbuf);
+
+void *
+ringbuf_iter_next (struct ringbuf_iter *iter);
+
+void *
+ringbuf_iter_first (struct ringbuf_iter *iter,
+                                        const struct lsqpack_ringbuf *rbuf);
+
+static void
+verify_dyn_table (const struct lsqpack_dec *dec,
+                            const struct test_read_encoder_stream *test)
+{
+    const struct lsqpack_dec_table_entry *entry;
+    unsigned n;
+    struct ringbuf_iter riter;
+
+    assert(ringbuf_count(&dec->qpd_dyn_table) == test->n_entries);
+
+    for (n = 0; n < test->n_entries; ++n)
+    {
+        if (n == 0)
+            entry = ringbuf_iter_first(&riter, &dec->qpd_dyn_table);
+        else
+            entry = ringbuf_iter_next(&riter);
+        assert(entry);
+        assert(entry->dte_name_len == strlen(test->dyn_table[n].name));
+        assert(entry->dte_val_len == strlen(test->dyn_table[n].value));
+        assert(0 == memcmp(DTE_NAME(entry), test->dyn_table[n].name, entry->dte_name_len));
+        assert(0 == memcmp(DTE_VALUE(entry), test->dyn_table[n].value, entry->dte_val_len));
+    }
+}
+#else
+static void
+verify_dyn_table (const struct lsqpack_dec *dec,
+                            const struct test_read_encoder_stream *test)
+{
+    fprintf(stderr, "LSQPACK_DEVEL_MODE is not compiled: cannot verify dynamic table\n");
+}
+#endif
+
+
+static void
+run_test (const struct test_read_encoder_stream *test)
+{
+    struct lsqpack_dec dec;
+    size_t chunk_sz, off;
+    int r;
+
+    for (chunk_sz = 1; chunk_sz <= test->input_sz; ++chunk_sz)
+    {
+        lsqpack_dec_init(&dec, NULL, 0x1000, 100, NULL);
+
+        off = 0;
+        do
+        {
+            r = lsqpack_dec_enc_in(&dec, test->input + off,
+                                        MIN(chunk_sz, test->input_sz - off));
+            assert(r == 0);
+            off += MIN(chunk_sz, test->input_sz - off);
+        }
+        while (off < test->input_sz);
+
+        verify_dyn_table(&dec, test);
+
+        lsqpack_dec_cleanup(&dec);
+    }
+}
+
+
+int
+main (void)
+{
+    const struct test_read_encoder_stream *test;
+
+    for (test = tests; test < tests + sizeof(tests) / sizeof(tests[0]); ++test)
+        run_test(test);
+
+    return 0;
+}

data/ls-qpack/tools/har2qif.pl

@@ -0,0 +1,139 @@
+#!/usr/bin/env perl
+#
+# har2qif.pl    - Convert HAR file to a QIF file.
+#
+# QIF stands for "QPACK Interop Format."  It is meant to be easy to parse,
+# write, and compare.  The idea is that the QIF input to an encoder can
+# be compared to QIF output produced by the decoder using `diff(1)':
+#
+#   sh$ har2qif -requests my.har > in.qif
+#   sh$ ./qpack-encoder-A in.qif > binary-format    # See wiki
+#   sh$ ./qpack-decoder-B binary-format > out.qif
+#   sh$ diff in.qif out.qif && echo "Success!"
+#
+# The QIF format is plain text.  Each header field in on a separate line,
+# with name and value separated by the TAB character.  An empty line
+# signifies the end of a header set.  Lines beginning with '#' are ignored.
+#
+# HTTP/2 header sets are left untouched, while non-HTTP/2 header sets are
+# transformed to resemble HTTP/2:
+#   - Header names are lowercased
+#   - `Host' header name is removed from requests
+#   - Requests get :method, :scheme, :authority, and :path pseudo-headers
+#   - Responses get :status pseudo-headers
+
+use strict;
+use warnings;
+
+use Getopt::Long;
+use JSON qw(decode_json);
+use URI;
+
+my $key = 'request';
+my ($limit, $split_cookie);
+
+GetOptions( "help" => sub {
+    print <<USAGE;
+Usage: $0 [options] [file.har] > file.qif
+
+Options:
+    -requests       Print headers from requests.  This is the default.
+    -responses      Print headers from responses.
+    -split-cookie   Split the Cookie: header.
+    -limit N        Limit number of header sets to N.  The default
+                      is no limit.
+
+If file.har is not specified, the HAR is read from stdin
+USAGE
+
+    exit;
+},
+            "requests"  => sub { $key = "request", },
+            "responses" => sub { $key = "response", },
+            "split-cookie" => \$split_cookie,
+            "limit=i"   => \$limit,
+);
+
+my $json = decode_json( do { undef $/; <> });
+my @messages = map $$_{$key}, @{ $json->{log}{entries} };
+if (defined($limit))
+{
+    splice @messages, $limit;
+}
+
+my @header_sets = do {
+    if ($key eq 'request') {
+        map req_header_set($_), @messages
+    } else {
+        map resp_header_set($_), @messages
+    }
+};
+
+for (@header_sets) {
+    no warnings 'uninitialized';
+    print map "$$_[0]\t$$_[1]\n", @$_;
+    print "\n";
+}
+
+exit;
+
+# Looking at capitalization of the first header is a more reliable means
+# of determining HTTP version than relying on httpVersion field.
+#
+sub is_http2 {
+    my $message = shift;
+    if (defined($$message{headers}[0])
+                                && defined($$message{headers}[0]{name})) {
+        return $$message{headers}[0]{name} =~ /^[a-z:]/;
+    } elsif (defined($$message{httpVersion})) {
+        return $$message{httpVersion} =~ m~HTTP/2~i;
+    } else {
+        return;
+    }
+}
+
+sub req_header_set {
+    my $message = shift;
+    my @set;
+    if (!is_http2($message)) {
+        my @headers = map [ lc($$_{name}), $$_{value}, ],
+                      grep $$_{name} ne 'Host', @{ $$message{headers} };
+        my $uri = URI->new($$message{url});
+        @set = (
+            [ ':method',    $$message{method}, ],
+            [ ':scheme',    $uri->scheme, ],
+            [ ':authority', $uri->authority, ],
+            [ ':path',      $uri->path_query, ],
+            @headers,
+        );
+    } else {
+        @set = map [ $$_{name}, $$_{value}, ], @{ $$message{headers} };
+    }
+    if ($split_cookie) {
+        return [ map {
+                    if ('cookie' eq $$_[0]) {
+                        map [ 'cookie', $_, ], split /;\s+/, $$_[1]
+                    } else {
+                        $_
+                    }
+                 } @set ];
+    } else {
+        return \@set;
+    }
+}
+
+sub resp_header_set {
+    my $message = shift;
+    no warnings 'uninitialized';
+    if (!is_http2($message)) {
+        my @headers = map [ lc($$_{name}), $$_{value}, ],
+                                                @{ $$message{headers} };
+        my $uri = URI->new($$message{url});
+        return [
+            [ ':status',    $$message{status}, ],
+            @headers,
+        ];
+    } else {
+        return [ map [ $$_{name}, $$_{value}, ], @{ $$message{headers} } ]
+    }
+}

data/ls-qpack/tools/randomize-cookies.pl

@@ -0,0 +1,41 @@
+#!/usr/bin/env perl
+#
+# Given a QIF file, randomize cookie headers
+#
+# Usage: randomize-cookies.pl input.qif > output.qif
+
+@chars = ('0' .. '9', 'a' .. 'z', 'A' .. 'Z', split '', '/+*');
+
+sub randomify {
+    $val = shift;
+
+    if (exists($cached_vals{$val})) {
+        return $cached_vals{$val};
+    }
+
+    @val = split '', $val;
+    $seen_eq = 0;
+    for ($i = 0; $i < @val; ++$i)
+    {
+        if ($val[$i] ne '=' or $seen_eq++)
+        {
+            $rand = $rand[$i] //= int(rand(@chars));
+            # Output is a function of both position and value:
+            $val[$i] = $chars[ ($rand + ord($val[$i])) % @chars ];
+        }
+    }
+
+    return $cached_vals{$val} = join '', @val;
+}
+
+while (<>) {
+    chomp;
+    if (m/^cookie\t(.*)/) {
+        print "cookie\t", randomify($1), "\n";
+    } elsif (m/^set-cookie\t(.*)/) {
+        print "set-cookie\t", join('; ', map randomify($_),
+                                                    split /;\s+/, $1), "\n";
+    } else {
+        print $_, "\n";
+    }
+}

data/ls-qpack/tools/sort-qif.pl

@@ -0,0 +1,31 @@
+#!/usr/bin/env perl
+#
+# sort-qif.pl -- sort QIF file
+#
+# Sort QIF file.  This assumes that the header lists in the QIF file have a
+# leading comment that looks like '# stream $number'.
+#
+# Usage: sort-qif.pl [--strip-comments] [files] [--output FILE]
+
+use Getopt::Long;
+
+GetOptions("strip-comments" => \$strip_comments, output => \$output);
+
+if (defined($output)) {
+    open STDOUT, ">", $output or die "cannot open $output for writing: $!";
+}
+
+$/ = "\n\n";
+
+@chunks = map $$_[1],
+          sort { $$a[0] <=> $$b[0] }
+          map { /^*#\s*stream\s+(\d+)/; [ $1, $_ ] }
+          <>;
+
+if ($strip_comments) {
+    for (@chunks) {
+        s/^#.*\n//mg;
+    }
+}
+
+print @chunks;