Updated to fetch the interface information when the "getter" function triggers

Author: David Sommerseth

python-ethtool/etherinfo.c

@@ -24,35 +24,16 @@
 #include <stdlib.h>
 #include <asm/types.h>
 #include <sys/socket.h>
-#include <netlink/addr.h>
-#include <netlink/netlink.h>
-#include <netlink/handlers.h>
-#include <netlink/route/link.h>
-#include <netlink/route/addr.h>
-#include <arpa/inet.h>
 #include <assert.h>
 #include <errno.h>
+#include "etherinfo_struct.h"
 #include "etherinfo.h"
 
 /*
  *
  *   Internal functions for working with struct etherinfo
  *
  */
-
-inline struct etherinfo *new_etherinfo_record()
-{
-	struct etherinfo *ptr;
-
-	ptr = malloc(sizeof(struct etherinfo)+1);
-	if( ptr ) {
-		memset(ptr, 0, sizeof(struct etherinfo)+1);
-	}
-
-	return ptr;
-}
-
-
 void free_etherinfo(struct etherinfo *ptr)
 {
 	if( ptr == NULL ) { // Just for safety
@@ -82,6 +63,13 @@ void free_etherinfo(struct etherinfo *ptr)
  *
  */
 
+#define SET_STR_VALUE(dst, src) {	 \
+	if( dst ) {		 \
+		free(dst);	 \
+	};			 \
+	dst = strdup(src);       \
+	}
+
 static void callback_nl_link(struct nl_object *obj, void *arg)
 {
 	struct etherinfo *ethi = (struct etherinfo *) arg;
@@ -110,7 +98,7 @@ static void callback_nl_link(struct nl_object *obj, void *arg)
 			ptr += 3;
 		}
 	}
-	ethi->hwaddress = strdup(hwaddr);
+	SET_STR_VALUE(ethi->hwaddress, hwaddr);
 }
 
 
@@ -137,16 +125,16 @@ static void callback_nl_address(struct nl_object *obj, void *arg)
 			struct nl_addr *brdcst = rtnl_addr_get_broadcast((struct rtnl_addr *)obj);
 			char brdcst_str[66];
 
-			ethi->ipv4_address = strdup(ip_str);
+			SET_STR_VALUE(ethi->ipv4_address, ip_str);
 			ethi->ipv4_netmask = rtnl_addr_get_prefixlen((struct rtnl_addr*) obj);
 
 			if( brdcst ) {
 				memset(&brdcst_str, 0, 66);
 				inet_ntop(family, nl_addr_get_binary_addr(brdcst), (char *)&brdcst_str, 64);
-				ethi->ipv4_broadcast = strdup(brdcst_str);
+				SET_STR_VALUE(ethi->ipv4_broadcast, brdcst_str);
 			}
 		} else {
-			ethi->ipv6_address = strdup(ip_str);
+			SET_STR_VALUE(ethi->ipv6_address, ip_str);
 			ethi->ipv6_netmask = rtnl_addr_get_prefixlen((struct rtnl_addr*) obj);
 		}
 		return;
@@ -186,70 +174,59 @@ void dump_etherinfo(FILE *fp, struct etherinfo *ptr)
 	fprintf(fp, "\n");
 }
 
