void
netsnmp_access_interface_init(void)
{
netsnmp_assert(0 == _access_interface_init); /* who is calling twice? */
if (1 == _access_interface_init)
return;
_access_interface_init = 1;
#ifndef NETSNMP_ACCESS_INTERFACE_NOARCH
{
netsnmp_container * ifcontainer;
netsnmp_arch_interface_init();
/*
* load once to set up ifIndexes
*/
ifcontainer = netsnmp_access_interface_container_load(NULL, 0);
if(NULL != ifcontainer)
netsnmp_access_interface_container_free(ifcontainer, 0);
}
#endif
}
/**
* load initial data
*
* TODO:350:M: Implement ifTable 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
* ifTable_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
ifTable_container_load(netsnmp_container *container)
{
netsnmp_container *ifcontainer;
DEBUGMSGTL(("verbose:ifTable:ifTable_container_load", "called\n"));
/*
* TODO:351:M: |-> Load/update data in the ifTable container.
* loop over your ifTable data, allocate a rowreq context,
* set the index(es) [and data, optionally] and insert into
* the container.
*/
/*
* ifTable gets its data from the netsnmp_interface API.
*/
ifcontainer =
netsnmp_access_interface_container_load(NULL,
NETSNMP_ACCESS_INTERFACE_INIT_NOFLAGS);
if (NULL == ifcontainer)
return MFD_RESOURCE_UNAVAILABLE; /* msg already logged */
/*
* we just got a fresh copy of interface data. compare it to
* what we've already got, and make any adjustements...
*/
CONTAINER_FOR_EACH(container, (netsnmp_container_obj_func *)
_check_interface_entry_for_updates, ifcontainer);
/*
* now add any new interfaces
*/
CONTAINER_FOR_EACH(ifcontainer,
(netsnmp_container_obj_func *) _add_new_interface,
container);
/*
* free the container. we've either claimed each ifentry, or released it,
* so the dal function doesn't need to clear the container.
*/
netsnmp_access_interface_container_free(ifcontainer,
NETSNMP_ACCESS_INTERFACE_FREE_DONT_CLEAR);
DEBUGMSGT(("verbose:ifTable:ifTable_cache_load",
"%d records\n", CONTAINER_SIZE(container)));
if (_first_load)
_first_load = 0;
return MFD_SUCCESS;
} /* ifTable_container_load */
void
Interface_Scan_Init(void)
{
/*
* ifTable container shouldn't change, so we shouldn' have to
* re-fetch it every time.
*/
if (NULL != c)
netsnmp_access_interface_container_free(c, 0);
c = netsnmp_access_interface_container_load(NULL, 0);
if (NULL != c) {
if (NULL != it)
ITERATOR_RELEASE(it);
it = CONTAINER_ITERATOR(c);
}
if (NULL != it)
e = (netsnmp_interface_entry*)ITERATOR_FIRST(it);
}
netsnmp_container*
netsnmp_access_interface_container_load(netsnmp_container* container, u_int load_flags)
{
int rc;
DEBUGMSGTL(("access:interface:container", "load\n"));
netsnmp_assert(1 == _access_interface_init);
if (NULL == container)
container = netsnmp_access_interface_container_init(load_flags);
if (NULL == container) {
snmp_log(LOG_ERR, "no container specified/found for access_interface\n");
return NULL;
}
rc = netsnmp_arch_interface_container_load(container, load_flags);
if (0 != rc) {
netsnmp_access_interface_container_free(container,
NETSNMP_ACCESS_INTERFACE_FREE_NOFLAGS);
container = NULL;
}
return container;
}
/*
*
* @retval 0 success
* @retval -1 no container specified
* @retval -2 could not open /proc/net/dev
* @retval -3 could not create entry (probably malloc)
*/
int
netsnmp_arch_interface_container_load(netsnmp_container* container,
u_int load_flags)
{
FILE *devin;
char line[256];
netsnmp_interface_entry *entry = NULL;
static char scan_expected = 0;
int fd;
#ifdef NETSNMP_ENABLE_IPV6
netsnmp_container *addr_container;
#endif
DEBUGMSGTL(("access:interface:container:arch", "load (flags %p)\n",
load_flags));
if (NULL == container) {
snmp_log(LOG_ERR, "no container specified/found for interface\n");
return -1;
}
if (!(devin = fopen("/proc/net/dev", "r"))) {
DEBUGMSGTL(("access:interface",
"Failed to load Interface Table (linux1)\n"));
snmp_log(LOG_ERR, "cannot open /proc/net/dev ...\n");
return -2;
}
/*
* create socket for ioctls
*/
fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd < 0) {
snmp_log(LOG_ERR, "could not create socket\n");
return -2;
}
#ifdef NETSNMP_ENABLE_IPV6
/*
* get ipv6 addresses
*/
addr_container = netsnmp_access_ipaddress_container_load(NULL, 0);
#endif
/*
* Read the first two lines of the file, containing the header
* This indicates which version of the kernel we're working with,
* and hence which statistics are actually available.
*
* Wes originally suggested parsing the field names in this header
* to detect the position of individual fields directly,
* but I suspect this is probably more trouble than it's worth.
*/
fgets(line, sizeof(line), devin);
fgets(line, sizeof(line), devin);
if( 0 == scan_expected ) {
if (strstr(line, "compressed")) {
scan_expected = 10;
DEBUGMSGTL(("access:interface",
"using linux 2.2 kernel /proc/net/dev\n"));
} else {
scan_expected = 5;
DEBUGMSGTL(("access:interface",
"using linux 2.0 kernel /proc/net/dev\n"));
}
}
/*
* The rest of the file provides the statistics for each interface.
* Read in each line in turn, isolate the interface name
* and retrieve (or create) the corresponding data structure.
*/
while (fgets(line, sizeof(line), devin)) {
char *stats, *ifstart = line;
u_int flags;
oid if_index;
flags = 0;
if (line[strlen(line) - 1] == '\n')
line[strlen(line) - 1] = '\0';
while (*ifstart && *ifstart == ' ')
ifstart++;
if ((!*ifstart) || ((stats = strrchr(ifstart, ':')) == NULL)) {
snmp_log(LOG_ERR,
"interface data format error 1, line ==|%s|\n", line);
continue;
}
if ((scan_expected == 10) && ((stats - line) < 6)) {
snmp_log(LOG_ERR,
"interface data format error 2 (%d < 6), line ==|%s|\n",
stats - line, line);
}
DEBUGMSGTL(("9:access:ifcontainer", "processing '%s'\n", ifstart));
/*
* get index via ioctl.
* If we've met this interface before, use the same index.
* Otherwise find an unused index value and use that.
*/
*stats++ = 0; /* null terminate name */
if_index = netsnmp_arch_interface_index_find(ifstart);
/*
* set address type flags.
* the only way I know of to check an interface for
* ip version is to look for ip addresses. If anyone
* knows a better way, put it here!
*/
#ifdef NETSNMP_ENABLE_IPV6
_arch_interface_has_ipv6(if_index, &flags, addr_container);
#endif
netsnmp_access_interface_ioctl_has_ipv4(fd, ifstart, 0, &flags);
/*
* do we only want one address type?
*/
if (((load_flags & NETSNMP_ACCESS_INTERFACE_LOAD_IP4_ONLY) &&
((flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV4) == 0)) ||
((load_flags & NETSNMP_ACCESS_INTERFACE_LOAD_IP6_ONLY) &&
((flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV6) == 0))) {
DEBUGMSGTL(("9:access:ifcontainer",
"interface '%s' excluded by ip version\n",
ifstart));
continue;
}
entry = netsnmp_access_interface_entry_create(ifstart, 0);
if(NULL == entry) {
#ifdef NETSNMP_ENABLE_IPV6
netsnmp_access_ipaddress_container_free(addr_container, 0);
#endif
netsnmp_access_interface_container_free(container,
NETSNMP_ACCESS_INTERFACE_FREE_NOFLAGS);
fclose(devin);
close(fd);
return -3;
}
entry->ns_flags = flags; /* initial flags; we'll set more later */
/*
* xxx-rks: get descr by linking mem from /proc/pci and /proc/iomem
*/
/*
* use ioctls for some stuff
* (ignore rc, so we get as much info as possible)
*/
netsnmp_access_interface_ioctl_physaddr_get(fd, entry);
/*
* physaddr should have set type. make some guesses (based
* on name) if not.
*/
if(0 == entry->type) {
typedef struct _match_if {
int mi_type;
const char *mi_name;
} *pmatch_if, match_if;
static match_if lmatch_if[] = {
{IANAIFTYPE_SOFTWARELOOPBACK, "lo"},
{IANAIFTYPE_ETHERNETCSMACD, "eth"},
{IANAIFTYPE_ETHERNETCSMACD, "vmnet"},
{IANAIFTYPE_ISO88025TOKENRING, "tr"},
{IANAIFTYPE_FASTETHER, "feth"},
{IANAIFTYPE_GIGABITETHERNET,"gig"},
{IANAIFTYPE_PPP, "ppp"},
{IANAIFTYPE_SLIP, "sl"},
{IANAIFTYPE_TUNNEL, "sit"},
{IANAIFTYPE_BASICISDN, "ippp"},
{IANAIFTYPE_PROPVIRTUAL, "bond"}, /* Bonding driver find fastest slave */
{IANAIFTYPE_PROPVIRTUAL, "vad"}, /* ANS driver - ?speed? */
{0, 0} /* end of list */
};
int ii, len;
register pmatch_if pm;
for (ii = 0, pm = lmatch_if; pm->mi_name; pm++) {
len = strlen(pm->mi_name);
if (0 == strncmp(entry->name, pm->mi_name, len)) {
entry->type = pm->mi_type;
break;
}
}
if(NULL == pm->mi_name)
entry->type = IANAIFTYPE_OTHER;
}
if (IANAIFTYPE_ETHERNETCSMACD == entry->type)
entry->speed =
// 10000000;//incifer 20091027, fix read RTL8306 ocurred error.
netsnmp_linux_interface_get_if_speed(fd, entry->name);
#ifdef APPLIED_PATCH_836390 /* xxx-rks ifspeed fixes */
else if (IANAIFTYPE_PROPVIRTUAL == entry->type)
entry->speed = _get_bonded_if_speed(entry);
#endif
else
netsnmp_access_interface_entry_guess_speed(entry);
netsnmp_access_interface_ioctl_flags_get(fd, entry);
netsnmp_access_interface_ioctl_mtu_get(fd, entry);
/*
* Zero speed means link problem.
* - i'm not sure this is always true...
*/
if((entry->speed == 0) && (entry->os_flags & IFF_UP)) {
entry->os_flags &= ~IFF_RUNNING;
}
/*
* check for promiscuous mode.
* NOTE: there are 2 ways to set promiscuous mode in Linux
* (kernels later than 2.2.something) - using ioctls and
* using setsockopt. The ioctl method tested here does not
* detect if an interface was set using setsockopt. google
* on IFF_PROMISC and linux to see lots of arguments about it.
*/
if(entry->os_flags & IFF_PROMISC) {
entry->promiscuous = 1; /* boolean */
}
/*
* hardcoded max packet size
* (see ip_frag_reasm: if(len > 65535) goto out_oversize;)
*/
entry->reasm_max_v4 = entry->reasm_max_v6 = 65535;
entry->ns_flags |=
NETSNMP_INTERFACE_FLAGS_HAS_V4_REASMMAX |
NETSNMP_INTERFACE_FLAGS_HAS_V6_REASMMAX;
netsnmp_access_interface_entry_overrides(entry);
entry->speed_high = entry->speed / 1000000;
if (! (load_flags & NETSNMP_ACCESS_INTERFACE_LOAD_NO_STATS))
_parse_stats(entry, stats, scan_expected);
if (flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV4)
_arch_interface_flags_v4_get(entry);
#ifdef NETSNMP_ENABLE_IPV6
if (flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV6)
_arch_interface_flags_v6_get(entry);
#endif /* NETSNMP_ENABLE_IPV6 */
/*
* add to container
*/
CONTAINER_INSERT(container, entry);
}
#ifdef NETSNMP_ENABLE_IPV6
netsnmp_access_ipaddress_container_free(addr_container, 0);
#endif
fclose(devin);
close(fd);
return 0;
}