static void append_block(struct sfs_fs *sfs, struct cache_inode *file, size_t size, uint32_t ino, const char *filename) { static_assert(SFS_LN_NBLKS <= SFS_L2_NBLKS); assert(size <= SFS_BLKSIZE); uint32_t nblks = file->nblks; struct inode *inode = &(file->inode); if (nblks >= SFS_LN_NBLKS) { open_bug(sfs, filename, "file is too big.\n"); } if (nblks < SFS_L0_NBLKS) { inode->direct[nblks] = ino; } else if (nblks < SFS_L1_NBLKS) { nblks -= SFS_L0_NBLKS; update_cache(sfs, &(file->l1), &(inode->indirect)); uint32_t *data = file->l1->cache; data[nblks] = ino; } else if (nblks < SFS_L2_NBLKS) { nblks -= SFS_L1_NBLKS; update_cache(sfs, &(file->l2), &(inode->db_indirect)); uint32_t *data2 = file->l2->cache; update_cache(sfs, &(file->l1), &data2[nblks / SFS_BLK_NENTRY]); uint32_t *data1 = file->l1->cache; data1[nblks % SFS_BLK_NENTRY] = ino; } file->nblks ++; inode->size += size; inode->blocks ++; }
int check_proc_at_index(int index) { proc_entry *entry = get_proc_at_index(index); int sem; /* Check if this entry has ever been seized or not */ if (entry->key_active) { print(LOG_DEBUG, "key_active for index %d\n", index); /* get sem for the key */ if ((sem = create_lock(entry->key_active, 0)) == -1) { print(LOG_ERR, "Unable to create active lock in check_proc_at_index for key %d\n", entry->key_active); return 0; } /* check if cache is updated with sem */ if (mem_entry[index].active) { /* check if cache contains correct sem for the key */ if (sem != mem_entry[index].active) { print(LOG_DEBUG, "Cache and sem for key %d doesn't match, updating cache\n", entry->key_active); update_cache(index, entry); /*mem_entry[index].active = sem; */ } } else { print(LOG_DEBUG, "Cache empty update sem from key\n"); /*mem_entry[index].active = sem; */ update_cache(index, entry); } /* use sem in cache to check if active */ if (try_lock1(mem_entry[index].active)) { if (!memcmp (mem_entry[index].proc_name, entry->proc_name, PROC_NAME_SIZE)) { print(LOG_DEBUG, "Index %d is occupied by %s and active\n", index, entry->proc_name); } else { print(LOG_DEBUG, "Index %d is occupied by %s, cache is however outdated\n", index, entry->proc_name); update_cache(index, entry); } return 1; } else { print(LOG_DEBUG, "Index %d has been active but isn't any more, reset key_active\n", index); free_index(index); } } else { print(LOG_DEBUG, "Index %d has never been active (or released)\n", index); } return 0; }
/********************************************************************* * Process message Functions * *********************************************************************/ void process_arp_request(int sockfd, struct arp_msg *msg) { int i; struct arp_cache_entry cache_entry; bzero(&cache_entry, sizeof(cache_entry)); cache_entry.connfd = sockfd; cache_entry.sll_ifindex = my_index; cache_entry.sll_hatype = msg->hrd; strcpy(cache_entry.ip, msg->sender_ip); for (i = 0; i < IF_HADDR; i++){ cache_entry.mac[i] = msg->sender_mac[i]; } cache_entry.isComplete = 1; cache_entry.isValid = 1; cache_entry.isLocal = 0; // Pertains to the request, insert new entry if (strcmp(my_ip, msg->target_ip) == 0 || isDest(msg->target_ip) ) { puts("----->ARP: DESTINATION."); if ((i = search_cache(msg->sender_ip) == -1)) { puts("----->ARP: I DO pertain to this request. Create new entry for this <senderIP, senderMAC>.\n"); if (insert_entry(cache_entry) < 0) { perror("unable to insert cache entry."); } } else { puts("----->ARP: I DO pertain to this request. Update <senderIP, senderMAC>.\n"); update_cache(i, msg); } // Send ARP reply msg->op = ARP_REP; for (i = 0; i < INET_ADDRSTRLEN; i ++) { msg->target_ip[i] = msg->sender_ip[i]; } printf("Target ip:%s\n", msg->target_ip); for (i = 0; i < IF_HADDR; i++){ msg->target_mac[i] = msg->sender_mac[i]; } strcpy(msg->sender_ip, my_ip); for (i = 0; i < IF_HADDR; i++){ msg->sender_mac[i] = if_hwaddr[my_index][i]; } puts("----->ARP: I'm responsible for sending reply..."); send_arp_msg(sockfd, msg->target_mac, msg); puts("----->ARP: Reply sent.\n"); } else if ((i = search_cache(msg->sender_ip) != -1)) { // There is an existing entry, update puts("----->ARP: I'm not pertain to this request, but I have an existing entry, updating...\n"); update_cache(i, msg); } }
/** Gets the value associated with the key. returns true on success.. */ std::pair<bool, ValueType> get(const KeyType &key) const { // figure out who owns the key size_t hashvalue = hasher(key); size_t owningmachine = hashvalue % rpc.dc().numprocs(); std::pair<bool, ValueType> ret; // if I own the key, get it from the map table if (owningmachine == rpc.dc().procid()) { datalock.lock(); typename map_type::const_iterator iter = data.find(key); if (iter == data.end()) { ret.first = false; } else { ret.first = true; ret.second = iter->second; } datalock.unlock(); } else { ret = rpc.remote_request(owningmachine, &caching_dht<KeyType,ValueType>::get, key); if (ret.first) update_cache(key, ret.second); else invalidate(key); } return ret; }
int main(int argc, char* argv[]) { PGMemoRequest pgmr; zmqcpp::Socket socket(ZMQ_REP); bson::Document pgmconf = parse_config(argv[1]); zmqcpp::Message msg; std::string reply; if (pgmconf.field_names().count("zmq_bind")) socket.bind(pgmconf["zmq_bind"].data<std::string>()); else if (pgmconf.field_names().count("zmq_connect")) socket.connect(pgmconf["zmq_connect"].data<std::string>()); else { std::cerr << "No valid zmq_connect or zmq_bind configuration directive found; bailing" << std::endl; exit(1); } while (true) { socket.recv(msg); pgmr.ParseFromString(msg.last()); msg.clear(); memo_query(pgmr, pgmconf); pgmr.SerializeToString(&reply); socket.send(zmqcpp::Message(reply)); if(pgmr.cached() && pgmr.refresh()) update_cache(pgmr, pgmconf); } return 0; }
static void ez_psu_process_save(struct ez_psu_save *psave, struct xcl_context *xc, struct NL *nlp, const char *lang) { struct ez_psu p; memset(&p,'\0',sizeof(struct ez_psu)); p.lang = (char*)lang; if (ez_psu_parse(psave,&p)) return; /* for +=, add the PSU spec to the relevant ngrams list */ if (*p.operator == '+') { struct form *fp = new_persistent_form(); nl_set_location(file, psave->lnum); parse_ngram_line(nlp, (char*)ez_psu_create_input(&p), nlp->nngrams, nlp->owner, NULL); ++nlp->nngrams; /* then create a form structure and add it to the cache */ fp->lang = p.lang; fp->file = (char*)file; fp->lnum = psave->lnum; lemparse(p.lemma,fp); update_cache(xc,fp); } else { /* for =, find the form structure in cache or dictionary and clone it so we can add the new information */ } }
void camel_groupwise_journal_transfer (CamelGroupwiseJournal *groupwise_journal, CamelGroupwiseFolder *source_folder, CamelMimeMessage *message, const CamelMessageInfo *mi, const char *original_uid, char **transferred_uid, CamelException *ex) { CamelOfflineJournal *journal = (CamelOfflineJournal *) groupwise_journal; CamelGroupwiseStore *gw_store= CAMEL_GROUPWISE_STORE(journal->folder->parent_store) ; CamelGroupwiseJournalEntry *entry; char *uid; if (!update_cache (groupwise_journal, message, mi, &uid, ex)) return; entry = g_new (CamelGroupwiseJournalEntry, 1); entry->type = CAMEL_GROUPWISE_JOURNAL_ENTRY_APPEND; entry->uid = uid; entry->original_uid = g_strdup (original_uid); entry->source_container = g_strdup (camel_groupwise_store_container_id_lookup (gw_store, ((CamelFolder *)source_folder)->name)); e_dlist_addtail (&journal->queue, (EDListNode *) entry); if (transferred_uid) *transferred_uid = g_strdup (uid); }
/* * an expose event to our image window * we only handle the i channel for now */ gboolean image_expose_cb(GtkWidget *widget, GdkEventExpose *event, gpointer window) { struct map_cache *cache; struct image_channel *i_channel; struct map_geometry *geom; void *ret; extern void draw_sources_hook(GtkWidget *darea, GtkWidget *window, GdkRectangle *area); ret = g_object_get_data(G_OBJECT(window), "map_cache"); if (ret == NULL) /* no map cache, we don;t have a frame to display */ return TRUE; cache = ret; ret = g_object_get_data(G_OBJECT(window), "i_channel"); if (ret == NULL) /* no channel */ return TRUE; i_channel = ret; if (i_channel->fr == NULL) /* no frame */ return TRUE; ret = g_object_get_data(G_OBJECT(window), "geometry"); if (ret == NULL) /* no geometry */ return TRUE; geom = ret; if ((!i_channel->color && cache->type != MAP_CACHE_GRAY) || (i_channel->color && cache->type != MAP_CACHE_RGB)) { // d3_printf("expose: other cache type\n"); if (cache->dat) free(cache->dat); cache->cache_valid = 0; } else if (cache->zoom != geom->zoom) { // d3_printf("expose: other cache zoom\n"); cache->cache_valid = 0; } else if (i_channel->channel_changed) { // d3_printf("expose: other channel\n"); cache->cache_valid = 0; i_channel->channel_changed = 0; } else if (!area_in_cache(&(event->area), cache)) { // d3_printf("expose: other area\n"); cache->cache_valid = 0; } if (!cache->cache_valid) { update_cache(cache, geom, i_channel, &(event->area)); } if (cache->cache_valid) { // d3_printf("cache valid, area is %d by %d starting at %d, %d\n", // cache->w, cache->h, cache->x, cache->y); // d3_printf("expose: from cache\n"); if (cache->type == MAP_CACHE_GRAY) paint_from_gray_cache(widget, cache, &(event->area)); else paint_from_rgb_cache(widget, cache, &(event->area)); } draw_sources_hook(widget, window, &(event->area)); return TRUE; }
static gboolean try_query_info (GVfsBackend *backend, GVfsJobQueryInfo *job, const char *filename, GFileQueryInfoFlags flags, GFileInfo *info, GFileAttributeMatcher *matcher) { if (is_root (filename)) { GIcon *icon; g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY); g_file_info_set_name (info, "/"); g_file_info_set_display_name (info, g_vfs_backend_get_display_name (backend)); g_file_info_set_content_type (info, "inode/directory"); icon = g_vfs_backend_get_icon (backend); if (icon != NULL) g_file_info_set_icon (info, icon); g_vfs_job_succeeded (G_VFS_JOB (job)); } else update_cache (G_VFS_BACKEND_AFP_BROWSE (backend), G_VFS_JOB (job)->cancellable, query_info_cb, job); return TRUE; }
void TyplWrap::update_cache(size_t esize) { try { update_cache(entry_, esize); } catch (std::exception &e) { E2promErrMsg(e.what()); } }
static void on_setting_changed(HippoConnection *connection, const char *key, const char *value, void *data) { HippoSettings *settings = HIPPO_SETTINGS(data); update_cache(settings, key, value); }
indent& indent::operator--(int) { indentLevel--; assert(indentLevel>=0); if (indentLevel<0) indentLevel=0; update_cache(); return *this; }
void restore_variables_for_loadstate() { u32 oldpc; oldpc=(u32)m6502_pc; #if MOVIEPLAYER update_cache(); build_chr_decode(); #else rebankswitch(); #endif lastbank= memmap_tbl[ (((u32)m6502_pc) & PRG_BANK_MASK) / (1024*PRG_BANK_SIZE)]; m6502_pc= (u8*)((u32)oldpc+(u32)lastbank); m6502_s=(u8*)((u32)m6502_s+(u32)NES_RAM); cpustate[1]=(u32)memmap_tbl; ppustat_=ppustat_savestate; vramaddr = vramaddr_dummy; _pcmstart=(u8*) ((u32)_pcmstart+(u32)PCMWAV); _pcmcurrentaddr=(u8*) ((u32)_pcmcurrentaddr+(u32)PCMWAV); decode_timeouts(); //Old versions used a Scanlines counter, and state of "CPU cycles" register //had a negitive number to indicate how many cycles past the scanline start we were at. //Now we use a positive number indicating how many cycles are left until the next timeout. if (!(blocks_loaded & BLOCK_TIME)) { if ((_cpu_cycles/0x100) <= 0) { _cpu_cycles += _cycles_to_run * 256; } } //we added the irq_time_add variable to mapper 4 (MMC3), set this if it's zero. if (mapper_number == 4) { if (mapperstate[3] == 0) //irq_time_add, this may be 0 in old savestates, change to 12 { mapperstate[3] = 12; } } //If we didn't load sound state, then make these default changes: //disable Frame IRQ, and enable all sound channels. //Fixme: need to load old SND0 sound state correctly. if (!(blocks_loaded & BLOCK_SND1)) { _frame_mode = 0x80; _channel_enables = 0x0F; } }
/* * db_set -- * Store a line in the file. * * PUBLIC: int db_set __P((SCR *, db_recno_t, CHAR_T *, size_t)); */ int db_set(SCR *sp, db_recno_t lno, CHAR_T *p, size_t len) { DBT data, key; EXF *ep; const char *fp; size_t flen; #if defined(DEBUG) && 0 vtrace(sp, "replace line %lu: len %lu {%.*s}\n", (u_long)lno, (u_long)len, MIN(len, 20), p); #endif /* Check for no underlying file. */ if ((ep = sp->ep) == NULL) { ex_emsg(sp, NULL, EXM_NOFILEYET); return (1); } if (ep->l_win && ep->l_win != sp->wp) { ex_emsg(sp, NULL, EXM_LOCKED); return 1; } /* Log before change. */ log_line(sp, lno, LOG_LINE_RESET_B); INT2FILE(sp, p, len, fp, flen); /* Update file. */ memset(&key, 0, sizeof(key)); key.data = &lno; key.size = sizeof(lno); memset(&data, 0, sizeof(data)); data.data = __UNCONST(fp); data.size = flen; if ((sp->db_error = ep->db->put(ep->db, NULL, &key, &data, 0)) != 0) { msgq(sp, M_DBERR, "006|unable to store line %lu", (u_long)lno); return (1); } /* Flush the cache, update line count, before screen update. */ update_cache(sp, LINE_RESET, lno); /* File now dirty. */ if (F_ISSET(ep, F_FIRSTMODIFY)) (void)rcv_init(sp); F_SET(ep, F_MODIFIED); /* Log after change. */ log_line(sp, lno, LOG_LINE_RESET_F); /* Update screen. */ return (scr_update(sp, lno, LINE_RESET, 1)); }
static int lupdate(lua_State *L) { lua_getfield(L, LUA_REGISTRYINDEX, PROXYCACHE); lua_pushvalue(L, 1); // PROXYCACHE, table if (lua_rawget(L, -2) != LUA_TUSERDATA) { luaL_error(L, "Invalid proxy table %p", lua_topointer(L, 1)); } struct proxy * p = lua_touserdata(L, -1); luaL_checktype(L, 2, LUA_TLIGHTUSERDATA); const char * newdata = lua_touserdata(L, 2); update_cache(L, p->data, newdata); return 1; }
/* * db_delete -- * Delete a line from the file. * * PUBLIC: int db_delete __P((SCR *, db_recno_t)); */ int db_delete(SCR *sp, db_recno_t lno) { DBT key; EXF *ep; #if defined(DEBUG) && 0 vtrace(sp, "delete line %lu\n", (u_long)lno); #endif /* Check for no underlying file. */ if ((ep = sp->ep) == NULL) { ex_emsg(sp, NULL, EXM_NOFILEYET); return (1); } if (ep->l_win && ep->l_win != sp->wp) { ex_emsg(sp, NULL, EXM_LOCKED); return 1; } /* Update marks, @ and global commands. */ if (line_insdel(sp, LINE_DELETE, lno)) return 1; /* Log before change. */ log_line(sp, lno, LOG_LINE_DELETE_B); /* Update file. */ memset(&key, 0, sizeof(key)); key.data = &lno; key.size = sizeof(lno); if ((sp->db_error = ep->db->del(ep->db, NULL, &key, 0)) != 0) { msgq(sp, M_DBERR, "003|unable to delete line %lu", (u_long)lno); return (1); } /* Flush the cache, update line count, before screen update. */ update_cache(sp, LINE_DELETE, lno); /* File now modified. */ if (F_ISSET(ep, F_FIRSTMODIFY)) (void)rcv_init(sp); F_SET(ep, F_MODIFIED); /* Log after change. */ log_line(sp, lno, LOG_LINE_DELETE_F); /* Update screen. */ return (scr_update(sp, lno, LINE_DELETE, 1)); }
/// Sets the key to the value void set(const KeyType& key, const ValueType &newval) { size_t hashvalue = hasher(key); size_t owningmachine = hashvalue % rpc.dc().numprocs(); if (owningmachine == rpc.dc().procid()) { datalock.lock(); data[key] = newval; datalock.unlock(); } else { rpc.remote_call(owningmachine, &caching_dht<KeyType,ValueType>::set, key, newval); update_cache(key, newval); } }
void * madns_response(MADNS * mp, in_addr_t * ip) { while (1) { char pkt[DNS_PACKET_LEN]; INADDR sa; socklen_t salen = sizeof sa; RESPONSE resp; char ips[99]; int len = recvfrom(mp->sock, pkt, sizeof pkt, 0, (SADDR *) & sa, &salen); if (len <= 0) break; if (!parse_response(pkt, len, &resp)) continue; LOG("resp: ip %s ttl %lu tid %hu name %s\n", ipstr(resp.ip, ips), resp.ttl, resp.tid, resp.name); QUERY *qp = &mp->queries[(int)resp.tid % mp->qsize]; if (qp->ctx && qp->tid == resp.tid && qp->server && qp->server->ip == sa.sin_addr.s_addr) { if (resp.ip != INADDR_ANY && !strcasecmp(resp.name, qp->name)) update_cache(mp, &resp); return destroy_query(mp, qp, *ip = resp.ip); } log_packet(__LINE__, pkt, len); if (qp->server && qp->server->ip != sa.sin_addr.s_addr) LOG("resp.addr=%s tid=%hu ttl=%lu serv=%s\n", ipstr(sa.sin_addr.s_addr, pkt), resp.tid, resp.ttl, ipstr(qp->server->ip, pkt + 33)); } if (!qempty(&mp->active)) { QUERY *qp = link_QUERY(mp->active.next); if (qp->expires <= time(0)) return destroy_query(mp, qp, *ip = INADDR_ANY); } return NULL; }
/**@brief this function receives an arp message from outside and processes it * @param fins_received is the pointer to the fins frame which has been received by the ARP module */ void arp_in(struct finsFrame *fins_received){ struct ARP_message *arp_msg_ptr; fins_arp_in = fins_received; /**request or reply received from the network and as transmitted by the ethernet stub*/ if (fins_arp_in->dataOrCtrl == DATA && (fins_arp_in->destinationID.id == (unsigned char) ARPID)) { fins_to_arp(fins_arp_in, packet); //extract arp hdr from the fins frame host_to_net(packet); //convert it into the right format (e.g. htons issue etc.) arp_msg_ptr = &arp_msg; arp_hdr_to_msg(packet, arp_msg_ptr); //convert the hdr into an internal ARP message (e.g. use uint64_t instead of unsigned char) print_msgARP(arp_msg_ptr); if (check_valid_arp(arp_msg_ptr)==1){ update_cache(arp_msg_ptr); if ((arp_msg_ptr->target_IP_addrs==interface_IP_addrs) && (arp_msg_ptr->operation==ARPREQUESTOP)) arp_out(REPLYDATA);//generate reply else if ((arp_msg_ptr->target_IP_addrs==interface_IP_addrs) && (arp_msg_ptr->operation==ARPREPLYOP)) { target_IP_addrs = arp_msg.sender_IP_addrs; arp_out(REPLYCONTROL);//generate fins control carrying neighbor's MAC address } } } else if ((fins_arp_in->dataOrCtrl == CONTROL) && (fins_arp_in->ctrlFrame.opcode == WRITEREQUEST) && (fins_arp_in->destinationID.id == (unsigned char) ARPID)) {/**as a request received from the ethernet stub-- IP address is provided in this fins control frame*/ memcpy(fins_IP_address, fins_arp_in->ctrlFrame.paramterValue, PROTOCOLADDRSLEN); target_IP_addrs = gen_IP_addrs(fins_IP_address[0],fins_IP_address[1],fins_IP_address[2],fins_IP_address[3]); /**request initiated by the ethernet stub*/ if (search_list(ptr_cacheHeader, target_IP_addrs)==0)//i.e. not found arp_out(REQUESTDATA); //generate arp request for MAC address and send out to the network else arp_out(REPLYCONTROL);//generate fins control carrying MAC address foe ethernet } print_cache(); }
static int spr_get_sprite(UINT32 key) { SPRITE *p = spr_head[key & SPR_HASH_MASK]; while (p) { if (p->key == key) { if (p->used != frames_displayed) { update_cache(key << 7); p->used = frames_displayed; } return p->index; } p = p->next; } return -1; }
void camel_groupwise_journal_append (CamelGroupwiseJournal *groupwise_journal, CamelMimeMessage *message, const CamelMessageInfo *mi, char **appended_uid, CamelException *ex) { CamelOfflineJournal *journal = (CamelOfflineJournal *) groupwise_journal; CamelGroupwiseJournalEntry *entry; char *uid; if (!update_cache (groupwise_journal, message, mi, &uid, ex)) return; entry = g_new (CamelGroupwiseJournalEntry, 1); entry->type = CAMEL_GROUPWISE_JOURNAL_ENTRY_APPEND; entry->uid = uid; e_dlist_addtail (&journal->queue, (EDListNode *) entry); if (appended_uid) *appended_uid = g_strdup (uid); }
static gboolean try_mount_mountable (GVfsBackend *backend, GVfsJobMountMountable *job, const char *filename, GMountSource *mount_source) { GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend); if (is_root (filename)) { g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_NOT_MOUNTABLE_FILE, _("The file is not a mountable")); return TRUE; } update_cache (afp_backend, G_VFS_JOB (job)->cancellable, mount_mountable_cb, job); return TRUE; }
void image_box_to_cache(struct map_cache *cache, struct image_channel *channel, double zoom, int x, int y, int w, int h) { struct map_geometry geom; GdkRectangle area; int zoom_in = 1; int zoom_out = 1; if (zoom > 1.0 && zoom <= 16.0) { zoom_in = floor(zoom + 0.5); } else if (zoom < 1.0 && zoom >= (1.0 / 16.0)) { zoom_out = floor(1.0 / zoom + 0.5); } memset(&geom, 0, sizeof(struct map_geometry)); geom.zoom = zoom; area.x = x * zoom_in / zoom_out; area.y = y * zoom_in / zoom_out; area.width = w * zoom_in; area.height = h * zoom_in; update_cache(cache, &geom, channel, &area); }
static gboolean try_enumerate (GVfsBackend *backend, GVfsJobEnumerate *job, const char *filename, GFileAttributeMatcher *attribute_matcher, GFileQueryInfoFlags flags) { GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend); if (!is_root(filename)) { g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("File doesn't exist")); return TRUE; } update_cache (afp_backend, G_VFS_JOB (job)->cancellable, enumerate_cache_updated_cb, job); return TRUE; }
/** Gets the value associated with the key. returns true on success.. */ std::pair<bool, ValueType> get(const KeyType &key) const { std::pair<bool, ValueType> ret = get_owned(key); if (ret.first) return ret; wait_struct w; w.numreplies = rmi.numprocs() - 1; size_t ptr = reinterpret_cast<size_t>(&w); // otherwise I need to find someone with the key for (size_t i = 0;i < rmi.numprocs(); ++i) { if (i != rmi.procid()) { rmi.RPC_CALL(remote_call,&lazy_dht<KeyType,ValueType>::remote_get_owned) (i, key, rmi.procid(), ptr); } } w.mut.lock(); while (w.numreplies > 0) w.cond.wait(w.mut); w.mut.unlock(); ret.first = w.hasvalue; ret.second = w.val; if (ret.first) update_cache(key, ret.second); return ret; }
/* * net_register() * * Make sure the cache is properly sync'ed, and its registrations * are in order. * * Locking: the cache is locked by update_cache, and is held * throughout update_cache's execution because it reads and * possibly modifies cache links continuously. */ static int net_register(rcm_handle_t *hd) { update_cache(hd); /* * Need to register interest in all new resources * getting attached, so we get attach event notifications */ if (!events_registered) { if (rcm_register_event(hd, RCM_RESOURCE_PHYSLINK_NEW, 0, NULL) != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("NET: failed to register %s\n"), RCM_RESOURCE_PHYSLINK_NEW); return (RCM_FAILURE); } else { rcm_log_message(RCM_DEBUG, _("NET: registered %s \n"), RCM_RESOURCE_PHYSLINK_NEW); events_registered++; } } return (RCM_SUCCESS); }
static void probe_device(snmp_cache_t *device) /* I - Device */ { char uri[1024], /* Full device URI */ *uriptr, /* Pointer into URI */ *format; /* Format string for device */ device_uri_t *device_uri; /* Current DeviceURI match */ debug_printf("DEBUG: %.3f Probing %s...\n", run_time(), device->addrname); #ifdef __APPLE__ /* * If the printer supports Bonjour/mDNS, don't report it from the SNMP backend. */ if (!try_connect(&(device->address), device->addrname, 5353)) { debug_printf("DEBUG: %s supports mDNS, not reporting!\n", device->addrname); return; } #endif /* __APPLE__ */ /* * Lookup the device in the match table... */ for (device_uri = (device_uri_t *)cupsArrayFirst(DeviceURIs); device_uri; device_uri = (device_uri_t *)cupsArrayNext(DeviceURIs)) if (device->make_and_model && !regexec(&(device_uri->re), device->make_and_model, 0, NULL, 0)) { /* * Found a match, add the URIs... */ for (format = (char *)cupsArrayFirst(device_uri->uris); format; format = (char *)cupsArrayNext(device_uri->uris)) { for (uriptr = uri; *format && uriptr < (uri + sizeof(uri) - 1);) if (*format == '%' && format[1] == 's') { /* * Insert hostname/address... */ strlcpy(uriptr, device->addrname, sizeof(uri) - (size_t)(uriptr - uri)); uriptr += strlen(uriptr); format += 2; } else *uriptr++ = *format++; *uriptr = '\0'; update_cache(device, uri, NULL, NULL); } return; } /* * Then try the standard ports... */ if (!try_connect(&(device->address), device->addrname, 9100)) { debug_printf("DEBUG: %s supports AppSocket!\n", device->addrname); snprintf(uri, sizeof(uri), "socket://%s", device->addrname); update_cache(device, uri, NULL, NULL); } else if (!try_connect(&(device->address), device->addrname, 515)) { debug_printf("DEBUG: %s supports LPD!\n", device->addrname); snprintf(uri, sizeof(uri), "lpd://%s/", device->addrname); update_cache(device, uri, NULL, NULL); } }
void draw_multi_rooms (void) { int x, y; mr_map_rooms (); if (anim_cycle == 0) { generate_wall_colors_for_room (0, room0_wall_color); } if (em == PALACE && vm == VGA && (has_mr_view_changed () || em != mr.last.em || vm != mr.last.vm)) generate_wall_colors (); if (has_mr_view_changed ()) { generate_stars (); generate_mirrors_reflex (); } if (mouse_pos.room != mr.last.mouse_pos.room || mouse_pos.floor != mr.last.mouse_pos.floor || mouse_pos.place != mr.last.mouse_pos.place) { if (is_valid_pos (&mouse_pos)) update_cache_pos (&mouse_pos, em, vm); if (is_valid_pos (&mr.last.mouse_pos)) update_cache_pos (&mr.last.mouse_pos, em, vm); } if (anim_cycle == 0 || em != mr.last.em || vm != mr.last.vm || hgc != mr.last.hgc || hue != mr.last.hue) { update_room0_cache (em, vm); } if (anim_cycle == 0 || has_mr_view_changed () || em != mr.last.em || vm != mr.last.vm || hgc != mr.last.hgc || hue != mr.last.hue || level.number != mr.last.level) { update_cache (em, vm); } size_t i; for (i = 0; i < changed_pos_nmemb; i++) { /* printf ("%i,%i,%i\n", changed_pos[i].room, changed_pos[i].floor, changed_pos[i].place); */ update_cache_pos (&changed_pos[i], em, vm); } destroy_array ((void **) &changed_pos, &changed_pos_nmemb); clear_bitmap (screen, BLACK); for (y = mr.h - 1; y >= 0; y--) for (x = 0; x < mr.w; x++) { if (! mr.cell[x][y].room) continue; mr.dx = x; mr.dy = y; draw_animated_background (mr.cell[x][y].screen, mr.cell[x][y].room); } if (! no_room_drawing) draw_bitmap (cache, screen, 0, 0, 0); for (y = mr.h - 1; y >= 0; y--) for (x = 0; x < mr.w; x++) { if (! mr.cell[x][y].room) continue; mr.dx = x; mr.dy = y; draw_animated_foreground (mr.cell[x][y].screen, mr.cell[x][y].room); } if (mr.select_cycles > 0) { al_hold_bitmap_drawing (false); int x0 = ORIGINAL_WIDTH * mr.x; int y0 = ROOM_HEIGHT * mr.y + 3; int x1 = x0 + ORIGINAL_WIDTH; int y1 = y0 + ROOM_HEIGHT; draw_rectangle (screen, x0, y0, x1, y1, RED, 1); mr.select_cycles--; } mr.dx = mr.dy = -1; mr_update_last_settings (); }
/**@brief this function tests a set of functions which are used when * (1) a host receives an ARP request, and (2) keeps updating its cache based on * these ARP requests * @param fileName is the file from which the list of neighbors is drawn */ void send_receive_update(char *fileName) { extern struct node *ptr_cacheHeader; struct finsFrame request_fins, reply_fins, *request_fins_ptr, *reply_fins_ptr; struct ARP_message request_ARP1, request_ARP2, reply_ARP1, reply_ARP2; struct ARP_message *request_ARP_ptr1, *request_ARP_ptr2, *reply_ARP_ptr1, *reply_ARP_ptr2; struct arp_hdr hdr_ARP, *hdr_ARP_ptr; uint64_t MAC_addrs; uint32_t IP_addrs_read; int task; /**Following code generates a list of IP/MAC addresses of 'neighbors' and initializes cache*/ ptr_cacheHeader = init_intface(); gen_neighbor_list(fileName); init_recordsARP(fileName); print_cache(); print_neighbors(ptr_neighbor_list); hdr_ARP_ptr = &hdr_ARP; IP_addrs_read = 1; task = 1; /**Begin Initialize/Instantiate Pointers */ request_fins_ptr = &request_fins; reply_fins_ptr = &reply_fins; request_ARP_ptr1 = &request_ARP1; request_ARP_ptr2 = &request_ARP2; reply_ARP_ptr1 = &reply_ARP1; reply_ARP_ptr2 = &reply_ARP2; /**A host can send update its cache based on its own request or a request from another network host*/ while (IP_addrs_read!=0 && (task==0 || task == 1)) { PRINT_DEBUG("\nTest send request and update `0' or test receive a request `1' \n"); scanf("%d", &task); IP_addrs_read = read_IP_addrs(); /**The following functions test the internal operations of the module*/ if (task==0){ gen_requestARP(IP_addrs_read, request_ARP_ptr1); print_msgARP(request_ARP_ptr1); arp_to_fins(request_ARP_ptr1, request_fins_ptr); fins_to_arp(request_fins_ptr, request_ARP_ptr2); mimic_net_reply(request_ARP_ptr2, reply_ARP_ptr1); if (check_valid_arp(reply_ARP_ptr1)==1){ arp_to_fins(reply_ARP_ptr1, reply_fins_ptr); fins_to_arp(reply_fins_ptr, reply_ARP_ptr2); print_msgARP(reply_ARP_ptr2); update_cache(reply_ARP_ptr2);} print_cache(); } else if (task==1){ MAC_addrs = search_MAC_addrs(IP_addrs_read, ptr_neighbor_list); mimic_net_request(IP_addrs_read, MAC_addrs,request_ARP_ptr1); print_msgARP(request_ARP_ptr1); if (check_valid_arp(request_ARP_ptr1)==1){ arp_to_fins(request_ARP_ptr1, request_fins_ptr); fins_to_arp(request_fins_ptr, request_ARP_ptr2); print_msgARP(request_ARP_ptr2); update_cache(request_ARP_ptr2);} print_cache(); } /**The following functions test the external operation of the module*/ if (check_valid_arp(request_ARP_ptr2)==1){ hdr_ARP_ptr = &hdr_ARP; /**convert ARP message to htons format and generate MAC addresses as unsigned char ptr*/ net_fmt_conversion(request_ARP_ptr2, hdr_ARP_ptr); print_arp_hdr(hdr_ARP_ptr);/**print some fields of the ARP message in external format*/ host_fmt_conversion(hdr_ARP_ptr, request_ARP_ptr2);/**convert ARP message to ntohs format*/ print_msgARP(request_ARP_ptr2);/**print ARP message internal format*/ } } term_intface(); }
static int bee_dep_update(int argc, char *argv[]) { int c, help; char *pkg; char path[PATH_MAX + 1]; struct hash *graph; struct stat st; struct option long_options[] = { {"help", 0, &help, 1}, {0, 0, 0, 0} }; help = 0; while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) { switch (c) { case '?': usage_update(); return 1; } } if (help) { usage_update(); return 0; } if (argc == 1) { graph = get_cache(); if (update_cache(graph) || save_cache(graph, cache_filename())) { hash_free(graph); return 1; } hash_free(graph); return 0; } if (argc < 2) { fprintf(stderr, "bee-dep: pkgname needed\n"); return 1; } if (argc > 2) { fprintf(stderr, "bee-dep: too many arguments\n"); return 1; } pkg = argv[1]; if (sprintf(path, "%s/%s/DEPENDENCIES", bee_metadir(), pkg) < 0) { perror("bee-dep: sprintf"); return 1; } graph = get_cache(); if (stat(path, &st) != -1) { if (hash_search(graph, pkg)) { hash_free(graph); return 0; } if (graph_insert_nodes(graph, path)) { hash_free(graph); return 1; } } else { if (remove_package(graph, pkg)) { hash_free(graph); return 1; } } if (save_cache(graph, cache_filename())) { hash_free(graph); return 1; } hash_free(graph); return 0; }