int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
int fd;
struct nmparms p;
int val = 0;
unsigned int ulen;
int ret;
int i;
tcpTable_free(NULL, NULL);
if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) >= 0) {
p.objid = ID_tcpConnNumEnt;
p.buffer = (void *) &val;
ulen = sizeof(int);
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) == 0)
tcp_size = val;
if (tcp_size > 0) {
ulen = (unsigned) tcp_size *sizeof(mib_tcpConnEnt);
tcp_head = (mib_tcpConnEnt *) malloc(ulen);
p.objid = ID_tcpConnTable;
p.buffer = (void *) tcp_head;
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) < 0) {
tcp_size = 0;
}
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
FILE *in;
char line[256];
tcpTable_free(cache, NULL);
#if HAVE_NETLINK_NETLINK_H
if (tcpTable_load_netlink() == 0) {
return 0;
}
#endif
if (!(in = fopen("/proc/net/tcp", "r"))) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (linux1)\n"));
NETSNMP_LOGONCE((LOG_ERR, "snmpd: cannot open /proc/net/tcp ...\n"));
return -1;
}
/*
* scan proc-file and build up a linked list
* This will actually be built up in reverse,
* but since the entries are unsorted, that doesn't matter.
*/
while (line == fgets(line, sizeof(line), in)) {
struct inpcb pcb, *nnew;
unsigned int lp, fp;
int state, uid;
if (6 != sscanf(line,
"%*d: %x:%x %x:%x %x %*X:%*X %*X:%*X %*X %d",
&pcb.inp_laddr.s_addr, &lp,
&pcb.inp_faddr.s_addr, &fp, &state, &uid))
continue;
pcb.inp_lport = htons((unsigned short) lp);
pcb.inp_fport = htons((unsigned short) fp);
pcb.inp_state = (state & 0xf) < 12 ? linux_states[state & 0xf] : 2;
if (pcb.inp_state == 5 /* established */ ||
pcb.inp_state == 8 /* closeWait */ )
tcp_estab++;
pcb.uid = uid;
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (nnew == NULL)
break;
memcpy(nnew, &pcb, sizeof(struct inpcb));
nnew->inp_next = tcp_head;
tcp_head = nnew;
}
fclose(in);
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table (linux)\n"));
return 0;
}
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;
if (!NETSNMP_KLOOKUP(entry, (char *)&(nnew->pcb), sizeof(struct inpcb))) {
DEBUGMSGTL(("mibII/tcpTable:tcpTable_load", "klookup failed\n"));
break;
}
if (!NETSNMP_KLOOKUP(nnew->pcb.inp_ppcb, (char *)&tcpcb, sizeof(struct tcpcb))) {
DEBUGMSGTL(("mibII/tcpTable:tcpTable_load", "klookup failed\n"));
break;
}
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 (tcp_symbol)\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (tcp_symbol)\n"));
return -1;
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
size_t len;
int sname[] = { CTL_NET, PF_INET, IPPROTO_TCP, TCPCTL_PCBLIST };
char *tcpcb_buf = NULL;
struct xinpgen *xig = NULL;
netsnmp_inpcb *nnew;
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
tcpTable_free(NULL, NULL);
/*
* Read in the buffer containing the TCP table data
*/
len = 0;
if (sysctl(sname, 4, 0, &len, 0, 0) < 0 ||
(tcpcb_buf = malloc(len)) == NULL)
return -1;
if (sysctl(sname, 4, tcpcb_buf, &len, 0, 0) < 0) {
free(tcpcb_buf);
return -1;
}
/*
* Unpick this into the constituent 'xinpgen' structures, and extract
* the 'inpcb' elements into a linked list (built in reverse)
*/
xig = (struct xinpgen *) tcpcb_buf;
xig = (struct xinpgen *) ((char *) xig + xig->xig_len);
while (xig && (xig->xig_len > sizeof(struct xinpgen))) {
nnew = SNMP_MALLOC_TYPEDEF(netsnmp_inpcb);
if (!nnew)
break;
nnew->state = StateMap[((NS_ELEM *) xig)->xt_tp.t_state];
if (nnew->state == 5 /* established */ ||
nnew->state == 8 /* closeWait */ )
tcp_estab++;
memcpy(&(nnew->pcb), &(((NS_ELEM *) xig)->xt_inp),
sizeof(struct inpcb));
nnew->inp_next = tcp_head;
tcp_head = nnew;
xig = (struct xinpgen *) ((char *) xig + xig->xig_len);
}
free(tcpcb_buf);
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (sysctl)\n"));
return -1;
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
int fd;
struct nmparms p;
int val = 0;
unsigned int ulen;
int ret;
int i;
tcpTable_free(NULL, NULL);
if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) >= 0) {
p.objid = ID_tcpConnNumEnt;
p.buffer = (void *) &val;
ulen = sizeof(int);
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) == 0)
tcp_size = val;
if (tcp_size > 0) {
ulen = (unsigned) tcp_size *sizeof(mib_tcpConnEnt);
tcp_head = (mib_tcpConnEnt *) malloc(ulen);
p.objid = ID_tcpConnTable;
p.buffer = (void *) tcp_head;
p.len = &ulen;
if ((ret = get_mib_info(fd, &p)) < 0) {
tcp_size = 0;
}
}
close_mib(fd);
}
/*
* Count the number of established connections
* Probably not actually necessary for HP-UX
*/
for (i = 0; i < tcp_size; i++) {
if (tcp_head[i].State == 5 /* established */ ||
tcp_head[i].State == 8 /* closeWait */ )
tcp_estab++;
}
if (tcp_size > 0) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table (hpux11)\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (hpux11)\n"));
return -1;
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
struct inpcbtable table;
struct inpcb *entry;
struct tcpcb tcpcb;
netsnmp_inpcb *nnew;
int StateMap[] = { 1, 2, 3, 4, 5, 8, 6, 10, 9, 7, 11 };
tcpTable_free(NULL, NULL);
if (!auto_nlist(TCP_SYMBOL, (char *) &table, sizeof(table))) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to read inpcbtable\n"));
return -1;
}
/*
* Set up a linked list
*/
entry = table.inpt_queue.cqh_first;
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->inp_queue.cqe_next; /* Next kernel entry */
nnew->inp_next = tcp_head;
tcp_head = nnew;
if (entry == table.inpt_queue.cqh_first)
break;
}
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (pcb_table)\n"));
return -1;
}
int
tcpTable_load(netsnmp_cache *cache, void *vmagic)
{
mib2_tcpConnEntry_t entry;
netsnmp_tcpConnEntry *nnew;
netsnmp_tcpConnEntry *prev_entry = NULL;
tcpTable_free(NULL, NULL);
if (getMibstat(MIB_TCP_CONN, &entry, sizeof(mib2_tcpConnEntry_t),
GET_FIRST, &TCP_Cmp, &entry) != 0) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (solaris)\n"));
return -1;
}
while (1) {
/*
* Build up a linked list copy of the getMibstat results
* Note that since getMibstat returns rows in sorted order,
* we need to retain this order while building the list
* so new entries are added onto the end of the list.
* Note 2: at least Solaris 8-10 do not return rows in
* sorted order anymore
*/
nnew = SNMP_MALLOC_TYPEDEF(netsnmp_tcpConnEntry);
if (nnew == NULL)
break;
memcpy(&(nnew->entry), &entry, sizeof(mib2_tcpConnEntry_t));
if (!prev_entry)
tcp_head = nnew;
else
prev_entry->inp_next = nnew;
prev_entry = nnew;
if (getMibstat(MIB_TCP_CONN, &entry, sizeof(mib2_tcpConnEntry_t),
GET_NEXT, &TCP_Cmp, &entry) != 0)
break;
}
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table (solaris)\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (solaris)\n"));
return -1;
}
