1 /* Socket module header file */ 2 3 /* Includes needed for the sockaddr_* symbols below */ 4 #ifndef MS_WINDOWS 5 #ifdef __VMS 6 # include <socket.h> 7 # else 8 # include <sys/socket.h> 9 # endif 10 # include <netinet/in.h> 11 # if !defined(__CYGWIN__) 12 # include <netinet/tcp.h> 13 # endif 14 15 #else /* MS_WINDOWS */ 16 # include <winsock2.h> 17 18 /* 19 * If Windows has bluetooth support, include bluetooth constants. 20 */ 21 #ifdef AF_BTH 22 # include <ws2bth.h> 23 # include <pshpack1.h> 24 25 /* 26 * The current implementation assumes the bdaddr in the sockaddr structs 27 * will be a bdaddr_t. We treat this as an opaque type: on *nix systems, it 28 * will be a struct with a single member (an array of six bytes). On windows, 29 * we typedef this to ULONGLONG to match the Windows definition. 30 */ 31 typedef ULONGLONG bdaddr_t; 32 33 /* 34 * Redefine SOCKADDR_BTH to provide names compatible with _BT_RC_MEMB() macros. 35 */ 36 struct SOCKADDR_BTH_REDEF { 37 union { 38 USHORT addressFamily; 39 USHORT family; 40 }; 41 42 union { 43 ULONGLONG btAddr; 44 bdaddr_t bdaddr; 45 }; 46 47 GUID serviceClassId; 48 49 union { 50 ULONG port; 51 ULONG channel; 52 }; 53 54 }; 55 # include <poppack.h> 56 #endif 57 58 /* Windows 'supports' CMSG_LEN, but does not follow the POSIX standard 59 * interface at all, so there is no point including the code that 60 * attempts to use it. 61 */ 62 # ifdef PySocket_BUILDING_SOCKET 63 # undef CMSG_LEN 64 # endif 65 # include <ws2tcpip.h> 66 /* VC6 is shipped with old platform headers, and does not have MSTcpIP.h 67 * Separate SDKs have all the functions we want, but older ones don't have 68 * any version information. 69 * I use SIO_GET_MULTICAST_FILTER to detect a decent SDK. 70 */ 71 # ifdef SIO_GET_MULTICAST_FILTER 72 # include <mstcpip.h> /* for SIO_RCVALL */ 73 # define HAVE_ADDRINFO 74 # define HAVE_SOCKADDR_STORAGE 75 # define HAVE_GETADDRINFO 76 # define HAVE_GETNAMEINFO 77 # define ENABLE_IPV6 78 # else 79 typedef int socklen_t; 80 # endif /* IPPROTO_IPV6 */ 81 #endif /* MS_WINDOWS */ 82 83 #ifdef HAVE_SYS_UN_H 84 # include <sys/un.h> 85 #else 86 # undef AF_UNIX 87 #endif 88 89 #ifdef HAVE_LINUX_NETLINK_H 90 # ifdef HAVE_ASM_TYPES_H 91 # include <asm/types.h> 92 # endif 93 # include <linux/netlink.h> 94 #else 95 # undef AF_NETLINK 96 #endif 97 98 #ifdef HAVE_LINUX_QRTR_H 99 # ifdef HAVE_ASM_TYPES_H 100 # include <asm/types.h> 101 # endif 102 # include <linux/qrtr.h> 103 #else 104 # undef AF_QIPCRTR 105 #endif 106 107 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H 108 #include <bluetooth/bluetooth.h> 109 #include <bluetooth/rfcomm.h> 110 #include <bluetooth/l2cap.h> 111 #include <bluetooth/sco.h> 112 #include <bluetooth/hci.h> 113 #endif 114 115 #ifdef HAVE_BLUETOOTH_H 116 #include <bluetooth.h> 117 #endif 118 119 #ifdef HAVE_NET_IF_H 120 # include <net/if.h> 121 #endif 122 123 #ifdef HAVE_NETPACKET_PACKET_H 124 # include <sys/ioctl.h> 125 # include <netpacket/packet.h> 126 #endif 127 128 #ifdef HAVE_LINUX_TIPC_H 129 # include <linux/tipc.h> 130 #endif 131 132 #ifdef HAVE_LINUX_CAN_H 133 # include <linux/can.h> 134 #else 135 # undef AF_CAN 136 # undef PF_CAN 137 #endif 138 139 #ifdef HAVE_LINUX_CAN_RAW_H 140 #include <linux/can/raw.h> 141 #endif 142 143 #ifdef HAVE_LINUX_CAN_BCM_H 144 #include <linux/can/bcm.h> 145 #endif 146 147 #ifdef HAVE_LINUX_CAN_J1939_H 148 #include <linux/can/j1939.h> 149 #endif 150 151 #ifdef HAVE_SYS_SYS_DOMAIN_H 152 #include <sys/sys_domain.h> 153 #endif 154 #ifdef HAVE_SYS_KERN_CONTROL_H 155 #include <sys/kern_control.h> 156 #endif 157 158 #ifdef HAVE_LINUX_VM_SOCKETS_H 159 # include <linux/vm_sockets.h> 160 #else 161 # undef AF_VSOCK 162 #endif 163 164 #ifdef HAVE_SOCKADDR_ALG 165 166 # include <linux/if_alg.h> 167 # ifndef AF_ALG 168 # define AF_ALG 38 169 # endif 170 # ifndef SOL_ALG 171 # define SOL_ALG 279 172 # endif 173 174 /* Linux 3.19 */ 175 # ifndef ALG_SET_AEAD_ASSOCLEN 176 # define ALG_SET_AEAD_ASSOCLEN 4 177 # endif 178 # ifndef ALG_SET_AEAD_AUTHSIZE 179 # define ALG_SET_AEAD_AUTHSIZE 5 180 # endif 181 /* Linux 4.8 */ 182 # ifndef ALG_SET_PUBKEY 183 # define ALG_SET_PUBKEY 6 184 # endif 185 186 # ifndef ALG_OP_SIGN 187 # define ALG_OP_SIGN 2 188 # endif 189 # ifndef ALG_OP_VERIFY 190 # define ALG_OP_VERIFY 3 191 # endif 192 193 #endif /* HAVE_SOCKADDR_ALG */ 194 195 196 #ifndef Py__SOCKET_H 197 #define Py__SOCKET_H 198 #ifdef __cplusplus 199 extern "C" { 200 #endif 201 202 /* Python module and C API name */ 203 #define PySocket_MODULE_NAME "_socket" 204 #define PySocket_CAPI_NAME "CAPI" 205 #define PySocket_CAPSULE_NAME PySocket_MODULE_NAME "." PySocket_CAPI_NAME 206 207 /* Abstract the socket file descriptor type */ 208 #ifdef MS_WINDOWS 209 typedef SOCKET SOCKET_T; 210 # ifdef MS_WIN64 211 # define SIZEOF_SOCKET_T 8 212 # else 213 # define SIZEOF_SOCKET_T 4 214 # endif 215 #else 216 typedef int SOCKET_T; 217 # define SIZEOF_SOCKET_T SIZEOF_INT 218 #endif 219 220 #if SIZEOF_SOCKET_T <= SIZEOF_LONG 221 #define PyLong_FromSocket_t(fd) PyLong_FromLong((SOCKET_T)(fd)) 222 #define PyLong_AsSocket_t(fd) (SOCKET_T)PyLong_AsLong(fd) 223 #else 224 #define PyLong_FromSocket_t(fd) PyLong_FromLongLong((SOCKET_T)(fd)) 225 #define PyLong_AsSocket_t(fd) (SOCKET_T)PyLong_AsLongLong(fd) 226 #endif 227 228 /* Socket address */ 229 typedef union sock_addr { 230 struct sockaddr_in in; 231 struct sockaddr sa; 232 #ifdef AF_UNIX 233 struct sockaddr_un un; 234 #endif 235 #ifdef AF_NETLINK 236 struct sockaddr_nl nl; 237 #endif 238 #ifdef ENABLE_IPV6 239 struct sockaddr_in6 in6; 240 struct sockaddr_storage storage; 241 #endif 242 #if defined(HAVE_BLUETOOTH_H) && defined(__FreeBSD__) 243 struct sockaddr_l2cap bt_l2; 244 struct sockaddr_rfcomm bt_rc; 245 struct sockaddr_sco bt_sco; 246 struct sockaddr_hci bt_hci; 247 #elif defined(HAVE_BLUETOOTH_BLUETOOTH_H) 248 struct sockaddr_l2 bt_l2; 249 struct sockaddr_rc bt_rc; 250 struct sockaddr_sco bt_sco; 251 struct sockaddr_hci bt_hci; 252 #elif defined(MS_WINDOWS) 253 struct SOCKADDR_BTH_REDEF bt_rc; 254 #endif 255 #ifdef HAVE_NETPACKET_PACKET_H 256 struct sockaddr_ll ll; 257 #endif 258 #ifdef HAVE_LINUX_CAN_H 259 struct sockaddr_can can; 260 #endif 261 #ifdef HAVE_SYS_KERN_CONTROL_H 262 struct sockaddr_ctl ctl; 263 #endif 264 #ifdef HAVE_SOCKADDR_ALG 265 struct sockaddr_alg alg; 266 #endif 267 #ifdef AF_QIPCRTR 268 struct sockaddr_qrtr sq; 269 #endif 270 #ifdef AF_VSOCK 271 struct sockaddr_vm vm; 272 #endif 273 #ifdef HAVE_LINUX_TIPC_H 274 struct sockaddr_tipc tipc; 275 #endif 276 } sock_addr_t; 277 278 /* The object holding a socket. It holds some extra information, 279 like the address family, which is used to decode socket address 280 arguments properly. */ 281 282 typedef struct { 283 PyObject_HEAD 284 SOCKET_T sock_fd; /* Socket file descriptor */ 285 int sock_family; /* Address family, e.g., AF_INET */ 286 int sock_type; /* Socket type, e.g., SOCK_STREAM */ 287 int sock_proto; /* Protocol type, usually 0 */ 288 PyObject *(*errorhandler)(void); /* Error handler; checks 289 errno, returns NULL and 290 sets a Python exception */ 291 _PyTime_t sock_timeout; /* Operation timeout in seconds; 292 0.0 means non-blocking */ 293 } PySocketSockObject; 294 295 /* --- C API ----------------------------------------------------*/ 296 297 /* Short explanation of what this C API export mechanism does 298 and how it works: 299 300 The _ssl module needs access to the type object defined in 301 the _socket module. Since cross-DLL linking introduces a lot of 302 problems on many platforms, the "trick" is to wrap the 303 C API of a module in a struct which then gets exported to 304 other modules via a PyCapsule. 305 306 The code in socketmodule.c defines this struct (which currently 307 only contains the type object reference, but could very 308 well also include other C APIs needed by other modules) 309 and exports it as PyCapsule via the module dictionary 310 under the name "CAPI". 311 312 Other modules can now include the socketmodule.h file 313 which defines the needed C APIs to import and set up 314 a static copy of this struct in the importing module. 315 316 After initialization, the importing module can then 317 access the C APIs from the _socket module by simply 318 referring to the static struct, e.g. 319 320 Load _socket module and its C API; this sets up the global 321 PySocketModule: 322 323 if (PySocketModule_ImportModuleAndAPI()) 324 return; 325 326 327 Now use the C API as if it were defined in the using 328 module: 329 330 if (!PyArg_ParseTuple(args, "O!|zz:ssl", 331 332 PySocketModule.Sock_Type, 333 334 (PyObject*)&Sock, 335 &key_file, &cert_file)) 336 return NULL; 337 338 Support could easily be extended to export more C APIs/symbols 339 this way. Currently, only the type object is exported, 340 other candidates would be socket constructors and socket 341 access functions. 342 343 */ 344 345 /* C API for usage by other Python modules. 346 * Always add new things to the end for binary compatibility. */ 347 typedef struct { 348 PyTypeObject *Sock_Type; 349 PyObject *error; 350 PyObject *timeout_error; 351 } PySocketModule_APIObject; 352 353 #define PySocketModule_ImportModuleAndAPI() PyCapsule_Import(PySocket_CAPSULE_NAME, 1) 354 355 #ifdef __cplusplus 356 } 357 #endif 358 #endif /* !Py__SOCKET_H */ 359