-struct etherinfo *get_etherinfo(const char *ifdevname)
+
+int get_etherinfo(struct etherinfo *ethinf, struct _nlconnection *nlc, nlQuery query)
 {
-	struct etherinfo *ethinf = NULL;
-	struct nl_handle *handle;
 	struct nl_cache *link_cache;
 	struct nl_cache *addr_cache;
 	struct rtnl_addr *addr;
 	struct rtnl_link *link;
-	int ifindex;
-
-	/* Establish connection to NETLINK */
-	handle = nl_handle_alloc();
-	nl_connect(handle, NETLINK_ROUTE);
-
-	/* Find the interface index we're looking up */
-	link_cache = rtnl_link_alloc_cache(handle);
-	ifindex = rtnl_link_name2i(link_cache, ifdevname);
-	if( ifindex < 0 ) {
-		return NULL;
-	}
-
-	/* Create an empty record, where ethernet information will be saved */
-	ethinf = new_etherinfo_record();
-	if( !ethinf ) {
-		return NULL;
-	}
-	ethinf->index = ifindex;
-	ethinf->device = strdup(ifdevname); /* Should extract via libnl - nl_link callback? */
-
-	/* Extract MAC/hardware address of the interface */
-	link = rtnl_link_alloc();
-	rtnl_link_set_ifindex(link, ifindex);
-	nl_cache_foreach_filter(link_cache, (struct nl_object *)link, callback_nl_link, ethinf);
-	rtnl_link_put(link);
-	nl_cache_free(link_cache);
-
-	/* Extract IP address information */
-	addr_cache = rtnl_addr_alloc_cache(handle);
-	addr = rtnl_addr_alloc();
-	rtnl_addr_set_ifindex(addr, ifindex);
-	nl_cache_foreach_filter(addr_cache, (struct nl_object *)addr, callback_nl_address, ethinf);
-	rtnl_addr_put(addr);
-	nl_cache_free(addr_cache);
-
-	/* Close NETLINK connection */
-	nl_close(handle);
-	nl_handle_destroy(handle);
-
-	return ethinf;
-}
+	int ret = 0;
 
-#ifdef TESTPROG
-// Simple standalone test program
-int main(int argc, char **argv) {
-	struct etherinfo *inf = NULL;
-
-	inf = get_etherinfo(argv[1]);
-	if( inf == NULL ) {
-		fprintf(stderr, "Operation failed.  Could not retrieve ethernet information\n");
-		exit(2);
+	if( !ethinf || !nlc ) {
+		return 0;
 	}
-	dump_etherinfo(stdout, inf);
-	free_etherinfo(inf);
 
-	return 0;
+	/* Find the interface index we're looking up.
+	 * As we don't expect it to change, we're reusing a "cached"
+	 * interface index if we have that
+	 */
+	if( ethinf->index < 0 ) {
+		link_cache = rtnl_link_alloc_cache(nlc->nlrt_handle);
+		ethinf->index = rtnl_link_name2i(link_cache, ethinf->device);
+		if( ethinf->index < 0 ) {
+			return 0;
+		}
+		nl_cache_free(link_cache);
+	}
+
+	/* Query the for requested info vai NETLINK */
+	switch( query ) {
+	case NLQRY_LINK:
+		/* Extract MAC/hardware address of the interface */
+		link_cache = rtnl_link_alloc_cache(nlc->nlrt_handle);
+		link = rtnl_link_alloc();
+		rtnl_link_set_ifindex(link, ethinf->index);
+		nl_cache_foreach_filter(link_cache, (struct nl_object *)link, callback_nl_link, ethinf);
+		rtnl_link_put(link);
+		nl_cache_free(link_cache);
+		ret = 1;
+		break;
+
+	case NLQRY_ADDR:
+		/* Extract IP address information */
+		addr_cache = rtnl_addr_alloc_cache(nlc->nlrt_handle);
+		addr = rtnl_addr_alloc();
+		rtnl_addr_set_ifindex(addr, ethinf->index);
+		nl_cache_foreach_filter(addr_cache, (struct nl_object *)addr, callback_nl_address, ethinf);
+		rtnl_addr_put(addr);
+		nl_cache_free(addr_cache);
+		ret = 1;
+		break;
+
+	default:
+		ret = 0;
+	}
+	return ret;
 }
-#endif
+

python-ethtool/etherinfo.h

@@ -17,18 +17,16 @@
 #ifndef _ETHERINFO_H
 #define _ETHERINFO_H
 
-struct etherinfo {
-	int index;
-	char *device;
-	char *hwaddress;
-	char *ipv4_address;
-	int ipv4_netmask;
-	char *ipv4_broadcast;
-	char *ipv6_address;
-	int ipv6_netmask;
-};
+#include <netlink/addr.h>
+#include <netlink/netlink.h>
+#include <netlink/handlers.h>
+#include <netlink/route/link.h>
+#include <netlink/route/addr.h>
+#include <arpa/inet.h>
 
-struct etherinfo *get_etherinfo();
+typedef enum {NLQRY_LINK, NLQRY_ADDR} nlQuery;
+
+int get_etherinfo(struct etherinfo *ethinf, struct _nlconnection *nlc, nlQuery query);
 void free_etherinfo(struct etherinfo *ptr);
 void dump_etherinfo(FILE *, struct etherinfo *);
 

python-ethtool/etherinfo_obj.c

@@ -9,8 +9,9 @@
 
 #include <Python.h>
 #include "structmember.h"
-#include "etherinfo.h"
+
 #include "etherinfo_struct.h"
+#include "etherinfo.h"
 
 
 /**
@@ -20,8 +21,11 @@
  */
 void _ethtool_etherinfo_dealloc(etherinfo_py *self)
 {
-	if( self->info ) {
-		free_etherinfo(self->info);
+	if( self->data ) {
+		if( self->data->ethinfo ) {
+			free_etherinfo(self->data->ethinfo);
+		}
+		free(self->data);
 	}
 	self->ob_type->tp_free((PyObject*)self);
 }
@@ -63,7 +67,7 @@ int _ethtool_etherinfo_init(etherinfo_py *self, PyObject *args, PyObject *kwds)
 		PyErr_SetString(PyExc_AttributeError, "Invalid data pointer to constructor");
 		return -1;
 	}
-	self->info = (struct etherinfo *) PyCObject_AsVoidPtr(ethinf_ptr);
+	self->data = (struct etherinfo_obj_data *) PyCObject_AsVoidPtr(ethinf_ptr);
 	return 0;
 }
 
