Improved IPv6 support

As the IPv6 protocol allows a single device to have more than one IPv6 address,
the previous implementation did not provide all IPv6 information.  It would reject
all except the last parsed IPv6 address.

NOTE: This implementation will break the previous API.

This change removes the ethtool.etherinfo.ipv6_address and
ethtool.etherinfo.ipv6_netmask members.  A new member is added,
ethtool.etherinfo.ipv6_addresses (in plural).  This contains a tupple list
containing of ethtool.etherinfo_ipv6addr objects, one object for each configured
IPv6 address on the device.  These objects have the following members available:

  .address       - The IPv6 address
  .netmask       - The IPv6 netmask (in bit notation)
  .scope         - A string with the IPv6 address scope

Example code:

	import ethtool

	devs = ethtool.get_interfaces_info('eth0')
	for ip6 in devs[0].ipv6_addresses:
	    print "[%s] %s/%i" % (ip6.scope, ip6.address, ip6.netmask)

Signed-off-by: David Sommerseth <davids@redhat.com>

Author: David Sommerseth

python-ethtool/etherinfo.c

@@ -24,6 +24,7 @@
 #include <stdlib.h>
 #include <asm/types.h>
 #include <sys/socket.h>
+#include <netlink/route/rtnl.h>
 #include <assert.h>
 #include <errno.h>
 #include "etherinfo_struct.h"
@@ -34,6 +35,30 @@
  *   Internal functions for working with struct etherinfo
  *
  */
+#define SET_STR_VALUE(dst, src) {	 \
+	if( dst ) {		 \
+		free(dst);	 \
+	};			 \
+	dst = strdup(src);	 \
+	}
+
+
+void free_ipv6addresses(struct ipv6address *ptr) {
+	struct ipv6address *ipv6ptr = ptr;
+
+	if( !ptr ) {
+		return;
+	}
+
+	while( ipv6ptr ) {
+		struct ipv6address *tmp = ipv6ptr->next;
+
+		free(ipv6ptr->address);
+		free(ipv6ptr);
+		ipv6ptr = tmp;
+	}
+}
+
 void free_etherinfo(struct etherinfo *ptr)
 {
 	if( ptr == NULL ) { // Just for safety
@@ -51,25 +76,35 @@ void free_etherinfo(struct etherinfo *ptr)
 	if( ptr->ipv4_broadcast ) {
 		free(ptr->ipv4_broadcast);
 	}
-	if( ptr->ipv6_address ) {
-		free(ptr->ipv6_address);
+	if( ptr->ipv6_addresses ) {
+		free_ipv6addresses(ptr->ipv6_addresses);
 	}
 	free(ptr);
 }
 
+struct ipv6address * etherinfo_add_ipv6(struct ipv6address *addrptr, const char *addr, int netmask, int scope) {
+	struct ipv6address *newaddr = NULL;
+
+	newaddr = calloc(1, sizeof(struct ipv6address)+2);
+	if( !newaddr ) {
+		fprintf(stderr, "** ERROR ** Could not allocate memory for a new IPv6 address record (%s/%i [%i])",
+			addr, netmask, scope);
+		return addrptr;
+	}
+
+	SET_STR_VALUE(newaddr->address, addr);
+	newaddr->netmask = netmask;
+	newaddr->scope = scope;
+	newaddr->next = addrptr;
+	return newaddr;
+}
+
 
 /*
  *  libnl callback functions
  *
  */
 
-#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;
@@ -134,8 +169,10 @@ static void callback_nl_address(struct nl_object *obj, void *arg)
 				SET_STR_VALUE(ethi->ipv4_broadcast, brdcst_str);
 			}
 		} else {
-			SET_STR_VALUE(ethi->ipv6_address, ip_str);
-			ethi->ipv6_netmask = rtnl_addr_get_prefixlen((struct rtnl_addr*) obj);
+			ethi->ipv6_addresses = etherinfo_add_ipv6(ethi->ipv6_addresses,
+								  ip_str,
+								  rtnl_addr_get_prefixlen((struct rtnl_addr*) obj),
+								  rtnl_addr_get_scope((struct rtnl_addr*) obj));
 		}
 		return;
 	default:
@@ -167,9 +204,17 @@ void dump_etherinfo(FILE *fp, struct etherinfo *ptr)
 		}
 		fprintf(fp, "\n");
 	}
