This patch provides Python dlpi support.  It may be contributed upstream at

some point, but the suitability (or lack thereof) has not yet been determined.

--- /dev/null

+++ Python-2.6.4/Modules/dlpimodule.c

@@ -0,0 +1,1205 @@

+/*

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to

+ * deal in the Software without restriction, including without limitation the

+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

+ * sell copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

+ * DEALINGS IN THE SOFTWARE.

+ *

+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

+ */

+

+#include <Python.h>

+#include <stdio.h>

+#include <libdlpi.h>

+

+typedef struct {

+	PyObject_HEAD

+	dlpi_handle_t dlpihdl;

+} pylink_t;

+

+typedef struct {

+	PyObject *pyfunc;

+	PyObject *pyarg;

+} callback_data_t;

+

+/*

+ * dlpi_err: the only exception raised for libdlpi related error.

+ * The accompanying value is:

+ * (dlpi_error_number, string), when it's a dlpi specific error,

+ * or, (DL_SYSERR, errno, string), when it's coming from a system call.

+ */

+static PyObject *dlpi_err;

+

+static void

+dlpi_raise_exception(int err)

+{

+	PyObject *e = NULL;

+

+	if (err == DL_SYSERR) {

+		e = Py_BuildValue("(iis)", DL_SYSERR, errno, strerror(errno));

+	} else {

+		e = Py_BuildValue("(is)", err, dlpi_strerror(err));

+	}

+	if (e != NULL) {

+		PyErr_SetObject(dlpi_err, e);

+		Py_DECREF(e);

+	}

+}

+

+PyDoc_STRVAR(link_doc,

+    "link(linkname[, flags]) -> link object\n"

+    "\n"

+    "Open linkname with specified flags.\n"

+    "Three flags are supported: PASSIVE, RAW, NATIVE.\n"

+    "And these flags can be bitwise-OR'ed together(default flag is 0).\n"

+    "You need sys_net_rawaccess privilege to open a link.\n"

+    "See dlpi_open(3DLPI).\n"

+);

+static int

+link_init(PyObject *self, PyObject *args, PyObject *kwds)

+{

+	uint_t flags = 0;

+	dlpi_handle_t dh;

+	char *linkname;

+	int rval;

+	static char *keywords[] = {"linkname", "flags", NULL};

+	pylink_t *link = (pylink_t *)self;

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|I", keywords,

+	    &linkname, &flags))

+		return (-1);

+

+	if ((rval = dlpi_open(linkname, &dh, flags)) != DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (-1);

+	}

+

+	link->dlpihdl = dh;

+

+	return (0);

+}

+

+static void

+link_dealloc(pylink_t *link)

+{

+	if (link->dlpihdl != NULL)

+		dlpi_close(link->dlpihdl);

+	link->ob_type->tp_free((PyObject *)link);

+}

+

+PyDoc_STRVAR(bind_doc,

+    "bind(sap) -> unsigned int\n"

+    "\n"

+    "Attempts to bind the link to specified SAP, or ANY_SAP.\n"

+    "Returns the SAP that the function actually bound to, which\n"

+    "could be different from the SAP requested.\n"

+    "See dlpi_bind(3DLPI).\n"

+);

+static PyObject *

+link_bind(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	uint_t sap = 0, boundsap = 0;

+	static char *keywords[] = {"sap", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &sap))

+		return (NULL);

+

+	if ((rval = dlpi_bind(link->dlpihdl, sap, &boundsap)) !=

+	    DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	return (Py_BuildValue("I", boundsap));

+}

+

+PyDoc_STRVAR(unbind_doc,

+    "unbind() -> None\n"

+    "\n"

+    "Attempts to unbind the link from previously bound sap.\n"

+    "See dlpi_unbind(3DLPI).\n"

+);

+static PyObject *

+link_unbind(pylink_t *link)

