1 diff --git Python-2.6.4/Modules/dlpimodule.c Python-2.6.4/Modules/dlpimodule.c
2 new file mode 100644
3 --- /dev/null
4 +++ Python-2.6.4/Modules/dlpimodule.c
5 @@ -0,0 +1,1206 @@
6 +/*
7 + * Permission is hereby granted, free of charge, to any person obtaining a copy
8 + * of this software and associated documentation files (the "Software"), to
9 + * deal in the Software without restriction, including without limitation the
10 + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
11 + * sell copies of the Software, and to permit persons to whom the Software is
12 + * furnished to do so, subject to the following conditions:
13 + *
14 + * The above copyright notice and this permission notice shall be included in
15 + * all copies or substantial portions of the Software.
16 + *
17 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 + * DEALINGS IN THE SOFTWARE.
24 + *
25 + * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
26 + * Use is subject to license terms.
27 + */
28 +
29 +#include <Python.h>
30 +#include <stdio.h>
31 +#include <libdlpi.h>
32 +
33 +typedef struct {
34 + PyObject_HEAD
35 + dlpi_handle_t dlpihdl;
36 +} pylink_t;
37 +
38 +typedef struct {
39 + PyObject *pyfunc;
40 + PyObject *pyarg;
41 +} callback_data_t;
42 +
43 +/*
44 + * dlpi_err: the only exception raised for libdlpi related error.
45 + * The accompanying value is:
46 + * (dlpi_error_number, string), when it's a dlpi specific error,
47 + * or, (DL_SYSERR, errno, string), when it's coming from a system call.
48 + */
49 +static PyObject *dlpi_err;
50 +
51 +static void
52 +dlpi_raise_exception(int err)
53 +{
54 + PyObject *e = NULL;
55 +
56 + if (err == DL_SYSERR) {
57 + e = Py_BuildValue("(iis)", DL_SYSERR, errno, strerror(errno));
58 + } else {
59 + e = Py_BuildValue("(is)", err, dlpi_strerror(err));
60 + }
61 + if (e != NULL) {
62 + PyErr_SetObject(dlpi_err, e);
63 + Py_DECREF(e);
64 + }
65 +}
66 +
67 +PyDoc_STRVAR(link_doc,
68 + "link(linkname[, flags]) -> link object\n"
69 + "\n"
70 + "Open linkname with specified flags.\n"
71 + "Three flags are supported: PASSIVE, RAW, NATIVE.\n"
72 + "And these flags can be bitwise-OR'ed together(default flag is 0).\n"
73 + "You need sys_net_rawaccess privilege to open a link.\n"
74 + "See dlpi_open(3DLPI).\n"
75 +);
76 +static int
77 +link_init(PyObject *self, PyObject *args, PyObject *kwds)
78 +{
79 + uint_t flags = 0;
80 + dlpi_handle_t dh;
81 + char *linkname;
82 + int rval;
83 + static char *keywords[] = {"linkname", "flags", NULL};
84 + pylink_t *link = (pylink_t *)self;
85 +
86 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|I", keywords,
87 + &linkname, &flags))
88 + return (-1);
89 +
90 + if ((rval = dlpi_open(linkname, &dh, flags)) != DLPI_SUCCESS) {
91 + dlpi_raise_exception(rval);
92 + return (-1);
93 + }
94 +
95 + link->dlpihdl = dh;
96 +
97 + return (0);
98 +}
99 +
100 +static void
101 +link_dealloc(pylink_t *link)
102 +{
103 + if (link->dlpihdl != NULL)
104 + dlpi_close(link->dlpihdl);
105 + link->ob_type->tp_free((PyObject *)link);
106 +}
107 +
108 +PyDoc_STRVAR(bind_doc,
109 + "bind(sap) -> unsigned int\n"
110 + "\n"
111 + "Attempts to bind the link to specified SAP, or ANY_SAP.\n"
112 + "Returns the SAP that the function actually bound to, which\n"
113 + "could be different from the SAP requested.\n"
114 + "See dlpi_bind(3DLPI).\n"
115 +);
116 +static PyObject *
117 +link_bind(pylink_t *link, PyObject *args, PyObject *kwds)
118 +{
119 + uint_t sap = 0, boundsap = 0;
120 + static char *keywords[] = {"sap", NULL};
121 + int rval;
122 +
123 + if (link->dlpihdl == NULL) {
124 + errno = EINVAL;
125 + dlpi_raise_exception(DL_SYSERR);
126 + return (NULL);
127 + }
128 +
129 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &sap))
130 + return (NULL);
131 +
132 + if ((rval = dlpi_bind(link->dlpihdl, sap, &boundsap)) !=
133 + DLPI_SUCCESS) {
134 + dlpi_raise_exception(rval);
135 + return (NULL);
136 + }
137 +
138 + return (Py_BuildValue("I", boundsap));
139 +}
140 +
141 +PyDoc_STRVAR(unbind_doc,
142 + "unbind() -> None\n"
143 + "\n"
144 + "Attempts to unbind the link from previously bound sap.\n"
145 + "See dlpi_unbind(3DLPI).\n"
146 +);
147 +static PyObject *
148 +link_unbind(pylink_t *link)
149 +{
150 + int rval;
151 +
152 + if (link->dlpihdl == NULL) {
153 + errno = EINVAL;
154 + dlpi_raise_exception(DL_SYSERR);
155 + return (NULL);
156 + }
157 +
158 + if ((rval = dlpi_unbind(link->dlpihdl)) != DLPI_SUCCESS) {
159 + dlpi_raise_exception(rval);
160 + return (NULL);
161 + }
162 +
163 + Py_INCREF(Py_None);
164 + return (Py_None);
165 +}
166 +
167 +PyDoc_STRVAR(send_doc,
168 + "send(destaddr, message[, sap, minpri, maxpri]) -> None\n"
169 + "\n"
170 + "Attempts to send message over this link to sap on destaddr.\n"
171 + "If SAP is not specified, the bound SAP is used\n"
172 + "You can also specify priority range (minpri, maxpri).\n"
173 + "See dlpi_send(3DLPI).\n"
174 +);
175 +static PyObject *
176 +link_send(pylink_t *link, PyObject *args, PyObject *kwds)
177 +{
178 + char *daddr = NULL, *msgbuf = NULL;
179 + size_t daddrlen = 0, msglen = 0;
180 + t_scalar_t minpri = DL_QOS_DONT_CARE, maxpri = DL_QOS_DONT_CARE;
181 + uint_t sap = DLPI_ANY_SAP;
182 + dlpi_sendinfo_t ds, *dsp = NULL;
183 + static char *keywords[] =
184 + {"destaddr", "message", "sap", "minpri", "maxpri", NULL};
185 + int rval;
186 +
187 + if (link->dlpihdl == NULL) {
188 + errno = EINVAL;
189 + dlpi_raise_exception(DL_SYSERR);
190 + return (NULL);
191 + }
192 +
193 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#s#|Iii", keywords,
194 + &daddr, &daddrlen, &msgbuf, &msglen, &sap, &minpri, &maxpri))
195 + return (NULL);
196 +
197 + if ((sap != DLPI_ANY_SAP) || (minpri != DL_QOS_DONT_CARE) ||
198 + (maxpri != DL_QOS_DONT_CARE)) {
199 + ds.dsi_sap = sap;
200 + ds.dsi_prio.dl_min = minpri;
201 + ds.dsi_prio.dl_max = maxpri;
202 + dsp = &ds;
203 + }
204 +
205 + if ((rval = dlpi_send(link->dlpihdl, daddr, daddrlen,
206 + msgbuf, msglen, dsp)) != DLPI_SUCCESS) {
207 + dlpi_raise_exception(rval);
208 + return (NULL);
209 + }
210 +
211 + Py_INCREF(Py_None);
212 + return (Py_None);
213 +}
214 +
215 +PyDoc_STRVAR(recv_doc,
216 + "recv(msglen[, timeout]) -> (string, string), or (None, None)\n"
217 + "\n"
218 + "Attempts to receive message over this link.\n"
219 + "You need to specify the message length for the received message.\n"
220 + "And you can specify timeout value in milliseconds.\n"
221 + "The default timeout value is -1 (wait forever).\n"
222 + "Returns (source address, message data), or (None, None) when error occurs.\n"
223 + "See dlpi_recv(3DLPI).\n"
224 +);
225 +static PyObject *
226 +link_recv(pylink_t *link, PyObject *args, PyObject *kwds)
227 +{
228 + PyObject *obj;
229 + char *saddr = NULL, *msgbuf = NULL;
230 + size_t saddrlen = 0, msglen = 0, *saddrlenp = NULL, *msglenp = NULL;
231 + int msec = -1; /* block until receive data */
232 + static char *keywords[] = {"msglen", "timeout", NULL};
233 + int rval;
234 +
235 + if (link->dlpihdl == NULL) {
236 + errno = EINVAL;
237 + dlpi_raise_exception(DL_SYSERR);
238 + return (NULL);
239 + }
240 +
241 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "k|i",
242 + keywords, &msglen, &msec))
243 + return (NULL);
244 +
245 + if (msglen > 0) {
246 + msgbuf = malloc(msglen);
247 + if (msgbuf == NULL) {
248 + dlpi_raise_exception(DL_SYSERR);
249 + return (NULL);
250 + }
251 + saddrlen = DLPI_PHYSADDR_MAX;
252 + saddr = malloc(saddrlen);
253 + if (saddr == NULL) {
254 + dlpi_raise_exception(DL_SYSERR);
255 + free(msgbuf);
256 + return (NULL);
257 + }
258 + msglenp = &msglen;
259 + saddrlenp = &saddrlen;
260 + }
261 +
262 + if ((rval = dlpi_recv(link->dlpihdl, saddr, saddrlenp, msgbuf,
263 + msglenp, msec, NULL)) != DLPI_SUCCESS) {
264 + if (msgbuf != NULL)
265 + free(msgbuf);
266 + if (saddr != NULL)
267 + free(saddr);
268 + dlpi_raise_exception(rval);
269 + return (NULL);
270 + }
271 +
272 + obj = Py_BuildValue("s#s#", saddr, saddrlen, msgbuf, msglen);
273 + if (msgbuf != NULL)
274 + free(msgbuf);
275 + if (saddr != NULL)
276 + free(saddr);
277 + return (obj);
278 +}
279 +
280 +PyDoc_STRVAR(disabmulti_doc,
281 + "disabmulti(address) -> None\n"
282 + "\n"
283 + "Disable a specified multicast address on this link.\n"
284 + "See dlpi_disabmulti(3DLPI).\n"
285 +);
286 +static PyObject *
287 +link_disabmulti(pylink_t *link, PyObject *args, PyObject *kwds)
288 +{
289 + char *addr = NULL;
290 + size_t addrlen = 0;
291 + static char *keywords[] = {"address", NULL};
292 + int rval;
293 +
294 + if (link->dlpihdl == NULL) {
295 + errno = EINVAL;
296 + dlpi_raise_exception(DL_SYSERR);
297 + return (NULL);
298 + }
299 +
300 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords,
301 + &addr, &addrlen))
302 + return (NULL);
303 +
304 + if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) {
305 + errno = EINVAL;
306 + dlpi_raise_exception(DL_SYSERR);
307 + return (NULL);
308 + }
309 +
310 + if ((rval = dlpi_disabmulti(link->dlpihdl, addr, addrlen)) !=
311 + DLPI_SUCCESS) {
312 + dlpi_raise_exception(rval);
313 + return (NULL);
314 + }
315 +
316 + Py_INCREF(Py_None);
317 + return (Py_None);
318 +}
319 +
320 +PyDoc_STRVAR(enabmulti_doc,
321 + "enabmulti(address) -> None\n"
322 + "\n"
323 + "Enable a specified multicast address on this link.\n"
324 + "See dlpi_enabmulti(3DLPI).\n"
325 +);
326 +static PyObject *
327 +link_enabmulti(pylink_t *link, PyObject *args, PyObject *kwds)
328 +{
329 + char *addr = NULL;
330 + size_t addrlen = 0;
331 + static char *keywords[] = {"address", NULL};
332 + int rval;
333 +
334 + if (link->dlpihdl == NULL) {
335 + errno = EINVAL;
336 + dlpi_raise_exception(DL_SYSERR);
337 + return (NULL);
338 + }
339 +
340 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords,
341 + &addr, &addrlen))
342 + return (NULL);
343 +
344 + if ((addrlen == 0) || (addrlen > DLPI_PHYSADDR_MAX)) {
345 + errno = EINVAL;
346 + dlpi_raise_exception(DL_SYSERR);
347 + return (NULL);
348 + }
349 +
350 + if ((rval = dlpi_enabmulti(link->dlpihdl, addr, addrlen)) !=
351 + DLPI_SUCCESS) {
352 + dlpi_raise_exception(rval);
353 + return (NULL);
354 + }
355 +
356 + Py_INCREF(Py_None);
357 + return (Py_None);
358 +}
359 +
360 +static void
361 +dlpi_callback(dlpi_handle_t hdl, dlpi_notifyinfo_t *ni, void *arg)
362 +{
363 + callback_data_t *cd = (callback_data_t *)arg;
364 + PyObject *arglist, *result;
365 +
366 + switch (ni->dni_note) {
367 + case DL_NOTE_SPEED:
368 + arglist = Py_BuildValue("(OII)",
369 + cd->pyarg, ni->dni_note, ni->dni_speed);
370 + break;
371 + case DL_NOTE_SDU_SIZE:
372 + arglist = Py_BuildValue("(OII)",
373 + cd->pyarg, ni->dni_note, ni->dni_size);
374 + break;
375 + case DL_NOTE_PHYS_ADDR:
376 + arglist = Py_BuildValue("(OIs#)",
377 + cd->pyarg, ni->dni_note, ni->dni_physaddr,
378 + ni->dni_physaddrlen);
379 + break;
380 + default:
381 + arglist = Py_BuildValue("(OIO)", cd->pyarg, ni->dni_note,
382 + Py_None);
383 + }
384 +
385 + result = PyEval_CallObject(cd->pyfunc, arglist);
386 + Py_DECREF(arglist);
387 + if (result == NULL) {
388 + PyErr_Clear(); /* cannot raise error */
389 + }
390 + Py_DECREF(result);
391 + Py_DECREF(cd->pyfunc);
392 + Py_XDECREF(cd->pyarg);
393 + free(cd);
394 +}
395 +
396 +PyDoc_STRVAR(enabnotify_doc,
397 + "enabnotify(events, function[, arg]) -> unsigned long\n"
398 + "\n"
399 + "Enables a notification callback for the set of specified events,\n"
400 + "which must be one or more (by a logical OR) events listed as below:\n"
401 + "NOTE_LINK_DOWN Notify when link has gone down\n"
402 + "NOTE_LINK_UP Notify when link has come up\n"
403 + "NOTE_PHYS_ADDR Notify when address changes\n"
404 + "NOTE_SDU_SIZE Notify when MTU changes\n"
405 + "NOTE_SPEED Notify when speed changes\n"
406 + "NOTE_PROMISC_ON_PHYS Notify when PROMISC_PHYS is set\n"
407 + "NOTE_PROMISC_OFF_PHYS Notify when PROMISC_PHYS is cleared\n"
408 + "Returns a handle for this registration.\n"
409 + "See dlpi_enabnotify(3DLPI).\n"
410 +);
411 +static PyObject *
412 +link_enabnotify(pylink_t *link, PyObject *args, PyObject *kwds)
413 +{
414 + PyObject *func = NULL, *arg = NULL;
415 + callback_data_t *cd;
416 + uint_t notes = 0;
417 + static char *keywords[] = {"events", "function", "arg", NULL};
418 + dlpi_notifyid_t id;
419 + int rval;
420 +
421 + if (link->dlpihdl == NULL) {
422 + errno = EINVAL;
423 + dlpi_raise_exception(DL_SYSERR);
424 + return (NULL);
425 + }
426 +
427 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "IO|O",
428 + keywords, ¬es, &func, &arg))
429 + return (NULL);
430 +
431 + if (!PyCallable_Check(func)) {
432 + errno = EINVAL;
433 + dlpi_raise_exception(DL_SYSERR);
434 + return (NULL);
435 + }
436 +
437 + cd = malloc(sizeof(callback_data_t));
438 + if (cd == NULL) {
439 + dlpi_raise_exception(DL_SYSERR);
440 + return (NULL);
441 + }
442 + Py_INCREF(func);
443 + Py_XINCREF(arg);
444 + cd->pyfunc = func;
445 + cd->pyarg = arg;
446 +
447 + if ((rval = dlpi_enabnotify(link->dlpihdl, notes, dlpi_callback,
448 + cd, &id)) != DLPI_SUCCESS) {
449 + free(cd);
450 + Py_DECREF(func);
451 + Py_XDECREF(arg);
452 + dlpi_raise_exception(rval);
453 + return (NULL);
454 + }
455 +
456 + return (Py_BuildValue("k", id));
457 +}
458 +
459 +PyDoc_STRVAR(disabnotify_doc,
460 + "disabnotify(handle) -> argument object, or None\n"
461 + "\n"
462 + "Disables the notification registration associated with handle.\n"
463 + "You should get this handle by calling enabnotify().\n"
464 + "Returns the argument passed in when registering the callback, or None.\n"
465 + "See dlpi_disabnotify(3DLPI).\n"
466 +);
467 +static PyObject *
468 +link_disabnotify(pylink_t *link, PyObject *args, PyObject *kwds)
469 +{
470 + dlpi_notifyid_t id;
471 + callback_data_t *arg;
472 + PyObject *pyargsaved;
473 + static char *keywords[] = {"handle", NULL};
474 + int rval;
475 +
476 + if (link->dlpihdl == NULL) {
477 + errno = EINVAL;
478 + dlpi_raise_exception(DL_SYSERR);
479 + return (NULL);
480 + }
481 +
482 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "k", keywords, &id))
483 + return (NULL);
484 +
485 + if ((rval = dlpi_disabnotify(link->dlpihdl, id, (void **)&arg)) !=
486 + DLPI_SUCCESS) {
487 + dlpi_raise_exception(rval);
488 + return (NULL);
489 + }
490 +
491 + /* clean up */
492 + pyargsaved = arg->pyarg;
493 + Py_XINCREF(pyargsaved);
494 + Py_XDECREF(arg->pyarg);
495 + Py_DECREF(arg->pyfunc);
496 + free(arg);
497 +
498 + if (pyargsaved != NULL)
499 + return (pyargsaved);
500 +
501 + Py_INCREF(Py_None);
502 + return (Py_None);
503 +}
504 +
505 +PyDoc_STRVAR(get_sap_doc,
506 + "get_sap() -> unsigned int\n"
507 + "\n"
508 + "Returns the sap bound to this link.\n"
509 + "See dlpi_info(3DLPI).\n"
510 +);
511 +static PyObject *
512 +link_get_sap(pylink_t *link)
513 +{
514 + dlpi_info_t info;
515 + int rval;
516 +
517 + if (link->dlpihdl == NULL) {
518 + errno = EINVAL;
519 + dlpi_raise_exception(DL_SYSERR);
520 + return (NULL);
521 + }
522 +
523 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
524 + DLPI_SUCCESS) {
525 + dlpi_raise_exception(rval);
526 + return (NULL);
527 + }
528 +
529 + return (Py_BuildValue("I", info.di_sap));
530 +}
531 +
532 +PyDoc_STRVAR(get_fd_doc,
533 + "get_fd() -> int\n"
534 + "\n"
535 + "Returns the integer file descriptor that can be used to directly\n"
536 + "operate on the link.\n"
537 + "See dlpi_fd(3DLPI).\n"
538 +);
539 +static PyObject *
540 +link_get_fd(pylink_t *link)
541 +{
542 + int fd;
543 +
544 + if (link->dlpihdl == NULL) {
545 + errno = EINVAL;
546 + dlpi_raise_exception(DL_SYSERR);
547 + return (NULL);
548 + }
549 +
550 + if ((fd = dlpi_fd(link->dlpihdl)) == -1) {
551 + dlpi_raise_exception(DL_SYSERR);
552 + return (NULL);
553 + }
554 +
555 + return (Py_BuildValue("i", fd));
556 +}
557 +
558 +PyDoc_STRVAR(get_linkname_doc,
559 + "get_linkname() -> string\n"
560 + "\n"
561 + "Returns the name of the link.\n"
562 + "See dlpi_linkname(3DLPI).\n"
563 +);
564 +static PyObject *
565 +link_get_linkname(pylink_t *link)
566 +{
567 + const char *name = NULL;
568 +
569 + if (link->dlpihdl == NULL) {
570 + errno = EINVAL;
571 + dlpi_raise_exception(DL_SYSERR);
572 + return (NULL);
573 + }
574 +
575 + if ((name = dlpi_linkname(link->dlpihdl)) == NULL) {
576 + dlpi_raise_exception(DL_SYSERR);
577 + return (NULL);
578 + }
579 +
580 + return (Py_BuildValue("s", name));
581 +}
582 +
583 +PyDoc_STRVAR(get_bcastaddr_doc,
584 + "get_bcastaddr() -> string, or None\n"
585 + "\n"
586 + "Returns the broadcast address of the link.\n"
587 + "Returns None if the broadcast address is empty.\n"
588 + "See dlpi_info(3DLPI).\n"
589 +);
590 +static PyObject *
591 +link_get_bcastaddr(pylink_t *link)
592 +{
593 + char *addr[DLPI_PHYSADDR_MAX];
594 + size_t addrlen = 0;
595 + dlpi_info_t info;
596 + int rval;
597 +
598 + if (link->dlpihdl == NULL) {
599 + errno = EINVAL;
600 + dlpi_raise_exception(DL_SYSERR);
601 + return (NULL);
602 + }
603 +
604 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
605 + DLPI_SUCCESS) {
606 + dlpi_raise_exception(rval);
607 + return (NULL);
608 + }
609 +
610 + if (info.di_bcastaddrlen == 0) {
611 + Py_INCREF(Py_None);
612 + return (Py_None);
613 + }
614 +
615 + return (Py_BuildValue("s#", info.di_bcastaddr, info.di_bcastaddrlen));
616 +}
617 +
618 +PyDoc_STRVAR(get_physaddr_doc,
619 + "get_physaddr(addrtype) -> string, or None\n"
620 + "\n"
621 + "Addrtype can be any one of the value listed below:\n"
622 + "FACT_PHYS_ADDR Factory physical address\n"
623 + "CURR_PHYS_ADDR Current physical address\n"
624 + "Returns the corresponding physical address of the link.\n"
625 + "See dlpi_get_physaddr(3DLPI).\n"
626 +);
627 +static PyObject *
628 +link_get_physaddr(pylink_t *link, PyObject *args, PyObject *kwds)
629 +{
630 + char *addr[DLPI_PHYSADDR_MAX];
631 + size_t addrlen = DLPI_PHYSADDR_MAX;
632 + static char *keywords[] = {"addrtype", NULL};
633 + uint_t type;
634 + int rval;
635 +
636 + if (link->dlpihdl == NULL) {
637 + errno = EINVAL;
638 + dlpi_raise_exception(DL_SYSERR);
639 + return (NULL);
640 + }
641 +
642 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &type))
643 + return (NULL);
644 +
645 + if ((rval = dlpi_get_physaddr(link->dlpihdl, type, addr, &addrlen)) !=
646 + DLPI_SUCCESS) {
647 + dlpi_raise_exception(rval);
648 + return (NULL);
649 + }
650 +
651 + return (Py_BuildValue("s#", addr, addrlen));
652 +}
653 +
654 +PyDoc_STRVAR(set_physaddr_doc,
655 + "set_physaddr(address) -> None\n"
656 + "\n"
657 + "Sets the physical address of the link.\n"
658 + "See dlpi_set_physaddr(3DLPI).\n"
659 +);
660 +static PyObject *
661 +link_set_physaddr(pylink_t *link, PyObject *args, PyObject *kwds)
662 +{
663 + char *addr = NULL;
664 + size_t addrlen = 0;
665 + static char *keywords[] = {"address", NULL};
666 + int rval;
667 +
668 + if (link->dlpihdl == NULL) {
669 + errno = EINVAL;
670 + dlpi_raise_exception(DL_SYSERR);
671 + return (NULL);
672 + }
673 +
674 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", keywords,
675 + &addr, &addrlen))
676 + return (NULL);
677 +
678 + if ((rval = dlpi_set_physaddr(link->dlpihdl, DL_CURR_PHYS_ADDR,
679 + addr, addrlen)) != DLPI_SUCCESS) {
680 + dlpi_raise_exception(rval);
681 + return (NULL);
682 + }
683 +
684 + Py_INCREF(Py_None);
685 + return (Py_None);
686 +}
687 +
688 +PyDoc_STRVAR(promiscon_doc,
689 + "promiscon([level]) -> None\n"
690 + "\n"
691 + "Enables promiscuous mode for the link at levels:\n"
692 + "PROMISC_PHYS Promiscuous mode at the physical level(default)\n"
693 + "PROMISC_SAP Promiscuous mode at the SAP level\n"
694 + "PROMISC_MULTI Promiscuous mode for all multicast addresses\n"
695 + "See dlpi_promiscon(3DLPI).\n"
696 +);
697 +static PyObject *
698 +link_promiscon(pylink_t *link, PyObject *args, PyObject *kwds)
699 +{
700 + uint_t level = DL_PROMISC_PHYS;
701 + static char *keywords[] = {"level", NULL};
702 + int rval;
703 +
704 + if (link->dlpihdl == NULL) {
705 + errno = EINVAL;
706 + dlpi_raise_exception(DL_SYSERR);
707 + return (NULL);
708 + }
709 +
710 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|I", keywords, &level))
711 + return (NULL);
712 +
713 + if ((rval = dlpi_promiscon(link->dlpihdl, level)) != DLPI_SUCCESS) {
714 + dlpi_raise_exception(rval);
715 + return (NULL);
716 + }
717 +
718 + Py_INCREF(Py_None);
719 + return (Py_None);
720 +}
721 +
722 +PyDoc_STRVAR(promiscoff_doc,
723 + "promiscoff([level]) -> None\n"
724 + "\n"
725 + "Disables promiscuous mode for the link at levels:\n"
726 + "PROMISC_PHYS Promiscuous mode at the physical level(default)\n"
727 + "PROMISC_SAP Promiscuous mode at the SAP level\n"
728 + "PROMISC_MULTI Promiscuous mode for all multicast addresses\n"
729 + "See dlpi_promiscoff(3DLPI).\n"
730 +);
731 +static PyObject *
732 +link_promiscoff(pylink_t *link, PyObject *args, PyObject *kwds)
733 +{
734 + uint_t level = DL_PROMISC_PHYS;
735 + static char *keywords[] = {"level", NULL};
736 + int rval;
737 +
738 + if (link->dlpihdl == NULL) {
739 + errno = EINVAL;
740 + dlpi_raise_exception(DL_SYSERR);
741 + return (NULL);
742 + }
743 +
744 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|I", keywords, &level))
745 + return (NULL);
746 +
747 + if ((rval = dlpi_promiscoff(link->dlpihdl, level)) != DLPI_SUCCESS) {
748 + dlpi_raise_exception(rval);
749 + return (NULL);
750 + }
751 +
752 + Py_INCREF(Py_None);
753 + return (Py_None);
754 +}
755 +
756 +PyDoc_STRVAR(get_timeout_doc,
757 + "get_timeout() -> int\n"
758 + "\n"
759 + "Returns current time out value of the link.\n"
760 + "See dlpi_info(3DLPI).\n"
761 +);
762 +static PyObject *
763 +link_get_timeout(pylink_t *link)
764 +{
765 + dlpi_info_t info;
766 + int rval;
767 +
768 + if (link->dlpihdl == NULL) {
769 + errno = EINVAL;
770 + dlpi_raise_exception(DL_SYSERR);
771 + return (NULL);
772 + }
773 +
774 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
775 + DLPI_SUCCESS) {
776 + dlpi_raise_exception(rval);
777 + return (NULL);
778 + }
779 +
780 + return (Py_BuildValue("i", info.di_timeout));
781 +}
782 +
783 +PyDoc_STRVAR(get_mactype_doc,
784 + "get_mactype() -> unsigned char\n"
785 + "\n"
786 + "Returns MAC type of the link.\n"
787 + "See <sys/dlpi.h> for the list of possible MAC types.\n"
788 + "See dlpi_info(3DLPI).\n"
789 +);
790 +static PyObject *
791 +link_get_mactype(pylink_t *link)
792 +{
793 + dlpi_info_t info;
794 + int rval;
795 +
796 + if (link->dlpihdl == NULL) {
797 + errno = EINVAL;
798 + dlpi_raise_exception(DL_SYSERR);
799 + return (NULL);
800 + }
801 +
802 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
803 + DLPI_SUCCESS) {
804 + dlpi_raise_exception(rval);
805 + return (NULL);
806 + }
807 +
808 + return (Py_BuildValue("B", info.di_mactype));
809 +}
810 +
811 +PyDoc_STRVAR(set_timeout_doc,
812 + "set_timeout(timeout) -> None\n"
813 + "\n"
814 + "Sets time out value of the link (default value: DEF_TIMEOUT).\n"
815 + "See dlpi_set_timeout(3DLPI).\n"
816 +);
817 +static PyObject *
818 +link_set_timeout(pylink_t *link, PyObject *args, PyObject *kwds)
819 +{
820 + int timeout = DLPI_DEF_TIMEOUT;
821 + static char *keywords[] = {"timeout", NULL};
822 + int rval;
823 +
824 + if (link->dlpihdl == NULL) {
825 + errno = EINVAL;
826 + dlpi_raise_exception(DL_SYSERR);
827 + return (NULL);
828 + }
829 +
830 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", keywords, &timeout))
831 + return (NULL);
832 +
833 + if ((rval = dlpi_set_timeout(link->dlpihdl, timeout)) != DLPI_SUCCESS) {
834 + dlpi_raise_exception(rval);
835 + return (NULL);
836 + }
837 +
838 + Py_INCREF(Py_None);
839 + return (Py_None);
840 +}
841 +
842 +PyDoc_STRVAR(get_sdu_doc,
843 + "get_sdu() -> (unsigned int, unsigned int)\n"
844 + "\n"
845 + "Returns (min sdu, max sdu).\n"
846 + "See dlpi_info(3DLPI).\n"
847 +);
848 +static PyObject *
849 +link_get_sdu(pylink_t *link)
850 +{
851 + dlpi_info_t info;
852 + int rval;
853 +
854 + if (link->dlpihdl == NULL) {
855 + errno = EINVAL;
856 + dlpi_raise_exception(DL_SYSERR);
857 + return (NULL);
858 + }
859 +
860 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
861 + DLPI_SUCCESS) {
862 + dlpi_raise_exception(rval);
863 + return (NULL);
864 + }
865 +
866 + return (Py_BuildValue("II", info.di_min_sdu, info.di_max_sdu));
867 +}
868 +
869 +PyDoc_STRVAR(get_state_doc,
870 + "get_state() -> unsigned int\n"
871 + "\n"
872 + "Returns current state of the link (either UNBOUND or IDLE).\n"
873 + "See dlpi_info(3DLPI).\n"
874 +);
875 +static PyObject *
876 +link_get_state(pylink_t *link)
877 +{
878 + dlpi_info_t info;
879 + int rval;
880 +
881 + if (link->dlpihdl == NULL) {
882 + errno = EINVAL;
883 + dlpi_raise_exception(DL_SYSERR);
884 + return (NULL);
885 + }
886 +
887 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
888 + DLPI_SUCCESS) {
889 + dlpi_raise_exception(rval);
890 + return (NULL);
891 + }
892 +
893 + return (Py_BuildValue("I", info.di_state));
894 +}
895 +
896 +PyDoc_STRVAR(get_qos_select_doc,
897 + "get_qos_select() -> (unsigned int, int, int, int)\n"
898 + "\n"
899 + "Returns (qos type, trans delay, priority, residul err).\n"
900 + "Unsupported QOS parameters are set to UNKNOWN.\n"
901 + "See dlpi_info(3DLPI).\n"
902 +);
903 +static PyObject *
904 +link_get_qos_select(pylink_t *link)
905 +{
906 + dlpi_info_t info;
907 + int rval;
908 +
909 + if (link->dlpihdl == NULL) {
910 + errno = EINVAL;
911 + dlpi_raise_exception(DL_SYSERR);
912 + return (NULL);
913 + }
914 +
915 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
916 + DLPI_SUCCESS) {
917 + dlpi_raise_exception(rval);
918 + return (NULL);
919 + }
920 +
921 + return (Py_BuildValue("Iiiii",
922 + info.di_qos_sel.dl_qos_type,
923 + info.di_qos_sel.dl_trans_delay,
924 + info.di_qos_sel.dl_priority,
925 + info.di_qos_sel.dl_residual_error));
926 +}
927 +
928 +PyDoc_STRVAR(get_qos_range_doc,
929 + "get_qos_range() -> \n"
930 + " (unsigned int, (int, int), (int, int), (int, int), int)\n"
931 + "\n"
932 + "Returns (qos type, (trans delay target, trans delay accept),\n"
933 + "(min priority, max priority), (min protection, max protection),\n"
934 + "residual err).\n"
935 + "Unsupported QOS range values are set to UNKNOWN.\n"
936 + "See dlpi_info(3DLPI).\n"
937 +);
938 +static PyObject *
939 +link_get_qos_range(pylink_t *link)
940 +{
941 + dlpi_info_t info;
942 + int rval;
943 +
944 + if (link->dlpihdl == NULL) {
945 + errno = EINVAL;
946 + dlpi_raise_exception(DL_SYSERR);
947 + return (NULL);
948 + }
949 +
950 + if ((rval = dlpi_info(link->dlpihdl, &info, 0)) !=
951 + DLPI_SUCCESS) {
952 + dlpi_raise_exception(rval);
953 + return (NULL);
954 + }
955 +
956 + return (Py_BuildValue("I(ii)(ii)(ii)i",
957 + info.di_qos_range.dl_qos_type,
958 + info.di_qos_range.dl_trans_delay.dl_target_value,
959 + info.di_qos_range.dl_trans_delay.dl_accept_value,
960 + info.di_qos_range.dl_priority.dl_min,
961 + info.di_qos_range.dl_priority.dl_max,
962 + info.di_qos_range.dl_protection.dl_min,
963 + info.di_qos_range.dl_protection.dl_max,
964 + info.di_qos_range.dl_residual_error));
965 +}
966 +
967 +static PyMethodDef pylink_methods[] = {
968 + {"bind", (PyCFunction)link_bind, METH_VARARGS|METH_KEYWORDS, bind_doc},
969 + {"unbind", (PyCFunction)link_unbind, METH_NOARGS, unbind_doc},
970 + {"send", (PyCFunction)link_send, METH_VARARGS|METH_KEYWORDS,
971 + send_doc},
972 + {"recv", (PyCFunction)link_recv, METH_VARARGS|METH_KEYWORDS,
973 + recv_doc},
974 + {"disabmulti", (PyCFunction)link_disabmulti, METH_VARARGS|METH_KEYWORDS,
975 + disabmulti_doc},
976 + {"enabmulti", (PyCFunction)link_enabmulti, METH_VARARGS|METH_KEYWORDS,
977 + enabmulti_doc},
978 + {"enabnotify", (PyCFunction)link_enabnotify,
979 + METH_VARARGS|METH_KEYWORDS, enabnotify_doc},
980 + {"disabnotify", (PyCFunction)link_disabnotify,
981 + METH_VARARGS|METH_KEYWORDS, disabnotify_doc},
982 + {"get_fd", (PyCFunction)link_get_fd, METH_NOARGS, get_fd_doc},
983 + {"get_sap", (PyCFunction)link_get_sap, METH_NOARGS, get_sap_doc},
984 + {"get_mactype", (PyCFunction)link_get_mactype, METH_NOARGS,
985 + get_mactype_doc},
986 + {"get_linkname", (PyCFunction)link_get_linkname, METH_NOARGS,
987 + get_linkname_doc},
988 + {"get_bcastaddr", (PyCFunction)link_get_bcastaddr, METH_NOARGS,
989 + get_bcastaddr_doc},
990 + {"get_physaddr", (PyCFunction)link_get_physaddr,
991 + METH_VARARGS|METH_KEYWORDS, get_physaddr_doc},
992 + {"set_physaddr", (PyCFunction)link_set_physaddr,
993 + METH_VARARGS|METH_KEYWORDS, set_physaddr_doc},
994 + {"promiscon", (PyCFunction)link_promiscon, METH_VARARGS|METH_KEYWORDS,
995 + promiscon_doc},
996 + {"promiscoff", (PyCFunction)link_promiscoff, METH_VARARGS|METH_KEYWORDS,
997 + promiscoff_doc},
998 + {"get_timeout", (PyCFunction)link_get_timeout, METH_NOARGS,
999 + get_timeout_doc},
1000 + {"set_timeout", (PyCFunction)link_set_timeout,
1001 + METH_VARARGS|METH_KEYWORDS, set_timeout_doc},
1002 + {"get_sdu", (PyCFunction)link_get_sdu, METH_NOARGS, get_sdu_doc},
1003 + {"get_state", (PyCFunction)link_get_state, METH_NOARGS,
1004 + get_state_doc},
1005 + {"get_qos_select", (PyCFunction)link_get_qos_select, METH_NOARGS,
1006 + get_qos_select_doc},
1007 + {"get_qos_range", (PyCFunction)link_get_qos_range, METH_NOARGS,
1008 + get_qos_range_doc},
1009 + {NULL}
1010 +};
1011 +
1012 +static PyTypeObject pylink_type = {
1013 + PyObject_HEAD_INIT(0) /* Must fill in type value later */
1014 + 0, /* ob_size */
1015 + "dlpi.link", /* tp_name */
1016 + sizeof(pylink_t), /* tp_basicsize */
1017 + 0, /* tp_itemsize */
1018 + (destructor)link_dealloc, /* tp_dealloc */
1019 + 0, /* tp_print */
1020 + 0, /* tp_getattr */
1021 + 0, /* tp_setattr */
1022 + 0, /* tp_compare */
1023 + 0, /* tp_repr */
1024 + 0, /* tp_as_number */
1025 + 0, /* tp_as_sequence */
1026 + 0, /* tp_as_mapping */
1027 + 0, /* tp_hash */
1028 + 0, /* tp_call */
1029 + 0, /* tp_str */
1030 + 0, /* tp_getattro */
1031 + 0, /* tp_setattro */
1032 + 0, /* tp_as_buffer */
1033 + Py_TPFLAGS_DEFAULT, /* tp_flags */
1034 + link_doc, /* tp_doc */
1035 + 0, /* tp_traverse */
1036 + 0, /* tp_clear */
1037 + 0, /* tp_richcompare */
1038 + 0, /* tp_weaklistoffset */
1039 + 0, /* tp_iter */
1040 + 0, /* tp_iternext */
1041 + pylink_methods, /* tp_methods */
1042 + 0, /* tp_members */
1043 + 0, /* tp_getset */
1044 + 0, /* tp_base */
1045 + 0, /* tp_dict */
1046 + 0, /* tp_descr_get */
1047 + 0, /* tp_descr_set */
1048 + 0, /* tp_dictoffset */
1049 + (initproc)link_init, /* tp_init */
1050 + 0, /* tp_alloc */
1051 + PyType_GenericNew, /* tp_new */
1052 + 0, /* tp_free */
1053 +};
1054 +
1055 +PyDoc_STRVAR(arptype_doc,
1056 + "arptype(arptype) -> unsigned int\n"
1057 + "\n"
1058 + "Converts a DLPI MAC type to an ARP hardware type defined\n"
1059 + " in <netinet/arp.h>\n"
1060 + "See dlpi_arptype(3DLPI)\n"
1061 +);
1062 +static PyObject *
1063 +arptype(PyObject *dlpi, PyObject *args, PyObject *kwds)
1064 +{
1065 + static char *keywords[] = {"arptype", NULL};
1066 + uint_t dlpityp, arptyp;
1067 +
1068 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &dlpityp))
1069 + return (NULL);
1070 +
1071 + if ((arptyp = dlpi_arptype(dlpityp)) == 0) {
1072 + errno = EINVAL;
1073 + dlpi_raise_exception(DL_SYSERR);
1074 + return (NULL);
1075 + }
1076 +
1077 + return (Py_BuildValue("I", arptyp));
1078 +}
1079 +
1080 +PyDoc_STRVAR(iftype_doc,
1081 + "iftype(iftype) -> unsigned int\n"
1082 + "\n"
1083 + "Converts a DLPI MAC type to a BSD socket interface type\n"
1084 + "defined in <net/if_types.h>\n"
1085 + "See dlpi_iftype(3DLPI)\n"
1086 +);
1087 +static PyObject *
1088 +iftype(PyObject *dlpi, PyObject *args, PyObject *kwds)
1089 +{
1090 + static char *keywords[] = {"iftype", NULL};
1091 + uint_t dlpityp, iftyp;
1092 +
1093 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &dlpityp))
1094 + return (NULL);
1095 +
1096 + if ((iftyp = dlpi_iftype(dlpityp)) == 0) {
1097 + errno = EINVAL;
1098 + dlpi_raise_exception(DL_SYSERR);
1099 + return (NULL);
1100 + }
1101 +
1102 + return (Py_BuildValue("I", iftyp));
1103 +}
1104 +
1105 +PyDoc_STRVAR(mactype_doc,
1106 + "mactype(mactype) -> string\n"
1107 + "\n"
1108 + "Returns a string that describes the specified mactype.\n"
1109 + "Valid mac types are defined in <sys/dlpi.h>.\n"
1110 + "See dlpi_mactype(3DLPI)\n"
1111 +);
1112 +static PyObject *
1113 +mactype(PyObject *dlpi, PyObject *args, PyObject *kwds)
1114 +{
1115 + static char *keywords[] = {"mactype", NULL};
1116 + uint_t mactyp;
1117 +
1118 + if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", keywords, &mactyp))
1119 + return (NULL);
1120 +
1121 + return (Py_BuildValue("s", dlpi_mactype(mactyp)));
1122 +}
1123 +
1124 +static boolean_t
1125 +link_walker(const char *name, void *arg)
1126 +{
1127 + PyObject *linkname;
1128 + PyObject *list = (PyObject *)arg;
1129 +
1130 + if ((list == NULL) || !PyList_Check(list))
1131 + return (B_FALSE);
1132 +
1133 + linkname = Py_BuildValue("s", name);
1134 + if (PyList_Append(list, linkname) == -1)
1135 + return (B_TRUE);
1136 +
1137 + Py_DECREF(linkname);
1138 + return (B_FALSE);
1139 +}
1140 +
1141 +PyDoc_STRVAR(listlink_doc,
1142 + "listlink() -> list\n"
1143 + "\n"
1144 + "Returns a list containing link names of all links on the system.\n"
1145 +);
1146 +static PyObject *
1147 +listlink(PyObject *dlpi)
1148 +{
1149 + PyObject *list;
1150 +
1151 + if ((list = PyList_New(0)) == NULL)
1152 + return (NULL);
1153 +
1154 + dlpi_walk(link_walker, list, 0);
1155 + return (list);
1156 +}
1157 +
1158 +static PyMethodDef dlpi_methods[] = {
1159 + {"arptype", (PyCFunction)arptype, METH_VARARGS|METH_KEYWORDS,
1160 + arptype_doc},
1161 + {"iftype", (PyCFunction)iftype, METH_VARARGS|METH_KEYWORDS,
1162 + iftype_doc},
1163 + {"mactype", (PyCFunction)mactype, METH_VARARGS|METH_KEYWORDS,
1164 + mactype_doc},
1165 + {"listlink", (PyCFunction)listlink, METH_NOARGS, listlink_doc},
1166 + {NULL}
1167 +};
1168 +
1169 +PyMODINIT_FUNC
1170 +initdlpi(void)
1171 +{
1172 + PyObject *mod;
1173 +
1174 + if (PyType_Ready(&pylink_type) < 0)
1175 + return;
1176 +
1177 + mod = Py_InitModule("dlpi", dlpi_methods);
1178 + if (mod == NULL)
1179 + return;
1180 +
1181 + dlpi_err = PyErr_NewException("dlpi.error", NULL, NULL);
1182 + if (dlpi_err == NULL)
1183 + return;
1184 + PyModule_AddObject(mod, "error", dlpi_err);
1185 +
1186 + Py_INCREF(&pylink_type);
1187 + PyModule_AddObject(mod, "link", (PyObject *)&pylink_type);
1188 + PyModule_AddIntConstant(mod, "PASSIVE", DLPI_PASSIVE);
1189 + PyModule_AddIntConstant(mod, "RAW", DLPI_RAW);
1190 + PyModule_AddIntConstant(mod, "NATIVE", DLPI_NATIVE);
1191 + PyModule_AddIntConstant(mod, "ANY_SAP", DLPI_ANY_SAP);
1192 + PyModule_AddIntConstant(mod, "DEF_TIMEOUT", DLPI_DEF_TIMEOUT);
1193 + PyModule_AddIntConstant(mod, "NOTE_LINK_DOWN", DL_NOTE_LINK_DOWN);
1194 + PyModule_AddIntConstant(mod, "NOTE_LINK_UP", DL_NOTE_LINK_UP);
1195 + PyModule_AddIntConstant(mod, "NOTE_PHYS_ADDR", DL_NOTE_PHYS_ADDR);
1196 + PyModule_AddIntConstant(mod, "NOTE_SDU_SIZE", DL_NOTE_SDU_SIZE);
1197 + PyModule_AddIntConstant(mod, "NOTE_SPEED", DL_NOTE_SPEED);
1198 + PyModule_AddIntConstant(mod, "NOTE_PROMISC_ON_PHYS",
1199 + DL_NOTE_PROMISC_ON_PHYS);
1200 + PyModule_AddIntConstant(mod, "NOTE_PROMISC_OFF_PHYS",
1201 + DL_NOTE_PROMISC_OFF_PHYS);
1202 + PyModule_AddIntConstant(mod, "FACT_PHYS_ADDR", DL_FACT_PHYS_ADDR);
1203 + PyModule_AddIntConstant(mod, "CURR_PHYS_ADDR", DL_CURR_PHYS_ADDR);
1204 + PyModule_AddIntConstant(mod, "PROMISC_PHYS", DL_PROMISC_PHYS);
1205 + PyModule_AddIntConstant(mod, "PROMISC_SAP", DL_PROMISC_SAP);
1206 + PyModule_AddIntConstant(mod, "PROMISC_MULTI", DL_PROMISC_MULTI);
1207 + PyModule_AddIntConstant(mod, "UNKNOWN", DL_UNKNOWN);
1208 + PyModule_AddIntConstant(mod, "UNBOUND", DL_UNBOUND);
1209 + PyModule_AddIntConstant(mod, "IDLE", DL_IDLE);
1210 + PyModule_AddIntConstant(mod, "SYSERR", DL_SYSERR);
1211 +}
1212 diff --git Python-2.6.4/setup.py Python-2.6.4/setup.py
1213 --- Python-2.6.4/setup.py
1214 +++ Python-2.6.4/setup.py
1215 @@ -1284,6 +1284,12 @@
1216 exts.append( Extension('ucred', ['ucred.c'],
1217 libraries = ['tsol']) )
1218
1219 + # dlpi module (Solaris)
1220 + dlpi_inc = find_file('libdlpi.h', [], inc_dirs)
1221 + if dlpi_inc is not None:
1222 + exts.append( Extension('dlpi', ['dlpimodule.c'],
1223 + libraries = ['dlpi']) )
1224 +
1225 # Thomas Heller's _ctypes module
1226 self.detect_ctypes(inc_dirs, lib_dirs)
1227
1228 diff --git Python-2.6.4/lib/test/dlpitest.py Python-2.6.4/Lib/test/dlpitest.py
1229 new file mode 100644
1230 --- /dev/null 2011-02-12 03:13:26.000000000 -0600
1231 +++ Python-2.6.4/Lib/test/dlpitest.py 2011-01-20 13:52:42.895865414 -0600
1232 @@ -0,0 +1,96 @@
1233 +#!/usr/bin/python2.6
1234 +
1235 +import dlpi
1236 +import sys
1237 +import time
1238 +import struct
1239 +
1240 +#test listlink
1241 +linklist = dlpi.listlink()
1242 +print "Found %d links:" % len(linklist)
1243 +print linklist
1244 +
1245 +#pick up the first data link for below testing
1246 +linkname = linklist[0]
1247 +
1248 +#open link
1249 +print "opening link: " + linkname + "..."
1250 +testlink = dlpi.link(linkname)
1251 +
1252 +#read some info of testlink
1253 +print "linkname is %s" % testlink.get_linkname()
1254 +print "link fd is %d" % testlink.get_fd()
1255 +mactype = testlink.get_mactype()
1256 +print "dlpi mactype is %d" % mactype
1257 +print "after convert:"
1258 +print "\tmactype is %s" % dlpi.mactype(mactype)
1259 +print "\tiftype is %d" % dlpi.iftype(mactype)
1260 +print "\tarptype is %d" % dlpi.arptype(mactype)
1261 +bcastaddr = testlink.get_bcastaddr()
1262 +print "broadcast addr is: ",
1263 +print struct.unpack("BBBBBB",bcastaddr)
1264 +physaddr = testlink.get_physaddr(dlpi.FACT_PHYS_ADDR)
1265 +print "factory physical address is: ",
1266 +print struct.unpack("BBBBBB",physaddr)
1267 +print "current timeout value is %d" % testlink.get_timeout()
1268 +print "sdu is:",
1269 +print testlink.get_sdu()
1270 +print "qos select is:",
1271 +print testlink.get_qos_select()
1272 +print "qos range is:",
1273 +print testlink.get_qos_range()
1274 +
1275 +#set some config value of testlink and read them again
1276 +print "setting current physiacal addr to aa:0:10:13:27:5"
1277 +testlink.set_physaddr('\xaa\0\x10\x13\x27\5')
1278 +physaddr = testlink.get_physaddr(dlpi.CURR_PHYS_ADDR)
1279 +print "current physical addr is: ",
1280 +print struct.unpack("BBBBBB",physaddr)
1281 +print "set timeout value to 6..."
1282 +testlink.set_timeout(6)
1283 +print "timeout value is %d" % testlink.get_timeout()
1284 +
1285 +#test enable/disable multicast
1286 +print "enable/disable multicast address 1:0:5e:0:0:5"
1287 +testlink.enabmulti('\1\0\x5e\0\0\5')
1288 +testlink.disabmulti('\1\0\x5e\0\0\5')
1289 +
1290 +#test bind
1291 +print "binding to SAP 0x9000..."
1292 +testlink.bind(0x9000)
1293 +print "sap is %x" % testlink.get_sap()
1294 +print "state is: %d" % testlink.get_state()
1295 +
1296 +#test send
1297 +print "sending broadcast loopback packet..."
1298 +testlink.send(bcastaddr, '\0\1\2\3\4\5')
1299 +
1300 +#test notify functionality
1301 +arg = "notification callback arg"
1302 +def notify(arg, notes, value):
1303 + print "NOTE_PROMISC_ON_PHYS notification received with arg: '%s'" % arg
1304 +print "enabled notification on NOTE_PROMISC_ON_PHYS"
1305 +id = testlink.enabnotify(dlpi.NOTE_PROMISC_ON_PHYS, notify, arg) #enable notification
1306 +testlink.promiscon() #trigger the event (will be seen while receiving pkt below)
1307 +
1308 +#test receive
1309 +print "testing receiving..."
1310 +try:
1311 + testlink.recv(0, 0) #should see NOTE_PROMISC_ON_PHYS event here
1312 +except dlpi.error, err:
1313 + errnum, errinfo = err
1314 + if errnum == 10006:
1315 + pass #timeout error is expected here
1316 + else: #test fails if reach here
1317 + print "test failed",
1318 + print errnum,
1319 + print err
1320 +
1321 +testlink.promiscoff()
1322 +testlink.disabnotify(id) #disable notification
1323 +
1324 +#test unbind
1325 +print "unbinding..."
1326 +testlink.unbind()
1327 +print "sap is %x" % testlink.get_sap()
1328 +print "state is: %d" % testlink.get_state()