-	if( ptr->ipv6_address ) {
-		fprintf(fp, "\tIPv6 address: %s/%i\n",
-			ptr->ipv6_address, ptr->ipv6_netmask);
+	if( ptr->ipv6_addresses ) {
+		struct ipv6address *ipv6 = ptr->ipv6_addresses;
+
+		fprintf(fp, "\tIPv6 addresses:\n");
+		for(; ipv6; ipv6 = ipv6->next) {
+			char scope[66];
+
+			rtnl_scope2str(ipv6->scope, scope, 64);
+			fprintf(fp, "\t		       [%s] %s/%i\n",
+				scope, ipv6->address, ipv6->netmask);
+		}
 	}
 	fprintf(fp, "\n");
 }
@@ -214,6 +259,10 @@ int get_etherinfo(struct etherinfo *ethinf, struct _nlconnection *nlc, nlQuery q
 		break;
 
 	case NLQRY_ADDR:
+		/* Remove old IPv6 information we might have */
+		free_ipv6addresses(ethinf->ipv6_addresses);
+		ethinf->ipv6_addresses = NULL;
+
 		/* Extract IP address information */
 		addr_cache = rtnl_addr_alloc_cache(nlc->nlrt_handle);
 		addr = rtnl_addr_alloc();

python-ethtool/etherinfo.h

@@ -30,4 +30,6 @@ int get_etherinfo(struct etherinfo *ethinf, struct _nlconnection *nlc, nlQuery q
 void free_etherinfo(struct etherinfo *ptr);
 void dump_etherinfo(FILE *, struct etherinfo *);
 
+void free_ipv6addresses(struct ipv6address *ptr);
+
 #endif

python-ethtool/etherinfo_ipv6_obj.c

@@ -0,0 +1,215 @@
+/**
+ * @file   etherinfo_ipv6_obj.c
+ * @author David Sommerseth <davids@redhat.com>
+ * @date   Thu Jul 29 17:51:28 2010
+ *
+ * @brief  Python ethtool.etherinfo class functions.
+ *
+ */
+
+#include <Python.h>
+#include "structmember.h"
+
+#include <netlink/route/rtnl.h>
+#include "etherinfo_struct.h"
+#include "etherinfo.h"
+
+
+/**
+ * ethtool.etherinfo deallocator - cleans up when a object is deleted
+ *
+ * @param self etherinfo_ipv6_py object structure
+ */
+void _ethtool_etherinfo_ipv6_dealloc(etherinfo_ipv6_py *self)
+{
+	if( self->addrdata ) {
+		free_ipv6addresses(self->addrdata);
+	}
+	self->ob_type->tp_free((PyObject*)self);
+}
+
+
+/**
+ * ethtool.etherinfo function, creating a new etherinfo object
+ *
+ * @param type
+ * @param args
+ * @param kwds
+ *
+ * @return Returns in PyObject with the new object on success, otherwise NULL
+ */
+PyObject *_ethtool_etherinfo_ipv6_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	etherinfo_ipv6_py *self;
+
+	self = (etherinfo_ipv6_py *)type->tp_alloc(type, 0);
+	return (PyObject *)self;
+}
+
+
+/**
+ * ethtool.etherinfo init (constructor) method.  Makes sure the object is initialised correctly.
+ *
+ * @param self
+ * @param args
+ * @param kwds
+ *
+ * @return Returns 0 on success.
+ */
+int _ethtool_etherinfo_ipv6_init(etherinfo_ipv6_py *self, PyObject *args, PyObject *kwds)
+{
+	static char *etherinfo_kwlist[] = {"etherinfo_ipv6_ptr", NULL};
+	PyObject *ethinf_ptr = NULL;
+
+	if( !PyArg_ParseTupleAndKeywords(args, kwds, "O", etherinfo_kwlist, &ethinf_ptr)) {
+		PyErr_SetString(PyExc_AttributeError, "Invalid data pointer to constructor");
+		return -1;
+	}
+	self->addrdata = (struct ipv6address *) PyCObject_AsVoidPtr(ethinf_ptr);
+	return 0;
+}
+
+/**
+ * ethtool.etherinfo function for retrieving data from a Python object.
+ *
+ * @param self
+ * @param attr_o  contains the object member request (which element to return)
+ *
+ * @return Returns a PyObject with the value requested on success, otherwise NULL
+ */
+PyObject *_ethtool_etherinfo_ipv6_getter(etherinfo_ipv6_py *self, PyObject *attr_o)
+{
+	PyObject *ret;
+	char *attr = PyString_AsString(attr_o);
+
+	if( !self || !self->addrdata ) {
+		PyErr_SetString(PyExc_AttributeError, "No data available");
+		return NULL;
+	}
+
+	if( strcmp(attr, "address") == 0 ) {
+		ret = RETURN_STRING(self->addrdata->address);
+	} else if( strcmp(attr, "netmask") == 0 ) {
+		ret = PyInt_FromLong(self->addrdata->netmask);
+	} else if( strcmp(attr, "scope") == 0 ) {
+		char scope[66];
+
+		rtnl_scope2str(self->addrdata->scope, scope, 66);
+		ret = PyString_FromString(scope);
+	} else {
+		ret = PyObject_GenericGetAttr((PyObject *)self, attr_o);
+	}
+	return ret;
+}
+
+
+/**
+ * ethtool.etherinfo function for setting a value to a object member.  This feature is
+ * disabled by always returning -1, as the values are read-only by the user.
+ *
+ * @param self
+ * @param attr_o
+ * @param val_o
+ *
+ * @return Returns always -1 (failure).
+ */
+int _ethtool_etherinfo_ipv6_setter(etherinfo_ipv6_py *self, PyObject *attr_o, PyObject *val_o)
+{
+	PyErr_SetString(PyExc_AttributeError, "etherinfo_ipv6addr member values are read-only.");
+	return -1;
+}
+
+
+/**
+ * Creates a human readable format of the information when object is being treated as a string
+ *
+ * @param self
+ *
+ * @return Returns a PyObject with a string with all of the information
+ */
+PyObject *_ethtool_etherinfo_ipv6_str(etherinfo_ipv6_py *self)
+{
+	char scope[66];
+
+	if( !self || !self->addrdata ) {
+		PyErr_SetString(PyExc_AttributeError, "No data available");
+		return NULL;
+	}
+
+	rtnl_scope2str(self->addrdata->scope, scope, 64);
+	return PyString_FromFormat("[%s] %s/%i\n",
+				   scope,
+				   self->addrdata->address,
+				   self->addrdata->netmask);
+}
+
+
+/**
+ * This is required by Python, which lists all accessible methods
+ * in the object.  But no methods are provided.
+ *
+ */
+static PyMethodDef _ethtool_etherinfo_ipv6_methods[] = {
+    {NULL}  /**< No methods defined */
+};
+
+/**
+ * Defines all accessible object members
+ *
+ */
+static PyMemberDef _ethtool_etherinfo_ipv6_members[] = {
+    {"address", T_OBJECT_EX, offsetof(etherinfo_ipv6_py, addrdata), 0,
+     "IPv6 address"},
+    {"netmask", T_OBJECT_EX, offsetof(etherinfo_ipv6_py, addrdata), 0,
+     "IPv6 netmask"},
+    {"scope", T_OBJECT_EX, offsetof(etherinfo_ipv6_py, addrdata), 0,
+     "IPv6 IP address scope"},
+    {NULL}  /* End of member list */
+};
+
+/**
+ * Definition of the functions a Python class/object requires.
+ *
+ */
+PyTypeObject ethtool_etherinfoIPv6Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,                         /*ob_size*/
+    "ethtool.etherinfo_ipv6addr", /*tp_name*/
+    sizeof(etherinfo_ipv6_py), /*tp_basicsize*/
+    0,                         /*tp_itemsize*/
+    (destructor)_ethtool_etherinfo_ipv6_dealloc,/*tp_dealloc*/
+    0,                         /*tp_print*/
+    0,                         /*tp_getattr*/
+    0,                         /*tp_setattr*/
+    0,                         /*tp_compare*/
+    0,                         /*tp_repr*/
+    0,                         /*tp_as_number*/
+    0,                         /*tp_as_sequence*/
+    0,                         /*tp_as_mapping*/
+    0,                         /*tp_hash */
+    0,                         /*tp_call*/
+    (reprfunc)_ethtool_etherinfo_ipv6_str,        /*tp_str*/
+    (getattrofunc)_ethtool_etherinfo_ipv6_getter, /*tp_getattro*/
+    (setattrofunc)_ethtool_etherinfo_ipv6_setter, /*tp_setattro*/
+    0,                         /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+    "IPv6 address information", /* tp_doc */
+    0,		               /* tp_traverse */
+    0,		               /* tp_clear */
+    0,		               /* tp_richcompare */
+    0,		               /* tp_weaklistoffset */
+    0,		               /* tp_iter */
+    0,		               /* tp_iternext */
+    _ethtool_etherinfo_ipv6_methods,            /* tp_methods */
+    _ethtool_etherinfo_ipv6_members,            /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    (initproc)_ethtool_etherinfo_ipv6_init,     /* tp_init */
+    0,                         /* tp_alloc */
+    _ethtool_etherinfo_ipv6_new,                /* tp_new */
+};
+