5 # include <sys/types.h>
6 # include <sys/socket.h>
10 # if HAVE_SOCKET_IOCTLS
11 # include <sys/ioctl.h>
12 # include <netinet/in.h>
13 # include <arpa/inet.h>
17 #include <sys/sockio.h>
19 # endif /* HAVE_SOCKET_IOCTLS */
21 /* For logical interfaces support we convert all names to same name prefixed with l */
29 # include <net/if_dl.h>
32 /* For the benefit of stupid platforms (Linux), include all the sockaddr
33 definitions we can lay our hands on. It can also be useful for the benefit
34 of another stupid platform (FreeBSD, see PR 152036). */
35 #include <netinet/in.h>
36 # if HAVE_NETASH_ASH_H
37 # include <netash/ash.h>
39 # if HAVE_NETATALK_AT_H
40 # include <netatalk/at.h>
42 # if HAVE_NETAX25_AX25_H
43 # include <netax25/ax25.h>
45 # if HAVE_NETECONET_EC_H
46 # include <neteconet/ec.h>
48 # if HAVE_NETIPX_IPX_H
49 # include <netipx/ipx.h>
51 # if HAVE_NETPACKET_PACKET_H
52 # include <netpacket/packet.h>
54 # if HAVE_NETROSE_ROSE_H
55 # include <netrose/rose.h>
57 # if HAVE_LINUX_IRDA_H
58 # include <linux/irda.h>
61 # include <linux/atm.h>
64 # include <linux/llc.h>
66 # if HAVE_LINUX_TIPC_H
67 # include <linux/tipc.h>
70 # include <linux/dn.h>
73 /* Map address families to sizes of sockaddr structs */
74 static int af_to_len(int af)
77 case AF_INET: return sizeof (struct sockaddr_in);
78 #if defined(AF_INET6) && HAVE_SOCKADDR_IN6
79 case AF_INET6: return sizeof (struct sockaddr_in6);
81 #if defined(AF_AX25) && HAVE_SOCKADDR_AX25
82 # if defined(AF_NETROM)
83 case AF_NETROM: /* I'm assuming this is carried over x25 */
85 case AF_AX25: return sizeof (struct sockaddr_ax25);
87 #if defined(AF_IPX) && HAVE_SOCKADDR_IPX
88 case AF_IPX: return sizeof (struct sockaddr_ipx);
90 #if defined(AF_APPLETALK) && HAVE_SOCKADDR_AT
91 case AF_APPLETALK: return sizeof (struct sockaddr_at);
93 #if defined(AF_ATMPVC) && HAVE_SOCKADDR_ATMPVC
94 case AF_ATMPVC: return sizeof (struct sockaddr_atmpvc);
96 #if defined(AF_ATMSVC) && HAVE_SOCKADDR_ATMSVC
97 case AF_ATMSVC: return sizeof (struct sockaddr_atmsvc);
99 #if defined(AF_X25) && HAVE_SOCKADDR_X25
100 case AF_X25: return sizeof (struct sockaddr_x25);
102 #if defined(AF_ROSE) && HAVE_SOCKADDR_ROSE
103 case AF_ROSE: return sizeof (struct sockaddr_rose);
105 #if defined(AF_DECnet) && HAVE_SOCKADDR_DN
106 case AF_DECnet: return sizeof (struct sockaddr_dn);
108 #if defined(AF_PACKET) && HAVE_SOCKADDR_LL
109 case AF_PACKET: return sizeof (struct sockaddr_ll);
111 #if defined(AF_ASH) && HAVE_SOCKADDR_ASH
112 case AF_ASH: return sizeof (struct sockaddr_ash);
114 #if defined(AF_ECONET) && HAVE_SOCKADDR_EC
115 case AF_ECONET: return sizeof (struct sockaddr_ec);
117 #if defined(AF_IRDA) && HAVE_SOCKADDR_IRDA
118 case AF_IRDA: return sizeof (struct sockaddr_irda);
121 return sizeof (struct sockaddr);
124 #if !HAVE_SOCKADDR_SA_LEN
125 #define SA_LEN(sa) af_to_len(sa->sa_family)
127 #define SS_LEN(sa) af_to_len(sa->ss_family)
129 #define SS_LEN(sa) SA_LEN(sa)
132 #define SA_LEN(sa) sa->sa_len
133 #endif /* !HAVE_SOCKADDR_SA_LEN */
136 # include <ifaddrs.h>
137 # endif /* HAVE_GETIFADDRS */
139 # if !HAVE_GETIFADDRS && (!HAVE_SOCKET_IOCTLS || !HAVE_SIOCGIFCONF)
140 /* If the platform doesn't define, what we need, barf. If you're seeing this,
141 it means you need to write suitable code to retrieve interface information
143 # error You need to add code for your platform.
146 #else /* defined(WIN32) */
148 # include <winsock2.h>
149 # include <iphlpapi.h>
151 #endif /* defined(WIN32) */
161 /* On systems without AF_LINK (Windows, for instance), define it anyway, but
162 give it a crazy value. On Linux, which has AF_PACKET but not AF_LINK,
163 define AF_LINK as the latter instead. */
166 # define AF_LINK AF_PACKET
168 # define AF_LINK -1000
170 # define HAVE_AF_LINK 0
172 # define HAVE_AF_LINK 1
176 #if !HAVE_GETNAMEINFO
178 #undef NI_NUMERICHOST
180 #define getnameinfo our_getnameinfo
181 #define NI_NUMERICHOST 1
183 /* A very simple getnameinfo() for platforms without */
185 getnameinfo (const struct sockaddr *addr, int addr_len,
186 char *buffer, int buflen,
187 char *buf2, int buf2len,
190 switch (addr->sa_family) {
193 const struct sockaddr_in *sin = (struct sockaddr_in *)addr;
194 const unsigned char *bytes = (unsigned char *)&sin->sin_addr.s_addr;
197 sprintf (tmpbuf, "%d.%d.%d.%d",
198 bytes[0], bytes[1], bytes[2], bytes[3]);
200 strncpy (buffer, tmpbuf, buflen);
206 const struct sockaddr_in6 *sin = (const struct sockaddr_in6 *)addr;
207 const unsigned char *bytes = sin->sin6_addr.s6_addr;
209 char tmpbuf[80], *ptr = tmpbuf;
210 int done_double_colon = FALSE;
211 int colon_mode = FALSE;
213 for (n = 0; n < 8; ++n) {
214 unsigned char b1 = bytes[2 * n];
215 unsigned char b2 = bytes[2 * n + 1];
222 sprintf (ptr, "%x%02x", b1, b2);
230 sprintf (ptr, "%x", b2);
235 if (done_double_colon) {
242 done_double_colon = TRUE;
255 strncpy (buffer, tmpbuf, buflen);
258 #endif /* AF_INET6 */
268 string_from_sockaddr (struct sockaddr *addr,
272 struct sockaddr* bigaddr = 0;
274 struct sockaddr* gniaddr;
277 if (!addr || addr->sa_family == AF_UNSPEC)
280 if (SA_LEN(addr) < af_to_len(addr->sa_family)) {
281 /* Someteims ifa_netmask can be truncated. So let's detruncate it. FreeBSD
282 * PR: kern/152036: getifaddrs(3) returns truncated sockaddrs for netmasks
283 * -- http://www.freebsd.org/cgi/query-pr.cgi?pr=152036 */
284 gnilen = af_to_len(addr->sa_family);
285 bigaddr = calloc(1, gnilen);
288 memcpy(bigaddr, addr, SA_LEN(addr));
289 #if HAVE_SOCKADDR_SA_LEN
290 bigaddr->sa_len = gnilen;
294 gnilen = SA_LEN(addr);
298 failure = getnameinfo (gniaddr, gnilen,
316 /* BSD-like systems have AF_LINK */
317 if (addr->sa_family == AF_LINK) {
318 struct sockaddr_dl *dladdr = (struct sockaddr_dl *)addr;
319 len = dladdr->sdl_alen;
320 data = LLADDR(dladdr);
323 #if defined(AF_PACKET)
324 /* Linux has AF_PACKET instead */
325 if (addr->sa_family == AF_PACKET) {
326 struct sockaddr_ll *lladdr = (struct sockaddr_ll *)addr;
327 len = lladdr->sll_halen;
328 data = (const char *)lladdr->sll_addr;
331 /* We don't know anything about this sockaddr, so just display
332 the entire data area in binary. */
333 len -= (sizeof (struct sockaddr) - sizeof (addr->sa_data));
334 data = addr->sa_data;
335 #if defined(AF_PACKET)
342 if (buflen < 3 * len)
348 for (n = 0; n < len; ++n) {
349 sprintf (ptr, "%02x:", data[n] & 0xff);
357 #endif /* !defined(WIN32) */
360 add_to_family (PyObject *result, int family, PyObject *dict)
362 PyObject *py_family = PyInt_FromLong (family);
363 PyObject *list = PyDict_GetItem (result, py_family);
372 list = PyList_New (1);
375 Py_DECREF (py_family);
379 PyList_SET_ITEM (list, 0, dict);
380 PyDict_SetItem (result, py_family, list);
383 PyList_Append (list, dict);
391 ifaddrs (PyObject *self, PyObject *args)
397 PIP_ADAPTER_INFO pAdapterInfo = NULL;
398 PIP_ADAPTER_INFO pInfo = NULL;
399 ULONG ulBufferLength = 0;
404 if (!PyArg_ParseTuple (args, "s", &ifname))
407 result = PyDict_New ();
413 /* First, retrieve the adapter information. We do this in a loop, in
414 case someone adds or removes adapters in the meantime. */
416 dwRet = GetAdaptersInfo(pAdapterInfo, &ulBufferLength);
418 if (dwRet == ERROR_BUFFER_OVERFLOW) {
421 pAdapterInfo = (PIP_ADAPTER_INFO)malloc (ulBufferLength);
425 PyErr_SetString (PyExc_MemoryError, "Not enough memory");
429 } while (dwRet == ERROR_BUFFER_OVERFLOW);
431 /* If we failed, then fail in Python too */
432 if (dwRet != ERROR_SUCCESS && dwRet != ERROR_NO_DATA) {
437 PyErr_SetString (PyExc_OSError,
438 "Unable to obtain adapter information.");
442 for (pInfo = pAdapterInfo; pInfo; pInfo = pInfo->Next) {
445 if (strcmp (pInfo->AdapterName, ifname) != 0)
450 /* Do the physical address */
451 if (256 >= 3 * pInfo->AddressLength) {
452 PyObject *hwaddr, *dict;
457 for (n = 0; n < pInfo->AddressLength; ++n) {
458 sprintf (ptr, "%02x:", pInfo->Address[n] & 0xff);
463 hwaddr = PyString_FromString (buffer);
464 dict = PyDict_New ();
473 PyDict_SetItemString (dict, "addr", hwaddr);
476 if (!add_to_family (result, AF_LINK, dict)) {
483 for (str = &pInfo->IpAddressList; str; str = str->Next) {
484 PyObject *addr = PyString_FromString (str->IpAddress.String);
485 PyObject *mask = PyString_FromString (str->IpMask.String);
486 PyObject *bcast = NULL;
489 /* If this isn't the loopback interface, work out the broadcast
490 address, for better compatibility with other platforms. */
491 if (pInfo->Type != MIB_IF_TYPE_LOOPBACK) {
492 unsigned long inaddr = inet_addr (str->IpAddress.String);
493 unsigned long inmask = inet_addr (str->IpMask.String);
497 in.S_un.S_addr = (inaddr | ~inmask) & 0xfffffffful;
499 brstr = inet_ntoa (in);
502 bcast = PyString_FromString (brstr);
505 dict = PyDict_New ();
517 PyDict_SetItemString (dict, "addr", addr);
519 PyDict_SetItemString (dict, "netmask", mask);
521 PyDict_SetItemString (dict, "broadcast", bcast);
527 if (!add_to_family (result, AF_INET, dict)) {
536 #elif HAVE_GETIFADDRS
537 struct ifaddrs *addrs = NULL;
538 struct ifaddrs *addr = NULL;
540 if (getifaddrs (&addrs) < 0) {
542 PyErr_SetFromErrno (PyExc_OSError);
546 for (addr = addrs; addr; addr = addr->ifa_next) {
548 PyObject *pyaddr = NULL, *netmask = NULL, *braddr = NULL;
550 if (strcmp (addr->ifa_name, ifname) != 0)
553 /* Sometimes there are records without addresses (e.g. in the case of a
554 dial-up connection via ppp, which on Linux can have a link address
555 record with no actual address). We skip these as they aren't useful.
556 Thanks to Christian Kauhaus for reporting this issue. */
562 if (string_from_sockaddr (addr->ifa_addr, buffer, sizeof (buffer)) == 0)
563 pyaddr = PyString_FromString (buffer);
565 if (string_from_sockaddr (addr->ifa_netmask, buffer, sizeof (buffer)) == 0)
566 netmask = PyString_FromString (buffer);
568 if (string_from_sockaddr (addr->ifa_broadaddr, buffer, sizeof (buffer)) == 0)
569 braddr = PyString_FromString (buffer);
571 PyObject *dict = PyDict_New();
575 Py_XDECREF (netmask);
583 PyDict_SetItemString (dict, "addr", pyaddr);
585 PyDict_SetItemString (dict, "netmask", netmask);
588 if (addr->ifa_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
589 PyDict_SetItemString (dict, "peer", braddr);
591 PyDict_SetItemString (dict, "broadcast", braddr);
595 Py_XDECREF (netmask);
598 if (!add_to_family (result, addr->ifa_addr->sa_family, dict)) {
606 #elif HAVE_SOCKET_IOCTLS
608 int sock = socket(AF_INET, SOCK_DGRAM, 0);
612 PyErr_SetFromErrno (PyExc_OSError);
616 struct CNAME(ifreq) ifr;
617 PyObject *addr = NULL, *netmask = NULL, *braddr = NULL, *dstaddr = NULL;
621 strncpy (ifr.CNAME(ifr_name), ifname, IFNAMSIZ);
623 #if HAVE_SIOCGIFHWADDR
624 if (ioctl (sock, SIOCGIFHWADDR, &ifr) == 0) {
627 if (string_from_sockaddr (ifr->CNAME(ifr_addr), buffer, sizeof (buffer)) == 0) {
628 PyObject *hwaddr = PyString_FromString (buffer);
629 PyObject *dict = PyDict_New ();
630 PyObject *list = PyList_New (1);
631 PyObject *family = PyInt_FromLong (AF_LINK);
633 if (!hwaddr || !dict || !list || !family) {
643 PyDict_SetItemString (dict, "addr", hwaddr);
646 PyList_SET_ITEM (list, 0, dict);
648 PyDict_SetItem (result, family, list);
657 if (ioctl (sock, SIOCGLIFADDR, &ifr) == 0) {
659 if (ioctl (sock, SIOCGIFADDR, &ifr) == 0) {
663 if (string_from_sockaddr ((struct sockaddr *)&ifr.CNAME(ifr_addr), buffer, sizeof (buffer)) == 0)
664 addr = PyString_FromString (buffer);
668 #if HAVE_SIOCGIFNETMASK
670 if (ioctl (sock, SIOCGLIFNETMASK, &ifr) == 0) {
672 if (ioctl (sock, SIOCGIFNETMASK, &ifr) == 0) {
676 if (string_from_sockaddr ((struct sockaddr *)&ifr.CNAME(ifr_addr), buffer, sizeof (buffer)) == 0)
677 netmask = PyString_FromString (buffer);
681 #if HAVE_SIOCGIFFLAGS
683 if (ioctl (sock, SIOCGLIFFLAGS, &ifr) == 0) {
685 if (ioctl (sock, SIOCGIFFLAGS, &ifr) == 0) {
689 if (ifr.CNAME(ifr_flags) & IFF_POINTOPOINT)
694 #if HAVE_SIOCGIFBRDADDR
696 if (!is_p2p && ioctl (sock, SIOCGLIFBRDADDR, &ifr) == 0) {
698 if (!is_p2p && ioctl (sock, SIOCGIFBRDADDR, &ifr) == 0) {
702 if (string_from_sockaddr ((struct sockaddr *)&ifr.CNAME(ifr_addr), buffer, sizeof (buffer)) == 0)
703 braddr = PyString_FromString (buffer);
707 #if HAVE_SIOCGIFDSTADDR
709 if (is_p2p && ioctl (sock, SIOCGLIFBRDADDR, &ifr) == 0) {
711 if (is_p2p && ioctl (sock, SIOCGIFBRDADDR, &ifr) == 0) {
715 if (string_from_sockaddr ((struct sockaddr *)&ifr.CNAME(ifr_addr), buffer, sizeof (buffer)) == 0)
716 dstaddr = PyString_FromString (buffer);
720 PyObject *dict = PyDict_New();
724 Py_XDECREF (netmask);
726 Py_XDECREF (dstaddr);
733 PyDict_SetItemString (dict, "addr", addr);
735 PyDict_SetItemString (dict, "netmask", netmask);
737 PyDict_SetItemString (dict, "broadcast", braddr);
739 PyDict_SetItemString (dict, "peer", dstaddr);
742 Py_XDECREF (netmask);
744 Py_XDECREF (dstaddr);
746 if (!PyDict_Size (dict))
749 PyObject *list = PyList_New(1);
758 PyList_SET_ITEM (list, 0, dict);
760 PyObject *family = PyInt_FromLong (AF_INET);
768 PyDict_SetItem (result, family, list);
775 #endif /* HAVE_SOCKET_IOCTLS */
781 PyErr_SetString (PyExc_ValueError,
782 "You must specify a valid interface name.");
788 interfaces (PyObject *self)
793 PIP_ADAPTER_INFO pAdapterInfo = NULL;
794 PIP_ADAPTER_INFO pInfo = NULL;
795 ULONG ulBufferLength = 0;
798 /* First, retrieve the adapter information */
800 dwRet = GetAdaptersInfo(pAdapterInfo, &ulBufferLength);
802 if (dwRet == ERROR_BUFFER_OVERFLOW) {
805 pAdapterInfo = (PIP_ADAPTER_INFO)malloc (ulBufferLength);
808 PyErr_SetString (PyExc_MemoryError, "Not enough memory");
812 } while (dwRet == ERROR_BUFFER_OVERFLOW);
814 /* If we failed, then fail in Python too */
815 if (dwRet != ERROR_SUCCESS && dwRet != ERROR_NO_DATA) {
819 PyErr_SetString (PyExc_OSError,
820 "Unable to obtain adapter information.");
824 result = PyList_New(0);
826 if (dwRet == ERROR_NO_DATA) {
831 for (pInfo = pAdapterInfo; pInfo; pInfo = pInfo->Next) {
832 PyObject *ifname = PyString_FromString (pInfo->AdapterName);
834 PyList_Append (result, ifname);
839 #elif HAVE_GETIFADDRS
840 const char *prev_name = NULL;
841 struct ifaddrs *addrs = NULL;
842 struct ifaddrs *addr = NULL;
844 result = PyList_New (0);
846 if (getifaddrs (&addrs) < 0) {
848 PyErr_SetFromErrno (PyExc_OSError);
852 for (addr = addrs; addr; addr = addr->ifa_next) {
853 if (!prev_name || strncmp (addr->ifa_name, prev_name, IFNAMSIZ) != 0) {
854 PyObject *ifname = PyString_FromString (addr->ifa_name);
856 if (!PySequence_Contains (result, ifname))
857 PyList_Append (result, ifname);
859 prev_name = addr->ifa_name;
864 #elif HAVE_SIOCGIFCONF
865 const char *prev_name = NULL;
866 int fd = socket (AF_INET, SOCK_DGRAM, 0);
867 struct CNAME(ifconf) ifc;
871 PyErr_SetFromErrno (PyExc_OSError);
875 // Try to find out how much space we need
876 #if HAVE_SIOCGSIZIFCONF
877 if (ioctl (fd, SIOCGSIZIFCONF, &len) < 0)
879 #elif HAVE_SIOCGLIFNUM
880 { struct lifnum lifn;
881 lifn.lifn_family = AF_UNSPEC;
882 lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES;
883 ifc.lifc_family = AF_UNSPEC;
884 ifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES;
885 if (ioctl (fd, SIOCGLIFNUM, (char *)&lifn) < 0)
888 len = lifn.lifn_count;
892 // As a last resort, guess
896 ifc.CNAME(ifc_len) = len * sizeof (struct CNAME(ifreq));
897 ifc.CNAME(ifc_buf) = malloc (ifc.CNAME(ifc_len));
899 if (!ifc.CNAME(ifc_buf)) {
900 PyErr_SetString (PyExc_MemoryError, "Not enough memory");
906 if (ioctl (fd, SIOCGLIFCONF, &ifc) < 0) {
908 if (ioctl (fd, SIOCGIFCONF, &ifc) < 0) {
910 free (ifc.CNAME(ifc_req));
911 PyErr_SetFromErrno (PyExc_OSError);
916 result = PyList_New (0);
917 struct CNAME(ifreq) *pfreq = ifc.CNAME(ifc_req);
918 for (n = 0; n < ifc.CNAME(ifc_len)/sizeof(struct CNAME(ifreq));
920 if (!prev_name || strncmp (prev_name, pfreq->CNAME(ifr_name), IFNAMSIZ) != 0) {
921 PyObject *name = PyString_FromString (pfreq->CNAME(ifr_name));
923 if (!PySequence_Contains (result, name))
924 PyList_Append (result, name);
927 prev_name = pfreq->CNAME(ifr_name);
931 free (ifc.CNAME(ifc_buf));
933 #endif /* HAVE_SIOCGIFCONF */
938 static PyMethodDef methods[] = {
939 { "ifaddresses", (PyCFunction)ifaddrs, METH_VARARGS,
940 "Obtain information about the specified network interface.\n"
942 "Returns a dict whose keys are equal to the address family constants,\n"
943 "e.g. netifaces.AF_INET, and whose values are a list of addresses in\n"
944 "that family that are attached to the network interface." },
945 { "interfaces", (PyCFunction)interfaces, METH_NOARGS,
946 "Obtain a list of the interfaces available on this machine." },
947 { NULL, NULL, 0, NULL }
959 iResult = WSAStartup(MAKEWORD (2, 2), &wsad);
962 m = Py_InitModule ("netifaces", methods);
964 /* Address families (auto-detect using #ifdef) */
965 PyObject *address_family_dict = PyDict_New();
967 PyModule_AddIntConstant (m, "AF_UNSPEC", AF_UNSPEC);
968 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_UNSPEC),
969 PyString_FromString("AF_UNSPEC"));
972 PyModule_AddIntConstant (m, "AF_UNIX", AF_UNIX);
973 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_UNIX),
974 PyString_FromString("AF_UNIX"));
977 PyModule_AddIntConstant (m, "AF_FILE", AF_FILE);
978 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_FILE),
979 PyString_FromString("AF_FILE"));
982 PyModule_AddIntConstant (m, "AF_INET", AF_INET);
983 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_INET),
984 PyString_FromString("AF_INET"));
987 PyModule_AddIntConstant (m, "AF_AX25", AF_AX25);
988 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_AX25),
989 PyString_FromString("AF_AX25"));
992 PyModule_AddIntConstant (m, "AF_IMPLINK", AF_IMPLINK);
993 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_IMPLINK),
994 PyString_FromString("AF_IMPLINK"));
997 PyModule_AddIntConstant (m, "AF_PUP", AF_PUP);
998 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_PUP),
999 PyString_FromString("AF_PUP"));
1002 PyModule_AddIntConstant (m, "AF_CHAOS", AF_CHAOS);
1003 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_CHAOS),
1004 PyString_FromString("AF_CHAOS"));
1007 PyModule_AddIntConstant (m, "AF_NS", AF_NS);
1008 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NS),
1009 PyString_FromString("AF_NS"));
1012 PyModule_AddIntConstant (m, "AF_ISO", AF_ISO);
1013 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ISO),
1014 PyString_FromString("AF_ISO"));
1017 PyModule_AddIntConstant (m, "AF_ECMA", AF_ECMA);
1018 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ECMA),
1019 PyString_FromString("AF_ECMA"));
1022 PyModule_AddIntConstant (m, "AF_DATAKIT", AF_DATAKIT);
1023 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_DATAKIT),
1024 PyString_FromString("AF_DATAKIT"));
1027 PyModule_AddIntConstant (m, "AF_CCITT", AF_CCITT);
1028 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_CCITT),
1029 PyString_FromString("AF_CCITT"));
1032 PyModule_AddIntConstant (m, "AF_SNA", AF_SNA);
1033 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_SNA),
1034 PyString_FromString("AF_SNA"));
1037 PyModule_AddIntConstant (m, "AF_DECnet", AF_DECnet);
1038 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_DECnet),
1039 PyString_FromString("AF_DECnet"));
1042 PyModule_AddIntConstant (m, "AF_DLI", AF_DLI);
1043 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_DLI),
1044 PyString_FromString("AF_DLI"));
1047 PyModule_AddIntConstant (m, "AF_LAT", AF_LAT);
1048 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_LAT),
1049 PyString_FromString("AF_LAT"));
1052 PyModule_AddIntConstant (m, "AF_HYLINK", AF_HYLINK);
1053 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_HYLINK),
1054 PyString_FromString("AF_HYLINK"));
1057 PyModule_AddIntConstant (m, "AF_APPLETALK", AF_APPLETALK);
1058 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_APPLETALK),
1059 PyString_FromString("AF_APPLETALK"));
1062 PyModule_AddIntConstant (m, "AF_ROUTE", AF_ROUTE);
1063 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ROUTE),
1064 PyString_FromString("AF_ROUTE"));
1067 PyModule_AddIntConstant (m, "AF_LINK", AF_LINK);
1068 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_LINK),
1069 PyString_FromString("AF_LINK"));
1072 PyModule_AddIntConstant (m, "AF_PACKET", AF_PACKET);
1073 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_PACKET),
1074 PyString_FromString("AF_PACKET"));
1077 PyModule_AddIntConstant (m, "AF_COIP", AF_COIP);
1078 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_COIP),
1079 PyString_FromString("AF_COIP"));
1082 PyModule_AddIntConstant (m, "AF_CNT", AF_CNT);
1083 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_CNT),
1084 PyString_FromString("AF_CNT"));
1087 PyModule_AddIntConstant (m, "AF_IPX", AF_IPX);
1088 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_IPX),
1089 PyString_FromString("AF_IPX"));
1092 PyModule_AddIntConstant (m, "AF_SIP", AF_SIP);
1093 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_SIP),
1094 PyString_FromString("AF_SIP"));
1097 PyModule_AddIntConstant (m, "AF_NDRV", AF_NDRV);
1098 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NDRV),
1099 PyString_FromString("AF_NDRV"));
1102 PyModule_AddIntConstant (m, "AF_ISDN", AF_ISDN);
1103 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ISDN),
1104 PyString_FromString("AF_ISDN"));
1107 PyModule_AddIntConstant (m, "AF_INET6", AF_INET6);
1108 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_INET6),
1109 PyString_FromString("AF_INET6"));
1112 PyModule_AddIntConstant (m, "AF_NATM", AF_NATM);
1113 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NATM),
1114 PyString_FromString("AF_NATM"));
1117 PyModule_AddIntConstant (m, "AF_SYSTEM", AF_SYSTEM);
1118 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_SYSTEM),
1119 PyString_FromString("AF_SYSTEM"));
1122 PyModule_AddIntConstant (m, "AF_NETBIOS", AF_NETBIOS);
1123 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETBIOS),
1124 PyString_FromString("AF_NETBIOS"));
1127 PyModule_AddIntConstant (m, "AF_NETBEUI", AF_NETBEUI);
1128 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETBEUI),
1129 PyString_FromString("AF_NETBEUI"));
1132 PyModule_AddIntConstant (m, "AF_PPP", AF_PPP);
1133 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_PPP),
1134 PyString_FromString("AF_PPP"));
1137 PyModule_AddIntConstant (m, "AF_ATM", AF_ATM);
1138 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ATM),
1139 PyString_FromString("AF_ATM"));
1142 PyModule_AddIntConstant (m, "AF_ATMPVC", AF_ATMPVC);
1143 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ATMPVC),
1144 PyString_FromString("AF_ATMPVC"));
1147 PyModule_AddIntConstant (m, "AF_ATMSVC", AF_ATMSVC);
1148 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ATMSVC),
1149 PyString_FromString("AF_ATMSVC"));
1152 PyModule_AddIntConstant (m, "AF_NETGRAPH", AF_NETGRAPH);
1153 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETGRAPH),
1154 PyString_FromString("AF_NETGRAPH"));
1157 PyModule_AddIntConstant (m, "AF_VOICEVIEW", AF_VOICEVIEW);
1158 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_VOICEVIEW),
1159 PyString_FromString("AF_VOICEVIEW"));
1162 PyModule_AddIntConstant (m, "AF_FIREFOX", AF_FIREFOX);
1163 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_FIREFOX),
1164 PyString_FromString("AF_FIREFOX"));
1167 PyModule_AddIntConstant (m, "AF_UNKNOWN1", AF_UNKNOWN1);
1168 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_UNKNOWN1),
1169 PyString_FromString("AF_UNKNOWN1"));
1172 PyModule_AddIntConstant (m, "AF_BAN", AF_BAN);
1173 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_BAN),
1174 PyString_FromString("AF_BAN"));
1177 PyModule_AddIntConstant (m, "AF_CLUSTER", AF_CLUSTER);
1178 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_CLUSTER),
1179 PyString_FromString("AF_CLUSTER"));
1182 PyModule_AddIntConstant (m, "AF_12844", AF_12844);
1183 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_12844),
1184 PyString_FromString("AF_12844"));
1187 PyModule_AddIntConstant (m, "AF_IRDA", AF_IRDA);
1188 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_IRDA),
1189 PyString_FromString("AF_IRDA"));
1192 PyModule_AddIntConstant (m, "AF_NETDES", AF_NETDES);
1193 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETDES),
1194 PyString_FromString("AF_NETDES"));
1197 PyModule_AddIntConstant (m, "AF_NETROM", AF_NETROM);
1198 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETROM),
1199 PyString_FromString("AF_NETROM"));
1202 PyModule_AddIntConstant (m, "AF_BRIDGE", AF_BRIDGE);
1203 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_BRIDGE),
1204 PyString_FromString("AF_BRIDGE"));
1207 PyModule_AddIntConstant (m, "AF_X25", AF_X25);
1208 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_X25),
1209 PyString_FromString("AF_X25"));
1212 PyModule_AddIntConstant (m, "AF_ROSE", AF_ROSE);
1213 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ROSE),
1214 PyString_FromString("AF_ROSE"));
1217 PyModule_AddIntConstant (m, "AF_SECURITY", AF_SECURITY);
1218 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_SECURITY),
1219 PyString_FromString("AF_SECURITY"));
1222 PyModule_AddIntConstant (m, "AF_KEY", AF_KEY);
1223 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_KEY),
1224 PyString_FromString("AF_KEY"));
1227 PyModule_AddIntConstant (m, "AF_NETLINK", AF_NETLINK);
1228 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_NETLINK),
1229 PyString_FromString("AF_NETLINK"));
1232 PyModule_AddIntConstant (m, "AF_ASH", AF_ASH);
1233 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ASH),
1234 PyString_FromString("AF_ASH"));
1237 PyModule_AddIntConstant (m, "AF_ECONET", AF_ECONET);
1238 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_ECONET),
1239 PyString_FromString("AF_ECONET"));
1242 PyModule_AddIntConstant (m, "AF_SNA", AF_SNA);
1243 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_SNA),
1244 PyString_FromString("AF_SNA"));
1247 PyModule_AddIntConstant (m, "AF_PPPOX", AF_PPPOX);
1248 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_PPPOX),
1249 PyString_FromString("AF_PPPOX"));
1252 PyModule_AddIntConstant (m, "AF_WANPIPE", AF_WANPIPE);
1253 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_WANPIPE),
1254 PyString_FromString("AF_WANPIPE"));
1257 PyModule_AddIntConstant (m, "AF_BLUETOOTH", AF_BLUETOOTH);
1258 PyDict_SetItem(address_family_dict, PyInt_FromLong(AF_BLUETOOTH),
1259 PyString_FromString("AF_BLUETOOTH"));
1261 PyModule_AddObject(m, "address_families", address_family_dict);