int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcb tcp_inpcb;
struct tcpcb tcpcb;
netsnmp_inpcb *nnew;
struct inpcb *entry;
#ifdef hpux
int StateMap[] = { 1, 2, 3, -1, 4, 5, 8, 6, 10, 9, 7, 11 };
#else
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
#endif
tcpTable_free(NULL, NULL);
if (!auto_nlist(TCP_SYMBOL, (char *) &tcp_inpcb, sizeof(tcp_inpcb))) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to read tcp_symbol\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = tcp_inpcb.INP_NEXT_SYMBOL;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(netsnmp_inpcb);
if (!nnew)
break;
klookup((unsigned long) entry, (char *)&(nnew->pcb), sizeof(struct inpcb));
klookup((int) nnew->pcb.inp_ppcb, (char *)&tcpcb, sizeof(struct tcpcb));
nnew->state = StateMap[tcpcb.t_state];
if (nnew->state == 5 /* established */ ||
nnew->state == 8 /* closeWait */ )
tcp_estab++;
entry = nnew->pcb.INP_NEXT_SYMBOL; /* Next kernel entry */
nnew->inp_next = tcp_head;
tcp_head = nnew;
if (entry == tcp_inpcb.INP_NEXT_SYMBOL)
break;
}
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (tcp_symbol)\n"));
return -1;
}
int KNLookup(struct nlist nl[],
int nl_which,
char *buf,
int s)
{
struct nlist *nlp = &nl[nl_which];
if (nlp->n_value == 0) {
fprintf (stderr, "Accessing non-nlisted variable: %s\n", nlp->n_name);
nlp->n_value = -1; /* only one error message ... */
return 0;
}
if (nlp->n_value == -1)
return 0;
return klookup(nlp->n_value, buf, s);
}
int
auto_nlist(char *string,
char *var,
int size)
{
long result;
int ret;
result = auto_nlist_value(string);
if (result != -1) {
if (var != NULL) {
ret = klookup(result, var, size);
if (!ret)
fprintf(stderr, "auto_nlist failed on %s at location %lx\n",
string, result);
return ret;
} else
return 1;
}
return 0;
}
int
udpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcb udp_inpcb;
struct inpcb *nnew, *entry;
udpTable_free(NULL, NULL);
if (!auto_nlist(UDB_SYMBOL, (char *) &udp_inpcb, sizeof(udp_inpcb))) {
DEBUGMSGTL(("mibII/udpTable", "Failed to read udb_symbol\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = udp_inpcb.INP_NEXT_SYMBOL;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (!nnew)
break;
klookup((unsigned long) entry, (char *) nnew, sizeof(struct inpcb));
entry = nnew->INP_NEXT_SYMBOL; /* Next kernel entry */
nnew->INP_NEXT_SYMBOL = udp_head;
udp_head = nnew;
if (entry == udp_inpcb.INP_NEXT_SYMBOL)
break;
}
if (udp_head) {
DEBUGMSGTL(("mibII/udpTable", "Loaded UDP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/udpTable", "Failed to load UDP Table (udb_symbol)\n"));
return -1;
}
int
udpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcbtable table;
struct inpcb *nnew, *entry;
udpTable_free(NULL, NULL);
if (!auto_nlist(UDB_SYMBOL, (char *) &table, sizeof(table))) {
DEBUGMSGTL(("mibII/udpTable", "Failed to read inpcbtable\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = table.inpt_queue.cqh_first;
while (entry) {
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (!nnew)
break;
klookup((unsigned long) entry, (char *) nnew, sizeof(struct inpcb));
entry = nnew->inp_queue.cqe_next; /* Next kernel entry */
nnew->inp_queue.cqe_next = udp_head;
udp_head = nnew;
if (entry == table.inpt_queue.cqh_first)
break;
}
if (udp_head) {
DEBUGMSGTL(("mibII/udpTable", "Loaded UDP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/udpTable", "Failed to load UDP Table (pcb_table)\n"));
return -1;
}
static int
ARP_Scan_Next(u_long * IPAddr, char *PhysAddr, u_long * ifType)
#endif
{
#ifndef CAN_USE_SYSCTL
#ifdef linux
if (arptab_current < arptab_size) {
/*
* copy values
*/
*IPAddr = at[arptab_current].at_iaddr.s_addr;
*ifType =
(at[arptab_current].
at_flags & ATF_PERM) ? 4 /*static */ : 3 /*dynamic */ ;
*ifIndex = at[arptab_current].if_index;
memcpy(PhysAddr, &at[arptab_current].at_enaddr,
sizeof(at[arptab_current].at_enaddr));
/*
* increment to point next entry
*/
arptab_current++;
/*
* return success
*/
return (1);
}
#elif defined(hpux11)
if (arptab_current < arptab_size) {
/*
* copy values
*/
*IPAddr = at[arptab_current].NetAddr;
memcpy(PhysAddr, at[arptab_current].PhysAddr.o_bytes,
at[arptab_current].PhysAddr.o_length);
*ifType = at[arptab_current].Type;
*ifIndex = at[arptab_current].IfIndex;
/*
* increment to point next entry
*/
arptab_current++;
/*
* return success
*/
return (1);
}
#elif !defined(ARP_SCAN_FOUR_ARGUMENTS) || defined(hpux)
register struct arptab *atab;
while (arptab_current < arptab_size) {
#ifdef STRUCT_ARPHD_HAS_AT_NEXT
/*
* The arp table is an array of linked lists of arptab entries.
* Unused slots have pointers back to the array entry itself
*/
if (at_ptr == (auto_nlist_value(ARPTAB_SYMBOL) +
arptab_current * sizeof(struct arphd))) {
/*
* Usused
*/
arptab_current++;
at_ptr = at[arptab_current].at_next;
continue;
}
klookup(at_ptr, (char *) &at_entry, sizeof(struct arptab));
klookup(at_entry.at_ac, (char *) &at_com, sizeof(struct arpcom));
at_ptr = at_entry.at_next;
atab = &at_entry;
*ifIndex = at_com.ac_if.if_index; /* not strictly ARPHD */
#else /* STRUCT_ARPHD_HAS_AT_NEXT */
atab = &at[arptab_current++];
#endif /* STRUCT_ARPHD_HAS_AT_NEXT */
if (!(atab->at_flags & ATF_COM))
continue;
*ifType = (atab->at_flags & ATF_PERM) ? 4 : 3;
*IPAddr = atab->at_iaddr.s_addr;
#if defined (sunV3) || defined(sparc) || defined(hpux)
memcpy(PhysAddr, (char *) &atab->at_enaddr,
sizeof(atab->at_enaddr));
#endif
#if defined(mips) || defined(ibm032)
memcpy(PhysAddr, (char *) atab->at_enaddr,
sizeof(atab->at_enaddr));
#endif
return (1);
}
#endif /* linux || hpux11 || !ARP_SCAN_FOUR_ARGUMENTS || hpux */
return 0; /* we need someone with an irix box to fix this section */
#else /* !CAN_USE_SYSCTL */
struct rt_msghdr *rtm;
struct sockaddr_inarp *sin;
struct sockaddr_dl *sdl;
while (rtnext < lim) {
rtm = (struct rt_msghdr *) rtnext;
sin = (struct sockaddr_inarp *) (rtm + 1);
sdl = (struct sockaddr_dl *) (sin + 1);
rtnext += rtm->rtm_msglen;
if (sdl->sdl_alen) {
*IPAddr = sin->sin_addr.s_addr;
memcpy(PhysAddr, (char *) LLADDR(sdl), sdl->sdl_alen);
*ifIndex = sdl->sdl_index;
*ifType = 1; /* XXX */
return (1);
}
}
return (0); /* "EOF" */
#endif /* !CAN_USE_SYSCTL */
}
