void send_keys(struct network_status *net_stat, struct keypair *keypair) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& keypair(keypair, ?attacker_id, ?id, ?info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count1) &*& true == bad(attacker_id); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& keypair(keypair, attacker_id, id, info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count2); @*/ { //@ close key_request(attacker_id, 0); struct item *key_sym = create_symmetric_key(); struct item *key_priv = keypair_get_private_key(keypair); struct item *key_pub = keypair_get_public_key(keypair); //@ assert item(key_sym, ?k_sym, pub); //@ assert item(key_pub, ?k_pub, pub); //@ assert item(key_priv, ?k_priv, pub); //@ open proof_obligations(pub); //@ assert is_public_symmetric_key(?proof_sym, pub); //@ assert is_public_public_key(?proof_pub, pub); //@ assert is_public_private_key(?proof_priv, pub); //@ proof_sym(k_sym); //@ proof_pub(k_pub); //@ proof_priv(k_priv); //@ close proof_obligations(pub); network_send(net_stat, key_sym); network_send(net_stat, key_pub); network_send(net_stat, key_priv); item_free(key_sym); item_free(key_pub); item_free(key_priv); }
struct item *app_receive(struct item *key) /*@ requires [?f0]world(ss_pub) &*& item(key, symmetric_key_item(?creator, ?id), ss_pub); @*/ /*@ ensures [f0]world(ss_pub) &*& item(key, symmetric_key_item(creator, id), ss_pub) &*& item(result, ?msg, ss_pub) &*& ( bad(creator) || collision_in_run() || app_send_event(creator, msg) ); @*/ { struct network_status *net_stat = network_bind_and_accept(APP_RECEIVE_PORT); struct item *m = network_receive(net_stat); struct item *hash = pair_get_first(m); struct item *message = pair_get_second(m); //@ assert item(m, pair_item(?hmac_i, ?message_i), ss_pub); //@ open [_]ss_pub(pair_item(hmac_i, message_i)); //@ if (!collision_in_run()) open [_]ss_pub(hmac_i); //@ if (!collision_in_run()) open [_]ss_pub(message_i); item_free(m); hmac_verify(hash, key, message); item_free(hash); network_disconnect(net_stat); return message; }
void app_send(struct item *key, struct item *message) /*@ requires [?f0]world(ss_pub) &*& item(key, symmetric_key_item(?creator, ?id), ss_pub) &*& item(message, ?msg, ss_pub) &*& [_]ss_pub(msg) &*& app_send_event(creator, msg) == true; @*/ /*@ ensures [f0]world(ss_pub) &*& item(key, symmetric_key_item(creator, id), ss_pub) &*& item(message, msg, ss_pub); @*/ { struct network_status *net_stat = network_connect("localhost", APP_RECEIVE_PORT); struct item *hash = create_hmac(key, message); //@ assert item(hash, ?h, ss_pub); //@ get_info_for_item(h); //@ close ss_pub(h); //@ leak ss_pub(h); struct item *m = create_pair(hash, message); //@ assert item(m, ?pmessage, ss_pub); //@ get_info_for_item(pmessage); //@ close ss_pub(pmessage); //@ leak ss_pub(pmessage); network_send(net_stat, m); item_free(hash); item_free(m); network_disconnect(net_stat); }
void send_pair_decomposed(struct network_status *net_stat) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(?principal, ?count1) &*& true == bad(principal); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(principal, ?count2); @*/ { struct item *pair = network_receive(net_stat); //@ assert item(pair, ?p, pub); if (is_pair(pair)) { struct item *first = pair_get_first(pair); struct item *second = pair_get_second(pair); //@ open proof_obligations(pub); //@ assert is_public_pair_decompose(?proof1, pub); //@ assert is_public_collision(?proof2, pub); //@ proof1(p); //@ assert item(first, ?f, pub); //@ if (col) proof2(f); //@ assert item(second, ?s, pub); //@ if (col) proof2(s); //@ close proof_obligations(pub); network_send(net_stat, first); network_send(net_stat, second); item_free(first); item_free(second); } item_free(pair); }
void send_pair_composed(struct network_status *net_stat) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(?principal, ?count1) &*& true == bad(principal); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(principal, ?count2); @*/ { struct item *first = network_receive(net_stat); struct item *second = network_receive(net_stat); struct item * pair = create_pair(first, second); //@ assert item(first, ?f, pub); //@ assert item(second, ?s, pub); //@ assert item(pair, pair_item(f, s), pub); //@ open proof_obligations(pub); //@ assert is_public_pair_compose(?proof, pub); //@ proof(f, s); //@ close proof_obligations(pub); network_send(net_stat, pair); item_free(pair); item_free(first); item_free(second); }
/* if return item is not NULL, free by caller */ item *item_get(char *key, size_t nkey){ item *it = NULL; DBT dbkey, dbdata; bool stop; int ret; /* first, alloc a fixed size */ it = item_alloc2(settings.item_buf_size); if (it == 0) { return NULL; } BDB_CLEANUP_DBT(); dbkey.data = key; dbkey.size = nkey; dbdata.ulen = settings.item_buf_size; dbdata.data = it; dbdata.flags = DB_DBT_USERMEM; stop = false; /* try to get a item from bdb */ while (!stop) { switch (ret = dbp->get(dbp, NULL, &dbkey, &dbdata, 0)) { case DB_BUFFER_SMALL: /* user mem small */ /* free the original smaller buffer */ item_free(it); /* alloc the correct size */ it = item_alloc2(dbdata.size); if (it == NULL) { return NULL; } dbdata.ulen = dbdata.size; dbdata.data = it; break; case 0: /* Success. */ stop = true; break; case DB_NOTFOUND: stop = true; item_free(it); it = NULL; break; default: /* TODO: may cause bug here, if return DB_BUFFER_SMALL then retun non-zero again * here 'it' may not a full one. a item buffer larger than item_buf_size may be added to freelist */ stop = true; item_free(it); it = NULL; if (settings.verbose > 1) { fprintf(stderr, "dbp->get: %s\n", db_strerror(ret)); } } } return it; }
struct item *asymmetric_authenticated_decryption(char recipient, struct item *public_key, struct item *private_key, struct item *message) /*@ requires [?f]world(?pub) &*& generated_values(?principal1, ?count1) &*& item(public_key, ?pub_k, pub) &*& pub_k == public_key_item(?principal2, ?count2) &*& item(private_key, ?priv_k, pub) &*& priv_k == private_key_item(?principal3, ?count3) &*& item(message, ?msg, pub); @*/ /*@ ensures [f]world(pub) &*& generated_values(principal1, count1 + 1) &*& item(public_key, pub_k, pub) &*& item(private_key, priv_k, pub) &*& item(message, msg, pub) &*& item(result, ?decrypted, pub) &*& collision_in_run() ? true : msg == pair_item(?enc, ?sig) &*& enc == asymmetric_encrypted_item(?principal4, ?count4, ?pay, _) &*& sig == asymmetric_signature_item(principal2, count2, some(?msg_id), _) &*& msg_id == pair_item(data_item(cons(recipient, nil)), hash_item(some(enc))) &*& principal4 == principal3 && count4 == count3 ? pay == some(decrypted) : [_]pub(decrypted) ; @*/ { check_is_pair(message); struct item* encrypted = pair_get_first(message); check_is_asymmetric_encrypted(encrypted); struct item* signature = pair_get_second(message); struct item* rcp = create_data_item_from_char(recipient); struct item* hash = create_hash(encrypted); struct item* pair = create_pair(rcp, hash); asymmetric_signature_verify(public_key, pair, signature); struct item *result = asymmetric_decryption(private_key, encrypted); item_free(encrypted); item_free(rcp); item_free(pair); item_free(hash); item_free(signature); return result; }
void do_item_remove(item *it) { #ifdef MOXI_ITEM_MALLOC item_free(it); #else MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes); assert((it->it_flags & ITEM_SLABBED) == 0); if (it->refcount != 0) { it->refcount--; DEBUG_REFCNT(it, '-'); } if (it->refcount == 0 && (it->it_flags & ITEM_LINKED) == 0) { item_free(it); } #endif }
void increment_and_send_nonce(struct network_status *net_stat) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(?principal, ?count1) &*& true == bad(principal); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(principal, ?count2); @*/ { struct item *nonce = network_receive(net_stat); //@ assert item(nonce, ?n, pub); if (is_nonce(nonce)) { increment_nonce(nonce); //@ assert item(nonce, ?n_inc, pub); //@ open proof_obligations(pub); /*@ if (col) { assert is_public_collision(?proof, pub); proof(n_inc); } else { assert is_public_incremented_nonce(?proof, pub); proof(n, n_inc); } @*/ //@ close proof_obligations(pub); network_send(net_stat, nonce); } item_free(nonce); }
void *sender_t(void* data) //@ : pthread_run_joinable //@ requires pthread_run_pre(sender_t)(data, ?x); //@ ensures pthread_run_post(sender_t)(data, x) &*& result == 0; { //@ open pthread_run_pre(sender_t)(data, _); struct ss_auth_args *args = (void*) data; struct item *key = args->key; //@ assert principal(?principal, ?count); //@ item n = nonce_item(principal, count + 1, 0); //@ close ss_auth_pub(n); //@ leak ss_auth_pub(n); int i = random_int(); struct item *mess_authage = create_data_item((void*) &i, (int) sizeof(int)); //@ chars_to_integer(&i); //@ assert item(key, private_key_item(?sender, _), ss_auth_pub); //@ item datai = data_item(chars_of_int(i)); //@ assume (app_send_event(sender, datai)); //@ assert [_]world(ss_auth_pub, ss_auth_key_clsfy); //@ close ss_auth_pub(datai); //@ leak ss_auth_pub(datai); app_send(key, mess_authage); //@ close pthread_run_post(sender_t)(data, _); item_free(mess_authage); return 0; }
void move_curitem(int direction) { list_item tmp; if(curitem < 0 || curitem > last_item()) return; tmp = item_create(); item_copy(tmp, db_item_get(curitem)); switch(direction) { case MOVE_ITEM_UP: if( curitem < 1 ) goto out_move; item_copy(db_item_get(curitem), db_item_get(curitem - 1)); item_copy(db_item_get(curitem-1), tmp); scroll_up(); break; case MOVE_ITEM_DOWN: if(curitem >= last_item()) goto out_move; item_copy(db_item_get(curitem), db_item_get(curitem + 1)); item_copy(db_item_get(curitem + 1), tmp); scroll_down(); break; } out_move: item_free(&tmp); }
void remove_duplicates() { int i,j,k; char *tmpj; if(list_is_empty()) return; /* Scan from the last one */ for(j = LAST_ITEM - 1; j >= 0; j--) { tmpj = db_name_get(j); for(i = LAST_ITEM; i > j; i--) /* Check name and merge if dups */ if (0 == strcmp(tmpj,db_name_get(i))) { item_merge(database[j],database[i]); if (curitem == i) curitem--; for(k = i; k < LAST_ITEM; k++) { item_copy(database[k], database[k + 1]); } item_free(&database[LAST_ITEM]); items--; } } adjust_list_capacity(); }
void merge_selected_items() { int i, j; int destitem = -1; if((list_is_empty()) || (selected_items() < 2)) return; /* Find the top item */ for(j=0; destitem < 0; j++) if(selected[j]) destitem = j; /* Merge pairwise */ for(j = LAST_ITEM; j > destitem; j--) { if(selected[j]) { item_merge(database[destitem],database[j]); for(i = j; i < LAST_ITEM; i++) { /* TODO: this can be done by moving pointers */ item_copy(database[i], database[i + 1]); selected[i] = selected[i + 1]; } item_free(&database[LAST_ITEM]); items--; } } if(curitem > LAST_ITEM && items > 0) curitem = LAST_ITEM; adjust_list_capacity(); select_none(); }
/* margin: in: <0,any, 0,real matched, >0: pts-off>=off && (pts->off-off)<=margin out: (pts->off-off) pts: out; */ int ptslist_lookup(ptslist_mgr_t *mgr, int64_t off, int64_t *pts, int *margin) { struct item *temp; struct item *find; int reverse = 0; int omargin = *margin; int err = -1; temp = item_alloc(mgr->ptsitem.item_ext_buf_size); if (!temp) { return -1; } ITEM_OFF(temp) = off; if (mgr->lastoffset - off < off) { reverse = 1; } find = itemlist_find_match_item_ex(&mgr->ptsitem, temp, ptslist_is_wanted, reverse); if (!find) { err = -2; goto errout; } *pts = ITEM_PTS(find); *margin = (int)(ITEM_OFF(find) - off); if (omargin < 0 || *margin <= omargin) { err = -0; } else { err = -3; } errout: item_free(temp); return err; }
int ptslist_chekin(ptslist_mgr_t *mgr, int64_t off, int64_t pts) { struct item *newitem; int ret; if (off < 0 || pts < 0) { return -1; //not valied off and pts; } newitem = item_alloc(mgr->ptsitem.item_ext_buf_size); if (!newitem) { av_log(NULL, AV_LOG_INFO, "ptslist_chekin-fialed,no memory!\n"); return AVERROR(ENOMEM); } newitem->item_data = mgr->index++; ITEM_OFF(newitem) = off; ITEM_PTS(newitem) = pts; mgr->lastoffset = off; ret = itemlist_add_tail(&mgr->ptsitem, newitem); if (ret) { /*item list fulled,del oldest one.*/ struct item *t; t = itemlist_get_head(&mgr->ptsitem); if (t) { item_free(t); } ret = itemlist_add_tail(&mgr->ptsitem, newitem); } return ret; }
void send_data(struct network_status *net_stat) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(?principal, ?count1) &*& true == bad(principal); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(principal, ?count2); @*/ { int data_size = random_int_(); if (data_size > MIN_RANDOM_SIZE) { char* data = malloc((int) data_size); if (data == 0) abort_crypto_lib("malloc failed"); random_buffer_(data, data_size); struct item *item = create_data_item(data, data_size); //@ assert item(item, ?i, pub) &*& i == data_item(?d); free(data); //@ open proof_obligations(pub); //@ assert is_public_data(?proof, pub); //@ proof(i); //@ close proof_obligations(pub); network_send(net_stat, item); item_free(item); } }
void remove_selected_items() { int i, j; if(list_is_empty()) return; if(!selected_items()) selected[curitem] = 1; for(j = LAST_ITEM; j >= 0; j--) { if(selected[j]) { db_free_item(j); /* added for .4 data_s_ */ for(i = j; i < LAST_ITEM; i++) { item_copy(database[i], database[i + 1]); selected[i] = selected[i + 1]; } item_free(&database[LAST_ITEM]); items--; } } if(curitem > LAST_ITEM && items > 0) curitem = LAST_ITEM; adjust_list_capacity(); select_none(); }
enum store_item_type do_store_item(item *it, const uint32_t hv) { enum store_item_type stored; char *key = ITEM_key(it); item *old_it = do_item_get(key, it->nkey, hv); if (old_it != NULL) { assert(old_it != it); before_write(old_it); do_item_unlink_nolock(old_it, hv); //do_item_remove(old_it); /* release our reference */ item_free(old_it); assert((old_it->it_flags & ITEM_LINKED) == 0); assert((old_it->it_flags & ITEM_SLABBED) != 0); after_write(old_it); } before_write(it); int ret = do_item_link_nolock(it, hv); after_write(it); if (ret == 0) { stored = NOT_STORED; printf("not stored\n"); } else { stored = STORED; } return stored; }
int create_principal(struct keypair** keypair) /*@ requires world(?pub, ?key_clsfy) &*& pointer(keypair, _) &*& principals_created(?count); @*/ /*@ ensures world(pub, key_clsfy) &*& principals_created(result) &*& result == count + 1 &*& principal(result, 1) &*& pointer(keypair, ?p_keypair) &*& keypair(p_keypair, result, 1, 0, pub); @*/ { //@ open principals_created(count); //@ principal_create(); if (counter >= INT_MAX - 1) { abort_crypto_lib("To many principals generated"); } counter++; //@ close keypair_request(count + 1, 0); struct keypair *k = create_keypair(counter); *keypair = k; struct item *key = keypair_get_public_key(k); register_public_key(counter, key); item_free(key); return counter; //@ close principals_created(count + 1); }
BOOL Del_Cur_Item ( LNK_LST *lst ) { LST_ITM *p, *last; LST_ITM *next_item = LST_nxt(lst); if ( LST_Empty(lst) ) return FALSE; /* not in the list => nothing to delete */ last = NULL; for ( p=LST_first(lst); p!=NULL; p=LST_next(p) ) { if ( LST_next(p) == next_item ) { if ( last == NULL ) /* it was the first item in the list */ LST_first(lst) = LST_next(p); else /* it was not the first item in the list */ LST_next(last) = LST_next(p); item_free ( p ); /* put deleted item into the free list */ decr_LST_len(lst); return TRUE; /* it was deleted from the list => return TRUE */ } last = p; } /* If we get to here, we went through the list, but we did not find * an item with an LST_next field matching the next item of the list. */ return FALSE; }
void item_remove(item *it) { assert((it->it_flags & ITEM_SLABBED) == 0); if (it->refcount) it->refcount--; assert((it->it_flags & ITEM_DELETED) == 0 || it->refcount); if (it->refcount == 0 && (it->it_flags & ITEM_LINKED) == 0) { item_free(it); } }
//向slab归还item void do_item_remove(item *it) { MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes); assert((it->it_flags & ITEM_SLABBED) == 0); //引用计数为0时归还 if (refcount_decr(&it->refcount) == 0) { item_free(it); } }
void send_symmetric_encrypted(struct network_status *net_stat, struct keypair *keypair) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& keypair(keypair, ?attacker_id, ?id, ?info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count1) &*& true == bad(attacker_id); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& keypair(keypair, attacker_id, id, info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count2); @*/ { struct item *key = network_receive(net_stat); //@ assert item(key, ?k, pub); if (is_symmetric_key(key)) { struct item *pay = network_receive(net_stat); //@ assert item(pay, ?p, pub); //@ open proof_obligations(pub); //@ item nonce = nonce_item(attacker_id, count1 + 1, 0); //@ assert is_public_nonce(?proof1, pub); //@ proof1(nonce); struct item *enc = symmetric_encryption(key, pay); //@ assert item(enc, ?e, pub); /*@ if (col) { assert is_public_collision(?proof2, pub); proof2(e); } else { assert is_public_symmetric_encrypted(?proof2, pub); proof2(e); } @*/ //@ close proof_obligations(pub); network_send(net_stat, enc); item_free(enc); item_free(pay); } item_free(key); }
//remove是把item从slab中释放掉(但是这个释放为提高效率也只是把它放到了slab中的空闲链表中) void LRU_list::do_item_remove(base_item* it) { if ((it->item_flag & Slab::ITEM_SLABBED) != 0) return; //原子自减 if (std::atomic_fetch_sub(&(it->refcount), 1u) == 0) { item_free(it); } }
void do_item_remove(item *it) { syslog(LOG_INFO, "[%s:%s:%d]", __FILE__, __func__, __LINE__); MEMCACHED_ITEM_REMOVE(ITEM_key(it), it->nkey, it->nbytes); assert((it->it_flags & ITEM_SLABBED) == 0); if (refcount_decr(&it->refcount) == 0) { item_free(it); } }
void send_hmac(struct network_status *net_stat, struct keypair *keypair) /*@ requires [?f0]world(?pub, ?key_clsfy) &*& keypair(keypair, ?attacker_id, ?id, ?info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count1) &*& true == bad(attacker_id); @*/ /*@ ensures [f0]world(pub, key_clsfy) &*& keypair(keypair, attacker_id, id, info, pub) &*& proof_obligations(pub) &*& network_status(net_stat) &*& principal(attacker_id, ?count2); @*/ { struct item *key = network_receive(net_stat); //@ assert item(key, ?k, pub); if (is_symmetric_key(key)) { struct item *pay = network_receive(net_stat); //@ assert item(pay, ?p, pub); //@ close hash_item_payload(pub, true, p); //@ leak hash_item_payload(pub, true, p); struct item *mac = create_hmac(key, pay); //@ assert item(mac, ?h, pub); //@ open proof_obligations(pub); /*@ if (col) { assert is_public_collision(?proof, pub); proof(h); } else { assert is_public_hmac(?proof, pub); proof(h); } @*/ //@ close proof_obligations(pub); network_send(net_stat, mac); item_free(mac); item_free(pay); } item_free(key); }
void complete_nread(conn *c) { item *it = c->item; int comm = c->item_comm; item *old_it; time_t now = time(0); stats.set_cmds++; while(1) { if (strncmp(ITEM_data(it) + it->nbytes - 2, "\r\n", 2) != 0) { out_string(c, "CLIENT_ERROR bad data chunk"); break; } old_it = assoc_find(ITEM_key(it)); if (old_it && settings.oldest_live && old_it->time <= settings.oldest_live) { item_unlink(old_it); old_it = 0; } if (old_it && old_it->exptime && old_it->exptime < now) { item_unlink(old_it); old_it = 0; } if (old_it && comm==NREAD_ADD) { item_update(old_it); out_string(c, "NOT_STORED"); break; } if (!old_it && comm == NREAD_REPLACE) { out_string(c, "NOT_STORED"); break; } if (old_it && (old_it->it_flags & ITEM_DELETED) && (comm == NREAD_REPLACE || comm == NREAD_ADD)) { out_string(c, "NOT_STORED"); break; } if (old_it) { item_replace(old_it, it); } else item_link(it); c->item = 0; out_string(c, "STORED"); return; } item_free(it); c->item = 0; return; }
void item_unlink(item *it) { if (it->it_flags & ITEM_LINKED) { it->it_flags &= ~ITEM_LINKED; stats.curr_bytes -= ITEM_ntotal(it); stats.curr_items -= 1; assoc_delete(ITEM_key(it)); item_unlink_q(it); } if (it->refcount == 0) item_free(it); }
static void _item_remove(struct item *it) { assert(it->magic == ITEM_MAGIC); assert(!item_is_slabbed(it)); if (it->refcount != 0) { item_release_refcount(it); } if (it->refcount == 0 && !item_is_linked(it)) { item_free(it); } }
void do_item_release(struct default_engine *engine, hash_item *it) { MEMCACHED_ITEM_REMOVE(item_get_key(it), it->nkey, it->nbytes); if (it->refcount != 0) { it->refcount--; DEBUG_REFCNT(it, '-'); } if (it->refcount == 0 && (it->iflag & ITEM_LINKED) == 0) { item_free(engine, it); } }