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; }
main() { CACHE *cache; char cmd[2]; int val, *pval; /* Print some instructions. */ printf("This program demonstrates the various cache manipulation\n"); printf("routines supplied by this package. Although this program\n"); printf("manipulates a cache of integers, data of any type and size\n"); printf("(and not just integers) are supported by the routines. See\n"); printf("the man page for more information.\n\n"); printf("We illustrate a cache with a maximum size of 3 entries.\n\n"); /* Allocate a new cache. */ cache = cache_init(MAX_ELEMENTS); print_cache(cache); /* Get some commands. */ printf("\n(e)nter new element, (c)heck for element; (q)uit: "); while (scanf("%1s", cmd) != EOF) { switch (cmd[0]) { case 'e': printf("Value (int) to enter: "); if (scanf("%d", &val)) { /* We ignore the return code here, but in practice, * we may fail (with a return code of NULL). */ cache_enter(cache, &val, sizeof(val), &pval); if (pval != NULL) { printf("%d was removed to make room.\n", *pval); } } break; case 'c': printf("Value (int) to check for: "); if (scanf("%d", &val)) { pval = (int *) cache_check(cache, (char *) &val, match); if (pval != NULL) { printf("%d found!\n", *pval); } else { printf("Not found.\n"); } } break; case 'q': cache_free(cache, CACHE_DEALLOC); exit(0); break; default: printf("'%s' not a recognized command!\n", cmd); break; } print_cache(cache); printf("\n(e)nter new element, (c)heck for element; (q)uit: "); } exit(0); }
void __heap_free(heap_t * self, void *ptr, const char *file, int line) { if (unlikely(self == NULL)) throw_unexpected(HEAP_NULL); void *data = (void *)((uint32_t) ptr & ~(self->page_size - 1)); cache_t *c = (cache_t *) (data + self->page_size - sizeof(cache_t)); cache_check(c); slab_free(cache_slab(c), ptr); }
bool queue_manager::rename_extname(queue_file* fp, const char* extName) { if (cache_check(fp) == false) { logger_warn("file(%s)'s key(%s) not exist", fp->get_filePath(), fp->key()); return false; } return fp->move_file(fp->get_queueName(), extName); }
HEADER *headersDepth(const char *t, time_t time, int depth) { HEADER hdr, *h = &hdr; LIST *l; const char* cachekey=t; /* D support (doesn't affect C(++), because a source file is never included) */ if(depth == 0) { cachekey=malloc(strlen(t)+sizeof("source:")); strcpy((char*)cachekey,"source:"); strcpy((char*)cachekey+7,t); } if (!headerhash) headerhash = hashinit(sizeof(HEADER), "headers"); h->key = cachekey; h->includes = 0; h->time = time; h->headers = 0; h->newest = 0; if (!hashenter(headerhash, (HASHDATA **)&h)) return h; h->key = newstr(t); #ifdef USE_CACHE if (!cache_check(cachekey, time, &h->includes)) { h->includes = headers1(t, depth); cache_enter(cachekey, time, h->includes); } #else h->includes = headers1(t, depth); #endif if(depth == 0) free((char*)cachekey); l = h->includes; while (l) { const char *t2 = search(t, l->string, &time); if (time) h->headers = headerentry(h->headers, headersDepth(t2, time, depth+1)); l = list_next(l); } return h; }
struct peer_cache *rand_cache(struct peer_cache *c, int n) { struct peer_cache *res; cache_check(c); if (c->current_size < n) { n = c->current_size; } res = cache_init(n, c->metadata_size, c->max_timestamp); while(res->current_size < n) { int j; j = ((double)rand() / (double)RAND_MAX) * c->current_size; cache_insert(res, c->entries + j, c->metadata + c->metadata_size * j); c->current_size--; memmove(c->entries + j, c->entries + j + 1, sizeof(struct cache_entry) * (c->current_size - j)); memmove(c->metadata + c->metadata_size * j, c->metadata + c->metadata_size * (j + 1), c->metadata_size * (c->current_size - j)); c->entries[c->current_size].id = NULL; cache_check(c); } return res; }
int cache_init (fastphoto_t * params, char * path_info) { char * cachedir = params->config.cachedir; char * cachefile, * c; int cached; if (params->scale) { cachefile = alloc_snprintf ("%s%s?scale=%d", cachedir, path_info, params->scale); } else { cachefile = alloc_snprintf ("%s%s?x=%d&y=%d", cachedir, path_info, params->x, params->y); } if (params->quality) { c = alloc_snprintf ("%s&q=%d", cachefile, params->quality); free (cachefile); cachefile = c; } if (params->gray) { c = alloc_snprintf ("%s&gray", cachefile); free (cachefile); cachefile = c; } photo_init (¶ms->out, cachefile); cached = cache_check (params); if (cached == -1) { params->out.name = NULL; } else { if (cached) { fprintf (stderr, "fastphoto: Using cachefile %s\n", cachefile); } else { fprintf (stderr, "fastphoto: Creating cachefile %s\n", cachefile); if (!mkdirs (cachefile)) { fprintf (stderr, "fastphoto: Error creating cachefile %s\n", cachefile); free (cachefile); params->out.name = NULL; memory_init (params); } } } return 0; }
/****************************************************** int parse_request: deals with GET requests ******************************************************/ int parse_request(char *msg, int sock) { printf(" *** INCOMING REQUEST ***\n"); char *msg_whole; msg_whole = malloc(MAX_MSG_LENGTH); strcpy(msg_whole, msg); char *URL = get_URL_from_request(msg); //get target URL; will need for caching char *host = get_host_from_request(msg); //get host printf("FINAL URL: %s\nFINAL HOST: %s\n", URL, host); char *ip_addr = host_to_ipaddr(host); if(ip_addr == NULL) return 1; if(cache_check(URL, sock)) return 0; client(ip_addr, msg_whole, sock, URL); //free(URL); return 0; }
static void secure_beacon_recv(struct net_buf_simple *buf) { u8_t *data, *net_id, *auth; struct bt_mesh_subnet *sub; u32_t iv_index; bool new_key, kr_change, iv_change; u8_t flags; if (buf->len < 21) { BT_ERR("Too short secure beacon (len %u)", buf->len); return; } sub = cache_check(buf->data); if (sub) { /* We've seen this beacon before - just update the stats */ goto update_stats; } /* So we can add to the cache if auth matches */ data = buf->data; flags = net_buf_simple_pull_u8(buf); net_id = buf->data; net_buf_simple_pull(buf, 8); iv_index = net_buf_simple_pull_be32(buf); auth = buf->data; BT_DBG("flags 0x%02x id %s iv_index 0x%08x", flags, bt_hex(net_id, 8), iv_index); sub = bt_mesh_subnet_find(net_id, flags, iv_index, auth, &new_key); if (!sub) { BT_DBG("No subnet that matched beacon"); return; } if (sub->kr_phase == BT_MESH_KR_PHASE_2 && !new_key) { BT_WARN("Ignoring Phase 2 KR Update secured using old key"); return; } cache_add(data, sub); /* If we have NetKey0 accept initiation only from it */ if (bt_mesh_subnet_get(BT_MESH_KEY_PRIMARY) && sub->net_idx != BT_MESH_KEY_PRIMARY) { BT_WARN("Ignoring secure beacon on non-primary subnet"); goto update_stats; } BT_DBG("net_idx 0x%04x iv_index 0x%08x, current iv_index 0x%08x", sub->net_idx, iv_index, bt_mesh.iv_index); if (bt_mesh.ivu_initiator && bt_mesh.iv_update == BT_MESH_IV_UPDATE(flags)) { bt_mesh_beacon_ivu_initiator(false); } iv_change = bt_mesh_net_iv_update(iv_index, BT_MESH_IV_UPDATE(flags)); kr_change = bt_mesh_kr_update(sub, BT_MESH_KEY_REFRESH(flags), new_key); if (kr_change) { bt_mesh_net_beacon_update(sub); } if (iv_change) { /* Update all subnets */ bt_mesh_net_sec_update(NULL); } else if (kr_change) { /* Key Refresh without IV Update only impacts one subnet */ bt_mesh_net_sec_update(sub); } update_stats: if (bt_mesh_beacon_get() == BT_MESH_BEACON_ENABLED && sub->beacons_cur < 0xff) { sub->beacons_cur++; } }
void cache_recvmsg() { unsigned int recv_ip; unsigned short recv_port; unsigned char buf[1024]; struct sockaddr_in si_other; socklen_t slen=sizeof(si_other); uint ticks = GetTickCount(); struct cs_cachepeer_data *peer; int received = recvfrom( cfg.cachesock, buf, sizeof(buf), 0, (struct sockaddr*)&si_other, &slen); memcpy( &recv_ip, &si_other.sin_addr, 4); recv_port = ntohs(si_other.sin_port); if (received>0) { if (flag_debugnet) { debugf(" cache: recv data (%d) from address (%s:%d)\n", received, ip2string(recv_ip), recv_port ); debughex(buf,received); } // Store Data struct cache_data req; switch(buf[0]) { case TYPE_REQUEST: // Check Peer peer = getpeerbyaddr(recv_ip,recv_port); if (!peer) { peer = getpeerbyip(recv_ip); if (!peer) break; } peer->lastactivity = ticks; //peer->totreq++; // Check Multics diferent version if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break; // Check CSP if (received==20) { // arbiter number strcpy(peer->program,"CSP"); break; } // Check Status if (peer->disabled) break; // Get DATA req.tag = buf[1]; req.sid = (buf[2]<<8) | buf[3]; req.onid = (buf[4]<<8) | buf[5]; req.caid = (buf[6]<<8) | buf[7]; req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11]; // Check Cache Request if (!cache_check(&req)) break; // peer->reqnb++; // ADD CACHE struct cache_data *pcache = cache_fetch( &req ); if (pcache==NULL) { //*debugf(" [CACHE] << Cache Request from %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash); pcache = cache_new( &req ); if (cfg.cache.trackermode) { // Send REQUEST to all Peers struct cs_cachepeer_data *p = cfg.cachepeer; while (p) { if (!p->disabled) if (p->host->ip && p->port) if ( (p->lastactivity+75000)>ticks ) if ( !p->fblock0onid || pcache->onid ) cache_send_request(pcache,p); p = p->next; } pcache->sendcache = 1; cfg.cachereq++; } } else if (!cfg.cache.trackermode) { if ( (pcache->status==CACHE_STAT_DCW)&&(pcache->sendcache!=2) ) { //debugf(" [CACHE] << Request Reply >> to peer %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash); peer->ihitfwd++; peer->hitfwd++; cache_send_reply(pcache,peer); } } break; case TYPE_REPLY: // Check Peer peer = getpeerbyaddr(recv_ip,recv_port); if (!peer) { peer = getpeerbyip(recv_ip); if (!peer) break; } peer->lastactivity = ticks; //peer->totrep++; // Check Multics diferent version if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break; // Check Status if (peer->disabled) break; // 02 80 00CD 0001 0500 8D1DB359 80 // failed // 02 80 00CD 0001 0500 8D1DB359 80 00CD 0000 0500 63339F359A663232B73158405A255DDC // OLD // 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW if (buf[12]!=buf[1]) { //peer->rep_badheader++; break; } req.tag = buf[1]; req.sid = (buf[2]<<8) | buf[3]; req.onid = (buf[4]<<8) | buf[5]; req.caid = (buf[6]<<8) | buf[7]; req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11]; // Check Cache Request if (!cache_check(&req)) { //peer->rep_badfields++; break; } // if (received==13) { // FAILED //peer->rep_failed++; //*debugf(" [CACHE] <| Failed Cache Reply from %s (CAID:%04x SID:%04x ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.onid); // NOTHING TO DO break; } else if (received>=29) { // 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW if ( !acceptDCW(buf+13) ) { //peer->rep_baddcw++; break; } //*debugf(" [CACHE] << Good Cache Reply from %s %04x:%04x:%08x (ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.hash, req.onid); peer->repok++; // Request+Reply // Search for Cache data struct cache_data *pcache = cache_fetch( &req ); if (pcache==NULL) pcache = cache_new( &req ); if (pcache->status!=CACHE_STAT_DCW) { //*debugf(" [CACHE] Update Cache DCW %04x:%04x:%08x\n", pcache->caid, pcache->sid, pcache->hash); pcache->peerid = peer->id; memcpy(pcache->cw, buf+13, 16); pcache->status = CACHE_STAT_DCW; if (pcache->sendpipe) { uchar buf[128]; // 32 por defecto buf[0] = PIPE_CACHE_FIND_SUCCESS; buf[1] = 11+2+16; // Data length buf[2] = pcache->tag; buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff; buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff; buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff; buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff; buf[13] = peer->id>>8; buf[14] = peer->id&0xff; memcpy( buf+15, pcache->cw, 16); //*debugf(" pipe Cache->Ecm: PIPE_CACHE_FIND_SUCCESS %04x:%04x:%08x\n",pcache->caid, pcache->sid, pcache->hash); // debughex(buf, 13+16); pipe_send( srvsocks[1], buf, 13+2+16); //pcache->sendpipe = 0; } if (cfg.cache.trackermode) { // Send REQUEST to all Peers struct cs_cachepeer_data *p = cfg.cachepeer; while (p) { if (!p->disabled) if (p->host->ip && p->port) if ( (p->lastactivity+75000)>ticks ) if ( !p->fblock0onid || pcache->onid ) cache_send_reply(pcache,p); p = p->next; } pcache->sendcache = 2; cfg.cacherep++; } } else if ( pcache->sendpipe && memcmp(pcache->cw, buf+13, 16) ) { // resend to server pcache->peerid = peer->id; memcpy(pcache->cw, buf+13, 16); pcache->status = CACHE_STAT_DCW; uchar buf[128]; // 32 por defecto buf[0] = PIPE_CACHE_FIND_SUCCESS; buf[1] = 11+2+16; // Data length buf[2] = pcache->tag; buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff; buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff; buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff; buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff; buf[13] = peer->id>>8; buf[14] = peer->id&0xff; memcpy( buf+15, pcache->cw, 16); pipe_send( srvsocks[1], buf, 13+2+16); }