+{

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if ((rval = dlpi_unbind(link->dlpihdl)) != DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	Py_INCREF(Py_None);

+	return (Py_None);

+}

+

+PyDoc_STRVAR(send_doc,

+    "send(destaddr, message[, sap, minpri, maxpri]) -> None\n"

+    "\n"

+    "Attempts to send message over this link to sap on destaddr.\n"

+    "If SAP is not specified, the bound SAP is used\n"

+    "You can also specify priority range (minpri, maxpri).\n"

+    "See dlpi_send(3DLPI).\n"

+);

+static PyObject *

+link_send(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	char *daddr = NULL, *msgbuf = NULL;

+	size_t daddrlen = 0, msglen = 0;

+	t_scalar_t minpri = DL_QOS_DONT_CARE, maxpri = DL_QOS_DONT_CARE;

+	uint_t sap = DLPI_ANY_SAP;

+	dlpi_sendinfo_t ds, *dsp = NULL;

+	static char *keywords[] =

+	    {"destaddr", "message", "sap", "minpri", "maxpri", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#s#|Iii", keywords,

+	    &daddr, &daddrlen, &msgbuf, &msglen, &sap, &minpri, &maxpri))

+		return (NULL);

+

+	if ((sap != DLPI_ANY_SAP) || (minpri != DL_QOS_DONT_CARE) ||

+	    (maxpri != DL_QOS_DONT_CARE)) {

+		ds.dsi_sap = sap;

+		ds.dsi_prio.dl_min = minpri;

+		ds.dsi_prio.dl_max = maxpri;

+		dsp = &ds;

+	}

+

+	if ((rval = dlpi_send(link->dlpihdl, daddr, daddrlen,

+	    msgbuf, msglen, dsp)) != DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	Py_INCREF(Py_None);

+	return (Py_None);

+}

+

+PyDoc_STRVAR(recv_doc,

+    "recv(msglen[, timeout]) -> (string, string), or (None, None)\n"

+    "\n"

+    "Attempts to receive message over this link.\n"

+    "You need to specify the message length for the received message.\n"

+    "And you can specify timeout value in milliseconds.\n"

+    "The default timeout value is -1 (wait forever).\n"

+    "Returns (source address, message data), or (None, None) when error occurs.\n"

+    "See dlpi_recv(3DLPI).\n"

+);

+static PyObject *

+link_recv(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	PyObject *obj;

+	char *saddr = NULL, *msgbuf = NULL;

+	size_t saddrlen = 0, msglen = 0, *saddrlenp = NULL, *msglenp = NULL;

+	int msec = -1; /* block until receive data */

+	static char *keywords[] = {"msglen", "timeout", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "k|i",

+	    keywords, &msglen, &msec))

+		return (NULL);

+

+	if (msglen > 0) {

+		msgbuf = malloc(msglen);

+		if (msgbuf == NULL) {

+			dlpi_raise_exception(DL_SYSERR);

+			return (NULL);

+		}

+		saddrlen = DLPI_PHYSADDR_MAX;

+		saddr = malloc(saddrlen);

+		if (saddr == NULL) {

+			dlpi_raise_exception(DL_SYSERR);

+			free(msgbuf);

+			return (NULL);

+		}

+		msglenp = &msglen;

+		saddrlenp = &saddrlen;

+	}

+

+	if ((rval = dlpi_recv(link->dlpihdl, saddr, saddrlenp, msgbuf,

+	    msglenp, msec, NULL)) != DLPI_SUCCESS) {

+		if (msgbuf != NULL)

+			free(msgbuf);

+		if (saddr != NULL)

+			free(saddr);

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	obj = Py_BuildValue("s#s#", saddr, saddrlen, msgbuf, msglen);

+	if (msgbuf != NULL)

+		free(msgbuf);

+	if (saddr != NULL)

+		free(saddr);

+	return (obj);

+}

+

+PyDoc_STRVAR(disabmulti_doc,

+    "disabmulti(address) -> None\n"

+    "\n"

+    "Disable a specified multicast address on this link.\n"

+    "See dlpi_disabmulti(3DLPI).\n"

+);

+static PyObject *

+link_disabmulti(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	char *addr = NULL;

+	size_t addrlen = 0;

+	static char *keywords[] = {"address", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords,

+	    &addr, &addrlen))

+		return (NULL);

+

+	if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if ((rval = dlpi_disabmulti(link->dlpihdl, addr, addrlen)) !=

+	    DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	Py_INCREF(Py_None);

+	return (Py_None);

+}

+

+PyDoc_STRVAR(enabmulti_doc,

+    "enabmulti(address) -> None\n"

+    "\n"

+    "Enable a specified multicast address on this link.\n"

+    "See dlpi_enabmulti(3DLPI).\n"

+);

+static PyObject *

+link_enabmulti(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	char *addr = NULL;

+	size_t addrlen = 0;

+	static char *keywords[] = {"address", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords,

+	    &addr, &addrlen))

+		return (NULL);

+

+	if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if ((rval = dlpi_enabmulti(link->dlpihdl, addr, addrlen)) !=

+	    DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	Py_INCREF(Py_None);

+	return (Py_None);

+}

+

+static void

+dlpi_callback(dlpi_handle_t hdl, dlpi_notifyinfo_t *ni, void *arg)

+{

+	callback_data_t *cd = (callback_data_t *)arg;

+	PyObject *arglist, *result;

+

+	switch (ni->dni_note) {

+	case DL_NOTE_SPEED:

+		arglist = Py_BuildValue("(OII)",

+		    cd->pyarg, ni->dni_note, ni->dni_speed);

+		break;

+	case DL_NOTE_SDU_SIZE:

+		arglist = Py_BuildValue("(OII)",

+		    cd->pyarg, ni->dni_note, ni->dni_size);

+		break;

+	case DL_NOTE_PHYS_ADDR:

+		arglist = Py_BuildValue("(OIs#)",

+		    cd->pyarg, ni->dni_note, ni->dni_physaddr,

+		    ni->dni_physaddrlen);

+		break;

+	default:

+		arglist = Py_BuildValue("(OIO)", cd->pyarg, ni->dni_note,

+		    Py_None);

+	}

+

+	result = PyEval_CallObject(cd->pyfunc, arglist);

+	Py_DECREF(arglist);

+	if (result == NULL) {

+		PyErr_Clear(); /* cannot raise error */

+	}

+	Py_DECREF(result);

+	Py_DECREF(cd->pyfunc);

+	Py_XDECREF(cd->pyarg);

+	free(cd);

+}

+

+PyDoc_STRVAR(enabnotify_doc,

+    "enabnotify(events, function[, arg]) -> unsigned long\n"

+    "\n"

+    "Enables a notification callback for the set of specified events,\n"

+    "which must be one or more (by a logical OR) events listed as below:\n"

+    "NOTE_LINK_DOWN         Notify when link has gone down\n"

+    "NOTE_LINK_UP           Notify when link has come up\n"

+    "NOTE_PHYS_ADDR         Notify when address changes\n"

+    "NOTE_SDU_SIZE          Notify when MTU changes\n"

+    "NOTE_SPEED             Notify when speed changes\n"

+    "NOTE_PROMISC_ON_PHYS   Notify when PROMISC_PHYS is set\n"

+    "NOTE_PROMISC_OFF_PHYS  Notify when PROMISC_PHYS is cleared\n"

+    "Returns a handle for this registration.\n"

+    "See dlpi_enabnotify(3DLPI).\n"

+);

+static PyObject *

+link_enabnotify(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	PyObject *func = NULL, *arg = NULL;

+	callback_data_t *cd;

+	uint_t notes = 0;

+	static char *keywords[] = {"events", "function", "arg", NULL};

+	dlpi_notifyid_t id;

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "IO|O",

+	    keywords, &notes, &func, &arg))