@@ -86,29 +90,38 @@ int _ethtool_etherinfo_init(etherinfo_py *self, PyObject *args, PyObject *kwds)
  */
 PyObject *_ethtool_etherinfo_getter(etherinfo_py *self, PyObject *attr_o)
 {
+	PyObject *ret;
 	char *attr = PyString_AsString(attr_o);
 
-	if( !self || !self->info ) {
+	if( !self || !self->data ) {
 		PyErr_SetString(PyExc_AttributeError, "No data available");
 		return NULL;
 	}
 
 	if( strcmp(attr, "device") == 0 ) {
-		return RETURN_STRING(self->info->device);
+		ret = RETURN_STRING(self->data->ethinfo->device);
 	} else if( strcmp(attr, "mac_address") == 0 ) {
-		return RETURN_STRING(self->info->hwaddress);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_LINK);
+		ret = RETURN_STRING(self->data->ethinfo->hwaddress);
 	} else if( strcmp(attr, "ipv4_address") == 0 ) {
-		return RETURN_STRING(self->info->ipv4_address);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_LINK);
+		ret = RETURN_STRING(self->data->ethinfo->ipv4_address);
 	} else if( strcmp(attr, "ipv4_netmask") == 0 ) {
-		return PyInt_FromLong(self->info->ipv4_netmask);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_ADDR);
+		ret = PyInt_FromLong(self->data->ethinfo->ipv4_netmask);
 	} else if( strcmp(attr, "ipv4_broadcast") == 0 ) {
-		return RETURN_STRING(self->info->ipv4_broadcast);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_ADDR);
+		ret = RETURN_STRING(self->data->ethinfo->ipv4_broadcast);
 	} else if( strcmp(attr, "ipv6_address") == 0 ) {
-		return RETURN_STRING(self->info->ipv6_address);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_ADDR);
+		ret = RETURN_STRING(self->data->ethinfo->ipv6_address);
 	} else if( strcmp(attr, "ipv6_netmask") == 0 ) {
-		return PyInt_FromLong(self->info->ipv6_netmask);
+		get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_ADDR);
+		ret = PyInt_FromLong(self->data->ethinfo->ipv6_netmask);
+	} else {
+		ret = PyObject_GenericGetAttr((PyObject *)self, attr_o);
 	}
-	return PyObject_GenericGetAttr((PyObject *)self, attr_o);
+	return ret;
 }
 
 
