irda socket support

Modules/socketmodule.c

 /* Socket module */
 
 /*
 
 This module provides an interface to Berkeley socket IPC.
 
 Limitations:
 
 - Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
   portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported
@@ skipping 1242 matching lines @@
         {
             struct sockaddr_ctl *a = (struct sockaddr_ctl *)addr;
             return Py_BuildValue("(II)", a->sc_id, a->sc_unit);
         }
 #endif
         default:
             PyErr_SetString(PyExc_ValueError,
                             "Invalid address type");
             return 0;
         }
+#endif
+
+#ifdef AF_IRDA
+    case AF_IRDA:
+    {
+        struct sockaddr_irda *a = (struct sockaddr_irda *)addr;
+
+        return Py_BuildValue("iO&", a->sir_addr,
+                                    PyUnicode_DecodeFSDefault, a->sir_name);
+    }
 #endif
 
     /* More cases here... */
 
     default:
         /* If we don't know the address family, don't raise an
            exception -- return it as an (int, bytes) tuple. */
         return Py_BuildValue("iy#",
                              addr->sa_family,
                              addr->sa_data,
@@ skipping 477 matching lines @@
               
             *len_ret = sizeof(*addr);
             return 1;
         }
 #endif
         default:
             PyErr_SetString(PyExc_OSError,
                             "getsockaddrarg: unsupported PF_SYSTEM protocol");
             return 0;
         }
+#endif
+
+#ifdef HAVE_IRDA_H
+    case AF_IRDA:
+    {
+        struct sockaddr_irda *addr;
+        int daddr;
+        PyObject *service;
+        addr = (struct sockaddr_irda *)addr_ret;
+        Py_ssize_t len;
+
+        if (!PyArg_ParseTuple(args, "iO&", &daddr,
+                                           PyUnicode_FSConverter, &service))
+            return 0;
+
+        len = PyBytes_GET_SIZE(service);
+
+        if (len <= 0 || len >= sizeof(addr->sir_name)) {
+            PyErr_SetString(PyExc_OSError, "AF_IRDA service name too long");
+            Py_DECREF(service);
+            return 0;
+        }
+
+#ifdef HAVE_LINUX_IRDA_H
+        addr->sir_family = AF_IRDA;
+        addr->sir_lsap_sel = LSAP_ANY;
+        addr->sir_addr = daddr;
+        strcpy(addr->sir_name, PyBytes_AS_STRING(service));
+#else /* Windows */
+        addr->irdaAddressFamily = AF_IRDA;
+        addr->irdaDeviceID[0] = (daddr >> 24) & Oxff;
+        addr->irdaDeviceID[1] = (daddr >> 16) & Oxff;
+        addr->irdaDeviceID[2] = (daddr >> 8) & Oxff;
+        addr->irdaDeviceID[3] = daddr & Oxff;
+        strcpy(addr->irdaServiceName, PyBytes_AS_STRING(service));
+#endif
+
+        Py_DECREF(service);
+        *len_ret = sizeof(*addr);
+        return 1;
+    }
 #endif
 
     /* More cases here... */
 
     default:
         PyErr_SetString(PyExc_OSError, "getsockaddrarg: bad family");
         return 0;
 
     }
 }
@@ skipping 103 matching lines @@
             *len_ret = sizeof (struct sockaddr_ctl);
             return 1;
 #endif
         default:
             PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
                             "unknown PF_SYSTEM protocol");
             return 0;
         }
 #endif
 
+#ifdef AF_IRDA
+    case AF_IRDA:
+    {
+        *len_ret = sizeof (struct sockaddr_irda);
+        return 1;
+    }
+#endif
+ 
     /* More cases here... */
 
     default:
         PyErr_SetString(PyExc_OSError, "getsockaddrlen: bad family");
         return 0;
 
     }
 }
 
 
@@ skipping 3921 matching lines @@
 #ifdef PF_RDS
     PyModule_AddIntConstant(m, "PF_RDS", PF_RDS);
 #endif
 
 /* Kernel event messages */
 #ifdef PF_SYSTEM
     PyModule_AddIntConstant(m, "PF_SYSTEM", PF_SYSTEM);
 #endif
 #ifdef AF_SYSTEM
     PyModule_AddIntConstant(m, "AF_SYSTEM", AF_SYSTEM);
+#endif
+
+/* Infrared Data Association */
+#ifdef AF_IRDA
+    PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
+#endif
+#ifdef PF_IRDA
+    PyModule_AddIntConstant(m, "PF_IRDA", PF_IRDA);
 #endif
 
 #ifdef AF_PACKET
     PyModule_AddIntMacro(m, AF_PACKET);
 #endif
 #ifdef PF_PACKET
     PyModule_AddIntMacro(m, PF_PACKET);
 #endif
 #ifdef PACKET_HOST
     PyModule_AddIntMacro(m, PACKET_HOST);
@@ skipping 52 matching lines @@
 #ifdef TIPC_SUB_CANCEL
     /* doesn't seem to be available everywhere */
     PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
 #endif
     PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
     PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
     PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
     PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
     PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
     PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
+#endif
+
+#ifdef HAVE_IRDA_H
+    PyModule_AddIntConstant(m, "SOL_IRLMP", SOL_IRLMP);
+    PyModule_AddIntConstant(m, "IRLMP_ENUMDEVICES", IRLMP_ENUMDEVICES);
+    PyModule_AddIntConstant(m, "IRLMP_IAS_SET", IRLMP_IAS_SET);
+    PyModule_AddIntConstant(m, "IRLMP_IAS_QUERY", IRLMP_IAS_QUERY);
 #endif
 
     /* Socket types */
     PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
     PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
 /* We have incomplete socket support. */
     PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
     PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
 #if defined(SOCK_RDM)
     PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
@@ skipping 817 matching lines @@
             return NULL;
         memcpy(&packed_addr, src, sizeof(packed_addr));
         return strncpy(dst, inet_ntoa(packed_addr), size);
     }
     /* Should set errno to EAFNOSUPPORT */
     return NULL;
 }
 
 #endif
 #endif