lsqpack demo

test.c

#include <stdio.h>
#include <stdlib.h>
#include "lsqpack.h"
#include "lsxpack_header.h"

void dhi_unblocked(void* hblock_ctx) {
  printf("dhi_unblocked\n");
}

typedef struct st_hblock_ctx {
  struct lsxpack_header xhdr;
  size_t buf_off;
  char   buf[0x1000];
} hblock_ctx_t;

struct lsxpack_header* dhi_prepare_decode(void* hblock_ctx_p, struct lsxpack_header* xhdr, size_t space) {
  printf("dhi_prepare_decode: xhdr=%lu, space=%lu\n", (size_t)xhdr, space);
  hblock_ctx_t* block_ctx = (hblock_ctx_t*)hblock_ctx_p;

  if (xhdr != NULL) {
    xhdr->val_len = space;
  } else {
    lsxpack_header_prepare_decode(&block_ctx->xhdr, block_ctx->buf, block_ctx->buf_off, space);
  }
  return &block_ctx->xhdr;;
}

int dhi_process_header(void* hblock_ctx, struct lsxpack_header* xhdr) {
  printf("dhi_process_header: xhdr=%lu\n", (size_t)xhdr);
  printf("%.*s: %.*s\n", xhdr->name_len, (xhdr->buf + xhdr->name_offset), xhdr->val_len, (xhdr->buf + xhdr->val_offset));
  return 0;
}

void print_bytes(void* buf, size_t len) {
  unsigned char* cbuf = (unsigned char*)buf;
  for (size_t i = 0; i < len; ++i) {
    int n = (int)cbuf[i];
    int u = (n >> 4) & 0xf;
    int l = (n) & 0xf;
    printf("%x%x", u, l);
  }
  printf("\n");
}

int main(int argc, char** argv) {
  struct lsqpack_enc* enc = malloc(sizeof(struct lsqpack_enc));
  size_t sdtc_buf_size = 1024;
  unsigned char* sdtc_buf = malloc(sdtc_buf_size);
  int ret = lsqpack_enc_init(enc, stdout, 0x1000, 0x1000, 0, 0, sdtc_buf, &sdtc_buf_size);
  printf("lsqpack_enc_init return = %d, sdtc_buf_size = %lu\n", ret, sdtc_buf_size);

  ret = lsqpack_enc_start_header(enc, 100, 0);
  printf("lsqpack_enc_start_header return = %d\n", ret);

  enum lsqpack_enc_status enc_status;
  size_t enc1_sz = 1024;
  unsigned char* enc1_buf = malloc(enc1_sz);
  size_t header1_sz = 1024;
  unsigned char* header1_buf = malloc(header1_sz);

  char* header1_raw = "aaaaaaaaaaaaa: helloworld";
  struct lsxpack_header header1;
  lsxpack_header_set_offset2(&header1, header1_raw, 0, 13, 15, 10);

  enc_status = lsqpack_enc_encode(enc,
    enc1_buf, &enc1_sz,
    header1_buf, &header1_sz,
    &header1,
    0);
  printf("lsqpack_enc_encode return = %d, buf_sz = %lu, header_sz = %lu\n", enc_status, enc1_sz, header1_sz);
  print_bytes(enc1_buf, enc1_sz);
  print_bytes(header1_buf, header1_sz);

  char* header2_raw = ":method: GET";
  struct lsxpack_header header2;
  lsxpack_header_set_offset2(&header2, header2_raw, 0, 7, 9, 3);

  size_t enc2_sz = 1024;
  unsigned char* enc2_buf = malloc(enc2_sz);
  size_t header2_sz = 1024;
  unsigned char* header2_buf = malloc(header2_sz);

  enc_status = lsqpack_enc_encode(enc,
    enc2_buf, &enc2_sz,
    header2_buf, &header2_sz,
    &header2,
    0);
  printf("lsqpack_enc_encode return = %d, buf_sz = %lu, header_sz = %lu\n", enc_status, enc2_sz, header2_sz);
  print_bytes(enc2_buf, enc2_sz);
  print_bytes(header2_buf, header2_sz);

  size_t end_header_size = 1024;
  unsigned char* end_header_buf = malloc(sizeof(unsigned char) * end_header_size);
  size_t end_header_ret = lsqpack_enc_end_header(enc, end_header_buf, end_header_size, NULL);
  printf("lsqpack_enc_end_header return = %lu\n", end_header_ret);
  print_bytes(end_header_buf, end_header_ret);

  struct lsqpack_dec* dec = malloc(sizeof(struct lsqpack_dec));
  struct lsqpack_dec_hset_if hset_if;
  hset_if.dhi_unblocked = dhi_unblocked;
  hset_if.dhi_prepare_decode = dhi_prepare_decode;
  hset_if.dhi_process_header = dhi_process_header;
  lsqpack_dec_init(dec, stdout, 0x1000, 0, &hset_if, 0);

  /*
  size_t all_header_sz = end_header_ret + header1_sz + header2_sz;
  unsigned char* all_header = malloc(all_header_sz);
  const unsigned char* all_header_ptr = all_header;
  memcpy(all_header, end_header_buf, end_header_ret);
  memcpy(all_header + end_header_ret, header1_buf, header1_sz);
  memcpy(all_header + end_header_ret + header1_sz, header2_buf, header2_sz);
  printf("all_header_sz = %lu\n", all_header_sz);
  print_bytes(all_header, all_header_sz);
  */

  hblock_ctx_t* block_ctx = malloc(sizeof(hblock_ctx_t));
  memset(block_ctx, 0, sizeof(hblock_ctx_t));
  // size_t dec_sz = 1024;
  // void* dec_buf = malloc(dec_sz);
  enum lsqpack_read_header_status read_status;
  // read_status = lsqpack_dec_header_in(dec, block_ctx, 100, all_header_sz, &all_header_ptr, all_header_sz, NULL, NULL);
  // printf("lsqpack_dec_header_in return = %d, all_header_ptr = %lu, all_header = %lu\n", read_status, (size_t)all_header_ptr, (size_t)all_header);

  const unsigned char* const_end_header_buf = end_header_buf;
  read_status = lsqpack_dec_header_in(dec, block_ctx, 100,
    end_header_ret + header1_sz + header2_sz,
    &const_end_header_buf, end_header_ret,
    NULL, NULL);
  printf("lsqpack_dec_header_in return = %d, const_end_header_buf = %lu, end_header_buf = %lu\n",
    read_status, (size_t)const_end_header_buf, (size_t)end_header_buf);

  const unsigned char* const_header1_buf = header1_buf;
  read_status = lsqpack_dec_header_read(dec, block_ctx,
    &const_header1_buf, header1_sz,
    NULL, NULL);
  printf("lsqpack_dec_header_read return = %d, const_header1_buf = %lu, header1_buf = %lu\n",
    read_status, (size_t)const_header1_buf, (size_t)header1_buf);

  const unsigned char* const_header2_buf = header2_buf;
  read_status = lsqpack_dec_header_read(dec, block_ctx,
    &const_header2_buf, header2_sz,
    NULL, NULL);
  printf("lsqpack_dec_header_read return = %d, const_header2_buf = %lu, header2_buf = %lu\n",
    read_status, (size_t)const_header2_buf, (size_t)header2_buf);

  return 0;
}