@@ -140,34 +153,37 @@ PyObject *_ethtool_etherinfo_str(etherinfo_py *self)
 {
 	PyObject *ret = NULL;
 
-	if( !self || !self->info ) {
+	if( !self || !self->data || !self->data->nlc || !self->data->ethinfo ) {
 		PyErr_SetString(PyExc_AttributeError, "No data available");
 		return NULL;
 	}
 
-	ret = PyString_FromFormat("Device %s:\n", self->info->device);
-	if( self->info->hwaddress ) {
-		PyObject *tmp = PyString_FromFormat("\tMAC address: %s\n", self->info->hwaddress);
+	get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_LINK);
+	get_etherinfo(self->data->ethinfo, self->data->nlc, NLQRY_ADDR);
+
+	ret = PyString_FromFormat("Device %s:\n", self->data->ethinfo->device);
+	if( self->data->ethinfo->hwaddress ) {
+		PyObject *tmp = PyString_FromFormat("\tMAC address: %s\n", self->data->ethinfo->hwaddress);
 		PyString_Concat(&ret, tmp);
 	}
 
-	if( self->info->ipv4_address ) {
+	if( self->data->ethinfo->ipv4_address ) {
 		PyObject *tmp = PyString_FromFormat("\tIPv4 address: %s/%i",
-						   self->info->ipv4_address,
-						   self->info->ipv4_netmask);
-		if( self->info->ipv4_broadcast ) {
+						   self->data->ethinfo->ipv4_address,
+						   self->data->ethinfo->ipv4_netmask);
+		if( self->data->ethinfo->ipv4_broadcast ) {
 			PyObject *tmp2 = PyString_FromFormat("    Broadcast: %s",
-							     self->info->ipv4_broadcast);
+							     self->data->ethinfo->ipv4_broadcast);
 			PyString_Concat(&tmp, tmp2);
 		}
 		PyString_Concat(&tmp, PyString_FromString("\n"));
 		PyString_Concat(&ret, tmp);
 	}
 
-	if( self->info->ipv6_address ) {
+	if( self->data->ethinfo->ipv6_address ) {
 		PyObject *tmp = PyString_FromFormat("\tIPv6 address: %s/%i\n",
-						   self->info->ipv6_address,
-						   self->info->ipv6_netmask);
+						   self->data->ethinfo->ipv6_address,
+						   self->data->ethinfo->ipv6_netmask);
 		PyString_Concat(&ret, tmp);
 	}
 	return ret;

python-ethtool/etherinfo_obj.h

@@ -36,19 +36,19 @@ static PyMethodDef _ethtool_etherinfo_methods[] = {
  *
  */
 static PyMemberDef _ethtool_etherinfo_members[] = {
-    {"device", T_OBJECT_EX, offsetof(etherinfo_py, info), 0,
+    {"device", T_OBJECT_EX, offsetof(etherinfo_py, data), 0,
      "Device name of the interface"},
-    {"mac_address", T_OBJECT_EX, offsetof(etherinfo_py, info), 0,
+    {"mac_address", T_OBJECT_EX, offsetof(etherinfo_py, data), 0,
      "MAC address / hardware address of the interface"},
-    {"ipv4_address", T_OBJECT_EX, offsetof(etherinfo_py, info), 0,
+    {"ipv4_address", T_OBJECT_EX, offsetof(etherinfo_py, data), 0,
      "IPv4 address"},
-    {"ipv4_netmask", T_INT, offsetof(etherinfo_py, info), 0,
+    {"ipv4_netmask", T_INT, offsetof(etherinfo_py, data), 0,
      "IPv4 netmask in bits"},
-    {"ipv4_broadcast", T_OBJECT_EX, offsetof(etherinfo_py, info), 0,
+    {"ipv4_broadcast", T_OBJECT_EX, offsetof(etherinfo_py, data), 0,
      "IPv4 broadcast address"},
-    {"ipv6_address", T_OBJECT_EX, offsetof(etherinfo_py, info), 0,
+    {"ipv6_address", T_OBJECT_EX, offsetof(etherinfo_py, data), 0,
      "IPv6 address"},
-    {"ipv6_netmask", T_INT, offsetof(etherinfo_py, info), 0,
+    {"ipv6_netmask", T_INT, offsetof(etherinfo_py, data), 0,
      "IPv6 netmask in bits"},
     {NULL}  /* End of member list */
 };