[insert project logo here (125x200px max)] Navigator Home Downloads Documentation Research News Forums Project Summary CVS repository Mailinglists Help Announcement Developer Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums. Copyright and Licensing Information Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL). All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License. All sourcecode is made publicly available. Acknowledgement Splash and the Splash website are hosted by SourceForge.net

Splash - Documentation SNMP Plus a Lightweight API for SNAP Handling             snap_svc/snap_svc_snmp.c Go to the documentation of this file. /* snap service library */ /* (c) Willem de Bruijn, 2002, 2003 */ /* Licensed under the BSD License */ /* snap_svc_snmp library sourcefile */ #include <stdio.h> #include <string.h> #include <net-snmp/net-snmp-config.h> #include <net-snmp/net-snmp-includes.h> #include <net-snmp/definitions.h> #include <net-snmp/pdu_api.h> #include <net-snmp/agent/snmp_agent.h> #include "snap_svc.h" #include "snap_svc_snmp.h" #include "d_printf.h" /* referenced external variables */ extern int callback_master_num; /* some variable to reference the master */ /* global variables*/ unsigned short svc_snmp_active = 0; unsigned short svc_snmp_pdu_load = 0; /* how many variables are we referencing? */ netsnmp_pdu* svc_snmp_pdu = NULL; /* the pdu (really ;-) )*/ netsnmp_session* svc_snmp_session = NULL; /* the connection */ int svc_snmp_pdu_waiting = 0; /* library handling functions */ void snap_external_svclib_init(){ if (snap_external_svclib_snmp_init(NULL)) d_printf(50,"snap_svc_snmp : initialized\n"); } void snap_external_svclib_done(){ /* snmp lib specific */ if (svc_snmp_pdu){ snmp_free_pdu(svc_snmp_pdu); svc_snmp_pdu = NULL; } if (svc_snmp_session || svc_snmp_active) snap_external_svclib_snmp_close(NULL); svc_snmp_pdu_load = 0; svc_snmp_session = NULL; svc_snmp_pdu_waiting = 0; d_printf(50,"snap_svc_snmp : closed\n"); } /* there is where functions inside the library should be listed for registration */ void snap_external_svclib_getnextfunc(char** snapsvc_name, snapsvc_func_proto* snapsvc_func, int* snapsvc_args, int* snapsvc_rets){ switch (svc_fun_counter){ case 0 : (*snapsvc_name) = strdup ("snmp_init"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_init; (*snapsvc_args) = 0; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 1 : (*snapsvc_name) = strdup ("snmp_init_ip"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_init_ip; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 2 : (*snapsvc_name) = strdup ("snmp_pdu_init"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_initpdu; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 3 : (*snapsvc_name) = strdup ("snmp_pdu_addvar_null"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_addvar_null; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 4 : (*snapsvc_name) = strdup ("snmp_pdu_addvar_withvalue"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_addvar_withvalue; (*snapsvc_args) = 4; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 5 : (*snapsvc_name) = strdup ("snmp_pdu_send"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_execpdu; (*snapsvc_args) = 0; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 6 : (*snapsvc_name) = strdup ("snmp_close"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_close; (*snapsvc_args) = 0; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 7 : (*snapsvc_name) = strdup ("snmp_getsingle"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_getsingle; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 8 : (*snapsvc_name) = strdup ("snmp_setsingle"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_setsingle; (*snapsvc_args) = 4; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 9 : (*snapsvc_name) = strdup ("snmp_getnexthop"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_getnexthopfromip; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; case 10 : (*snapsvc_name) = strdup ("snmp_getneighbours"); (*snapsvc_func) = (snapsvc_func_proto) &snap_external_svclib_snmp_getallotherneighboursfromip; (*snapsvc_args) = 1; (*snapsvc_rets) = SVC_SNMP_TYPE_NULL; break; /* unknown handler -> return NULL as end-of-list symbol */ default : (*snapsvc_name) = NULL; (*snapsvc_func) = NULL; (*snapsvc_args) = 0; (*snapsvc_rets) = 0; } svc_fun_counter ++; } /* snmp callback handler*/ int snap_external_svclib_snmp_INTERNAL_execpdu_handler(int op, netsnmp_session * session, int reqid, netsnmp_pdu *pdu, void *useless){ netsnmp_variable_list* curlist; int count = 0; if (op == NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE ){ /* create a structure to hold the results */ curlist = pdu->variables; while (curlist){ count++; curlist = curlist->next_variable; } snap_external_svclib_free_local_returnstruct(); svc_return = (struct svc_returnstruct*) calloc (1,sizeof(struct svc_returnstruct)); svc_return->length = count; svc_return->list = (struct svc_returnitem*) calloc (count,sizeof(struct svc_returnitem)); /* write data to SNAP stack */ curlist = pdu->variables; count = 0; while(curlist){ /* simply walk the available options and select the necessary one */ /* NB: net-snmp uses a #ifdef OPAQUE_SPECIAL_TYPES top add the float and double type. We will adhere to the failsafe case == undefined */ /* copy the OID */ svc_return->list[count].oid_length = curlist->name_length; svc_return->list[count].oid = calloc (curlist->name_length, sizeof(unsigned long)); memmove(svc_return->list[count].oid, curlist->name, curlist->name_length * sizeof(unsigned long)); /* copy the value length */ svc_return->list[count].length = curlist->val_len; /* copy the value */ switch(curlist->type){ case ASN_BIT_STR : case ASN_OCTET_STR : svc_return->list[count].type = SVC_SNMP_TYPE_STRING; svc_return->list[count].data = calloc (curlist->val_len, sizeof(u_char)); memmove(svc_return->list[count].data,curlist->val.string,curlist->val_len); break; case ASN_IPADDRESS : svc_return->list[count].type = SVC_SNMP_TYPE_ADDR; svc_return->list[count].data = calloc (curlist->val_len, sizeof(uint32_t)); memmove(svc_return->list[count].data,curlist->val.integer,sizeof(uint32_t)); break; case ASN_BOOLEAN : case ASN_INTEGER : case ASN_TIMETICKS : case ASN_COUNTER : case ASN_GAUGE : /* case ASN_UNSIGNED : is the same as ASN_GAUGE */ svc_return->list[count].type = SVC_SNMP_TYPE_INT; svc_return->list[count].data = calloc (curlist->val_len, sizeof(int)); memmove(svc_return->list[count].data,curlist->val.integer,curlist->val_len); break; case ASN_OBJECT_ID : svc_return->list[count].type = SVC_SNMP_TYPE_LONG; svc_return->list[count].data = calloc (curlist->val_len, sizeof(unsigned long)); memmove(svc_return->list[count].data,curlist->val.string,curlist->val_len); break; case ASN_COUNTER64 : svc_return->list[count].type = SVC_SNMP_TYPE_LONG; svc_return->list[count].data = calloc (curlist->val_len, sizeof(unsigned long)); ((unsigned long*) svc_return->list[count].data)[0] = curlist->val.counter64->high; ((unsigned long*) svc_return->list[count].data)[1] = curlist->val.counter64->low; svc_return->list[count].length = 2; /* override general case */ break; case ASN_NULL : svc_return->list[count].type = SVC_SNMP_TYPE_NULL; svc_return->list[count].data = NULL; svc_return->list[count].length = 0; break; default : svc_return->list[count].type = SVC_SNMP_TYPE_NULL; svc_return->list[count].data = NULL; svc_return->list[count].length = 0; d_printf(10,"snap_svc_snmp : received value of unknown ASN type [%d], treating it as NULL\n",curlist->type); } curlist = curlist->next_variable; count ++; } /* notify our waiting function */ svc_snmp_pdu_waiting = 0; return 1; } else{ d_printf(10,"snap_svc_snmp : received error message %d while expecting result\n",op); if (op == 2){ /* timeout */ svc_snmp_pdu_waiting = 0; } return 0; } } /* ADD SERVICES BELOW */ /* declarations of snap service handlers */ int snap_external_svclib_snmp_init(void* useless){ if (svc_snmp_active) snap_external_svclib_snmp_close(NULL); SOCK_STARTUP; svc_snmp_session = netsnmp_callback_open(callback_master_num, snap_external_svclib_snmp_INTERNAL_execpdu_handler, NULL, NULL); if (svc_snmp_session == NULL) { d_printf(50,"snap_svc_snmp : error while opening callback transport \n"); return 1; } svc_snmp_active = 1; return 0; } int snap_external_svclib_snmp_init_ip(unsigned int ip){ if (svc_snmp_active) snap_external_svclib_snmp_close(NULL); SOCK_STARTUP; svc_snmp_session = calloc( sizeof(netsnmp_session), 1); snmp_sess_init( svc_snmp_session ); /* set up defaults */ svc_snmp_session->peername = malloc (sizeof(char) * 16); sprintf(svc_snmp_session->peername,"%u.%u.%u.%u",ip << 24 >> 24, ip << 16 >> 24, ip << 8 >> 24, ip >> 24); d_printf(110,"snap_svc_snmp_ip : trying ip %s\n",svc_snmp_session->peername); svc_snmp_session->callback = snap_external_svclib_snmp_INTERNAL_execpdu_handler; svc_snmp_session->remote_port = 161; svc_snmp_session->version = SNMP_VERSION_2c; svc_snmp_session->community = strdup("public"); svc_snmp_session->community_len = 6; svc_snmp_session = snmp_open(svc_snmp_session); if ( svc_snmp_session == NULL) { d_printf(50,"snap_svc_snmp : error while opening ip transport \n"); snmp_perror("snap_svc_snmp"); return 1; } svc_snmp_active = 1; return 0; } int snap_external_svclib_snmp_initpdu(unsigned int msg_type){ /* open a connection if it does not yet exist */ if (!svc_snmp_session) snap_external_svclib_snmp_init(NULL); d_printf(200,"snap_svc_snmp : message type is %u\n",msg_type); /* remove the current pdu if it exists */ if (svc_snmp_pdu){ snmp_free_pdu(svc_snmp_pdu); svc_snmp_pdu = NULL; svc_snmp_pdu_load = 0; } /* initialize the pdu */ svc_snmp_pdu = snmp_pdu_create(msg_type); if (svc_snmp_pdu == NULL){ d_printf(10,"snap_svc_snmp : error creating a PDU \n"); return 1; } svc_snmp_pdu->version = SNMP_VERSION_2c; /* keep the communication as simple as possible */ svc_snmp_pdu->securityName = strdup("anonymousSecName001"); svc_snmp_pdu->securityNameLen = 19; svc_snmp_pdu->securityModel = SNMP_SEC_MODEL_ANY; svc_snmp_pdu->errindex = 0; svc_snmp_pdu->community = strdup("public"); svc_snmp_pdu->community_len = 6; svc_snmp_pdu->flags = svc_snmp_pdu->flags | UCD_MSG_FLAG_ALWAYS_IN_VIEW; /* BEWARE: this statement makes the system bypasse the access control code */ svc_snmp_pdu_load = 0; return 0; } int snap_external_svclib_snmp_addvar_null(char* name){ oid my_oid[MAX_OID_LEN]; int my_oid_length = MAX_OID_LEN; if (!svc_snmp_pdu){ int msgtype = SNMP_MSG_GET; snap_external_svclib_snmp_initpdu(msgtype); } /* convert the string encoded name to an oid and add the variable */ d_printf(100,"snap_svc_snmp : finding OID for string %s\n",name); if (!snmp_parse_oid(name, my_oid,&my_oid_length)){ d_printf(20,"snap_svc_snmp : unable to create OID from input string, received SNMP error code %d\n",snmp_errno); return 1; } if (snmp_add_null_var(svc_snmp_pdu, my_oid, my_oid_length) == NULL){ d_printf(20,"snap_svc_snmp : unable to add variable to the PDU, received SNMP error code %d\n",snmp_errno); return 1; } return 0; } int snap_external_svclib_snmp_addvar_withvalue(char* name, int type, void* value, int valuelen){ oid my_oid[MAX_OID_LEN]; int my_oid_length = MAX_OID_LEN; if (!svc_snmp_pdu){ int msgtype = SNMP_MSG_SET; snap_external_svclib_snmp_initpdu(msgtype); } /* convert the string encoded name to an oid and add the variable */ if (!snmp_parse_oid(name, my_oid,&my_oid_length)){ d_printf(20,"snap_svc_snmp : unable to create OID from input string, received SNMP error code %d\n",snmp_errno); return 1; } if (snmp_pdu_add_variable(svc_snmp_pdu, my_oid, my_oid_length, type, value, valuelen) == NULL){ d_printf(20,"snap_svc_snmp : unable to add variable to the PDU\n"); return 1; } return 0; } int snap_external_svclib_snmp_execpdu(void* useless){ /* do some safety checks */ if (!svc_snmp_pdu){ d_printf(10, "snap_svc_snmp : no PDU initialized, unable to send it"); return 1; } /* send the PDU */ d_printf_timed(5,"snap_svc_snmp : sending a request to SNMP ...\n"); if (! snmp_send(svc_snmp_session, svc_snmp_pdu)){ d_printf(10,"snap_svc_snmp : unable to send the request to the snmplibrary, received SNMP error code %d\n",snmp_errno); snmp_perror("snap_svc_snmp"); snmp_free_pdu(svc_snmp_pdu); svc_snmp_pdu = NULL; return 1; } /* wait for handler to return */ svc_snmp_pdu_waiting = 1; while (svc_snmp_pdu_waiting) { int fds = 0, block = 1; fd_set fdset; struct timeval timeout; timeout.tv_sec = 3; /* timeout in 3 secs */ timeout.tv_usec = 0; d_printf(200,"snap_svc_snmp : ... waiting for a response ...\n"); FD_ZERO(&fdset); snmp_select_info(&fds, &fdset, &timeout, &block); fds = select(fds, &fdset, NULL, NULL, block ? NULL : &timeout); if (fds) snmp_read(&fdset); else snmp_timeout(); } d_printf_timed(5,"snap_svc_snmp : ... finished\n"); /* if the request succeeded the pdu will be freed in the snmplib DO NOT FREE! */ svc_snmp_pdu = NULL; if (svc_snmp_pdu_load != 0) svc_snmp_pdu_load = 0; return 0; } int snap_external_svclib_snmp_close(void* useless){ if (svc_snmp_active){ if (svc_snmp_pdu){ snmp_free_pdu(svc_snmp_pdu); svc_snmp_pdu = NULL; } if (!svc_snmp_session) return 0; /* close the connection */ if (!snmp_close(svc_snmp_session)) d_printf(50,"snap_svc_snmp : I was unable to gracefully shut down the snmp connection, destroying... \n"); svc_snmp_session = NULL; SOCK_CLEANUP; svc_snmp_active = 0; } return 0; } /* declarations of DERIVED snap service handlers */ /* return a single value */ int snap_external_svclib_snmp_getsingle(char* name){ int msgtype = SNMP_MSG_GET; snap_external_svclib_snmp_initpdu(msgtype); snap_external_svclib_snmp_addvar_null(name); snap_external_svclib_snmp_execpdu(NULL); return 0; } /* set a single value */ int snap_external_svclib_snmp_setsingle(char* name, int type, void* value, int valuelen){ int msgtype = SNMP_MSG_SET; snap_external_svclib_snmp_initpdu(msgtype); snap_external_svclib_snmp_addvar_withvalue(name, type, value, valuelen); snap_external_svclib_snmp_execpdu(NULL); return 0; } /* find the incoming interface N from the last hop command IP (the in_IP) and calculate the next hop using ~ interface (N+1) mod (#ifaces) */ int snap_external_svclib_snmp_getiface(unsigned long in_ip){ char oid[100]; int iface = -1; sprintf(oid,"ipAdEntIfIndex.%lu.%lu.%lu.%lu",in_ip << 24 >> 24, in_ip << 16 >> 24, in_ip << 8 >> 24, in_ip >> 24); d_printf(50,"oid = %s\n",oid); snap_external_svclib_snmp_getsingle(oid); if (svc_return->length == 1){ if (svc_return->list[0].type == SVC_SNMP_TYPE_INT && svc_return->list[0].length == 4) iface = *((int*) svc_return->list[0].data); else d_printf(20,"ERROR >> wrong returntype or incorrect length [%d:%lu]\n",svc_return->list[0].type,svc_return->list[0].length); } else d_printf(20,"ERROR >> retrieving an incorrect number of results [%d]\n",svc_return->length); d_printf(50,"DEBUG >> iface = %d\n",iface); return iface; } unsigned long snap_external_svclib_snmp_gethop(int iface){ int loopcount, dotcount; int msgtype = SNMP_MSG_GETBULK; char* out_ip = NULL; char oid[100]; int ip_temp[4]; unsigned long ip_address = 0; snap_external_svclib_snmp_initpdu(msgtype); svc_snmp_pdu->non_repeaters=0; svc_snmp_pdu->max_repetitions=10; snap_external_svclib_snmp_addvar_null("ipRouteIfIndex"); snap_external_svclib_snmp_execpdu(NULL); d_printf(50,"DEBUG >> received bulk response with %d variables\n",svc_return->length); loopcount = 0; while (loopcount < svc_return->length){ if (svc_return->list[loopcount].type == SVC_SNMP_TYPE_INT && svc_return->list[loopcount].length == 4){ if ( *((int*) svc_return->list[loopcount].data) == iface){ /* if we have a hop on the right interface */ snprint_objid(oid,100,svc_return->list[loopcount].oid,svc_return->list[loopcount].oid_length); if (!strncmp(oid,"RFC1213-MIB::ipRouteIfIndex",27)){ /* only keep the last part: the IP address */ loopcount = strlen(oid) - 1; dotcount = 0; while (loopcount && dotcount < 4){ if (oid[loopcount] == '.'){ dotcount ++; ip_address += strtoul(&oid[loopcount],NULL,10) << dotcount * 8; d_printf(50,"DEBUG >> ip so far = %ld, new = %d\n",ip_address,atoi(&oid[loopcount])); } loopcount --; } loopcount += 2; /* forget the last dot and the last loopcount-- */ out_ip = strdup (&oid[loopcount]); d_printf(50,"DEBUG >> found a correct hop [%s], iface is %d\n",out_ip, iface); loopcount = svc_return->length + 1; /* exit this while loop */ } d_printf(20,"ERROR >> oid : %s, iface = %d\n",oid, iface); } } else d_printf(20,"ERROR >> wrong returntype or incorrect length [%d:%lu]\n",svc_return->list[loopcount].type,svc_return->list[loopcount].length); loopcount++; } if (loopcount != svc_return->length + 2) d_printf(10,"ERROR >> unable to find correct hop\n"); /* convert from char to IP */ if (out_ip){ sscanf(out_ip,"%d.%d.%d.%d",&ip_temp[0],&ip_temp[1],&ip_temp[2],&ip_temp[3]); /*ip_address = ((unsigned long) ip_temp[0] << 24) & ((unsigned long) ip_temp[1] << 16) & ((unsigned long) (ip_temp[2] << 8)) & ((unsigned long) ip_temp[3]); */ for (loopcount = 3; loopcount >= 0; loopcount--){ ip_address = ip_address << 8; ip_address += ip_temp[loopcount]; } d_printf(50,"DEBUG >> ip = %lu.%lu.%lu.%lu (long) == %s (string)\n",ip_address << 24 >> 24, ip_address << 16 >> 24, ip_address << 8 >> 24, ip_address >> 24, out_ip); free (out_ip); } return ip_address; } int snap_external_svclib_snmp_getifnumber(void* useless){ int ifnumber = -1; snap_external_svclib_snmp_getsingle("ifNumber.0"); if (svc_return->length == 1){ if (svc_return->list[0].type == SVC_SNMP_TYPE_INT && svc_return->list[0].length == 4) ifnumber = *((int*) svc_return->list[0].data); else d_printf(20,"ERROR >> wrong returntype or incorrect length [%d:%lu]\n",svc_return->list[0].type,svc_return->list[0].length); } else d_printf(20,"ERROR >> retrieving an incorrect number of results [%d]\n",svc_return->length); d_printf(50,"DEBUG >> ifNumber.0 = %d\n",ifnumber); return ifnumber; } int snap_external_svclib_snmp_isupiface(int iface){ char oid[10]; int status = -1; sprintf(oid,"ifOperStatus.%d",iface); snap_external_svclib_snmp_getsingle(oid); if (svc_return->length == 1){ if (svc_return->list[0].type == SVC_SNMP_TYPE_INT && svc_return->list[0].length == 4) status = *((int*) svc_return->list[0].data); else d_printf(20,"ERROR >> wrong returntype or incorrect length [%d:%lu]\n",svc_return->list[0].type,svc_return->list[0].length); } else d_printf(20,"ERROR >> retrieving an incorrect number of results [%d]\n",svc_return->length); d_printf(50,"DEBUG >> iface %d has status %d (1=up, 2=down)\n",iface, status); return status; } int snap_external_svclib_snmp_getnextiface(int old_iface){ int ifnumber, isup = 0, count=0, iface; ifnumber = snap_external_svclib_snmp_getifnumber(NULL); iface = old_iface; if (iface != -1 && ifnumber != -1){ do{ if (iface < ifnumber) iface ++ ; else iface = 2; isup = snap_external_svclib_snmp_isupiface(iface); count++; } while (isup != 1 && count < ifnumber); } if (isup != 1) return -1; else return iface; } int snap_external_svclib_snmp_getnextifacefromip(unsigned long in_ip){ int iface; iface = snap_external_svclib_snmp_getiface(in_ip); return snap_external_svclib_snmp_getnextiface(iface); } unsigned long snap_internal_svclib_snmp_getnexthopfromip(unsigned long in_ip){ int iface; unsigned long ip = 0; iface = snap_external_svclib_snmp_getnextifacefromip(in_ip); if (iface != -1) ip = snap_external_svclib_snmp_gethop(iface); return ip; } unsigned long snap_external_svclib_snmp_getnexthopfromip(unsigned long in_ip){ unsigned long ip = snap_internal_svclib_snmp_getnexthopfromip(in_ip); snap_external_svclib_free_local_returnstruct(); svc_return = (struct svc_returnstruct*) calloc (1,sizeof(struct svc_returnstruct)); svc_return->length = 1; svc_return->list = (struct svc_returnitem*) calloc (1,sizeof(struct svc_returnitem)); svc_return->list[0].data = calloc (1, sizeof(unsigned long)); memmove(svc_return->list[0].data,&ip,sizeof(unsigned long)); svc_return->list[0].type = SVC_SNMP_TYPE_ADDR; return ip; } int snap_external_svclib_snmp_getallotherneighboursfromip(unsigned long in_ip){ unsigned long ip = in_ip; int listcount=0, ifnumber, whilecount=2; struct svc_returnstruct* svc_temp; ifnumber = snap_external_svclib_snmp_getifnumber(NULL); ifnumber--; /* disregard the local interface */ snap_external_svclib_free_local_returnstruct(); svc_temp = (struct svc_returnstruct*) calloc (1,sizeof(struct svc_returnstruct)); svc_temp->length = ifnumber + 1; svc_temp->list = (struct svc_returnitem*) calloc (ifnumber+1,sizeof(struct svc_returnitem)); while(whilecount <= ifnumber + 1){ d_printf(50,"DEBUG >> finding a hop for iface %d\n",whilecount); if (snap_external_svclib_snmp_isupiface(whilecount) == 1){ ip = snap_external_svclib_snmp_gethop(whilecount); svc_temp->list[listcount].data = calloc (1, sizeof(unsigned long)); memmove(svc_temp->list[listcount].data,&ip,sizeof(unsigned long)); svc_temp->list[listcount].type = SVC_SNMP_TYPE_ADDR; listcount++; d_printf(50,"DEBUG >> visited an iface\n"); } else{ svc_temp->list[listcount].type = SVC_SNMP_TYPE_NULL; svc_temp->list[listcount].data = NULL; svc_temp->list[listcount].length = 0; listcount++; } whilecount++; } /* the #of new entries */ svc_temp->list[ifnumber].type = SVC_SNMP_TYPE_INT; svc_temp->list[ifnumber].data = calloc (1, sizeof(int)); memmove(svc_temp->list[ifnumber].data,&listcount,sizeof(int)); snap_external_svclib_free_local_returnstruct(); svc_return = svc_temp; /* if (count != ifnumber) d_printf(50,"WARNING : found %d hops, only going to use %d\n",count,ifnumber); */ return listcount; }