/****************************************************************
...
*****************************************************************/
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);
}
