void free_session_slot(struct session_slot_table *sst, int slotid,
uint32_t server_highest, uint32_t target_highest,
bool sent)
{
pthread_mutex_lock(&sst->mutex);
assert(!bs_get(sst->free_slots, slotid));
bs_set(sst->free_slots, slotid);
if (slotid + 1 == sst->highest_used_slotid_plus1) {
int s = slotid - 1;
while (s >= 0 && bs_get(sst->free_slots, s))
--s;
sst->highest_used_slotid_plus1 = s + 1;
}
if (sent) {
assert(server_highest + 1 >= sst->highest_used_slotid_plus1);
sst->server_highest_slotid = server_highest;
sst->target_highest_slotid = target_highest;
/* increment sequenceid */
atomic_inc_uint32_t(sst->slots + slotid);
}
if (slotid <= target_highest) {
pthread_cond_signal(&sst->slot_cv);
}
pthread_mutex_unlock(&sst->mutex);
}
int /* Returns number of bytes in in_bytes used to generate dvi_samples */
vdvi_decode(bitstream_t *bs, unsigned char *dvi_buf, unsigned int dvi_samples)
{
u_char cw, cb;
unsigned int i, j, bytes_used;
/* This code is ripe for optimization ... */
assert(dvi_samples == VDVI_SAMPLES_PER_FRAME);
for(j = 0; j < dvi_samples; j++) {
#ifdef TEST_DVI
check_padding();
#endif
cb = 2;
cw = bs_get(bs, 2);
do {
for(i = 0; i < 16; i++) {
if (dmap_bits[i] != cb) continue;
if (dmap[i] == cw) goto dvi_out_pack;
}
cb++;
cw <<=1;
cw |= bs_get(bs, 1);
assert(cb <= 8);
#ifdef TEST_DVI
check_padding();
#endif
} while(1);
dvi_out_pack:
#ifdef TEST_DVI
check_padding();
#endif
if (j & 0x01) {
dvi_buf[j/2] |= i;
} else {
dvi_buf[j/2] = i << 4;
}
#ifdef TEST_DVI
check_padding();
#endif
}
bytes_used = bs_bytes_used(bs);
assert(bytes_used <= dvi_samples);
return bytes_used;
}
int main() {
char *d;
struct bs s;
bs_init(&s,10);
bs_add(&s,"aa");
bs_add(&s,"ab");
bs_add(&s,"ac");
bs_add(&s,"ad123456789");
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
bs_get(&s,&d);
printf("ret \"%s\"\n",d);
}
static err_status_t
probe_csbh(csbh_context_t *ctx, void *buf, unsigned long buf_len)
{
buffer_stream_t bs;
csbh_header_t *header;
csbh_rsa_pubkey_t *pubkey;
csbh_rsa_signature_t *sig;
void *body;
csbh_internal_t *priv;
unsigned long body_size, pad_size;
err_status_t err;
if (!ctx || !buf || !buf_len)
return CLN_FW_ERR_INVALID_PARAMETER;
bs_init(&bs, buf, buf_len);
err = bs_post_get(&bs, (void **)&header, sizeof(*header));
if (is_err_status(err)) {
err(T("The length is not expected for searching CSBH header\n"));
return err;
}
if (header->Identifier != CSBH_IDENTIFIER) {
err(T("Failed to locate CSBH\n"));
return CLN_FW_ERR_INVALID_CSBH;
}
if (header->Version != CSBH_VERSION) {
err(T("Invalid CSBH version: 0x%08x\n"), header->Version);
return CLN_FW_ERR_INVALID_CSBH;
}
if (header->ModuleHeaderSize < sizeof(*header) + sizeof(csbh_rsa_pubkey_t)
+ sizeof(csbh_rsa_signature_t)) {
err(T("Invalid module header size: 0x%08x\n"), header->ModuleHeaderSize);
return CLN_FW_ERR_INVALID_CSBH;
}
pad_size = header->ModuleHeaderSize -
(sizeof(*header) + sizeof(csbh_rsa_pubkey_t) +
sizeof(csbh_rsa_signature_t));
if (header->ModuleSize < header->ModuleHeaderSize) {
err(T("Invalid Module size: 0x%08x\n"), header->ModuleSize);
return CLN_FW_ERR_INVALID_CSBH;
}
body_size = header->ModuleSize - header->ModuleHeaderSize;
if (!aligned(body_size, 64)) {
err(T("Body size not 64-bit aligned: 0x%lx\n"), body_size);
return CLN_FW_ERR_INVALID_CSBH;
}
if ((header->ReservedModuleVendor != CSBH_MODULE_VENDOR) && cln_fw_verbose())
warn(T("Module Vendor should be reserved: 0x%08x\n"),
header->ReservedModuleVendor);
if (header->HashAlgorithm != CSBH_HASH_ALGO_SHA256) {
err(T("Invalid hash algorithm: 0x%08x\n"), header->HashAlgorithm);
return CLN_FW_ERR_INVALID_CSBH;
}
if (header->CryptoAlgorithm != CSBH_CRYPTO_ALGO_RSA2048) {
err(T("Invalid crypto algorithm: 0x%08x\n"), header->CryptoAlgorithm);
return CLN_FW_ERR_INVALID_CSBH;
}
if (header->KeySize != sizeof(csbh_rsa_pubkey_t)) {
err(T("Invalid key size: 0x%08x\n"),
header->KeySize);
return CLN_FW_ERR_INVALID_CSBH;
}
if (header->SignatureSize != sizeof(csbh_rsa_signature_t)) {
err(T("Invalid signature size: 0x%08x\n"),
header->SignatureSize);
return CLN_FW_ERR_INVALID_CSBH;
}
err = bs_post_get(&bs, (void **)&pubkey, sizeof(*pubkey));
if (is_err_status(err)) {
err(T("Cannot locate CSBH public key\n"));
return err;
}
err = bs_post_get(&bs, (void **)&sig, sizeof(*sig));
if (is_err_status(err)) {
err(T("Cannot locate CSBH signature\n"));
return err;
}
err = bs_seek(&bs, pad_size);
if (is_err_status(err)) {
err(T("Cannot locate CSBH header pad\n"));
return err;
}
err = bs_get(&bs, (void **)&body, body_size);
if (is_err_status(err)) {
err(T("Cannot locate CSBH body\n"));
return err;
}
priv = eee_malloc(sizeof(*priv));
if (!priv)
return CLN_FW_ERR_OUT_OF_MEM;
ctx->csbh_size = header->ModuleSize;
ctx->body_size = body_size;
priv->header = header;
priv->pubkey = pubkey;
priv->signature = sig;
priv->body = body;
ctx->priv = priv;
return CLN_FW_ERR_NONE;
}