+		return (NULL);

+

+	if (!PyCallable_Check(func)) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	cd = malloc(sizeof(callback_data_t));

+	if (cd == NULL) {

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+	Py_INCREF(func);

+	Py_XINCREF(arg);

+	cd->pyfunc = func;

+	cd->pyarg = arg;

+

+	if ((rval = dlpi_enabnotify(link->dlpihdl, notes, dlpi_callback,

+	    cd, &id)) != DLPI_SUCCESS) {

+		free(cd);

+		Py_DECREF(func);

+		Py_XDECREF(arg);

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	return (Py_BuildValue("k", id));

+}

+

+PyDoc_STRVAR(disabnotify_doc,

+    "disabnotify(handle) -> argument object, or None\n"

+    "\n"

+    "Disables the notification registration associated with handle.\n"

+    "You should get this handle by calling enabnotify().\n"

+    "Returns the argument passed in when registering the callback, or None.\n"

+    "See dlpi_disabnotify(3DLPI).\n"

+);

+static PyObject *

+link_disabnotify(pylink_t *link, PyObject *args, PyObject *kwds)

+{

+	dlpi_notifyid_t id;

+	callback_data_t *arg;

+	PyObject *pyargsaved;

+	static char *keywords[] = {"handle", NULL};

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "k", keywords, &id))

+		return (NULL);

+

+	if ((rval = dlpi_disabnotify(link->dlpihdl, id, (void **)&arg)) !=

+	    DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+

+	/* clean up */

+	pyargsaved = arg->pyarg;

+	Py_XINCREF(pyargsaved);

+	Py_XDECREF(arg->pyarg);

+	Py_DECREF(arg->pyfunc);

+	free(arg);

+

+	if (pyargsaved != NULL)

+		return (pyargsaved);

+

+	Py_INCREF(Py_None);

+	return (Py_None);

+}

+

+PyDoc_STRVAR(get_sap_doc,

+    "get_sap() -> unsigned int\n"

+    "\n"

+    "Returns the sap bound to this link.\n"

+    "See dlpi_info(3DLPI).\n"

+);

+static PyObject *

+link_get_sap(pylink_t *link)

+{

+	dlpi_info_t info;

+	int rval;

+

+	if (link->dlpihdl == NULL) {

+		errno = EINVAL;

+		dlpi_raise_exception(DL_SYSERR);

+		return (NULL);

+	}

+

+	if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=

+	    DLPI_SUCCESS) {

+		dlpi_raise_exception(rval);

+		return (NULL);

+	}

+