/**************************************************************** ... *****************************************************************/ void diplomacy_dialog_erase_clause_callback(Widget w, XtPointer client_data, XtPointer call_data) { struct Diplomacy_dialog *pdialog=(struct Diplomacy_dialog *)client_data; XawListReturnStruct *ret; ret=XawListShowCurrent(pdialog->dip_clauselist); if(ret->list_index!=XAW_LIST_NONE) { int i; struct genlist_iterator myiter; genlist_iterator_init(&myiter, &pdialog->treaty.clauses, 0); for(i=0; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter), i++) { if(i==ret->list_index) { struct packet_diplomacy_info pa; struct Clause *pclause=(struct Clause *)ITERATOR_PTR(myiter); pa.plrno0=pdialog->treaty.plr0->player_no; pa.plrno1=pdialog->treaty.plr1->player_no; pa.plrno_from=pclause->from->player_no; pa.clause_type=pclause->type; pa.value=pclause->value; send_packet_diplomacy_info(&aconnection, PACKET_DIPLOMACY_REMOVE_CLAUSE, &pa); return; } } } }
/************************************************************************** ... **************************************************************************/ void button_down_citymap(Widget w, XEvent *event, String *argv, Cardinal *argc) { XButtonEvent *ev=&event->xbutton; struct genlist_iterator myiter; struct city *pcity; genlist_iterator_init(&myiter, &dialog_list, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) if(((struct city_dialog *)ITERATOR_PTR(myiter))->map_canvas==w) break; if((pcity=((struct city_dialog *)ITERATOR_PTR(myiter))->pcity)) { int xtile, ytile; struct packet_city_request packet; xtile=ev->x/tile_sprite_width; ytile=ev->y/tile_sprite_height; packet.city_id=pcity->id; packet.worker_x=xtile; packet.worker_y=ytile; packet.name[0]='\0'; if(pcity->city_map[xtile][ytile]==C_TILE_WORKER) send_packet_city_request(&aconnection, &packet, PACKET_CITY_MAKE_SPECIALIST); else if(pcity->city_map[xtile][ytile]==C_TILE_EMPTY) send_packet_city_request(&aconnection, &packet, PACKET_CITY_MAKE_WORKER); } }
void cpqNicIfLogMapTable_cache_reload(int index) { netsnmp_cache *cpqNicIfLogMapTable_cache = NULL; netsnmp_container *iflogmap_container; netsnmp_iterator *it; cpqNicIfLogMapTable_entry* entry = NULL; DEBUGMSGTL(("internal:cpqNicIfLogMapTable:_cache_reload", "triggered\n")); cpqNicIfLogMapTable_cache = netsnmp_cache_find_by_oid(cpqNicIfLogMapTable_oid, cpqNicIfLogMapTable_oid_len); if (cpqNicIfLogMapTable_cache != NULL) { iflogmap_container = cpqNicIfLogMapTable_cache->magic; it = CONTAINER_ITERATOR(iflogmap_container); entry = ITERATOR_FIRST( it ); while (entry != NULL ) { if (entry->cpqNicIfLogMapIndex == index) break; entry = ITERATOR_NEXT( it ); } ITERATOR_RELEASE( it ); if (entry != NULL) cpqNicIfLogMap_reload_entry(entry); } }
int swrun_count_processes_by_regex(pcre *regexp) { netsnmp_swrun_entry *entry; netsnmp_iterator *it; int i = 0; int found_ndx[30]; int found; char fullCommand[64 + 128 + 128 + 3]; netsnmp_cache *swrun_cache = netsnmp_swrun_cache(); netsnmp_container *swrun_container = netsnmp_swrun_container(); if ( !swrun_container || !regexp ) return 0; /* or -1 */ it = CONTAINER_ITERATOR( swrun_container ); while ((entry = (netsnmp_swrun_entry*)ITERATOR_NEXT( it )) != NULL) { // need to assemble full command back so regexps can get full picture sprintf(fullCommand, "%s %s", entry->hrSWRunPath, entry->hrSWRunParameters); found = pcre_exec(regexp, NULL, fullCommand, strlen(fullCommand), 0, 0, found_ndx, 30); if (found > 0) { i++; } } ITERATOR_RELEASE( it ); return i; }
/*************************************************************** ... ***************************************************************/ void player_set_unit_focus_status(struct player *pplayer) { struct genlist_iterator myiter; genlist_iterator_init(&myiter, &pplayer->units.list, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) ((struct unit *)ITERATOR_PTR(myiter))->focus_status=FOCUS_AVAIL; }
static int _cache_load(netsnmp_cache *cache, netsnmp_tdata *table) { netsnmp_container *maps; netsnmp_iterator *map_itr; netsnmp_cert_map *map; netsnmp_tdata_row *row; certToTSN_entry *entry; int rc = 0; DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "called, %" NETSNMP_PRIz "d rows\n", CONTAINER_SIZE(table->container))); /** get current active maps */ maps = netsnmp_cert_map_container(); if (NULL == maps) return 0; DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "maps %" NETSNMP_PRIz "d rows\n", CONTAINER_SIZE(maps))); map_itr = CONTAINER_ITERATOR(maps); if (NULL == map_itr) { DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "cant get map iterator\n")); return -1; } /* * insert rows for active maps into tbl container */ map = ITERATOR_FIRST(map_itr); for( ; map; map = ITERATOR_NEXT(map_itr)) { row = _entry_from_map(map); if (NULL == row) { rc =-1; break; } entry = (certToTSN_entry*)row->data; entry->rowStatus = RS_ACTIVE; if (netsnmp_tdata_add_row(table, row) != SNMPERR_SUCCESS) { tlstmCertToTSNTable_removeEntry(NULL, row); rc = -1; break; } } ITERATOR_RELEASE(map_itr); DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "done, %" NETSNMP_PRIz "d rows\n", CONTAINER_SIZE(table->container))); return rc; }
/* * log CSV version of trap. * dontcare param is there so this function can be passed directly * to CONTAINER_FOR_EACH. */ static void _sql_log(sql_buf *sqlb, void* dontcare) { netsnmp_iterator *it; sql_vb_buf *sqlvb; if ((NULL == sqlb) || sqlb->logged) return; /* * log trap info * nothing done to protect against data insertion attacks with * respect to bad data (commas, newlines, etc) */ snmp_log(LOG_ERR, "trap:%d-%d-%d %d:%d:%d,%s,%d,%d,%d,%s,%s,%d,%d,%d,%s,%s,%s,%s\n", sqlb->time.year,sqlb->time.month,sqlb->time.day, sqlb->time.hour,sqlb->time.minute,sqlb->time.second, sqlb->user, sqlb->type, sqlb->version, sqlb->reqid, sqlb->oid, sqlb->transport, sqlb->security_model, sqlb->msgid, sqlb->security_level, sqlb->context, sqlb->context_engine, sqlb->security_name, sqlb->security_engine); sqlb->logged = 1; /* prevent multiple logging */ it = CONTAINER_ITERATOR(sqlb->varbinds); if (NULL == it) { snmp_log(LOG_ERR, "error creating iterator; incomplete trap logged\n"); return; } /** log varbind info */ for( sqlvb = ITERATOR_FIRST(it); sqlvb; sqlvb = ITERATOR_NEXT(it)) { #ifdef NETSNMP_MYSQL_TRAP_VALUE_TEXT snmp_log(LOG_ERR,"varbind:%s,%s\n", sqlvb->oid, sqlvb->val); #else char *hex; int len = binary_to_hex(sqlvb->val, sqlvb->val_len, &hex); if (hex) { snmp_log(LOG_ERR,"varbind:%d,%s,%s\n", sqlvb->oid, hex); free(hex); } else { snmp_log(LOG_ERR,"malloc failed for varbind hex value\n"); snmp_log(LOG_ERR,"varbind:%s,\n", sqlvb->oid); } #endif } ITERATOR_RELEASE(it); }
/** create a new row in the table */ static void register_foreach(const struct sysORTable* data, void* dummy) { sysORTable_entry *entry; sysORLastChange = data->OR_uptime; entry = SNMP_MALLOC_TYPEDEF(sysORTable_entry); if (!entry) { snmp_log(LOG_ERR, "could not allocate storage, sysORTable is inconsistent\n"); } else { const oid firstNext = sysORNextIndex; netsnmp_iterator* it = CONTAINER_ITERATOR(table); do { const sysORTable_entry* value; const oid cur = sysORNextIndex; if (sysORNextIndex == SNMP_MIN(MAX_SUBID, 2147483647UL)) sysORNextIndex = 1; else ++sysORNextIndex; for (value = (sysORTable_entry*)it->curr(it); value && value->sysORIndex < cur; value = (sysORTable_entry*)ITERATOR_NEXT(it)) { } if (value && value->sysORIndex == cur) { if (sysORNextIndex < cur) it->reset(it); } else { entry->sysORIndex = cur; break; } } while (firstNext != sysORNextIndex); ITERATOR_RELEASE(it); if(firstNext == sysORNextIndex) { snmp_log(LOG_ERR, "Failed to locate a free index in sysORTable\n"); free(entry); } else { entry->data = data; entry->oid_index.len = 1; entry->oid_index.oids = &entry->sysORIndex; CONTAINER_INSERT(table, entry); } } }
/***************************************************************** ... *****************************************************************/ struct Diplomacy_dialog *find_diplomacy_by_input(Widget w) { struct genlist_iterator myiter; genlist_iterator_init(&myiter, &diplomacy_dialogs, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct Diplomacy_dialog *pdialog= (struct Diplomacy_dialog *)ITERATOR_PTR(myiter); if((pdialog->dip_gold_input0==w) || (pdialog->dip_gold_input1==w)) { return pdialog; } } return 0; }
/* this is called after the connection on the server side by us to check other aspects about the connection and obtain the securityName from the remote certificate. */ int netsnmp_tlsbase_extract_security_name (SSL * ssl, _netsnmpTLSBaseData * tlsdata) { netsnmp_container *chain_maps; netsnmp_cert_map *cert_map, *peer_cert; netsnmp_iterator *itr; int rc; netsnmp_assert_or_return (ssl != NULL, SNMPERR_GENERR); netsnmp_assert_or_return (tlsdata != NULL, SNMPERR_GENERR); if (NULL == (chain_maps = netsnmp_openssl_get_cert_chain (ssl))) return SNMPERR_GENERR; /* * map fingerprints to mapping entries */ rc = netsnmp_cert_get_secname_maps (chain_maps); if ((-1 == rc) || (CONTAINER_SIZE (chain_maps) == 0)) { netsnmp_cert_map_container_free (chain_maps); return SNMPERR_GENERR; } /* * change container to sorted (by clearing unsorted option), then * iterate over it until we find a map that returns a secname. */ CONTAINER_SET_OPTIONS (chain_maps, 0, rc); itr = CONTAINER_ITERATOR (chain_maps); if (NULL == itr) { snmp_log (LOG_ERR, "could not get iterator for secname fingerprints\n"); netsnmp_cert_map_container_free (chain_maps); return SNMPERR_GENERR; } peer_cert = cert_map = ITERATOR_FIRST (itr); for (; !tlsdata->securityName && cert_map; cert_map = ITERATOR_NEXT (itr)) tlsdata->securityName = netsnmp_openssl_extract_secname (cert_map, peer_cert); ITERATOR_RELEASE (itr); netsnmp_cert_map_container_free (chain_maps); return (tlsdata->securityName ? SNMPERR_SUCCESS : SNMPERR_GENERR); }
/**************************************************************** ... *****************************************************************/ struct city_dialog *get_city_dialog(struct city *pcity) { struct genlist_iterator myiter; if(!dialog_list_has_been_initialised) { genlist_init(&dialog_list); dialog_list_has_been_initialised=1; } genlist_iterator_init(&myiter, &dialog_list, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) if(((struct city_dialog *)ITERATOR_PTR(myiter))->pcity==pcity) return ITERATOR_PTR(myiter); return 0; }
/**************************************************************** ... *****************************************************************/ void city_dialog_update_present_units(struct city_dialog *pdialog, int unitid) { int i; struct genlist_iterator myiter; struct unit *punit; if(unitid) { for(i=0; i<NO_UNITS_SHOWN; i++) if(pdialog->present_unit_ids[i]==unitid) break; if(i==NO_UNITS_SHOWN) unitid=0; } genlist_iterator_init(&myiter, &map_get_tile(pdialog->pcity->x, pdialog->pcity->y)->units.list, 0); for(i=0; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter), i++) { punit=(struct unit*)ITERATOR_PTR(myiter); if(unitid && punit->id!=unitid) continue; put_unit_pixmap(punit, XawPixcommPixmap(pdialog->present_unit_pixcomms[i]), 0, 0); put_unit_pixmap_city_overlays(punit, XawPixcommPixmap(pdialog->present_unit_pixcomms[i]), 0,0); xaw_expose_now(pdialog->present_unit_pixcomms[i]); pdialog->present_unit_ids[i]=punit->id; XtRemoveAllCallbacks(pdialog->present_unit_pixcomms[i], XtNcallback); XtAddCallback(pdialog->present_unit_pixcomms[i], XtNcallback, present_units_callback, (XtPointer)punit->id); XtSetSensitive(pdialog->present_unit_pixcomms[i], TRUE); } for(; i<NO_UNITS_SHOWN; i++) { XawPixcommClear(pdialog->present_unit_pixcomms[i]); pdialog->present_unit_ids[i]=0; XtSetSensitive(pdialog->present_unit_pixcomms[i], FALSE); } }
void _load_trusted_certs(SSL_CTX *the_ctx) { netsnmp_container *trusted_certs = NULL; netsnmp_iterator *trusted_cert_iterator = NULL; char *fingerprint; trusted_certs = netsnmp_cert_get_trustlist(); trusted_cert_iterator = CONTAINER_ITERATOR(trusted_certs); if (trusted_cert_iterator) { for (fingerprint = (char *) ITERATOR_FIRST(trusted_cert_iterator); fingerprint; fingerprint = ITERATOR_NEXT(trusted_cert_iterator)) { if (!_trust_this_cert(the_ctx, fingerprint)) snmp_log(LOG_ERR, "failed to load trust cert: %s\n", fingerprint); } ITERATOR_RELEASE(trusted_cert_iterator); } }
/** remove a row from the table */ static int unregister_cb(int major, int minor, void* serv, void* client) { sysORTable_entry *value; netsnmp_iterator* it = CONTAINER_ITERATOR(table); DEBUGMSGTL(("mibII/sysORTable/unregister_cb", "unregister_cb(%d, %d, %p, %p)\n", major, minor, serv, client)); sysORLastChange = ((struct sysORTable*)(serv))->OR_uptime; while ((value = (sysORTable_entry*)ITERATOR_NEXT(it)) && value->data != serv); ITERATOR_RELEASE(it); if(value) { CONTAINER_REMOVE(table, value); free(value); } return SNMP_ERR_NOERROR; }
/************************************************************************** ... **************************************************************************/ struct Treaty *find_treaty(struct player *plr0, struct player *plr1) { struct genlist_iterator myiter; if(!did_init_treaties) { genlist_init(&treaties); did_init_treaties=1; } genlist_iterator_init(&myiter, &treaties, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct Treaty *ptreaty=(struct Treaty *)ITERATOR_PTR(myiter); if((ptreaty->plr0==plr0 && ptreaty->plr1==plr1) || (ptreaty->plr0==plr1 && ptreaty->plr1==plr0)) return ptreaty; } return 0; }
int swrun_count_processes_by_name( char *name ) { netsnmp_swrun_entry *entry; netsnmp_iterator *it; int i = 0; netsnmp_cache_check_and_reload(swrun_cache); if ( !swrun_container || !name ) return 0; /* or -1 */ it = CONTAINER_ITERATOR( swrun_container ); while ((entry = (netsnmp_swrun_entry*)ITERATOR_NEXT( it )) != NULL) { if (0 == strcmp( entry->hrSWRunName, name )) i++; } ITERATOR_RELEASE( it ); return i; }
int Interface_Scan_NextInt(int *index, char *name, netsnmp_interface_entry **entry, void *dc) { if (NULL == e) return 0; if(index) *index = e->index; if(name) strcpy(name, e->name); if (entry) *entry = e; e = (netsnmp_interface_entry*)ITERATOR_NEXT(it); return 1; }
/************************************************************************** ... **************************************************************************/ void update_find_dialog(Widget find_list) { int i, j; for(i=0, ncities_total=0; i<game.nplayers; i++) ncities_total+=city_list_size(&game.players[i].cities); city_name_ptrs=(char **)malloc(ncities_total*sizeof(char*)); for(i=0, j=0; i<game.nplayers; i++) { struct genlist_iterator myiter; genlist_iterator_init(&myiter, &game.players[i].cities.list, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct city *pcity=(struct city *)ITERATOR_PTR(myiter); *(city_name_ptrs+j++)=mystrdup(pcity->name); } } if(ncities_total) XawListChange(find_list, city_name_ptrs, ncities_total, 0, True); }
/***************************************************************** ... *****************************************************************/ struct Diplomacy_dialog *find_diplomacy_dialog(struct player *plr0, struct player *plr1) { struct genlist_iterator myiter; if(!diplomacy_dialogs_list_has_been_initialised) { genlist_init(&diplomacy_dialogs); diplomacy_dialogs_list_has_been_initialised=1; } genlist_iterator_init(&myiter, &diplomacy_dialogs, 0); for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct Diplomacy_dialog *pdialog= (struct Diplomacy_dialog *)ITERATOR_PTR(myiter); if((pdialog->treaty.plr0==plr0 && pdialog->treaty.plr1==plr1) || (pdialog->treaty.plr0==plr1 && pdialog->treaty.plr1==plr0)) return pdialog; } return 0; }
/************************************************************************** ... **************************************************************************/ void update_diplomacy_dialog(struct Diplomacy_dialog *pdialog) { int i; struct genlist_iterator myiter; genlist_iterator_init(&myiter, &pdialog->treaty.clauses, 0); for(i=0; i<MAX_NO_CLAUSES && ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct Clause *pclause=(struct Clause *)ITERATOR_PTR(myiter); switch(pclause->type) { case CLAUSE_ADVANCE: sprintf(pdialog->clauselist_strings[i], "The %s give %s", get_race_name_plural(pclause->from->race), advances[pclause->value].name); break; case CLAUSE_GOLD: sprintf(pdialog->clauselist_strings[i], "The %s give %d gold", get_race_name_plural(pclause->from->race), pclause->value); break; case CLAUSE_MAP: sprintf(pdialog->clauselist_strings[i], "The %s give their worldmap", get_race_name_plural(pclause->from->race)); break; } pdialog->clauselist_strings_ptrs[i]=pdialog->clauselist_strings[i]; i++; } pdialog->clauselist_strings_ptrs[i]=0; XawListChange(pdialog->dip_clauselist, pdialog->clauselist_strings_ptrs, 0, 0, False); xaw_set_bitmap(pdialog->dip_acceptthumb0, get_thumb_pixmap(pdialog->treaty.accept0)); xaw_set_bitmap(pdialog->dip_acceptthumb1, get_thumb_pixmap(pdialog->treaty.accept1)); }
int Interface_Scan_NextInt(int *index, char *name, netsnmp_interface_entry **entry, void *dc) { netsnmp_interface_entry* e = NULL; if (NULL == row) return 0; e = row->data.ifentry; if(index) *index = e->index; if(name) strcpy(name, e->name); if (entry) *entry = e; row = (ifTable_rowreq_ctx*) ITERATOR_NEXT(it); return 1; }
static void _cache_free(netsnmp_cache *cache, netsnmp_tdata *table) { netsnmp_tdata_row *row; netsnmp_iterator *tbl_itr; certToTSN_entry *entry; DEBUGMSGTL(("tlstmCertToTSNTable:cache:free", "called, %" NETSNMP_PRIz "d rows\n", CONTAINER_SIZE(table->container))); /** insert rows for active maps into tbl container */ tbl_itr = CONTAINER_ITERATOR(table->container); if (NULL == tbl_itr) { DEBUGMSGTL(("tlstmCertToTSNTable:cache:free", "cant get map iterator\n")); return; } row = ITERATOR_FIRST(tbl_itr); for( ; row; row = ITERATOR_NEXT(tbl_itr)) { entry = row->data; /* * remove all active rows (they are in the maps container kept * by the library). Keep inactive ones for next time. */ if (entry->rowStatus == RS_ACTIVE) { tlstmCertToTSNTable_removeEntry(NULL, row); ITERATOR_REMOVE(tbl_itr); continue; } } ITERATOR_RELEASE(tbl_itr); DEBUGMSGTL(("tlstmCertToTSNTable:cache:free", "done, %" NETSNMP_PRIz "d rows\n", CONTAINER_SIZE(table->container))); }
/************************************************************************** ... **************************************************************************/ void handle_city_info(struct packet_city_info *packet) { int i, x, y, city_is_new; struct city *pcity; pcity=city_list_find_id(&game.players[packet->owner].cities, packet->id); if(!pcity) { city_is_new=1; pcity=(struct city *)malloc(sizeof(struct city)); } else city_is_new=0; pcity->id=packet->id; pcity->owner=packet->owner; pcity->x=packet->x; pcity->y=packet->y; strcpy(pcity->name, packet->name); pcity->size=packet->size; pcity->ppl_happy[4]=packet->ppl_happy; pcity->ppl_content[4]=packet->ppl_content; pcity->ppl_unhappy[4]=packet->ppl_unhappy; pcity->ppl_elvis=packet->ppl_elvis; pcity->ppl_scientist=packet->ppl_scientist; pcity->ppl_taxman=packet->ppl_taxman; for (i=0;i<4;i++) pcity->trade[i]=packet->trade[i]; pcity->food_prod=packet->food_prod; pcity->food_surplus=packet->food_surplus; pcity->shield_prod=packet->shield_prod; pcity->shield_surplus=packet->shield_surplus; pcity->trade_prod=packet->trade_prod; pcity->corruption=packet->corruption; pcity->luxury_total=packet->luxury_total; pcity->tax_total=packet->tax_total; pcity->science_total=packet->science_total; pcity->food_stock=packet->food_stock; pcity->shield_stock=packet->shield_stock; pcity->polution=packet->polution; pcity->incite_revolt_cost=packet->incite_revolt_cost; pcity->is_building_unit=packet->is_building_unit; pcity->currently_building=packet->currently_building; pcity->did_buy=packet->did_buy; pcity->did_sell=packet->did_sell; i=0; for(y=0; y<CITY_MAP_SIZE; y++) for(x=0; x<CITY_MAP_SIZE; x++) pcity->city_map[x][y]=packet->city_map[i++]-'0'; for(i=0; i<B_LAST; i++) pcity->improvements[i]=(packet->improvements[i]=='1') ? 1 : 0; if(city_is_new) { unit_list_init(&pcity->units_supported); city_list_insert(&game.players[packet->owner].cities, pcity); map_set_city(pcity->x, pcity->y, pcity); if(pcity->owner==game.player_idx) city_report_dialog_update(); for(i=0; i<game.nplayers; i++) { struct genlist_iterator myiter; genlist_iterator_init(&myiter, &game.players[i].units.list, 0); for(;ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter)) { struct unit *punit=(struct unit *)ITERATOR_PTR(myiter); if(punit->homecity==pcity->id) unit_list_insert(&pcity->units_supported, punit); } } } refresh_tile_mapcanvas(pcity->x, pcity->y, 1); if(city_is_new && client_state==CLIENT_GAME_RUNNING_STATE && pcity->owner==game.player_idx) popup_city_dialog(pcity, 0); if(!city_is_new) refresh_city_dialog(pcity); }
static int _save_maps(int majorID, int minorID, void *serverarg, void *clientarg) { char sep[] = "\n##############################################################"; char buf[] = "#\n" "# certificate secName mapping persistent data\n" "#"; char *type = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE); netsnmp_container *maps = netsnmp_cert_map_container(); netsnmp_tdata_row *row; netsnmp_iterator *tbl_itr, *map_itr; netsnmp_cert_map *map; certToTSN_entry *entry; if ((NULL == maps) || ((CONTAINER_SIZE(maps) == 0) && (CONTAINER_SIZE(_table->container) == 0))) return SNMPERR_SUCCESS; read_config_store((char *) type, sep); read_config_store((char *) type, buf); /* * save active rows from maps */ if (NULL != maps) { map_itr = CONTAINER_ITERATOR(maps); if (NULL == map_itr) { DEBUGMSGTL(("tlstmCertToTSNTable:save", "cant get map iterator\n")); map = NULL; } else map = ITERATOR_FIRST(map_itr); for( ; map; map = ITERATOR_NEXT(map_itr)) { /** don't store config rows */ if (map->flags & NSCM_FROM_CONFIG) continue; _save_map(map, RS_ACTIVE, type); } } ITERATOR_RELEASE(map_itr); /* * save inactive rows from mib */ tbl_itr = CONTAINER_ITERATOR(_table->container); if (NULL == tbl_itr) DEBUGMSGTL(("tlstmCertToTSNTable:save", "cant get table iterator\n")); else { row = ITERATOR_FIRST(tbl_itr); for( ; row; row = ITERATOR_NEXT(tbl_itr)) { entry = row->data; /* * skip all active rows (should be in maps and thus saved * above) and volatile rows. */ if ((entry->rowStatus == RS_ACTIVE) || (entry->storageType != ST_NONVOLATILE)) continue; _save_entry(entry, type); } ITERATOR_RELEASE(tbl_itr); } read_config_store((char *) type, sep); read_config_store((char *) type, "\n"); /* * never fails */ return SNMPERR_SUCCESS; }
/* * check for ipv6 addresses */ void _arch_interface_has_ipv6(oid if_index, u_int *flags, netsnmp_container *addr_container) { #ifdef NETSNMP_ENABLE_IPV6 netsnmp_ipaddress_entry *addr_entry = NULL; netsnmp_iterator *addr_it = NULL; u_int addr_container_flags = 0; /* must init to 0 */ #endif if (NULL == flags) return; *flags &= ~NETSNMP_INTERFACE_FLAGS_HAS_IPV6; #ifdef NETSNMP_ENABLE_IPV6 /* * get ipv6 addresses */ if (NULL == addr_container) { /* * we only care about ipv6, if we need to allocate our own * temporary container. set the flags (which we also use later * to determine if we need to free the container). */ addr_container_flags = NETSNMP_ACCESS_IPADDRESS_LOAD_IPV6_ONLY; addr_container = netsnmp_access_ipaddress_container_load(NULL, addr_container_flags); if (NULL == addr_container) { DEBUGMSGTL(("access:ifcontainer", "couldn't get ip addresses container\n")); return; } } else { /* * addr_container flags must be 0, so we don't release the * user's container. */ netsnmp_assert(0 == addr_container_flags); } /* * get an ipaddress container iterator, and look for ipv6 addrs */ addr_it = CONTAINER_ITERATOR(addr_container); if (NULL == addr_it) { DEBUGMSGTL(("access:ifcontainer", "couldn't get ip addresses iterator\n")); if (0!=addr_container_flags) netsnmp_access_ipaddress_container_free(addr_container, 0); return; } addr_entry = ITERATOR_FIRST(addr_it); for( ; addr_entry ; addr_entry = ITERATOR_NEXT(addr_it) ) { /* * skip non matching indexes and ipv4 addresses */ if ((if_index != addr_entry->if_index) || (4 == addr_entry->ia_address_len)) continue; /* * found one! no need to keep looking, set the flag and bail */ *flags |= NETSNMP_INTERFACE_FLAGS_HAS_IPV6; break; } /* * make mama proud and clean up after ourselves */ ITERATOR_RELEASE(addr_it); if (0!=addr_container_flags) netsnmp_access_ipaddress_container_free(addr_container, 0); #endif }
/** * load initial data * * TODO:350:M: Implement ipAddressPrefixTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR : other error. * * This function is called to load the index(es) (and data, optionally) * for the every row in the data set. * * @remark * While loading the data, the only important thing is the indexes. * If access to your data is cheap/fast (e.g. you have a pointer to a * structure in memory), it would make sense to update the data here. * If, however, the accessing the data invovles more work (e.g. parsing * some other existing data, or peforming calculations to derive the data), * then you can limit yourself to setting the indexes and saving any * information you will need later. Then use the saved information in * ipAddressPrefixTable_row_prep() for populating data. * * @note * If you need consistency between rows (like you want statistics * for each row to be from the same time frame), you should set all * data here. * */ int ipAddressPrefixTable_container_load(netsnmp_container *container) { ipAddressPrefixTable_rowreq_ctx *rowreq_ctx = NULL, *tmp_rowreq_ctx; ipAddressTable_rowreq_ctx *addr_rowreq_ctx; netsnmp_container *addr_container; netsnmp_iterator *addr_it; size_t count = 0; u_char tmp_pfx[NETSNMP_ACCESS_IPADDRESS_BUF_SIZE]; DEBUGMSGTL(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_container_load", "called\n")); addr_container = ipAddressTable_container_get(); if (NULL == addr_container) { DEBUGMSGTL(("ipAddressPrefixTable:container_load", "couldn't get ipAddress container\n")); return MFD_RESOURCE_UNAVAILABLE; } addr_it = CONTAINER_ITERATOR(addr_container); if (NULL == addr_container) { DEBUGMSGTL(("ipAddressPrefixTable:container_load", "couldn't get ipAddress iterator\n")); return MFD_RESOURCE_UNAVAILABLE; } /* * TODO:351:M: |-> Load/update data in the ipAddressPrefixTable container. * loop over your ipAddressPrefixTable data, allocate a rowreq context, * set the index(es) [and data, optionally] and insert into * the container. */ for (addr_rowreq_ctx = ITERATOR_FIRST(addr_it); addr_rowreq_ctx; addr_rowreq_ctx = ITERATOR_NEXT(addr_it)) { /* * TODO:352:M: | |-> set indexes in new ipAddressPrefixTable rowreq context. * data context will be set from the param (unless NULL, * in which case a new data context will be allocated) */ if (NULL == rowreq_ctx) { rowreq_ctx = ipAddressPrefixTable_allocate_rowreq_ctx(NULL); if (NULL == rowreq_ctx) { snmp_log(LOG_ERR, "memory allocation failed\n"); return MFD_RESOURCE_UNAVAILABLE; } } netsnmp_ipaddress_prefix_copy(tmp_pfx, addr_rowreq_ctx->tbl_idx. ipAddressAddr, addr_rowreq_ctx->data-> ia_address_len, addr_rowreq_ctx->data-> ia_prefix_len); if (MFD_SUCCESS != ipAddressPrefixTable_indexes_set(rowreq_ctx, addr_rowreq_ctx->data-> if_index, addr_rowreq_ctx->tbl_idx. ipAddressAddrType, tmp_pfx, addr_rowreq_ctx->data-> ia_address_len, addr_rowreq_ctx->data-> ia_prefix_len)) { snmp_log(LOG_ERR, "error setting index while loading " "ipAddressPrefixTable data.\n"); ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx); continue; } /** do we already have this prefix? */ tmp_rowreq_ctx = CONTAINER_FIND(container, rowreq_ctx); if (NULL != tmp_rowreq_ctx) continue; /* * TODO:352:r: | |-> populate ipAddressPrefixTable data context. * Populate data context here. (optionally, delay until row prep) */ rowreq_ctx->data.ipAddressPrefixOrigin = addr_rowreq_ctx->data->ia_origin; /** defer the rest til row prep */ /* * insert into table container, clear ptr so we reallocate */ CONTAINER_INSERT(container, rowreq_ctx); rowreq_ctx = NULL; ++count; } DEBUGMSGT(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_container_load", "inserted %d records\n", count)); return MFD_SUCCESS; } /* ipAddressPrefixTable_container_load */
MOD_INIT_DECL( pip$_vendor$requests$status_codes ) { #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 static bool _init_done = false; // Modules might be imported repeatedly, which is to be ignored. if ( _init_done ) { return MOD_RETURN_VALUE( module_pip$_vendor$requests$status_codes ); } else { _init_done = true; } #endif #ifdef _NUITKA_MODULE // In case of a stand alone extension module, need to call initialization // the init here because that's the first and only time we are going to get // called here. // Initialize the constant values used. _initBuiltinModule(); createGlobalConstants(); // Initialize the compiled types of Nuitka. PyType_Ready( &Nuitka_Generator_Type ); PyType_Ready( &Nuitka_Function_Type ); PyType_Ready( &Nuitka_Method_Type ); PyType_Ready( &Nuitka_Frame_Type ); #if PYTHON_VERSION >= 350 PyType_Ready( &Nuitka_Coroutine_Type ); PyType_Ready( &Nuitka_CoroutineWrapper_Type ); #endif #if PYTHON_VERSION < 300 _initSlotCompare(); #endif #if PYTHON_VERSION >= 270 _initSlotIternext(); #endif patchBuiltinModule(); patchTypeComparison(); // Enable meta path based loader if not already done. setupMetaPathBasedLoader(); #if PYTHON_VERSION >= 300 patchInspectModule(); #endif #endif createModuleConstants(); createModuleCodeObjects(); // puts( "in initpip$_vendor$requests$status_codes" ); // Create the module object first. There are no methods initially, all are // added dynamically in actual code only. Also no "__doc__" is initially // set at this time, as it could not contain NUL characters this way, they // are instead set in early module code. No "self" for modules, we have no // use for it. #if PYTHON_VERSION < 300 module_pip$_vendor$requests$status_codes = Py_InitModule4( "pip._vendor.requests.status_codes", // Module Name NULL, // No methods initially, all are added // dynamically in actual module code only. NULL, // No __doc__ is initially set, as it could // not contain NUL this way, added early in // actual code. NULL, // No self for modules, we don't use it. PYTHON_API_VERSION ); #else module_pip$_vendor$requests$status_codes = PyModule_Create( &mdef_pip$_vendor$requests$status_codes ); #endif moduledict_pip$_vendor$requests$status_codes = (PyDictObject *)((PyModuleObject *)module_pip$_vendor$requests$status_codes)->md_dict; CHECK_OBJECT( module_pip$_vendor$requests$status_codes ); // Seems to work for Python2.7 out of the box, but for Python3, the module // doesn't automatically enter "sys.modules", so do it manually. #if PYTHON_VERSION >= 300 { int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_7407a472cb7f92da9dfbd02c8e685bfe, module_pip$_vendor$requests$status_codes ); assert( r != -1 ); } #endif // For deep importing of a module we need to have "__builtins__", so we set // it ourselves in the same way than CPython does. Note: This must be done // before the frame object is allocated, or else it may fail. PyObject *module_dict = PyModule_GetDict( module_pip$_vendor$requests$status_codes ); if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL ) { PyObject *value = (PyObject *)builtin_module; // Check if main module, not a dict then. #if !defined(_NUITKA_EXE) || !0 value = PyModule_GetDict( value ); #endif #ifndef __NUITKA_NO_ASSERT__ int res = #endif PyDict_SetItem( module_dict, const_str_plain___builtins__, value ); assert( res == 0 ); } #if PYTHON_VERSION >= 330 PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader ); #endif // Temp variables if any PyObject *tmp_for_loop_1__for_iterator = NULL; PyObject *tmp_for_loop_1__iter_value = NULL; PyObject *tmp_tuple_unpack_1__source_iter = NULL; PyObject *tmp_tuple_unpack_1__element_1 = NULL; PyObject *tmp_tuple_unpack_1__element_2 = NULL; PyObject *tmp_for_loop_2__for_iterator = NULL; PyObject *tmp_for_loop_2__iter_value = NULL; PyObject *exception_type = NULL, *exception_value = NULL; PyTracebackObject *exception_tb = NULL; NUITKA_MAY_BE_UNUSED int exception_lineno = -1; PyObject *exception_keeper_type_1; PyObject *exception_keeper_value_1; PyTracebackObject *exception_keeper_tb_1; NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; PyObject *exception_keeper_type_2; PyObject *exception_keeper_value_2; PyTracebackObject *exception_keeper_tb_2; NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; PyObject *exception_keeper_type_3; PyObject *exception_keeper_value_3; PyTracebackObject *exception_keeper_tb_3; NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; PyObject *tmp_assign_source_1; PyObject *tmp_assign_source_2; PyObject *tmp_assign_source_3; PyObject *tmp_assign_source_4; PyObject *tmp_assign_source_5; PyObject *tmp_assign_source_6; PyObject *tmp_assign_source_7; PyObject *tmp_assign_source_8; PyObject *tmp_assign_source_9; PyObject *tmp_assign_source_10; PyObject *tmp_assign_source_11; PyObject *tmp_assign_source_12; PyObject *tmp_assign_source_13; PyObject *tmp_assign_source_14; PyObject *tmp_assign_source_15; PyObject *tmp_assign_source_16; PyObject *tmp_assign_source_17; PyObject *tmp_called_name_1; PyObject *tmp_called_name_2; PyObject *tmp_called_name_3; PyObject *tmp_called_name_4; int tmp_cond_truth_1; PyObject *tmp_cond_value_1; PyObject *tmp_import_globals_1; PyObject *tmp_import_name_from_1; PyObject *tmp_iter_arg_1; PyObject *tmp_iter_arg_2; PyObject *tmp_iter_arg_3; PyObject *tmp_iterator_attempt; PyObject *tmp_iterator_name_1; PyObject *tmp_kw_name_1; PyObject *tmp_next_source_1; PyObject *tmp_next_source_2; PyObject *tmp_setattr_attr_1; PyObject *tmp_setattr_attr_2; PyObject *tmp_setattr_target_1; PyObject *tmp_setattr_target_2; PyObject *tmp_setattr_value_1; PyObject *tmp_setattr_value_2; PyObject *tmp_source_name_1; PyObject *tmp_source_name_2; PyObject *tmp_source_name_3; PyObject *tmp_unpack_1; PyObject *tmp_unpack_2; NUITKA_MAY_BE_UNUSED PyObject *tmp_unused; PyFrameObject *frame_module; // Module code. tmp_assign_source_1 = Py_None; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); tmp_assign_source_2 = const_str_digest_edc503ce8640402b515eac9b4be2e49c; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); tmp_assign_source_3 = Py_None; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); tmp_assign_source_4 = const_str_digest_92068ee7fa29014ac06ffc664a1b4b4e; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_4 ); // Frame without reuse. frame_module = MAKE_MODULE_FRAME( codeobj_fc398c3ce42402f17822919035abca66, module_pip$_vendor$requests$status_codes ); // Push the new frame as the currently active one, and we should be exclusively // owning it. pushFrameStack( frame_module ); assert( Py_REFCNT( frame_module ) == 1 ); #if PYTHON_VERSION >= 340 frame_module->f_executing += 1; #endif // Framed code: tmp_import_globals_1 = ((PyModuleObject *)module_pip$_vendor$requests$status_codes)->md_dict; frame_module->f_lineno = 3; tmp_import_name_from_1 = IMPORT_MODULE( const_str_plain_structures, tmp_import_globals_1, tmp_import_globals_1, const_tuple_str_plain_LookupDict_tuple, const_int_pos_1 ); if ( tmp_import_name_from_1 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 3; goto frame_exception_exit_1; } tmp_assign_source_5 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_LookupDict ); Py_DECREF( tmp_import_name_from_1 ); if ( tmp_assign_source_5 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 3; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_LookupDict, tmp_assign_source_5 ); tmp_assign_source_6 = PyDict_Copy( const_dict_19730b058f28080932defca1165e072e ); UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain__codes, tmp_assign_source_6 ); tmp_called_name_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_LookupDict ); if (unlikely( tmp_called_name_1 == NULL )) { tmp_called_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_LookupDict ); } if ( tmp_called_name_1 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "LookupDict" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 84; goto frame_exception_exit_1; } tmp_kw_name_1 = PyDict_Copy( const_dict_38252060f20256dc080a28c7e1fb8512 ); frame_module->f_lineno = 84; tmp_assign_source_7 = CALL_FUNCTION_WITH_KEYARGS( tmp_called_name_1, tmp_kw_name_1 ); Py_DECREF( tmp_kw_name_1 ); if ( tmp_assign_source_7 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 84; goto frame_exception_exit_1; } UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes, tmp_assign_source_7 ); tmp_source_name_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain__codes ); if (unlikely( tmp_source_name_1 == NULL )) { tmp_source_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__codes ); } if ( tmp_source_name_1 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_codes" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 86; goto frame_exception_exit_1; } tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_items ); if ( tmp_called_name_2 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 86; goto frame_exception_exit_1; } frame_module->f_lineno = 86; tmp_iter_arg_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_2 ); Py_DECREF( tmp_called_name_2 ); if ( tmp_iter_arg_1 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 86; goto frame_exception_exit_1; } tmp_assign_source_8 = MAKE_ITERATOR( tmp_iter_arg_1 ); Py_DECREF( tmp_iter_arg_1 ); if ( tmp_assign_source_8 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 86; goto frame_exception_exit_1; } assert( tmp_for_loop_1__for_iterator == NULL ); tmp_for_loop_1__for_iterator = tmp_assign_source_8; // Tried code: loop_start_1:; tmp_next_source_1 = tmp_for_loop_1__for_iterator; tmp_assign_source_9 = ITERATOR_NEXT( tmp_next_source_1 ); if ( tmp_assign_source_9 == NULL ) { if ( CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED() ) { goto loop_end_1; } else { FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); frame_module->f_lineno = 86; goto try_except_handler_1; } } { PyObject *old = tmp_for_loop_1__iter_value; tmp_for_loop_1__iter_value = tmp_assign_source_9; Py_XDECREF( old ); } // Tried code: tmp_iter_arg_2 = tmp_for_loop_1__iter_value; tmp_assign_source_10 = MAKE_ITERATOR( tmp_iter_arg_2 ); if ( tmp_assign_source_10 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 86; goto try_except_handler_2; } { PyObject *old = tmp_tuple_unpack_1__source_iter; tmp_tuple_unpack_1__source_iter = tmp_assign_source_10; Py_XDECREF( old ); } tmp_unpack_1 = tmp_tuple_unpack_1__source_iter; tmp_assign_source_11 = UNPACK_NEXT( tmp_unpack_1, 0, 2 ); if ( tmp_assign_source_11 == NULL ) { if ( !ERROR_OCCURRED() ) { exception_type = PyExc_StopIteration; Py_INCREF( exception_type ); exception_value = NULL; exception_tb = NULL; } else { FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); } exception_lineno = 86; goto try_except_handler_2; } { PyObject *old = tmp_tuple_unpack_1__element_1; tmp_tuple_unpack_1__element_1 = tmp_assign_source_11; Py_XDECREF( old ); } tmp_unpack_2 = tmp_tuple_unpack_1__source_iter; tmp_assign_source_12 = UNPACK_NEXT( tmp_unpack_2, 1, 2 ); if ( tmp_assign_source_12 == NULL ) { if ( !ERROR_OCCURRED() ) { exception_type = PyExc_StopIteration; Py_INCREF( exception_type ); exception_value = NULL; exception_tb = NULL; } else { FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); } exception_lineno = 86; goto try_except_handler_2; } { PyObject *old = tmp_tuple_unpack_1__element_2; tmp_tuple_unpack_1__element_2 = tmp_assign_source_12; Py_XDECREF( old ); } tmp_iterator_name_1 = tmp_tuple_unpack_1__source_iter; // Check if iterator has left-over elements. CHECK_OBJECT( tmp_iterator_name_1 ); assert( HAS_ITERNEXT( tmp_iterator_name_1 ) ); tmp_iterator_attempt = (*Py_TYPE( tmp_iterator_name_1 )->tp_iternext)( tmp_iterator_name_1 ); if (likely( tmp_iterator_attempt == NULL )) { PyObject *error = GET_ERROR_OCCURRED(); if ( error != NULL ) { if ( EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_StopIteration )) { CLEAR_ERROR_OCCURRED(); } else { FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); goto try_except_handler_2; } } } else { Py_DECREF( tmp_iterator_attempt ); // TODO: Could avoid PyErr_Format. #if PYTHON_VERSION < 300 PyErr_Format( PyExc_ValueError, "too many values to unpack" ); #else PyErr_Format( PyExc_ValueError, "too many values to unpack (expected 2)" ); #endif FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); goto try_except_handler_2; } goto try_end_1; // Exception handler code: try_except_handler_2:; exception_keeper_type_1 = exception_type; exception_keeper_value_1 = exception_value; exception_keeper_tb_1 = exception_tb; exception_keeper_lineno_1 = exception_lineno; exception_type = NULL; exception_value = NULL; exception_tb = NULL; exception_lineno = -1; Py_XDECREF( tmp_tuple_unpack_1__source_iter ); tmp_tuple_unpack_1__source_iter = NULL; Py_XDECREF( tmp_tuple_unpack_1__element_1 ); tmp_tuple_unpack_1__element_1 = NULL; Py_XDECREF( tmp_tuple_unpack_1__element_2 ); tmp_tuple_unpack_1__element_2 = NULL; // Re-raise. exception_type = exception_keeper_type_1; exception_value = exception_keeper_value_1; exception_tb = exception_keeper_tb_1; exception_lineno = exception_keeper_lineno_1; goto try_except_handler_1; // End of try: try_end_1:; tmp_assign_source_13 = tmp_tuple_unpack_1__element_1; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code, tmp_assign_source_13 ); tmp_assign_source_14 = tmp_tuple_unpack_1__element_2; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_titles, tmp_assign_source_14 ); CHECK_OBJECT( (PyObject *)tmp_tuple_unpack_1__source_iter ); Py_DECREF( tmp_tuple_unpack_1__source_iter ); tmp_tuple_unpack_1__source_iter = NULL; Py_XDECREF( tmp_tuple_unpack_1__element_1 ); tmp_tuple_unpack_1__element_1 = NULL; Py_XDECREF( tmp_tuple_unpack_1__element_2 ); tmp_tuple_unpack_1__element_2 = NULL; tmp_iter_arg_3 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_titles ); if (unlikely( tmp_iter_arg_3 == NULL )) { tmp_iter_arg_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_titles ); } if ( tmp_iter_arg_3 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "titles" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 87; goto try_except_handler_1; } tmp_assign_source_15 = MAKE_ITERATOR( tmp_iter_arg_3 ); if ( tmp_assign_source_15 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 87; goto try_except_handler_1; } { PyObject *old = tmp_for_loop_2__for_iterator; tmp_for_loop_2__for_iterator = tmp_assign_source_15; Py_XDECREF( old ); } // Tried code: loop_start_2:; tmp_next_source_2 = tmp_for_loop_2__for_iterator; tmp_assign_source_16 = ITERATOR_NEXT( tmp_next_source_2 ); if ( tmp_assign_source_16 == NULL ) { if ( CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED() ) { goto loop_end_2; } else { FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); frame_module->f_lineno = 87; goto try_except_handler_3; } } { PyObject *old = tmp_for_loop_2__iter_value; tmp_for_loop_2__iter_value = tmp_assign_source_16; Py_XDECREF( old ); } tmp_assign_source_17 = tmp_for_loop_2__iter_value; UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title, tmp_assign_source_17 ); tmp_setattr_target_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes ); if (unlikely( tmp_setattr_target_1 == NULL )) { tmp_setattr_target_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_codes ); } if ( tmp_setattr_target_1 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "codes" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 88; goto try_except_handler_3; } tmp_setattr_attr_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title ); if (unlikely( tmp_setattr_attr_1 == NULL )) { tmp_setattr_attr_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title ); } if ( tmp_setattr_attr_1 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 88; goto try_except_handler_3; } tmp_setattr_value_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code ); if (unlikely( tmp_setattr_value_1 == NULL )) { tmp_setattr_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_code ); } if ( tmp_setattr_value_1 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "code" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 88; goto try_except_handler_3; } tmp_unused = BUILTIN_SETATTR( tmp_setattr_target_1, tmp_setattr_attr_1, tmp_setattr_value_1 ); if ( tmp_unused == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 88; goto try_except_handler_3; } tmp_source_name_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title ); if (unlikely( tmp_source_name_2 == NULL )) { tmp_source_name_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title ); } if ( tmp_source_name_2 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 89; goto try_except_handler_3; } tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_startswith ); if ( tmp_called_name_3 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 89; goto try_except_handler_3; } frame_module->f_lineno = 89; tmp_cond_value_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_3, &PyTuple_GET_ITEM( const_tuple_str_chr_92_tuple, 0 ) ); Py_DECREF( tmp_called_name_3 ); if ( tmp_cond_value_1 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 89; goto try_except_handler_3; } tmp_cond_truth_1 = CHECK_IF_TRUE( tmp_cond_value_1 ); if ( tmp_cond_truth_1 == -1 ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); Py_DECREF( tmp_cond_value_1 ); exception_lineno = 89; goto try_except_handler_3; } Py_DECREF( tmp_cond_value_1 ); if ( tmp_cond_truth_1 == 1 ) { goto branch_no_1; } else { goto branch_yes_1; } branch_yes_1:; tmp_setattr_target_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes ); if (unlikely( tmp_setattr_target_2 == NULL )) { tmp_setattr_target_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_codes ); } if ( tmp_setattr_target_2 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "codes" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 90; goto try_except_handler_3; } tmp_source_name_3 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title ); if (unlikely( tmp_source_name_3 == NULL )) { tmp_source_name_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title ); } if ( tmp_source_name_3 == NULL ) { exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 90; goto try_except_handler_3; } tmp_called_name_4 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_upper ); if ( tmp_called_name_4 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 90; goto try_except_handler_3; } frame_module->f_lineno = 90; tmp_setattr_attr_2 = CALL_FUNCTION_NO_ARGS( tmp_called_name_4 ); Py_DECREF( tmp_called_name_4 ); if ( tmp_setattr_attr_2 == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 90; goto try_except_handler_3; } tmp_setattr_value_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code ); if (unlikely( tmp_setattr_value_2 == NULL )) { tmp_setattr_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_code ); } if ( tmp_setattr_value_2 == NULL ) { Py_DECREF( tmp_setattr_attr_2 ); exception_type = PyExc_NameError; Py_INCREF( exception_type ); exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "code" ); exception_tb = NULL; NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); CHAIN_EXCEPTION( exception_value ); exception_lineno = 90; goto try_except_handler_3; } tmp_unused = BUILTIN_SETATTR( tmp_setattr_target_2, tmp_setattr_attr_2, tmp_setattr_value_2 ); Py_DECREF( tmp_setattr_attr_2 ); if ( tmp_unused == NULL ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 90; goto try_except_handler_3; } branch_no_1:; if ( CONSIDER_THREADING() == false ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 87; goto try_except_handler_3; } goto loop_start_2; loop_end_2:; goto try_end_2; // Exception handler code: try_except_handler_3:; exception_keeper_type_2 = exception_type; exception_keeper_value_2 = exception_value; exception_keeper_tb_2 = exception_tb; exception_keeper_lineno_2 = exception_lineno; exception_type = NULL; exception_value = NULL; exception_tb = NULL; exception_lineno = -1; Py_XDECREF( tmp_for_loop_2__iter_value ); tmp_for_loop_2__iter_value = NULL; Py_XDECREF( tmp_for_loop_2__for_iterator ); tmp_for_loop_2__for_iterator = NULL; // Re-raise. exception_type = exception_keeper_type_2; exception_value = exception_keeper_value_2; exception_tb = exception_keeper_tb_2; exception_lineno = exception_keeper_lineno_2; goto try_except_handler_1; // End of try: try_end_2:; Py_XDECREF( tmp_for_loop_2__iter_value ); tmp_for_loop_2__iter_value = NULL; Py_XDECREF( tmp_for_loop_2__for_iterator ); tmp_for_loop_2__for_iterator = NULL; if ( CONSIDER_THREADING() == false ) { assert( ERROR_OCCURRED() ); FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); exception_lineno = 86; goto try_except_handler_1; } goto loop_start_1; loop_end_1:; goto try_end_3; // Exception handler code: try_except_handler_1:; exception_keeper_type_3 = exception_type; exception_keeper_value_3 = exception_value; exception_keeper_tb_3 = exception_tb; exception_keeper_lineno_3 = exception_lineno; exception_type = NULL; exception_value = NULL; exception_tb = NULL; exception_lineno = -1; Py_XDECREF( tmp_for_loop_1__iter_value ); tmp_for_loop_1__iter_value = NULL; Py_XDECREF( tmp_for_loop_1__for_iterator ); tmp_for_loop_1__for_iterator = NULL; // Re-raise. exception_type = exception_keeper_type_3; exception_value = exception_keeper_value_3; exception_tb = exception_keeper_tb_3; exception_lineno = exception_keeper_lineno_3; goto frame_exception_exit_1; // End of try: try_end_3:; // Restore frame exception if necessary. #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif popFrameStack(); assertFrameObject( frame_module ); Py_DECREF( frame_module ); goto frame_no_exception_1; frame_exception_exit_1:; #if 0 RESTORE_FRAME_EXCEPTION( frame_module ); #endif if ( exception_tb == NULL ) { exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno ); } else if ( exception_tb->tb_frame != frame_module ) { PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno ); traceback_new->tb_next = exception_tb; exception_tb = traceback_new; } // Put the previous frame back on top. popFrameStack(); #if PYTHON_VERSION >= 340 frame_module->f_executing -= 1; #endif Py_DECREF( frame_module ); // Return the error. goto module_exception_exit; frame_no_exception_1:; Py_XDECREF( tmp_for_loop_1__iter_value ); tmp_for_loop_1__iter_value = NULL; Py_XDECREF( tmp_for_loop_1__for_iterator ); tmp_for_loop_1__for_iterator = NULL; return MOD_RETURN_VALUE( module_pip$_vendor$requests$status_codes ); module_exception_exit: RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); return MOD_RETURN_VALUE( NULL ); }
int getPackage() { int timelen; netsnmp_container *pkg_container = NULL; netsnmp_cache *pkg_cache = NULL; netsnmp_iterator *it; cpqHoSwVerTable_entry *entry; int i; int pkgcount = 0; pkg_cache = netsnmp_cache_find_by_oid(cpqHoSwVerTable_oid, cpqHoSwVerTable_oid_len); if (pkg_cache == NULL) return 0; pkg_container = pkg_cache->magic; if (pkg_container == NULL) return 0; pkgcount = (oid)CONTAINER_SIZE(pkg_container); if ((packages = (pkg_entry**)malloc(pkgcount * sizeof(pkg_entry *))) == NULL) { return 0; } it = CONTAINER_ITERATOR( pkg_container ); entry = ITERATOR_FIRST( it ); i = 0; while (entry != NULL) { if ((packages[i] = (pkg_entry*)malloc(sizeof(pkg_entry))) == NULL) { continue; } memset(packages[i], 0, sizeof(pkg_entry)); if (entry->cpqHoSwVerName_len != 0 ) { packages[i]->sname = malloc(entry->cpqHoSwVerName_len + 1); memset(packages[i]->sname, 0, entry->cpqHoSwVerName_len + 1); strcpy(packages[i]->sname, entry->cpqHoSwVerName); packages[i]->name = malloc(entry->cpqHoSwVerName_len + 1); memset(packages[i]->name, 0, entry->cpqHoSwVerName_len + 1); strcpy(packages[i]->name, entry->cpqHoSwVerName); } else { packages[i]->sname = NULL; packages[i]->name = NULL; } if (entry->cpqHoSwVerVersion_len != 0 ) { packages[i]->version = malloc(entry->cpqHoSwVerVersion_len + 1); memset(packages[i]->version, 0, entry->cpqHoSwVerVersion_len + 1); strcpy(packages[i]->version, entry->cpqHoSwVerVersion); } else packages[i]->version = NULL; if (entry->vendor_len != 0 ) { packages[i]->vendor = malloc(entry->vendor_len + 1); memset(packages[i]->vendor, 0, entry->vendor_len + 1); strcpy(packages[i]->vendor, entry->vendor); } else packages[i]->vendor = NULL; if (entry->timestamp != 0) { packages[i]->timestamp = malloc(80); memset(packages[i]->timestamp, 0, 80); timelen = strftime(packages[i]->timestamp, 80, "%Y-%m-%d %H:%M:%S %z", gmtime(&entry->timestamp)); } else packages[i]->timestamp = NULL; i++; entry = ITERATOR_NEXT( it ); } ITERATOR_RELEASE( it ); return pkgcount; }
int udpEndpointTable_container_load(netsnmp_container *container) { udpEndpointTable_rowreq_ctx *rowreq_ctx; netsnmp_container *ep_c; netsnmp_iterator *ep_it; netsnmp_udp_endpoint_entry *ep; /* * temporary storage for index values */ u_long udpEndpointLocalAddressType; u_long udpEndpointRemoteAddressType; DEBUGMSGTL(("verbose:udpEndpointTable:udpEndpointTable_container_load", "called\n")); /* * TODO:351:M: |-> Load/update data in the udpEndpointTable container. * loop over your udpEndpointTable data, allocate a rowreq context, * set the index(es) [and data, optionally] and insert into * the container. */ ep_c = netsnmp_access_udp_endpoint_container_load(NULL, 0); if (NULL == ep_c) return MFD_RESOURCE_UNAVAILABLE; ep_it = CONTAINER_ITERATOR(ep_c); if (NULL == ep_c) { netsnmp_access_udp_endpoint_container_free(ep_c, 0); return MFD_RESOURCE_UNAVAILABLE; } for (ep = (netsnmp_udp_endpoint_entry*)ITERATOR_FIRST(ep_it); ep; ep = (netsnmp_udp_endpoint_entry*)ITERATOR_NEXT (ep_it)) { /* * TODO:352:M: | |-> set indexes in new udpEndpointTable rowreq context. */ rowreq_ctx = udpEndpointTable_allocate_rowreq_ctx(); if (NULL == rowreq_ctx) { snmp_log(LOG_ERR, "memory allocation failed\n"); return MFD_RESOURCE_UNAVAILABLE; } udpEndpointLocalAddressType = _address_type_from_len(ep->loc_addr_len); udpEndpointRemoteAddressType = _address_type_from_len(ep->rmt_addr_len); if (MFD_SUCCESS != udpEndpointTable_indexes_set(rowreq_ctx, udpEndpointLocalAddressType, (char *) ep->loc_addr, ep->loc_addr_len, ep->loc_port, udpEndpointRemoteAddressType, (char *) ep->rmt_addr, ep->rmt_addr_len, ep->rmt_port, ep->instance, ep->pid)) { snmp_log(LOG_ERR, "error setting index while loading " "udpEndpointTable data.\n"); udpEndpointTable_release_rowreq_ctx(rowreq_ctx); continue; } /* * TODO:352:r: | |-> populate udpEndpointTable data context. * Populate data context here. (optionally, delay until row prep) */ /* * non-TRANSIENT data: no need to copy. set pointer to data */ /* * insert into table container */ CONTAINER_INSERT(container, rowreq_ctx); } ITERATOR_RELEASE(ep_it); netsnmp_access_udp_endpoint_container_free(ep_c, 0); DEBUGMSGT(("verbose:udpEndpointTable:udpEndpointTable_container_load", "inserted %d records\n", (int)CONTAINER_SIZE(container))); return MFD_SUCCESS; } /* udpEndpointTable_container_load */
/* * save a buffered trap to sql database */ static void _sql_save(sql_buf *sqlb, void *dontcare) { netsnmp_iterator *it; sql_vb_buf *sqlvb; u_long trap_id; /* * don't even try if we don't have a database connection */ if (0 == _sql.connected) { _sql_log(sqlb, NULL); return; } /* * the prepared statements are bound to the static buffer objects, * so copy the queued data to the static version. */ _tbind[TBIND_HOST].buffer = sqlb->host; _tbind[TBIND_HOST].buffer_length = sqlb->host_len; _tbind[TBIND_OID].buffer = sqlb->oid; _tbind[TBIND_OID].buffer_length = sqlb->oid_len; _tbind[TBIND_REQID].buffer = (void *)&sqlb->reqid; _tbind[TBIND_VER].buffer = (void *)&sqlb->version; _tbind[TBIND_TYPE].buffer = (void *)&sqlb->type; _tbind[TBIND_SECURITY_MODEL].buffer = (void *)&sqlb->security_model; _tbind[TBIND_DATE].buffer = (void *)&sqlb->time; _tbind[TBIND_USER].buffer = sqlb->user; _tbind[TBIND_USER].buffer_length = sqlb->user_len; _tbind[TBIND_TRANSPORT].buffer = sqlb->transport; if (sqlb->transport) _tbind[TBIND_TRANSPORT].buffer_length = strlen(sqlb->transport); else _tbind[TBIND_TRANSPORT].buffer_length = 0; if ((SNMP_MP_MODEL_SNMPv3+1) == sqlb->version) { _no_v3 = 0; _tbind[TBIND_v3_MSGID].buffer = &sqlb->msgid; _tbind[TBIND_v3_SECURITY_LEVEL].buffer = &sqlb->security_level; _tbind[TBIND_v3_CONTEXT_NAME].buffer = sqlb->context; _tbind[TBIND_v3_CONTEXT_NAME].buffer_length = sqlb->context_len; _tbind[TBIND_v3_CONTEXT_ENGINE].buffer = sqlb->context_engine; _tbind[TBIND_v3_CONTEXT_ENGINE].buffer_length = sqlb->context_engine_len; _tbind[TBIND_v3_SECURITY_NAME].buffer = sqlb->security_name; _tbind[TBIND_v3_SECURITY_NAME].buffer_length = sqlb->security_name_len; _tbind[TBIND_v3_SECURITY_ENGINE].buffer = sqlb->security_engine; _tbind[TBIND_v3_SECURITY_ENGINE].buffer_length = sqlb->security_engine_len; } else { _no_v3 = 1; } if (mysql_stmt_bind_param(_sql.trap_stmt, _tbind) != 0) { netsnmp_sql_stmt_error(_sql.trap_stmt, "Could not bind parameters for INSERT"); _sql_log(sqlb, NULL); return; } /** execute the prepared statement */ if (mysql_stmt_execute(_sql.trap_stmt) != 0) { netsnmp_sql_stmt_error(_sql.trap_stmt, "Could not execute insert statement for trap"); _sql_log(sqlb, NULL); return; } trap_id = mysql_insert_id(_sql.conn); /* * iterate over the varbinds, copy data and insert */ it = CONTAINER_ITERATOR(sqlb->varbinds); if (NULL == it) { snmp_log(LOG_ERR,"Could not allocate iterator\n"); _sql_log(sqlb, NULL); return; } for( sqlvb = ITERATOR_FIRST(it); sqlvb; sqlvb = ITERATOR_NEXT(it)) { _vbind[VBIND_ID].buffer = (void *)&trap_id; _vbind[VBIND_TYPE].buffer = (void *)&sqlvb->type; _vbind[VBIND_OID].buffer = sqlvb->oid; _vbind[VBIND_OID].buffer_length = sqlvb->oid_len; _vbind[VBIND_VAL].buffer = sqlvb->val; _vbind[VBIND_VAL].buffer_length = sqlvb->val_len; if (mysql_stmt_bind_param(_sql.vb_stmt, _vbind) != 0) { netsnmp_sql_stmt_error(_sql.vb_stmt, "Could not bind parameters for INSERT"); _sql_log(sqlb, NULL); break; } if (mysql_stmt_execute(_sql.vb_stmt) != 0) { netsnmp_sql_stmt_error(_sql.vb_stmt, "Could not execute insert statement for varbind"); _sql_log(sqlb, NULL); break; } } ITERATOR_RELEASE(it); }