h2o_iovec_t h2o_http2_casper_get_cookie(h2o_http2_casper_t *casper)
{
if (casper->cookie_cache.base != NULL)
return casper->cookie_cache;
if (casper->keys.size == 0)
return (h2o_iovec_t){};
/* encode as binary */
char tiny_bin_buf[128], *bin_buf = tiny_bin_buf;
size_t bin_capacity = sizeof(tiny_bin_buf), bin_size;
while (bin_size = bin_capacity,
golombset_encode(casper->remainder_bits, casper->keys.entries, casper->keys.size, bin_buf, &bin_size) != 0) {
if (bin_buf != tiny_bin_buf)
free(bin_buf);
bin_capacity *= 2;
bin_buf = h2o_mem_alloc(bin_capacity);
}
char *header_bytes = h2o_mem_alloc(sizeof(COOKIE_NAME "=" COOKIE_ATTRIBUTES) - 1 + (bin_size + 3) * 4 / 3);
size_t header_len = 0;
header_len += append_str(header_bytes + header_len, H2O_STRLIT(COOKIE_NAME "="));
header_len += h2o_base64_encode(header_bytes + header_len, bin_buf, bin_size, 1);
header_len += append_str(header_bytes + header_len, H2O_STRLIT(COOKIE_ATTRIBUTES));
if (bin_buf != tiny_bin_buf)
free(bin_buf);
casper->cookie_cache = h2o_iovec_init(header_bytes, header_len);
return casper->cookie_cache;
}
static void create_accept_key(char *dst, const char *client_key)
{
uint8_t sha1buf[20], key_src[60];
memcpy(key_src, client_key, 24);
memcpy(key_src + 24, WS_GUID, 36);
SHA1(key_src, sizeof(key_src), sha1buf);
h2o_base64_encode(dst, sha1buf, sizeof(sha1buf), 0);
dst[28] = '\0';
}
void h2o_memcached_set(h2o_memcached_context_t *ctx, h2o_iovec_t key, h2o_iovec_t value, uint32_t expiration, int flags)
{
h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_SET, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0);
if ((flags & H2O_MEMCACHED_ENCODE_VALUE) != 0) {
req->data.set.value.base = h2o_mem_alloc((value.len + 2) / 3 * 4 + 1);
req->data.set.value.len = h2o_base64_encode(req->data.set.value.base, value.base, value.len, 1);
} else {
req->data.set.value = h2o_iovec_init(h2o_mem_alloc(value.len), value.len);
memcpy(req->data.set.value.base, value.base, value.len);
}
req->data.set.expiration = expiration;
dispatch(ctx, req);
}
static void test_decode_base64(void)
{
h2o_mem_pool_t pool;
char buf[256];
h2o_mem_init_pool(&pool);
h2o_iovec_t src = {H2O_STRLIT("The quick brown fox jumps over the lazy dog.")}, decoded;
h2o_base64_encode(buf, (const uint8_t *)src.base, src.len, 1);
ok(strcmp(buf, "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4") == 0);
decoded = h2o_decode_base64url(&pool, buf, strlen(buf));
ok(src.len == decoded.len);
ok(strcmp(decoded.base, src.base) == 0);
h2o_mem_clear_pool(&pool);
}
static h2o_memcached_req_t *create_req(h2o_memcached_context_t *ctx, enum en_h2o_memcached_req_type_t type, h2o_iovec_t key,
int encode_key)
{
h2o_memcached_req_t *req = h2o_mem_alloc(offsetof(h2o_memcached_req_t, key.base) + ctx->prefix.len +
(encode_key ? (key.len + 2) / 3 * 4 + 1 : key.len));
req->type = type;
req->pending = (h2o_linklist_t){};
req->inflight = (h2o_linklist_t){};
memset(&req->data, 0, sizeof(req->data));
if (ctx->prefix.len != 0)
memcpy(req->key.base, ctx->prefix.base, ctx->prefix.len);
req->key.len = ctx->prefix.len;
if (encode_key) {
req->key.len += h2o_base64_encode(req->key.base + req->key.len, key.base, key.len, 1);
} else {
memcpy(req->key.base + req->key.len, key.base, key.len);
req->key.len += key.len;
}
return req;
}
