bool queue_manager::move_file(queue_file* fp, const char* queueName, const char* extName)
{
string key(fp->key());
bool ret = fp->move_file(queueName, extName);
cache_del(key.c_str());
return ret;
}
static void expire_queries()
{
dns_query_t *q = NULL, *next = NULL;
int i = 0;
/* need to check for expired queries and either:
a) recheck/change ns
b) expire due to ttl
*/
if (query_head) {
for (q = query_head; q; q = q->next) {
if (q->expiretime <= now) { /* set in alloc_query */
if (q->next)
next = q->next;
egg_dns_cancel(q->id, 1);
if (!next) break;
q = next;
}
}
}
for (i = 0; i < ncache; i++) {
if (cache_expired(i)) {
cache_del(i);
if (i == ncache) break;
i--;
}
}
}
struct cache_object *cache_update_force(struct cache *c, void *ptr)
{
struct cache_object *obj;
int id;
obj = cache_find(c, ptr, &id);
if (obj) {
if (obj->status != C_OBJ_DEAD) {
cache_update(c, obj, id, ptr);
return obj;
} else {
cache_del(c, obj);
cache_object_free(obj);
}
}
obj = cache_object_new(c, ptr);
if (obj == NULL)
return NULL;
if (cache_add(c, obj, id) == -1) {
cache_object_free(obj);
return NULL;
}
return obj;
}
bool queue_manager::close_file(queue_file* fp)
{
string key(fp->key());
delete fp;
cache_del(key.c_str());
return true;
}
bool queue_manager::remove(queue_file* fp)
{
string key(fp->key());
bool ret = fp->remove();
delete fp;
cache_del(key.c_str());
return ret;
}
static int cyclon_parse_data(struct peersampler_context *context, const uint8_t *buff, int len)
{
cache_check(context->local_cache);
if (len) {
const struct topo_header *h = (const struct topo_header *)buff;
struct peer_cache *remote_cache;
struct peer_cache *sent_cache = NULL;
if (h->protocol != MSG_TYPE_TOPOLOGY) {
fprintf(stderr, "Peer Sampler: Wrong protocol!\n");
return -1;
}
context->bootstrap = false;
remote_cache = entries_undump(buff + sizeof(struct topo_header), len - sizeof(struct topo_header));
if (h->type == CYCLON_QUERY) {
sent_cache = rand_cache(context->local_cache, context->sent_entries);
cyclon_reply(context->pc, remote_cache, sent_cache);
context->dst = NULL;
}
cache_check(context->local_cache);
cache_add_cache(context->local_cache, remote_cache);
cache_free(remote_cache);
if (sent_cache) {
cache_add_cache(context->local_cache, sent_cache);
cache_free(sent_cache);
} else {
if (context->flying_cache) {
cache_add_cache(context->local_cache, context->flying_cache);
cache_free(context->flying_cache);
context->flying_cache = NULL;
}
}
}
if (time_to_send(context)) {
if (context->flying_cache) {
cache_add_cache(context->local_cache, context->flying_cache);
cache_free(context->flying_cache);
context->flying_cache = NULL;
}
cache_update(context->local_cache);
context->dst = last_peer(context->local_cache);
if (context->dst == NULL) {
return 0;
}
context->dst = nodeid_dup(context->dst);
cache_del(context->local_cache, context->dst);
context->flying_cache = rand_cache(context->local_cache, context->sent_entries - 1);
return cyclon_query(context->pc, context->flying_cache, context->dst);
}
cache_check(context->local_cache);
return 0;
}
int cache_object_put(struct cache_object *obj)
{
if (--obj->refcnt == 0) {
cache_del(obj->cache, obj);
cache_object_free(obj);
return 1;
}
return 0;
}
static int do_flush(void *data, void *n)
{
struct cache *c = data;
struct cache_object *obj = n;
cache_del(c, obj);
cache_object_free(obj);
return 0;
}
int
destroy(Objid oid)
{
if (!valid(oid)) {
return 1;
} else {
cache_del(oid.id, 0);
return 0;
}
}
void dns_cache_flush()
{
int i = 0;
for (i = 0; i < ncache; i++) {
cache_del(i);
if (i == ncache) break;
i--;
}
}
static void external_cache_del(struct nf_conntrack *ct)
{
struct cache_object *obj;
int id;
obj = cache_find(external, ct, &id);
if (obj) {
cache_del(external, obj);
cache_object_free(obj);
}
}
static void parse_del(struct req_info *req)
{
int hit, cache_only, sync, rv;
const unsigned char *key;
uint32_t ksize;
ksize = * (uint32_t *) req->payload;
ksize = ntohl(ksize);
if (req->psize < ksize) {
stats.net_broken_req++;
req->reply_err(req, ERR_BROKEN);
return;
}
if (settings.read_only) {
req->reply_err(req, ERR_RO);
return;
}
FILL_CACHE_FLAG(del);
FILL_SYNC_FLAG();
key = req->payload + sizeof(uint32_t);
hit = cache_del(cache_table, key, ksize);
if (cache_only && hit) {
req->reply_mini(req, REP_OK);
} else if (cache_only && !hit) {
req->reply_mini(req, REP_NOTIN);
} else if (!cache_only) {
rv = put_in_queue(req, REQ_DEL, sync, key, ksize, NULL, 0);
if (!rv) {
req->reply_err(req, ERR_MEM);
return;
}
if (!sync) {
req->reply_mini(req, REP_OK);
}
return;
}
return;
}
void cache_expire( void ) {
ITEM *item_sk = NULL;
ITEM *next_sk = NULL;
struct obj_key *sk = NULL;
item_sk = _main->cache->list->start;
while( item_sk ) {
sk = item_sk->val;
next_sk = list_next( item_sk );
/* Bad cache */
if( _main->p2p->time_now.tv_sec > sk->time ) {
cache_del( sk->session_id );
}
item_sk = next_sk;
}
}
void cache_expire( time_t now ) {
ITEM *item = NULL;
ITEM *next = NULL;
CACHE *cache = NULL;
item = list_start( _main->cache->list );
while( item != NULL ) {
next = list_next( item );
/* 30 minutes without activity. Kill it. */
cache = list_value( item );
if( now > cache->lifetime ) {
cache_del( item );
}
item = next;
}
}
int cache_add_ranked(struct peer_cache *c, struct nodeID *neighbour, const void *meta, int meta_size, ranking_function f, const void *tmeta)
{
int i, pos = 0;
if (meta_size && meta_size != c->metadata_size) {
return -3;
}
for (i = 0; i < c->current_size; i++) {
if (nodeid_equal(c->entries[i].id, neighbour)) {
if (f != NULL) {
cache_del(c,neighbour);
if (i == c->current_size) break;
} else {
cache_metadata_update(c,neighbour,meta,meta_size);
return -1;
}
}
if ((f != NULL) && f(tmeta, meta, c->metadata+(c->metadata_size * i)) == 2) {
pos++;
}
}
if (c->current_size == c->cache_size) {
return -2;
}
if (c->metadata_size) {
memmove(c->metadata + (pos + 1) * c->metadata_size, c->metadata + pos * c->metadata_size, (c->current_size - pos) * c->metadata_size);
if (meta_size) {
memcpy(c->metadata + pos * c->metadata_size, meta, meta_size);
} else {
memset(c->metadata + pos * c->metadata_size, 0, c->metadata_size);
}
}
for (i = c->current_size; i > pos; i--) {
c->entries[i] = c->entries[i - 1];
}
c->entries[pos].id = nodeid_dup(neighbour);
c->entries[pos].timestamp = 1;
c->current_size++;
return c->current_size;
}
static void external_cache_new(struct nf_conntrack *ct)
{
struct cache_object *obj;
int id;
obj = cache_find(external, ct, &id);
if (obj == NULL) {
retry:
obj = cache_object_new(external, ct);
if (obj == NULL)
return;
if (cache_add(external, obj, id) == -1) {
cache_object_free(obj);
return;
}
} else {
cache_del(external, obj);
cache_object_free(obj);
goto retry;
}
}
int cache_validate( UCHAR *session_id ) {
ITEM *item_sk = NULL;
struct obj_key *sk = NULL;
/* Key not found */
if( ( item_sk = hash_get( _main->cache->hash, session_id, SHA_DIGEST_LENGTH)) == NULL ) {
return 0;
}
sk = item_sk->val;
/* Unicast:
* Delete session id
*
* Multicast:
* Ignore session id, because we will receive multiple answers with same session id.
* The session id will timeout later...
*/
if( sk->type == SEND_UNICAST ) {
cache_del( session_id );
}
return 1;
}
// TODO: merge adjacent free blocks.
// TODO: create file holes for large free block
int dealloc_blk(ALLOC * a, handle_t handle)
{
off_t offset;
size_t len;
handle_t redirect, atoms;
int redirected = 0;
unsigned char bytes[8];
cache_del(a, handle);
Retry:
offset = hdl2off(handle);
if (readat(a->fd, bytes, 8, offset) != 8)
return -1;
switch (bytes[0]) {
case CTBLK_SHORT:
len = (size_t) bytes[1];
break;
case CTBLK_LONG:
len = (size_t) b2uint16(&bytes[1]);
break;
case REBLK:
if (redirected) // allow only once redirect
return -1;
redirect = b2hdl(&bytes[1]);
if (free_blk(a, handle, 1) != 0)
return -1;
handle = redirect;
redirected = 1;
goto Retry;
default:
xerrno = FATAL_BLKTAG;
return -1;
}
atoms = len2atom(len);
return free_blk(a, handle, atoms);
}
struct mcache_node *cache_lookup(uint8_t *l2_addr, uint8_t *ip_addr,
uint8_t len, time_t tstamp, uint16_t vlan_tag, struct mcache_node **cache)
{
struct mcache_node *node;
for (node = *cache; node != NULL; node = node->next) {
/* New cache nodes are inserted at the begining of the list
* resulting cache list ordered by timestamp.
*
* If we find old cache node we can safely delete it and all
* following nodes.
*/
if (cfg.ratelimit > 0 && tstamp > node->tstamp + cfg.ratelimit) {
cache_prune(node, cache);
return NULL;
}
if (vlan_tag != node->vlan_tag)
continue;
if (len != node->addr_len)
continue;
if (memcmp(ip_addr, node->ip_addr, len))
continue;
if (memcmp(l2_addr, node->l2_addr, sizeof(node->l2_addr))) {
cache_del(node, cache);
return NULL;
}
return node;
}
return NULL;
}
static int cyclon_remove_neighbour(struct peersampler_context *context, const struct nodeID *neighbour)
{
return cache_del(context->local_cache, neighbour);
}
