Branch data Line data Source code
1 : : /* Socket module */
2 : :
3 : : /*
4 : :
5 : : This module provides an interface to Berkeley socket IPC.
6 : :
7 : : Limitations:
8 : :
9 : : - Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
10 : : portable manner, though AF_PACKET, AF_NETLINK, AF_QIPCRTR and AF_TIPC are
11 : : supported under Linux.
12 : : - No read/write operations (use sendall/recv or makefile instead).
13 : : - Additional restrictions apply on some non-Unix platforms (compensated
14 : : for by socket.py).
15 : :
16 : : Module interface:
17 : :
18 : : - socket.error: exception raised for socket specific errors, alias for OSError
19 : : - socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
20 : : a subclass of socket.error
21 : : - socket.herror: exception raised for gethostby* errors,
22 : : a subclass of socket.error
23 : : - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
24 : : - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
25 : : - socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
26 : : - socket.getprotobyname(protocolname) --> protocol number
27 : : - socket.getservbyname(servicename[, protocolname]) --> port number
28 : : - socket.getservbyport(portnumber[, protocolname]) --> service name
29 : : - socket.socket([family[, type [, proto, fileno]]]) --> new socket object
30 : : (fileno specifies a pre-existing socket file descriptor)
31 : : - socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
32 : : - socket.ntohs(16 bit value) --> new int object
33 : : - socket.ntohl(32 bit value) --> new int object
34 : : - socket.htons(16 bit value) --> new int object
35 : : - socket.htonl(32 bit value) --> new int object
36 : : - socket.getaddrinfo(host, port [, family, type, proto, flags])
37 : : --> List of (family, type, proto, canonname, sockaddr)
38 : : - socket.getnameinfo(sockaddr, flags) --> (host, port)
39 : : - socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
40 : : - socket.has_ipv6: boolean value indicating if IPv6 is supported
41 : : - socket.inet_aton(IP address) -> 32-bit packed IP representation
42 : : - socket.inet_ntoa(packed IP) -> IP address string
43 : : - socket.getdefaulttimeout() -> None | float
44 : : - socket.setdefaulttimeout(None | float)
45 : : - socket.if_nameindex() -> list of tuples (if_index, if_name)
46 : : - socket.if_nametoindex(name) -> corresponding interface index
47 : : - socket.if_indextoname(index) -> corresponding interface name
48 : : - an internet socket address is a pair (hostname, port)
49 : : where hostname can be anything recognized by gethostbyname()
50 : : (including the dd.dd.dd.dd notation) and port is in host byte order
51 : : - where a hostname is returned, the dd.dd.dd.dd notation is used
52 : : - a UNIX domain socket address is a string specifying the pathname
53 : : - an AF_PACKET socket address is a tuple containing a string
54 : : specifying the ethernet interface and an integer specifying
55 : : the Ethernet protocol number to be received. For example:
56 : : ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
57 : : specify packet-type and ha-type/addr.
58 : : - an AF_QIPCRTR socket address is a (node, port) tuple where the
59 : : node and port are non-negative integers.
60 : : - an AF_TIPC socket address is expressed as
61 : : (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:
62 : : TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
63 : : and scope can be one of:
64 : : TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
65 : : The meaning of v1, v2 and v3 depends on the value of addr_type:
66 : : if addr_type is TIPC_ADDR_NAME:
67 : : v1 is the server type
68 : : v2 is the port identifier
69 : : v3 is ignored
70 : : if addr_type is TIPC_ADDR_NAMESEQ:
71 : : v1 is the server type
72 : : v2 is the lower port number
73 : : v3 is the upper port number
74 : : if addr_type is TIPC_ADDR_ID:
75 : : v1 is the node
76 : : v2 is the ref
77 : : v3 is ignored
78 : :
79 : :
80 : : Local naming conventions:
81 : :
82 : : - names starting with sock_ are socket object methods
83 : : - names starting with socket_ are module-level functions
84 : : - names starting with PySocket are exported through socketmodule.h
85 : :
86 : : */
87 : :
88 : : #ifndef Py_BUILD_CORE_BUILTIN
89 : : # define Py_BUILD_CORE_MODULE 1
90 : : #endif
91 : :
92 : : #ifdef __APPLE__
93 : : // Issue #35569: Expose RFC 3542 socket options.
94 : : #define __APPLE_USE_RFC_3542 1
95 : : #include <AvailabilityMacros.h>
96 : : /* for getaddrinfo thread safety test on old versions of OS X */
97 : : #ifndef MAC_OS_X_VERSION_10_5
98 : : #define MAC_OS_X_VERSION_10_5 1050
99 : : #endif
100 : : /*
101 : : * inet_aton is not available on OSX 10.3, yet we want to use a binary
102 : : * that was build on 10.4 or later to work on that release, weak linking
103 : : * comes to the rescue.
104 : : */
105 : : # pragma weak inet_aton
106 : : #endif
107 : :
108 : : #define PY_SSIZE_T_CLEAN
109 : : #include "Python.h"
110 : : #include "pycore_fileutils.h" // _Py_set_inheritable()
111 : : #include "structmember.h" // PyMemberDef
112 : :
113 : : #ifdef _Py_MEMORY_SANITIZER
114 : : # include <sanitizer/msan_interface.h>
115 : : #endif
116 : :
117 : : /* Socket object documentation */
118 : : PyDoc_STRVAR(sock_doc,
119 : : "socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object\n\
120 : : socket(family=-1, type=-1, proto=-1, fileno=None) -> socket object\n\
121 : : \n\
122 : : Open a socket of the given type. The family argument specifies the\n\
123 : : address family; it defaults to AF_INET. The type argument specifies\n\
124 : : whether this is a stream (SOCK_STREAM, this is the default)\n\
125 : : or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
126 : : specifying the default protocol. Keyword arguments are accepted.\n\
127 : : The socket is created as non-inheritable.\n\
128 : : \n\
129 : : When a fileno is passed in, family, type and proto are auto-detected,\n\
130 : : unless they are explicitly set.\n\
131 : : \n\
132 : : A socket object represents one endpoint of a network connection.\n\
133 : : \n\
134 : : Methods of socket objects (keyword arguments not allowed):\n\
135 : : \n\
136 : : _accept() -- accept connection, returning new socket fd and client address\n\
137 : : bind(addr) -- bind the socket to a local address\n\
138 : : close() -- close the socket\n\
139 : : connect(addr) -- connect the socket to a remote address\n\
140 : : connect_ex(addr) -- connect, return an error code instead of an exception\n\
141 : : dup() -- return a new socket fd duplicated from fileno()\n\
142 : : fileno() -- return underlying file descriptor\n\
143 : : getpeername() -- return remote address [*]\n\
144 : : getsockname() -- return local address\n\
145 : : getsockopt(level, optname[, buflen]) -- get socket options\n\
146 : : gettimeout() -- return timeout or None\n\
147 : : listen([n]) -- start listening for incoming connections\n\
148 : : recv(buflen[, flags]) -- receive data\n\
149 : : recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
150 : : recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
151 : : recvfrom_into(buffer[, nbytes, [, flags])\n\
152 : : -- receive data and sender\'s address (into a buffer)\n\
153 : : sendall(data[, flags]) -- send all data\n\
154 : : send(data[, flags]) -- send data, may not send all of it\n\
155 : : sendto(data[, flags], addr) -- send data to a given address\n\
156 : : setblocking(bool) -- set or clear the blocking I/O flag\n\
157 : : getblocking() -- return True if socket is blocking, False if non-blocking\n\
158 : : setsockopt(level, optname, value[, optlen]) -- set socket options\n\
159 : : settimeout(None | float) -- set or clear the timeout\n\
160 : : shutdown(how) -- shut down traffic in one or both directions\n\
161 : : \n\
162 : : [*] not available on all platforms!");
163 : :
164 : : /* XXX This is a terrible mess of platform-dependent preprocessor hacks.
165 : : I hope some day someone can clean this up please... */
166 : :
167 : : /* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
168 : : script doesn't get this right, so we hardcode some platform checks below.
169 : : On the other hand, not all Linux versions agree, so there the settings
170 : : computed by the configure script are needed! */
171 : :
172 : : #ifndef __linux__
173 : : # undef HAVE_GETHOSTBYNAME_R_3_ARG
174 : : # undef HAVE_GETHOSTBYNAME_R_5_ARG
175 : : # undef HAVE_GETHOSTBYNAME_R_6_ARG
176 : : #endif
177 : :
178 : : #if defined(__OpenBSD__)
179 : : # include <sys/uio.h>
180 : : #endif
181 : :
182 : : #if defined(__ANDROID__) && __ANDROID_API__ < 23
183 : : # undef HAVE_GETHOSTBYNAME_R
184 : : #endif
185 : :
186 : : #ifdef HAVE_GETHOSTBYNAME_R
187 : : # if defined(_AIX) && !defined(_LINUX_SOURCE_COMPAT)
188 : : # define HAVE_GETHOSTBYNAME_R_3_ARG
189 : : # elif defined(__sun) || defined(__sgi)
190 : : # define HAVE_GETHOSTBYNAME_R_5_ARG
191 : : # elif defined(__linux__)
192 : : /* Rely on the configure script */
193 : : # elif defined(_LINUX_SOURCE_COMPAT) /* Linux compatibility on AIX */
194 : : # define HAVE_GETHOSTBYNAME_R_6_ARG
195 : : # else
196 : : # undef HAVE_GETHOSTBYNAME_R
197 : : # endif
198 : : #endif
199 : :
200 : : #if !defined(HAVE_GETHOSTBYNAME_R) && !defined(MS_WINDOWS)
201 : : # define USE_GETHOSTBYNAME_LOCK
202 : : #endif
203 : :
204 : : #if defined(__APPLE__) || defined(__CYGWIN__) || defined(__NetBSD__)
205 : : # include <sys/ioctl.h>
206 : : #endif
207 : :
208 : :
209 : : #if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
210 : : /* make sure that the reentrant (gethostbyaddr_r etc)
211 : : functions are declared correctly if compiling with
212 : : MIPSPro 7.x in ANSI C mode (default) */
213 : :
214 : : /* XXX Using _SGIAPI is the wrong thing,
215 : : but I don't know what the right thing is. */
216 : : #undef _SGIAPI /* to avoid warning */
217 : : #define _SGIAPI 1
218 : :
219 : : #undef _XOPEN_SOURCE
220 : : #include <sys/socket.h>
221 : : #include <sys/types.h>
222 : : #include <netinet/in.h>
223 : : #ifdef _SS_ALIGNSIZE
224 : : #define HAVE_GETADDRINFO 1
225 : : #define HAVE_GETNAMEINFO 1
226 : : #endif
227 : :
228 : : #define HAVE_INET_PTON
229 : : #include <netdb.h>
230 : : #endif
231 : :
232 : : /* Solaris fails to define this variable at all. */
233 : : #if (defined(__sun) && defined(__SVR4)) && !defined(INET_ADDRSTRLEN)
234 : : #define INET_ADDRSTRLEN 16
235 : : #endif
236 : :
237 : : /* Generic includes */
238 : : #ifdef HAVE_SYS_TYPES_H
239 : : #include <sys/types.h>
240 : : #endif
241 : :
242 : : #ifdef HAVE_SYS_SOCKET_H
243 : : #include <sys/socket.h>
244 : : #endif
245 : :
246 : : #ifdef HAVE_NET_IF_H
247 : : #include <net/if.h>
248 : : #endif
249 : :
250 : : /* Generic socket object definitions and includes */
251 : : #define PySocket_BUILDING_SOCKET
252 : : #include "socketmodule.h"
253 : :
254 : : /* Addressing includes */
255 : :
256 : : #ifndef MS_WINDOWS
257 : :
258 : : /* Non-MS WINDOWS includes */
259 : : # include <netdb.h>
260 : : # include <unistd.h>
261 : :
262 : : /* Headers needed for inet_ntoa() and inet_addr() */
263 : : # include <arpa/inet.h>
264 : :
265 : : # include <fcntl.h>
266 : :
267 : : #else
268 : :
269 : : /* MS_WINDOWS includes */
270 : : # ifdef HAVE_FCNTL_H
271 : : # include <fcntl.h>
272 : : # endif
273 : :
274 : : /* Helpers needed for AF_HYPERV */
275 : : # include <Rpc.h>
276 : :
277 : : /* Macros based on the IPPROTO enum, see: https://bugs.python.org/issue29515 */
278 : : #ifdef MS_WINDOWS
279 : : #define IPPROTO_ICMP IPPROTO_ICMP
280 : : #define IPPROTO_IGMP IPPROTO_IGMP
281 : : #define IPPROTO_GGP IPPROTO_GGP
282 : : #define IPPROTO_TCP IPPROTO_TCP
283 : : #define IPPROTO_PUP IPPROTO_PUP
284 : : #define IPPROTO_UDP IPPROTO_UDP
285 : : #define IPPROTO_IDP IPPROTO_IDP
286 : : #define IPPROTO_ND IPPROTO_ND
287 : : #define IPPROTO_RAW IPPROTO_RAW
288 : : #define IPPROTO_MAX IPPROTO_MAX
289 : : #define IPPROTO_HOPOPTS IPPROTO_HOPOPTS
290 : : #define IPPROTO_IPV4 IPPROTO_IPV4
291 : : #define IPPROTO_IPV6 IPPROTO_IPV6
292 : : #define IPPROTO_ROUTING IPPROTO_ROUTING
293 : : #define IPPROTO_FRAGMENT IPPROTO_FRAGMENT
294 : : #define IPPROTO_ESP IPPROTO_ESP
295 : : #define IPPROTO_AH IPPROTO_AH
296 : : #define IPPROTO_ICMPV6 IPPROTO_ICMPV6
297 : : #define IPPROTO_NONE IPPROTO_NONE
298 : : #define IPPROTO_DSTOPTS IPPROTO_DSTOPTS
299 : : #define IPPROTO_EGP IPPROTO_EGP
300 : : #define IPPROTO_PIM IPPROTO_PIM
301 : : #define IPPROTO_ICLFXBM IPPROTO_ICLFXBM // WinSock2 only
302 : : #define IPPROTO_ST IPPROTO_ST // WinSock2 only
303 : : #define IPPROTO_CBT IPPROTO_CBT // WinSock2 only
304 : : #define IPPROTO_IGP IPPROTO_IGP // WinSock2 only
305 : : #define IPPROTO_RDP IPPROTO_RDP // WinSock2 only
306 : : #define IPPROTO_PGM IPPROTO_PGM // WinSock2 only
307 : : #define IPPROTO_L2TP IPPROTO_L2TP // WinSock2 only
308 : : #define IPPROTO_SCTP IPPROTO_SCTP // WinSock2 only
309 : : #endif /* MS_WINDOWS */
310 : :
311 : : /* Provides the IsWindows7SP1OrGreater() function */
312 : : #include <versionhelpers.h>
313 : : // For if_nametoindex() and if_indextoname()
314 : : #include <iphlpapi.h>
315 : :
316 : : /* remove some flags on older version Windows during run-time.
317 : : https://msdn.microsoft.com/en-us/library/windows/desktop/ms738596.aspx */
318 : : typedef struct {
319 : : DWORD build_number; /* available starting with this Win10 BuildNumber */
320 : : const char flag_name[20];
321 : : } FlagRuntimeInfo;
322 : :
323 : : /* IMPORTANT: make sure the list ordered by descending build_number */
324 : : static FlagRuntimeInfo win_runtime_flags[] = {
325 : : /* available starting with Windows 10 1709 */
326 : : {16299, "TCP_KEEPIDLE"},
327 : : {16299, "TCP_KEEPINTVL"},
328 : : /* available starting with Windows 10 1703 */
329 : : {15063, "TCP_KEEPCNT"},
330 : : /* available starting with Windows 10 1607 */
331 : : {14393, "TCP_FASTOPEN"}
332 : : };
333 : :
334 : : /*[clinic input]
335 : : module _socket
336 : : class _socket.socket "PySocketSockObject *" "&sock_type"
337 : : [clinic start generated code]*/
338 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7a8313d9b7f51988]*/
339 : :
340 : : static int
341 : : remove_unusable_flags(PyObject *m)
342 : : {
343 : : PyObject *dict;
344 : : OSVERSIONINFOEX info;
345 : : DWORDLONG dwlConditionMask;
346 : :
347 : : dict = PyModule_GetDict(m);
348 : : if (dict == NULL) {
349 : : return -1;
350 : : }
351 : :
352 : : /* set to Windows 10, except BuildNumber. */
353 : : memset(&info, 0, sizeof(info));
354 : : info.dwOSVersionInfoSize = sizeof(info);
355 : : info.dwMajorVersion = 10;
356 : : info.dwMinorVersion = 0;
357 : :
358 : : /* set Condition Mask */
359 : : dwlConditionMask = 0;
360 : : VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
361 : : VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
362 : : VER_SET_CONDITION(dwlConditionMask, VER_BUILDNUMBER, VER_GREATER_EQUAL);
363 : :
364 : : for (int i=0; i<sizeof(win_runtime_flags)/sizeof(FlagRuntimeInfo); i++) {
365 : : info.dwBuildNumber = win_runtime_flags[i].build_number;
366 : : /* greater than or equal to the specified version?
367 : : Compatibility Mode will not cheat VerifyVersionInfo(...) */
368 : : if (VerifyVersionInfo(
369 : : &info,
370 : : VER_MAJORVERSION|VER_MINORVERSION|VER_BUILDNUMBER,
371 : : dwlConditionMask)) {
372 : : break;
373 : : }
374 : : else {
375 : : PyObject *flag_name = PyUnicode_FromString(win_runtime_flags[i].flag_name);
376 : : if (flag_name == NULL) {
377 : : return -1;
378 : : }
379 : : PyObject *v = _PyDict_Pop(dict, flag_name, Py_None);
380 : : Py_DECREF(flag_name);
381 : : if (v == NULL) {
382 : : return -1;
383 : : }
384 : : Py_DECREF(v);
385 : : }
386 : : }
387 : : return 0;
388 : : }
389 : :
390 : : #endif
391 : :
392 : : #include <stddef.h>
393 : :
394 : : #ifndef O_NONBLOCK
395 : : # define O_NONBLOCK O_NDELAY
396 : : #endif
397 : :
398 : : /* include Python's addrinfo.h unless it causes trouble */
399 : : #if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
400 : : /* Do not include addinfo.h on some newer IRIX versions.
401 : : * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
402 : : * for example, but not by 6.5.10.
403 : : */
404 : : #elif defined(_MSC_VER) && _MSC_VER>1201
405 : : /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
406 : : * EAI_* constants are defined in (the already included) ws2tcpip.h.
407 : : */
408 : : #else
409 : : # include "addrinfo.h"
410 : : #endif
411 : :
412 : : #ifdef __APPLE__
413 : : /* On OS X, getaddrinfo returns no error indication of lookup
414 : : failure, so we must use the emulation instead of the libinfo
415 : : implementation. Unfortunately, performing an autoconf test
416 : : for this bug would require DNS access for the machine performing
417 : : the configuration, which is not acceptable. Therefore, we
418 : : determine the bug just by checking for __APPLE__. If this bug
419 : : gets ever fixed, perhaps checking for sys/version.h would be
420 : : appropriate, which is 10/0 on the system with the bug. */
421 : : #ifndef HAVE_GETNAMEINFO
422 : : /* This bug seems to be fixed in Jaguar. The easiest way I could
423 : : Find to check for Jaguar is that it has getnameinfo(), which
424 : : older releases don't have */
425 : : #undef HAVE_GETADDRINFO
426 : : #endif
427 : :
428 : : #ifdef HAVE_INET_ATON
429 : : #define USE_INET_ATON_WEAKLINK
430 : : #endif
431 : :
432 : : #endif
433 : :
434 : : /* I know this is a bad practice, but it is the easiest... */
435 : : #if !defined(HAVE_GETADDRINFO)
436 : : /* avoid clashes with the C library definition of the symbol. */
437 : : #define getaddrinfo fake_getaddrinfo
438 : : #define gai_strerror fake_gai_strerror
439 : : #define freeaddrinfo fake_freeaddrinfo
440 : : #include "getaddrinfo.c"
441 : : #endif
442 : : #if !defined(HAVE_GETNAMEINFO)
443 : : #define getnameinfo fake_getnameinfo
444 : : #include "getnameinfo.c"
445 : : #endif
446 : :
447 : : #ifdef MS_WINDOWS
448 : : #define SOCKETCLOSE closesocket
449 : : #endif
450 : :
451 : : #ifdef MS_WIN32
452 : : # undef EAFNOSUPPORT
453 : : # define EAFNOSUPPORT WSAEAFNOSUPPORT
454 : : #endif
455 : :
456 : : #ifndef SOCKETCLOSE
457 : : # define SOCKETCLOSE close
458 : : #endif
459 : :
460 : : #if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)
461 : : #define USE_BLUETOOTH 1
462 : : #if defined(__FreeBSD__)
463 : : #define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
464 : : #define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
465 : : #define BTPROTO_HCI BLUETOOTH_PROTO_HCI
466 : : #define SOL_HCI SOL_HCI_RAW
467 : : #define HCI_FILTER SO_HCI_RAW_FILTER
468 : : #define sockaddr_l2 sockaddr_l2cap
469 : : #define sockaddr_rc sockaddr_rfcomm
470 : : #define hci_dev hci_node
471 : : #define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
472 : : #define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
473 : : #define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
474 : : #elif defined(__NetBSD__) || defined(__DragonFly__)
475 : : #define sockaddr_l2 sockaddr_bt
476 : : #define sockaddr_rc sockaddr_bt
477 : : #define sockaddr_hci sockaddr_bt
478 : : #define sockaddr_sco sockaddr_bt
479 : : #define SOL_HCI BTPROTO_HCI
480 : : #define HCI_DATA_DIR SO_HCI_DIRECTION
481 : : #define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
482 : : #define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
483 : : #define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
484 : : #define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
485 : : #else
486 : : #define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
487 : : #define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
488 : : #define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
489 : : #define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
490 : : #endif
491 : : #endif
492 : :
493 : : #ifdef MS_WINDOWS
494 : : #define sockaddr_rc SOCKADDR_BTH_REDEF
495 : :
496 : : #define USE_BLUETOOTH 1
497 : : #define AF_BLUETOOTH AF_BTH
498 : : #define BTPROTO_RFCOMM BTHPROTO_RFCOMM
499 : : #define _BT_RC_MEMB(sa, memb) ((sa)->memb)
500 : : #endif
501 : :
502 : : /* Convert "sock_addr_t *" to "struct sockaddr *". */
503 : : #define SAS2SA(x) (&((x)->sa))
504 : :
505 : : /*
506 : : * Constants for getnameinfo()
507 : : */
508 : : #if !defined(NI_MAXHOST)
509 : : #define NI_MAXHOST 1025
510 : : #endif
511 : : #if !defined(NI_MAXSERV)
512 : : #define NI_MAXSERV 32
513 : : #endif
514 : :
515 : : #ifndef INVALID_SOCKET /* MS defines this */
516 : : #define INVALID_SOCKET (-1)
517 : : #endif
518 : :
519 : : #ifndef INADDR_NONE
520 : : #define INADDR_NONE (-1)
521 : : #endif
522 : :
523 : : #include "clinic/socketmodule.c.h"
524 : :
525 : : /* XXX There's a problem here: *static* functions are not supposed to have
526 : : a Py prefix (or use CapitalizedWords). Later... */
527 : :
528 : : /* Global variable holding the exception type for errors detected
529 : : by this module (but not argument type or memory errors, etc.). */
530 : : static PyObject *socket_herror;
531 : : static PyObject *socket_gaierror;
532 : :
533 : : /* A forward reference to the socket type object.
534 : : The sock_type variable contains pointers to various functions,
535 : : some of which call new_sockobject(), which uses sock_type, so
536 : : there has to be a circular reference. */
537 : : static PyTypeObject sock_type;
538 : :
539 : : #if defined(HAVE_POLL_H)
540 : : #include <poll.h>
541 : : #elif defined(HAVE_SYS_POLL_H)
542 : : #include <sys/poll.h>
543 : : #endif
544 : :
545 : : /* Largest value to try to store in a socklen_t (used when handling
546 : : ancillary data). POSIX requires socklen_t to hold at least
547 : : (2**31)-1 and recommends against storing larger values, but
548 : : socklen_t was originally int in the BSD interface, so to be on the
549 : : safe side we use the smaller of (2**31)-1 and INT_MAX. */
550 : : #if INT_MAX > 0x7fffffff
551 : : #define SOCKLEN_T_LIMIT 0x7fffffff
552 : : #else
553 : : #define SOCKLEN_T_LIMIT INT_MAX
554 : : #endif
555 : :
556 : : #ifdef HAVE_POLL
557 : : /* Instead of select(), we'll use poll() since poll() works on any fd. */
558 : : #define IS_SELECTABLE(s) 1
559 : : /* Can we call select() with this socket without a buffer overrun? */
560 : : #else
561 : : /* If there's no timeout left, we don't have to call select, so it's a safe,
562 : : * little white lie. */
563 : : #define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0)
564 : : #endif
565 : :
566 : : static PyObject*
567 : 0 : select_error(void)
568 : : {
569 : 0 : PyErr_SetString(PyExc_OSError, "unable to select on socket");
570 : 0 : return NULL;
571 : : }
572 : :
573 : : #ifdef MS_WINDOWS
574 : : #ifndef WSAEAGAIN
575 : : #define WSAEAGAIN WSAEWOULDBLOCK
576 : : #endif
577 : : #define CHECK_ERRNO(expected) \
578 : : (WSAGetLastError() == WSA ## expected)
579 : : #else
580 : : #define CHECK_ERRNO(expected) \
581 : : (errno == expected)
582 : : #endif
583 : :
584 : : #ifdef MS_WINDOWS
585 : : # define GET_SOCK_ERROR WSAGetLastError()
586 : : # define SET_SOCK_ERROR(err) WSASetLastError(err)
587 : : # define SOCK_TIMEOUT_ERR WSAEWOULDBLOCK
588 : : # define SOCK_INPROGRESS_ERR WSAEWOULDBLOCK
589 : : #else
590 : : # define GET_SOCK_ERROR errno
591 : : # define SET_SOCK_ERROR(err) do { errno = err; } while (0)
592 : : # define SOCK_TIMEOUT_ERR EWOULDBLOCK
593 : : # define SOCK_INPROGRESS_ERR EINPROGRESS
594 : : #endif
595 : :
596 : : #ifdef _MSC_VER
597 : : # define SUPPRESS_DEPRECATED_CALL __pragma(warning(suppress: 4996))
598 : : #else
599 : : # define SUPPRESS_DEPRECATED_CALL
600 : : #endif
601 : :
602 : : #ifdef MS_WINDOWS
603 : : /* Does WSASocket() support the WSA_FLAG_NO_HANDLE_INHERIT flag? */
604 : : static int support_wsa_no_inherit = -1;
605 : : #endif
606 : :
607 : : /* Convenience function to raise an error according to errno
608 : : and return a NULL pointer from a function. */
609 : :
610 : : static PyObject *
611 : 1642 : set_error(void)
612 : : {
613 : : #ifdef MS_WINDOWS
614 : : int err_no = WSAGetLastError();
615 : : /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
616 : : recognizes the error codes used by both GetLastError() and
617 : : WSAGetLastError */
618 : : if (err_no)
619 : : return PyErr_SetExcFromWindowsErr(PyExc_OSError, err_no);
620 : : #endif
621 : :
622 : 1642 : return PyErr_SetFromErrno(PyExc_OSError);
623 : : }
624 : :
625 : :
626 : : static PyObject *
627 : 0 : set_herror(int h_error)
628 : : {
629 : : PyObject *v;
630 : :
631 : : #ifdef HAVE_HSTRERROR
632 : 0 : v = Py_BuildValue("(is)", h_error, hstrerror(h_error));
633 : : #else
634 : : v = Py_BuildValue("(is)", h_error, "host not found");
635 : : #endif
636 [ # # ]: 0 : if (v != NULL) {
637 : 0 : PyErr_SetObject(socket_herror, v);
638 : 0 : Py_DECREF(v);
639 : : }
640 : :
641 : 0 : return NULL;
642 : : }
643 : :
644 : :
645 : : static PyObject *
646 : 18 : set_gaierror(int error)
647 : : {
648 : : PyObject *v;
649 : :
650 : : #ifdef EAI_SYSTEM
651 : : /* EAI_SYSTEM is not available on Windows XP. */
652 [ - + ]: 18 : if (error == EAI_SYSTEM)
653 : 0 : return set_error();
654 : : #endif
655 : :
656 : : #ifdef HAVE_GAI_STRERROR
657 : 18 : v = Py_BuildValue("(is)", error, gai_strerror(error));
658 : : #else
659 : : v = Py_BuildValue("(is)", error, "getaddrinfo failed");
660 : : #endif
661 [ + - ]: 18 : if (v != NULL) {
662 : 18 : PyErr_SetObject(socket_gaierror, v);
663 : 18 : Py_DECREF(v);
664 : : }
665 : :
666 : 18 : return NULL;
667 : : }
668 : :
669 : : /* Function to perform the setting of socket blocking mode
670 : : internally. block = (1 | 0). */
671 : : static int
672 : 12619 : internal_setblocking(PySocketSockObject *s, int block)
673 : : {
674 : 12619 : int result = -1;
675 : : #ifdef MS_WINDOWS
676 : : u_long arg;
677 : : #endif
678 : : #if !defined(MS_WINDOWS) \
679 : : && !((defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO)))
680 : : int delay_flag, new_delay_flag;
681 : : #endif
682 : :
683 : 12619 : Py_BEGIN_ALLOW_THREADS
684 : : #ifndef MS_WINDOWS
685 : : #if (defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO))
686 : 12619 : block = !block;
687 [ + + ]: 12619 : if (ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block) == -1)
688 : 1 : goto done;
689 : : #else
690 : : delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
691 : : if (delay_flag == -1)
692 : : goto done;
693 : : if (block)
694 : : new_delay_flag = delay_flag & (~O_NONBLOCK);
695 : : else
696 : : new_delay_flag = delay_flag | O_NONBLOCK;
697 : : if (new_delay_flag != delay_flag)
698 : : if (fcntl(s->sock_fd, F_SETFL, new_delay_flag) == -1)
699 : : goto done;
700 : : #endif
701 : : #else /* MS_WINDOWS */
702 : : arg = !block;
703 : : if (ioctlsocket(s->sock_fd, FIONBIO, &arg) != 0)
704 : : goto done;
705 : : #endif /* MS_WINDOWS */
706 : :
707 : 12618 : result = 0;
708 : :
709 : 12619 : done:
710 : 12619 : Py_END_ALLOW_THREADS
711 : :
712 [ + + ]: 12619 : if (result) {
713 : : #ifndef MS_WINDOWS
714 : 1 : PyErr_SetFromErrno(PyExc_OSError);
715 : : #else
716 : : PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
717 : : #endif
718 : : }
719 : :
720 : 12619 : return result;
721 : : }
722 : :
723 : : static int
724 : 72481 : internal_select(PySocketSockObject *s, int writing, _PyTime_t interval,
725 : : int connect)
726 : : {
727 : : int n;
728 : : #ifdef HAVE_POLL
729 : : struct pollfd pollfd;
730 : : _PyTime_t ms;
731 : : #else
732 : : fd_set fds, efds;
733 : : struct timeval tv, *tvp;
734 : : #endif
735 : :
736 : : /* must be called with the GIL held */
737 : : assert(PyGILState_Check());
738 : :
739 : : /* Error condition is for output only */
740 : : assert(!(connect && !writing));
741 : :
742 : : /* Guard against closed socket */
743 [ + + ]: 72481 : if (s->sock_fd == INVALID_SOCKET)
744 : 1 : return 0;
745 : :
746 : : /* Prefer poll, if available, since you can poll() any fd
747 : : * which can't be done with select(). */
748 : : #ifdef HAVE_POLL
749 : 72480 : pollfd.fd = s->sock_fd;
750 [ + + ]: 72480 : pollfd.events = writing ? POLLOUT : POLLIN;
751 [ + + ]: 72480 : if (connect) {
752 : : /* On Windows, the socket becomes writable on connection success,
753 : : but a connection failure is notified as an error. On POSIX, the
754 : : socket becomes writable on connection success or on connection
755 : : failure. */
756 : 505 : pollfd.events |= POLLERR;
757 : : }
758 : :
759 : : /* s->sock_timeout is in seconds, timeout in ms */
760 : 72480 : ms = _PyTime_AsMilliseconds(interval, _PyTime_ROUND_CEILING);
761 : : assert(ms <= INT_MAX);
762 : :
763 : : /* On some OSes, typically BSD-based ones, the timeout parameter of the
764 : : poll() syscall, when negative, must be exactly INFTIM, where defined,
765 : : or -1. See issue 37811. */
766 [ - + ]: 72480 : if (ms < 0) {
767 : : #ifdef INFTIM
768 : : ms = INFTIM;
769 : : #else
770 : 0 : ms = -1;
771 : : #endif
772 : : }
773 : :
774 : 72480 : Py_BEGIN_ALLOW_THREADS;
775 : 72480 : n = poll(&pollfd, 1, (int)ms);
776 : 72479 : Py_END_ALLOW_THREADS;
777 : : #else
778 : : if (interval >= 0) {
779 : : _PyTime_AsTimeval_clamp(interval, &tv, _PyTime_ROUND_CEILING);
780 : : tvp = &tv;
781 : : }
782 : : else
783 : : tvp = NULL;
784 : :
785 : : FD_ZERO(&fds);
786 : : FD_SET(s->sock_fd, &fds);
787 : : FD_ZERO(&efds);
788 : : if (connect) {
789 : : /* On Windows, the socket becomes writable on connection success,
790 : : but a connection failure is notified as an error. On POSIX, the
791 : : socket becomes writable on connection success or on connection
792 : : failure. */
793 : : FD_SET(s->sock_fd, &efds);
794 : : }
795 : :
796 : : /* See if the socket is ready */
797 : : Py_BEGIN_ALLOW_THREADS;
798 : : if (writing)
799 : : n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
800 : : NULL, &fds, &efds, tvp);
801 : : else
802 : : n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
803 : : &fds, NULL, &efds, tvp);
804 : : Py_END_ALLOW_THREADS;
805 : : #endif
806 : :
807 [ + + ]: 72480 : if (n < 0)
808 : 12 : return -1;
809 [ + + ]: 72468 : if (n == 0)
810 : 46 : return 1;
811 : 72422 : return 0;
812 : : }
813 : :
814 : : /* Call a socket function.
815 : :
816 : : On error, raise an exception and return -1 if err is set, or fill err and
817 : : return -1 otherwise. If a signal was received and the signal handler raised
818 : : an exception, return -1, and set err to -1 if err is set.
819 : :
820 : : On success, return 0, and set err to 0 if err is set.
821 : :
822 : : If the socket has a timeout, wait until the socket is ready before calling
823 : : the function: wait until the socket is writable if writing is nonzero, wait
824 : : until the socket received data otherwise.
825 : :
826 : : If the socket function is interrupted by a signal (failed with EINTR): retry
827 : : the function, except if the signal handler raised an exception (PEP 475).
828 : :
829 : : When the function is retried, recompute the timeout using a monotonic clock.
830 : :
831 : : sock_call_ex() must be called with the GIL held. The socket function is
832 : : called with the GIL released. */
833 : : static int
834 : 107680 : sock_call_ex(PySocketSockObject *s,
835 : : int writing,
836 : : int (*sock_func) (PySocketSockObject *s, void *data),
837 : : void *data,
838 : : int connect,
839 : : int *err,
840 : : _PyTime_t timeout)
841 : : {
842 : 107680 : int has_timeout = (timeout > 0);
843 : 107680 : _PyTime_t deadline = 0;
844 : 107680 : int deadline_initialized = 0;
845 : : int res;
846 : :
847 : : /* sock_call() must be called with the GIL held. */
848 : : assert(PyGILState_Check());
849 : :
850 : : /* outer loop to retry select() when select() is interrupted by a signal
851 : : or to retry select()+sock_func() on false positive (see above) */
852 : : while (1) {
853 : : /* For connect(), poll even for blocking socket. The connection
854 : : runs asynchronously. */
855 [ + + + - ]: 107681 : if (has_timeout || connect) {
856 [ + - ]: 72481 : if (has_timeout) {
857 : : _PyTime_t interval;
858 : :
859 [ + + ]: 72481 : if (deadline_initialized) {
860 : : /* recompute the timeout */
861 : 1 : interval = _PyDeadline_Get(deadline);
862 : : }
863 : : else {
864 : 72480 : deadline_initialized = 1;
865 : 72480 : deadline = _PyDeadline_Init(timeout);
866 : 72480 : interval = timeout;
867 : : }
868 : :
869 [ + - ]: 72481 : if (interval >= 0) {
870 : 72481 : res = internal_select(s, writing, interval, connect);
871 : : }
872 : : else {
873 : 0 : res = 1;
874 : : }
875 : : }
876 : : else {
877 : 0 : res = internal_select(s, writing, timeout, connect);
878 : : }
879 : :
880 [ + + ]: 72481 : if (res == -1) {
881 [ - + ]: 12 : if (err)
882 : 0 : *err = GET_SOCK_ERROR;
883 : :
884 [ + - ]: 12 : if (CHECK_ERRNO(EINTR)) {
885 : : /* select() was interrupted by a signal */
886 [ + + ]: 12 : if (PyErr_CheckSignals()) {
887 [ - + ]: 11 : if (err)
888 : 0 : *err = -1;
889 : 11 : return -1;
890 : : }
891 : :
892 : : /* retry select() */
893 : 1 : continue;
894 : : }
895 : :
896 : : /* select() failed */
897 : 0 : s->errorhandler();
898 : 0 : return -1;
899 : : }
900 : :
901 [ + + ]: 72469 : if (res == 1) {
902 [ + + ]: 46 : if (err)
903 : 1 : *err = SOCK_TIMEOUT_ERR;
904 : : else
905 : 45 : PyErr_SetString(PyExc_TimeoutError, "timed out");
906 : 46 : return -1;
907 : : }
908 : :
909 : : /* the socket is ready */
910 : : }
911 : :
912 : : /* inner loop to retry sock_func() when sock_func() is interrupted
913 : : by a signal */
914 : : while (1) {
915 : 107667 : Py_BEGIN_ALLOW_THREADS
916 : 107667 : res = sock_func(s, data);
917 : 107623 : Py_END_ALLOW_THREADS
918 : :
919 [ + + ]: 107625 : if (res) {
920 : : /* sock_func() succeeded */
921 [ - + ]: 106548 : if (err)
922 : 0 : *err = 0;
923 : 106548 : return 0;
924 : : }
925 : :
926 [ - + ]: 1077 : if (err)
927 : 0 : *err = GET_SOCK_ERROR;
928 : :
929 [ + + ]: 1077 : if (!CHECK_ERRNO(EINTR))
930 : 1033 : break;
931 : :
932 : : /* sock_func() was interrupted by a signal */
933 [ - + ]: 44 : if (PyErr_CheckSignals()) {
934 [ # # ]: 0 : if (err)
935 : 0 : *err = -1;
936 : 0 : return -1;
937 : : }
938 : :
939 : : /* retry sock_func() */
940 : : }
941 : :
942 [ + + ]: 1033 : if (s->sock_timeout > 0
943 [ + - - + ]: 36 : && (CHECK_ERRNO(EWOULDBLOCK) || CHECK_ERRNO(EAGAIN))) {
944 : : /* False positive: sock_func() failed with EWOULDBLOCK or EAGAIN.
945 : :
946 : : For example, select() could indicate a socket is ready for
947 : : reading, but the data then discarded by the OS because of a
948 : : wrong checksum.
949 : :
950 : : Loop on select() to recheck for socket readiness. */
951 : 0 : continue;
952 : : }
953 : :
954 : : /* sock_func() failed */
955 [ + - ]: 1033 : if (!err)
956 : 1033 : s->errorhandler();
957 : : /* else: err was already set before */
958 : 1033 : return -1;
959 : : }
960 : : }
961 : :
962 : : static int
963 : 103239 : sock_call(PySocketSockObject *s,
964 : : int writing,
965 : : int (*func) (PySocketSockObject *s, void *data),
966 : : void *data)
967 : : {
968 : 103239 : return sock_call_ex(s, writing, func, data, 0, NULL, s->sock_timeout);
969 : : }
970 : :
971 : :
972 : : /* Initialize a new socket object. */
973 : :
974 : : /* Default timeout for new sockets */
975 : : static _PyTime_t defaulttimeout = _PYTIME_FROMSECONDS(-1);
976 : :
977 : : static int
978 : 281981 : init_sockobject(PySocketSockObject *s,
979 : : SOCKET_T fd, int family, int type, int proto)
980 : : {
981 : 281981 : s->sock_fd = fd;
982 : 281981 : s->sock_family = family;
983 : :
984 : 281981 : s->sock_type = type;
985 : :
986 : : /* It's possible to pass SOCK_NONBLOCK and SOCK_CLOEXEC bit flags
987 : : on some OSes as part of socket.type. We want to reset them here,
988 : : to make socket.type be set to the same value on all platforms.
989 : : Otherwise, simple code like 'if sock.type == SOCK_STREAM' is
990 : : not portable.
991 : : */
992 : : #ifdef SOCK_NONBLOCK
993 : 281981 : s->sock_type = s->sock_type & ~SOCK_NONBLOCK;
994 : : #endif
995 : : #ifdef SOCK_CLOEXEC
996 : 281981 : s->sock_type = s->sock_type & ~SOCK_CLOEXEC;
997 : : #endif
998 : :
999 : 281981 : s->sock_proto = proto;
1000 : :
1001 : 281981 : s->errorhandler = &set_error;
1002 : : #ifdef SOCK_NONBLOCK
1003 [ + + ]: 281981 : if (type & SOCK_NONBLOCK)
1004 : 5 : s->sock_timeout = 0;
1005 : : else
1006 : : #endif
1007 : : {
1008 : 281976 : s->sock_timeout = defaulttimeout;
1009 [ + + ]: 281976 : if (defaulttimeout >= 0) {
1010 [ - + ]: 123 : if (internal_setblocking(s, 0) == -1) {
1011 : 0 : return -1;
1012 : : }
1013 : : }
1014 : : }
1015 : 281981 : return 0;
1016 : : }
1017 : :
1018 : :
1019 : : #ifdef HAVE_SOCKETPAIR
1020 : : /* Create a new socket object.
1021 : : This just creates the object and initializes it.
1022 : : If the creation fails, return NULL and set an exception (implicit
1023 : : in NEWOBJ()). */
1024 : :
1025 : : static PySocketSockObject *
1026 : 134558 : new_sockobject(SOCKET_T fd, int family, int type, int proto)
1027 : : {
1028 : : PySocketSockObject *s;
1029 : : s = (PySocketSockObject *)
1030 : 134558 : PyType_GenericNew(&sock_type, NULL, NULL);
1031 [ - + ]: 134558 : if (s == NULL)
1032 : 0 : return NULL;
1033 [ - + ]: 134558 : if (init_sockobject(s, fd, family, type, proto) == -1) {
1034 : 0 : Py_DECREF(s);
1035 : 0 : return NULL;
1036 : : }
1037 : 134558 : return s;
1038 : : }
1039 : : #endif
1040 : :
1041 : :
1042 : : /* Lock to allow python interpreter to continue, but only allow one
1043 : : thread to be in gethostbyname or getaddrinfo */
1044 : : #if defined(USE_GETHOSTBYNAME_LOCK)
1045 : : static PyThread_type_lock netdb_lock;
1046 : : #endif
1047 : :
1048 : :
1049 : : /* Convert a string specifying a host name or one of a few symbolic
1050 : : names to a numeric IP address. This usually calls gethostbyname()
1051 : : to do the work; the names "" and "<broadcast>" are special.
1052 : : Return the length (IPv4 should be 4 bytes), or negative if
1053 : : an error occurred; then an exception is raised. */
1054 : :
1055 : : static int
1056 : 9000 : setipaddr(const char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
1057 : : {
1058 : : struct addrinfo hints, *res;
1059 : : int error;
1060 : :
1061 : 9000 : memset((void *) addr_ret, '\0', sizeof(*addr_ret));
1062 [ + + ]: 9000 : if (name[0] == '\0') {
1063 : : int siz;
1064 : 16 : memset(&hints, 0, sizeof(hints));
1065 : 16 : hints.ai_family = af;
1066 : 16 : hints.ai_socktype = SOCK_DGRAM; /*dummy*/
1067 : 16 : hints.ai_flags = AI_PASSIVE;
1068 : 16 : Py_BEGIN_ALLOW_THREADS
1069 : 16 : error = getaddrinfo(NULL, "0", &hints, &res);
1070 : 16 : Py_END_ALLOW_THREADS
1071 : : /* We assume that those thread-unsafe getaddrinfo() versions
1072 : : *are* safe regarding their return value, ie. that a
1073 : : subsequent call to getaddrinfo() does not destroy the
1074 : : outcome of the first call. */
1075 [ - + ]: 16 : if (error) {
1076 : 0 : set_gaierror(error);
1077 : 0 : return -1;
1078 : : }
1079 [ + + - ]: 16 : switch (res->ai_family) {
1080 : 9 : case AF_INET:
1081 : 9 : siz = 4;
1082 : 9 : break;
1083 : : #ifdef ENABLE_IPV6
1084 : 7 : case AF_INET6:
1085 : 7 : siz = 16;
1086 : 7 : break;
1087 : : #endif
1088 : 0 : default:
1089 : 0 : freeaddrinfo(res);
1090 : 0 : PyErr_SetString(PyExc_OSError,
1091 : : "unsupported address family");
1092 : 0 : return -1;
1093 : : }
1094 [ - + ]: 16 : if (res->ai_next) {
1095 : 0 : freeaddrinfo(res);
1096 : 0 : PyErr_SetString(PyExc_OSError,
1097 : : "wildcard resolved to multiple address");
1098 : 0 : return -1;
1099 : : }
1100 [ - + ]: 16 : if (res->ai_addrlen < addr_ret_size)
1101 : 0 : addr_ret_size = res->ai_addrlen;
1102 : 16 : memcpy(addr_ret, res->ai_addr, addr_ret_size);
1103 : 16 : freeaddrinfo(res);
1104 : 16 : return siz;
1105 : : }
1106 : : /* special-case broadcast - inet_addr() below can return INADDR_NONE for
1107 : : * this */
1108 [ + + ]: 8984 : if (strcmp(name, "255.255.255.255") == 0 ||
1109 [ - + ]: 8983 : strcmp(name, "<broadcast>") == 0) {
1110 : : struct sockaddr_in *sin;
1111 [ - + - - ]: 1 : if (af != AF_INET && af != AF_UNSPEC) {
1112 : 0 : PyErr_SetString(PyExc_OSError,
1113 : : "address family mismatched");
1114 : 0 : return -1;
1115 : : }
1116 : 1 : sin = (struct sockaddr_in *)addr_ret;
1117 : 1 : memset((void *) sin, '\0', sizeof(*sin));
1118 : 1 : sin->sin_family = AF_INET;
1119 : : #ifdef HAVE_SOCKADDR_SA_LEN
1120 : : sin->sin_len = sizeof(*sin);
1121 : : #endif
1122 : 1 : sin->sin_addr.s_addr = INADDR_BROADCAST;
1123 : 1 : return sizeof(sin->sin_addr);
1124 : : }
1125 : :
1126 : : /* avoid a name resolution in case of numeric address */
1127 : : #ifdef HAVE_INET_PTON
1128 : : /* check for an IPv4 address */
1129 [ + + + + ]: 8983 : if (af == AF_UNSPEC || af == AF_INET) {
1130 : 7867 : struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1131 : 7867 : memset(sin, 0, sizeof(*sin));
1132 [ + + ]: 7867 : if (inet_pton(AF_INET, name, &sin->sin_addr) > 0) {
1133 : 5270 : sin->sin_family = AF_INET;
1134 : : #ifdef HAVE_SOCKADDR_SA_LEN
1135 : : sin->sin_len = sizeof(*sin);
1136 : : #endif
1137 : 5270 : return 4;
1138 : : }
1139 : : }
1140 : : #ifdef ENABLE_IPV6
1141 : : /* check for an IPv6 address - if the address contains a scope ID, we
1142 : : * fallback to getaddrinfo(), which can handle translation from interface
1143 : : * name to interface index */
1144 [ + + + + : 3713 : if ((af == AF_UNSPEC || af == AF_INET6) && !strchr(name, '%')) {
+ - ]
1145 : 1132 : struct sockaddr_in6 *sin = (struct sockaddr_in6 *)addr_ret;
1146 : 1132 : memset(sin, 0, sizeof(*sin));
1147 [ + + ]: 1132 : if (inet_pton(AF_INET6, name, &sin->sin6_addr) > 0) {
1148 : 1063 : sin->sin6_family = AF_INET6;
1149 : : #ifdef HAVE_SOCKADDR_SA_LEN
1150 : : sin->sin6_len = sizeof(*sin);
1151 : : #endif
1152 : 1063 : return 16;
1153 : : }
1154 : : }
1155 : : #endif /* ENABLE_IPV6 */
1156 : : #else /* HAVE_INET_PTON */
1157 : : /* check for an IPv4 address */
1158 : : if (af == AF_INET || af == AF_UNSPEC) {
1159 : : struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1160 : : memset(sin, 0, sizeof(*sin));
1161 : : if ((sin->sin_addr.s_addr = inet_addr(name)) != INADDR_NONE) {
1162 : : sin->sin_family = AF_INET;
1163 : : #ifdef HAVE_SOCKADDR_SA_LEN
1164 : : sin->sin_len = sizeof(*sin);
1165 : : #endif
1166 : : return 4;
1167 : : }
1168 : : }
1169 : : #endif /* HAVE_INET_PTON */
1170 : :
1171 : : /* perform a name resolution */
1172 : 2650 : memset(&hints, 0, sizeof(hints));
1173 : 2650 : hints.ai_family = af;
1174 : 2650 : Py_BEGIN_ALLOW_THREADS
1175 : 2650 : error = getaddrinfo(name, NULL, &hints, &res);
1176 : : #if defined(__digital__) && defined(__unix__)
1177 : : if (error == EAI_NONAME && af == AF_UNSPEC) {
1178 : : /* On Tru64 V5.1, numeric-to-addr conversion fails
1179 : : if no address family is given. Assume IPv4 for now.*/
1180 : : hints.ai_family = AF_INET;
1181 : : error = getaddrinfo(name, NULL, &hints, &res);
1182 : : }
1183 : : #endif
1184 : 2650 : Py_END_ALLOW_THREADS
1185 [ + + ]: 2650 : if (error) {
1186 : 12 : set_gaierror(error);
1187 : 12 : return -1;
1188 : : }
1189 [ + + ]: 2638 : if (res->ai_addrlen < addr_ret_size)
1190 : 15 : addr_ret_size = res->ai_addrlen;
1191 : 2638 : memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
1192 : 2638 : freeaddrinfo(res);
1193 [ + + - ]: 2638 : switch (addr_ret->sa_family) {
1194 : 2574 : case AF_INET:
1195 : 2574 : return 4;
1196 : : #ifdef ENABLE_IPV6
1197 : 64 : case AF_INET6:
1198 : 64 : return 16;
1199 : : #endif
1200 : 0 : default:
1201 : 0 : PyErr_SetString(PyExc_OSError, "unknown address family");
1202 : 0 : return -1;
1203 : : }
1204 : : }
1205 : :
1206 : :
1207 : : /* Convert IPv4 sockaddr to a Python str. */
1208 : :
1209 : : static PyObject *
1210 : 6401 : make_ipv4_addr(const struct sockaddr_in *addr)
1211 : : {
1212 : : char buf[INET_ADDRSTRLEN];
1213 [ - + ]: 6401 : if (inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(buf)) == NULL) {
1214 : 0 : PyErr_SetFromErrno(PyExc_OSError);
1215 : 0 : return NULL;
1216 : : }
1217 : 6401 : return PyUnicode_FromString(buf);
1218 : : }
1219 : :
1220 : : #ifdef ENABLE_IPV6
1221 : : /* Convert IPv6 sockaddr to a Python str. */
1222 : :
1223 : : static PyObject *
1224 : 1568 : make_ipv6_addr(const struct sockaddr_in6 *addr)
1225 : : {
1226 : : char buf[INET6_ADDRSTRLEN];
1227 [ - + ]: 1568 : if (inet_ntop(AF_INET6, &addr->sin6_addr, buf, sizeof(buf)) == NULL) {
1228 : 0 : PyErr_SetFromErrno(PyExc_OSError);
1229 : 0 : return NULL;
1230 : : }
1231 : 1568 : return PyUnicode_FromString(buf);
1232 : : }
1233 : : #endif
1234 : :
1235 : : #ifdef USE_BLUETOOTH
1236 : : /* Convert a string representation of a Bluetooth address into a numeric
1237 : : address. Returns the length (6), or raises an exception and returns -1 if
1238 : : an error occurred. */
1239 : :
1240 : : static int
1241 : 0 : setbdaddr(const char *name, bdaddr_t *bdaddr)
1242 : : {
1243 : : unsigned int b0, b1, b2, b3, b4, b5;
1244 : : char ch;
1245 : : int n;
1246 : :
1247 : 0 : n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
1248 : : &b5, &b4, &b3, &b2, &b1, &b0, &ch);
1249 [ # # # # ]: 0 : if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
1250 : :
1251 : : #ifdef MS_WINDOWS
1252 : : *bdaddr = (ULONGLONG)(b0 & 0xFF);
1253 : : *bdaddr |= ((ULONGLONG)(b1 & 0xFF) << 8);
1254 : : *bdaddr |= ((ULONGLONG)(b2 & 0xFF) << 16);
1255 : : *bdaddr |= ((ULONGLONG)(b3 & 0xFF) << 24);
1256 : : *bdaddr |= ((ULONGLONG)(b4 & 0xFF) << 32);
1257 : : *bdaddr |= ((ULONGLONG)(b5 & 0xFF) << 40);
1258 : : #else
1259 : 0 : bdaddr->b[0] = b0;
1260 : 0 : bdaddr->b[1] = b1;
1261 : 0 : bdaddr->b[2] = b2;
1262 : 0 : bdaddr->b[3] = b3;
1263 : 0 : bdaddr->b[4] = b4;
1264 : 0 : bdaddr->b[5] = b5;
1265 : : #endif
1266 : :
1267 : 0 : return 6;
1268 : : } else {
1269 : 0 : PyErr_SetString(PyExc_OSError, "bad bluetooth address");
1270 : 0 : return -1;
1271 : : }
1272 : : }
1273 : :
1274 : : /* Create a string representation of the Bluetooth address. This is always a
1275 : : string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
1276 : : value (zero padded if necessary). */
1277 : :
1278 : : static PyObject *
1279 : 0 : makebdaddr(bdaddr_t *bdaddr)
1280 : : {
1281 : : char buf[(6 * 2) + 5 + 1];
1282 : :
1283 : : #ifdef MS_WINDOWS
1284 : : int i;
1285 : : unsigned int octets[6];
1286 : :
1287 : : for (i = 0; i < 6; ++i) {
1288 : : octets[i] = ((*bdaddr) >> (8 * i)) & 0xFF;
1289 : : }
1290 : :
1291 : : sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1292 : : octets[5], octets[4], octets[3],
1293 : : octets[2], octets[1], octets[0]);
1294 : : #else
1295 : 0 : sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1296 : 0 : bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1297 : 0 : bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1298 : : #endif
1299 : :
1300 : 0 : return PyUnicode_FromString(buf);
1301 : : }
1302 : : #endif
1303 : :
1304 : :
1305 : : /* Create an object representing the given socket address,
1306 : : suitable for passing it back to bind(), connect() etc.
1307 : : The family field of the sockaddr structure is inspected
1308 : : to determine what kind of address it really is. */
1309 : :
1310 : : /*ARGSUSED*/
1311 : : static PyObject *
1312 : 10384 : makesockaddr(SOCKET_T sockfd, struct sockaddr *addr, size_t addrlen, int proto)
1313 : : {
1314 [ + + ]: 10384 : if (addrlen == 0) {
1315 : : /* No address -- may be recvfrom() from known socket */
1316 : 533 : Py_RETURN_NONE;
1317 : : }
1318 : :
1319 [ + + - + : 9851 : switch (addr->sa_family) {
- + - - -
+ - - ]
1320 : :
1321 : 6230 : case AF_INET:
1322 : : {
1323 : 6230 : const struct sockaddr_in *a = (const struct sockaddr_in *)addr;
1324 : 6230 : PyObject *addrobj = make_ipv4_addr(a);
1325 : 6230 : PyObject *ret = NULL;
1326 [ + - ]: 6230 : if (addrobj) {
1327 : 6230 : ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1328 : 6230 : Py_DECREF(addrobj);
1329 : : }
1330 : 6230 : return ret;
1331 : : }
1332 : :
1333 : : #if defined(AF_UNIX)
1334 : 2091 : case AF_UNIX:
1335 : : {
1336 : 2091 : struct sockaddr_un *a = (struct sockaddr_un *) addr;
1337 : : #ifdef __linux__
1338 : 2091 : size_t linuxaddrlen = addrlen - offsetof(struct sockaddr_un, sun_path);
1339 [ + + + + ]: 2091 : if (linuxaddrlen > 0 && a->sun_path[0] == 0) { /* Linux abstract namespace */
1340 : 114 : return PyBytes_FromStringAndSize(a->sun_path, linuxaddrlen);
1341 : : }
1342 : : else
1343 : : #endif /* linux */
1344 : : {
1345 : : /* regular NULL-terminated string */
1346 : 1977 : return PyUnicode_DecodeFSDefault(a->sun_path);
1347 : : }
1348 : : }
1349 : : #endif /* AF_UNIX */
1350 : :
1351 : : #if defined(AF_NETLINK)
1352 : 0 : case AF_NETLINK:
1353 : : {
1354 : 0 : struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1355 : 0 : return Py_BuildValue("II", a->nl_pid, a->nl_groups);
1356 : : }
1357 : : #endif /* AF_NETLINK */
1358 : :
1359 : : #if defined(AF_QIPCRTR)
1360 : 5 : case AF_QIPCRTR:
1361 : : {
1362 : 5 : struct sockaddr_qrtr *a = (struct sockaddr_qrtr *) addr;
1363 : 5 : return Py_BuildValue("II", a->sq_node, a->sq_port);
1364 : : }
1365 : : #endif /* AF_QIPCRTR */
1366 : :
1367 : : #if defined(AF_VSOCK)
1368 : 0 : case AF_VSOCK:
1369 : : {
1370 : 0 : struct sockaddr_vm *a = (struct sockaddr_vm *) addr;
1371 : 0 : return Py_BuildValue("II", a->svm_cid, a->svm_port);
1372 : : }
1373 : : #endif /* AF_VSOCK */
1374 : :
1375 : : #ifdef ENABLE_IPV6
1376 : 1524 : case AF_INET6:
1377 : : {
1378 : 1524 : const struct sockaddr_in6 *a = (const struct sockaddr_in6 *)addr;
1379 : 1524 : PyObject *addrobj = make_ipv6_addr(a);
1380 : 1524 : PyObject *ret = NULL;
1381 [ + - ]: 1524 : if (addrobj) {
1382 : 1524 : ret = Py_BuildValue("OiII",
1383 : : addrobj,
1384 : 1524 : ntohs(a->sin6_port),
1385 : 1524 : ntohl(a->sin6_flowinfo),
1386 : 1524 : a->sin6_scope_id);
1387 : 1524 : Py_DECREF(addrobj);
1388 : : }
1389 : 1524 : return ret;
1390 : : }
1391 : : #endif /* ENABLE_IPV6 */
1392 : :
1393 : : #ifdef USE_BLUETOOTH
1394 : 0 : case AF_BLUETOOTH:
1395 [ # # # # : 0 : switch (proto) {
# ]
1396 : :
1397 : : #ifdef BTPROTO_L2CAP
1398 : 0 : case BTPROTO_L2CAP:
1399 : : {
1400 : 0 : struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1401 : 0 : PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1402 : 0 : PyObject *ret = NULL;
1403 [ # # ]: 0 : if (addrobj) {
1404 : 0 : ret = Py_BuildValue("Oi",
1405 : : addrobj,
1406 : 0 : _BT_L2_MEMB(a, psm));
1407 : 0 : Py_DECREF(addrobj);
1408 : : }
1409 : 0 : return ret;
1410 : : }
1411 : :
1412 : : #endif /* BTPROTO_L2CAP */
1413 : :
1414 : 0 : case BTPROTO_RFCOMM:
1415 : : {
1416 : 0 : struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1417 : 0 : PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1418 : 0 : PyObject *ret = NULL;
1419 [ # # ]: 0 : if (addrobj) {
1420 : 0 : ret = Py_BuildValue("Oi",
1421 : : addrobj,
1422 : 0 : _BT_RC_MEMB(a, channel));
1423 : 0 : Py_DECREF(addrobj);
1424 : : }
1425 : 0 : return ret;
1426 : : }
1427 : :
1428 : : #ifdef BTPROTO_HCI
1429 : 0 : case BTPROTO_HCI:
1430 : : {
1431 : 0 : struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
1432 : : #if defined(__NetBSD__) || defined(__DragonFly__)
1433 : : return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));
1434 : : #else /* __NetBSD__ || __DragonFly__ */
1435 : 0 : PyObject *ret = NULL;
1436 : 0 : ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1437 : 0 : return ret;
1438 : : #endif /* !(__NetBSD__ || __DragonFly__) */
1439 : : }
1440 : :
1441 : : #if !defined(__FreeBSD__)
1442 : 0 : case BTPROTO_SCO:
1443 : : {
1444 : 0 : struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1445 : 0 : return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1446 : : }
1447 : : #endif /* !__FreeBSD__ */
1448 : : #endif /* BTPROTO_HCI */
1449 : :
1450 : 0 : default:
1451 : 0 : PyErr_SetString(PyExc_ValueError,
1452 : : "Unknown Bluetooth protocol");
1453 : 0 : return NULL;
1454 : : }
1455 : : #endif /* USE_BLUETOOTH */
1456 : :
1457 : : #if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)
1458 : 0 : case AF_PACKET:
1459 : : {
1460 : 0 : struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1461 : 0 : const char *ifname = "";
1462 : : struct ifreq ifr;
1463 : : /* need to look up interface name give index */
1464 [ # # ]: 0 : if (a->sll_ifindex) {
1465 : 0 : ifr.ifr_ifindex = a->sll_ifindex;
1466 [ # # ]: 0 : if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1467 : 0 : ifname = ifr.ifr_name;
1468 : : }
1469 : 0 : return Py_BuildValue("shbhy#",
1470 : : ifname,
1471 : 0 : ntohs(a->sll_protocol),
1472 : 0 : a->sll_pkttype,
1473 : 0 : a->sll_hatype,
1474 : 0 : a->sll_addr,
1475 : 0 : (Py_ssize_t)a->sll_halen);
1476 : : }
1477 : : #endif /* HAVE_NETPACKET_PACKET_H && SIOCGIFNAME */
1478 : :
1479 : : #ifdef HAVE_LINUX_TIPC_H
1480 : 0 : case AF_TIPC:
1481 : : {
1482 : 0 : struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1483 [ # # ]: 0 : if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1484 : 0 : return Py_BuildValue("IIIII",
1485 : 0 : a->addrtype,
1486 : : a->addr.nameseq.type,
1487 : : a->addr.nameseq.lower,
1488 : : a->addr.nameseq.upper,
1489 : 0 : a->scope);
1490 [ # # ]: 0 : } else if (a->addrtype == TIPC_ADDR_NAME) {
1491 : 0 : return Py_BuildValue("IIIII",
1492 : 0 : a->addrtype,
1493 : : a->addr.name.name.type,
1494 : : a->addr.name.name.instance,
1495 : : a->addr.name.name.instance,
1496 : 0 : a->scope);
1497 [ # # ]: 0 : } else if (a->addrtype == TIPC_ADDR_ID) {
1498 : 0 : return Py_BuildValue("IIIII",
1499 : 0 : a->addrtype,
1500 : : a->addr.id.node,
1501 : : a->addr.id.ref,
1502 : : 0,
1503 : 0 : a->scope);
1504 : : } else {
1505 : 0 : PyErr_SetString(PyExc_ValueError,
1506 : : "Invalid address type");
1507 : 0 : return NULL;
1508 : : }
1509 : : }
1510 : : #endif /* HAVE_LINUX_TIPC_H */
1511 : :
1512 : : #if defined(AF_CAN) && defined(SIOCGIFNAME)
1513 : 1 : case AF_CAN:
1514 : : {
1515 : 1 : struct sockaddr_can *a = (struct sockaddr_can *)addr;
1516 : 1 : const char *ifname = "";
1517 : : struct ifreq ifr;
1518 : : /* need to look up interface name given index */
1519 [ - + ]: 1 : if (a->can_ifindex) {
1520 : 0 : ifr.ifr_ifindex = a->can_ifindex;
1521 [ # # ]: 0 : if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1522 : 0 : ifname = ifr.ifr_name;
1523 : : }
1524 : :
1525 [ - - + ]: 1 : switch (proto) {
1526 : : #ifdef CAN_ISOTP
1527 : 0 : case CAN_ISOTP:
1528 : : {
1529 : 0 : return Py_BuildValue("O&kk", PyUnicode_DecodeFSDefault,
1530 : : ifname,
1531 : : a->can_addr.tp.rx_id,
1532 : : a->can_addr.tp.tx_id);
1533 : : }
1534 : : #endif /* CAN_ISOTP */
1535 : : #ifdef CAN_J1939
1536 : 0 : case CAN_J1939:
1537 : : {
1538 : 0 : return Py_BuildValue("O&KIB", PyUnicode_DecodeFSDefault,
1539 : : ifname,
1540 : 0 : (unsigned long long)a->can_addr.j1939.name,
1541 : 0 : (unsigned int)a->can_addr.j1939.pgn,
1542 : 0 : a->can_addr.j1939.addr);
1543 : : }
1544 : : #endif /* CAN_J1939 */
1545 : 1 : default:
1546 : : {
1547 : 1 : return Py_BuildValue("(O&)", PyUnicode_DecodeFSDefault,
1548 : : ifname);
1549 : : }
1550 : : }
1551 : : }
1552 : : #endif /* AF_CAN && SIOCGIFNAME */
1553 : :
1554 : : #ifdef PF_SYSTEM
1555 : : case PF_SYSTEM:
1556 : : switch(proto) {
1557 : : #ifdef SYSPROTO_CONTROL
1558 : : case SYSPROTO_CONTROL:
1559 : : {
1560 : : struct sockaddr_ctl *a = (struct sockaddr_ctl *)addr;
1561 : : return Py_BuildValue("(II)", a->sc_id, a->sc_unit);
1562 : : }
1563 : : #endif /* SYSPROTO_CONTROL */
1564 : : default:
1565 : : PyErr_SetString(PyExc_ValueError,
1566 : : "Invalid address type");
1567 : : return 0;
1568 : : }
1569 : : #endif /* PF_SYSTEM */
1570 : :
1571 : : #ifdef HAVE_SOCKADDR_ALG
1572 : 0 : case AF_ALG:
1573 : : {
1574 : 0 : struct sockaddr_alg *a = (struct sockaddr_alg *)addr;
1575 : 0 : return Py_BuildValue("s#s#HH",
1576 : 0 : a->salg_type,
1577 : 0 : strnlen((const char*)a->salg_type,
1578 : : sizeof(a->salg_type)),
1579 : 0 : a->salg_name,
1580 : 0 : strnlen((const char*)a->salg_name,
1581 : : sizeof(a->salg_name)),
1582 : : a->salg_feat,
1583 : : a->salg_mask);
1584 : : }
1585 : : #endif /* HAVE_SOCKADDR_ALG */
1586 : :
1587 : : #ifdef HAVE_AF_HYPERV
1588 : : case AF_HYPERV:
1589 : : {
1590 : : SOCKADDR_HV *a = (SOCKADDR_HV *) addr;
1591 : :
1592 : : wchar_t *guidStr;
1593 : : RPC_STATUS res = UuidToStringW(&a->VmId, &guidStr);
1594 : : if (res != RPC_S_OK) {
1595 : : PyErr_SetFromWindowsErr(res);
1596 : : return 0;
1597 : : }
1598 : : PyObject *vmId = PyUnicode_FromWideChar(guidStr, -1);
1599 : : res = RpcStringFreeW(&guidStr);
1600 : : assert(res == RPC_S_OK);
1601 : :
1602 : : res = UuidToStringW(&a->ServiceId, &guidStr);
1603 : : if (res != RPC_S_OK) {
1604 : : Py_DECREF(vmId);
1605 : : PyErr_SetFromWindowsErr(res);
1606 : : return 0;
1607 : : }
1608 : : PyObject *serviceId = PyUnicode_FromWideChar(guidStr, -1);
1609 : : res = RpcStringFreeW(&guidStr);
1610 : : assert(res == RPC_S_OK);
1611 : :
1612 : : return Py_BuildValue("NN", vmId, serviceId);
1613 : : }
1614 : : #endif /* AF_HYPERV */
1615 : :
1616 : : /* More cases here... */
1617 : :
1618 : 0 : default:
1619 : : /* If we don't know the address family, don't raise an
1620 : : exception -- return it as an (int, bytes) tuple. */
1621 : 0 : return Py_BuildValue("iy#",
1622 : 0 : addr->sa_family,
1623 : 0 : addr->sa_data,
1624 : : sizeof(addr->sa_data));
1625 : :
1626 : : }
1627 : : }
1628 : :
1629 : : /* Helper for getsockaddrarg: bypass IDNA for ASCII-only host names
1630 : : (in particular, numeric IP addresses). */
1631 : : struct maybe_idna {
1632 : : PyObject *obj;
1633 : : char *buf;
1634 : : };
1635 : :
1636 : : static void
1637 : 8815 : idna_cleanup(struct maybe_idna *data)
1638 : : {
1639 [ - + ]: 8815 : Py_CLEAR(data->obj);
1640 : 8815 : }
1641 : :
1642 : : static int
1643 : 8815 : idna_converter(PyObject *obj, struct maybe_idna *data)
1644 : : {
1645 : : size_t len;
1646 : : PyObject *obj2;
1647 [ - + ]: 8815 : if (obj == NULL) {
1648 : 0 : idna_cleanup(data);
1649 : 0 : return 1;
1650 : : }
1651 : 8815 : data->obj = NULL;
1652 : 8815 : len = -1;
1653 [ - + ]: 8815 : if (PyBytes_Check(obj)) {
1654 : 0 : data->buf = PyBytes_AsString(obj);
1655 : 0 : len = PyBytes_Size(obj);
1656 : : }
1657 [ - + ]: 8815 : else if (PyByteArray_Check(obj)) {
1658 : 0 : data->buf = PyByteArray_AsString(obj);
1659 : 0 : len = PyByteArray_Size(obj);
1660 : : }
1661 [ + - ]: 8815 : else if (PyUnicode_Check(obj)) {
1662 [ - + ]: 8815 : if (PyUnicode_READY(obj) == -1) {
1663 : 0 : return 0;
1664 : : }
1665 [ + - ]: 8815 : if (PyUnicode_IS_COMPACT_ASCII(obj)) {
1666 : 8815 : data->buf = PyUnicode_DATA(obj);
1667 : 8815 : len = PyUnicode_GET_LENGTH(obj);
1668 : : }
1669 : : else {
1670 : 0 : obj2 = PyUnicode_AsEncodedString(obj, "idna", NULL);
1671 [ # # ]: 0 : if (!obj2) {
1672 : 0 : PyErr_SetString(PyExc_TypeError, "encoding of hostname failed");
1673 : 0 : return 0;
1674 : : }
1675 : : assert(PyBytes_Check(obj2));
1676 : 0 : data->obj = obj2;
1677 : 0 : data->buf = PyBytes_AS_STRING(obj2);
1678 : 0 : len = PyBytes_GET_SIZE(obj2);
1679 : : }
1680 : : }
1681 : : else {
1682 : 0 : PyErr_Format(PyExc_TypeError, "str, bytes or bytearray expected, not %s",
1683 : 0 : Py_TYPE(obj)->tp_name);
1684 : 0 : return 0;
1685 : : }
1686 [ - + ]: 8815 : if (strlen(data->buf) != len) {
1687 [ # # ]: 0 : Py_CLEAR(data->obj);
1688 : 0 : PyErr_SetString(PyExc_TypeError, "host name must not contain null character");
1689 : 0 : return 0;
1690 : : }
1691 : 8815 : return Py_CLEANUP_SUPPORTED;
1692 : : }
1693 : :
1694 : : /* Parse a socket address argument according to the socket object's
1695 : : address family. Return 1 if the address was in the proper format,
1696 : : 0 of not. The address is returned through addr_ret, its length
1697 : : through len_ret. */
1698 : :
1699 : : static int
1700 : 12647 : getsockaddrarg(PySocketSockObject *s, PyObject *args,
1701 : : sock_addr_t *addrbuf, int *len_ret, const char *caller)
1702 : : {
1703 [ + - + - : 12647 : switch (s->sock_family) {
+ + - - -
+ + - ]
1704 : :
1705 : : #if defined(AF_UNIX)
1706 : 3800 : case AF_UNIX:
1707 : : {
1708 : : Py_buffer path;
1709 : 3800 : int retval = 0;
1710 : :
1711 : : /* PEP 383. Not using PyUnicode_FSConverter since we need to
1712 : : allow embedded nulls on Linux. */
1713 [ + + ]: 3800 : if (PyUnicode_Check(args)) {
1714 [ - + ]: 1211 : if ((args = PyUnicode_EncodeFSDefault(args)) == NULL)
1715 : 0 : return 0;
1716 : : }
1717 : : else
1718 : 2589 : Py_INCREF(args);
1719 [ + + ]: 3800 : if (!PyArg_Parse(args, "y*", &path)) {
1720 : 1 : Py_DECREF(args);
1721 : 1 : return retval;
1722 : : }
1723 : : assert(path.len >= 0);
1724 : :
1725 : 3799 : struct sockaddr_un* addr = &addrbuf->un;
1726 : : #ifdef __linux__
1727 [ + + + + ]: 3799 : if (path.len == 0 || *(const char *)path.buf == 0) {
1728 : : /* Linux abstract namespace extension:
1729 : : - Empty address auto-binding to an abstract address
1730 : : - Address that starts with null byte */
1731 [ + + ]: 3394 : if ((size_t)path.len > sizeof addr->sun_path) {
1732 : 1 : PyErr_SetString(PyExc_OSError,
1733 : : "AF_UNIX path too long");
1734 : 1 : goto unix_out;
1735 : : }
1736 : :
1737 : 3393 : *len_ret = path.len + offsetof(struct sockaddr_un, sun_path);
1738 : : }
1739 : : else
1740 : : #endif /* linux */
1741 : : {
1742 : : /* regular NULL-terminated string */
1743 [ + + ]: 405 : if ((size_t)path.len >= sizeof addr->sun_path) {
1744 : 6 : PyErr_SetString(PyExc_OSError,
1745 : : "AF_UNIX path too long");
1746 : 6 : goto unix_out;
1747 : : }
1748 : 399 : addr->sun_path[path.len] = 0;
1749 : :
1750 : : /* including the tailing NUL */
1751 : 399 : *len_ret = path.len + offsetof(struct sockaddr_un, sun_path) + 1;
1752 : : }
1753 : 3792 : addr->sun_family = s->sock_family;
1754 : 3792 : memcpy(addr->sun_path, path.buf, path.len);
1755 : :
1756 : 3792 : retval = 1;
1757 : 3799 : unix_out:
1758 : 3799 : PyBuffer_Release(&path);
1759 : 3799 : Py_DECREF(args);
1760 : 3799 : return retval;
1761 : : }
1762 : : #endif /* AF_UNIX */
1763 : :
1764 : : #if defined(AF_NETLINK)
1765 : 0 : case AF_NETLINK:
1766 : : {
1767 : : int pid, groups;
1768 : 0 : struct sockaddr_nl* addr = &addrbuf->nl;
1769 [ # # ]: 0 : if (!PyTuple_Check(args)) {
1770 : 0 : PyErr_Format(
1771 : : PyExc_TypeError,
1772 : : "%s(): AF_NETLINK address must be tuple, not %.500s",
1773 : 0 : caller, Py_TYPE(args)->tp_name);
1774 : 0 : return 0;
1775 : : }
1776 [ # # ]: 0 : if (!PyArg_ParseTuple(args,
1777 : : "II;AF_NETLINK address must be a pair "
1778 : : "(pid, groups)",
1779 : : &pid, &groups))
1780 : : {
1781 : 0 : return 0;
1782 : : }
1783 : 0 : addr->nl_family = AF_NETLINK;
1784 : 0 : addr->nl_pid = pid;
1785 : 0 : addr->nl_groups = groups;
1786 : 0 : *len_ret = sizeof(*addr);
1787 : 0 : return 1;
1788 : : }
1789 : : #endif /* AF_NETLINK */
1790 : :
1791 : : #if defined(AF_QIPCRTR)
1792 : 3 : case AF_QIPCRTR:
1793 : : {
1794 : : unsigned int node, port;
1795 : 3 : struct sockaddr_qrtr* addr = &addrbuf->sq;
1796 [ - + ]: 3 : if (!PyTuple_Check(args)) {
1797 : 0 : PyErr_Format(
1798 : : PyExc_TypeError,
1799 : : "getsockaddrarg: "
1800 : : "AF_QIPCRTR address must be tuple, not %.500s",
1801 : 0 : Py_TYPE(args)->tp_name);
1802 : 0 : return 0;
1803 : : }
1804 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &node, &port))
1805 : 0 : return 0;
1806 : 3 : addr->sq_family = AF_QIPCRTR;
1807 : 3 : addr->sq_node = node;
1808 : 3 : addr->sq_port = port;
1809 : 3 : *len_ret = sizeof(*addr);
1810 : 3 : return 1;
1811 : : }
1812 : : #endif /* AF_QIPCRTR */
1813 : :
1814 : : #if defined(AF_VSOCK)
1815 : 0 : case AF_VSOCK:
1816 : : {
1817 : 0 : struct sockaddr_vm* addr = &addrbuf->vm;
1818 : : int port, cid;
1819 : 0 : memset(addr, 0, sizeof(struct sockaddr_vm));
1820 [ # # ]: 0 : if (!PyTuple_Check(args)) {
1821 : 0 : PyErr_Format(
1822 : : PyExc_TypeError,
1823 : : "getsockaddrarg: "
1824 : : "AF_VSOCK address must be tuple, not %.500s",
1825 : 0 : Py_TYPE(args)->tp_name);
1826 : 0 : return 0;
1827 : : }
1828 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &cid, &port))
1829 : 0 : return 0;
1830 : 0 : addr->svm_family = s->sock_family;
1831 : 0 : addr->svm_port = port;
1832 : 0 : addr->svm_cid = cid;
1833 : 0 : *len_ret = sizeof(*addr);
1834 : 0 : return 1;
1835 : : }
1836 : : #endif /* AF_VSOCK */
1837 : :
1838 : :
1839 : : #ifdef AF_RDS
1840 : 7697 : case AF_RDS:
1841 : : /* RDS sockets use sockaddr_in: fall-through */
1842 : : #endif /* AF_RDS */
1843 : :
1844 : : case AF_INET:
1845 : : {
1846 : 7697 : struct maybe_idna host = {NULL, NULL};
1847 : : int port, result;
1848 [ + + ]: 7697 : if (!PyTuple_Check(args)) {
1849 : 5 : PyErr_Format(
1850 : : PyExc_TypeError,
1851 : : "%s(): AF_INET address must be tuple, not %.500s",
1852 : 5 : caller, Py_TYPE(args)->tp_name);
1853 : 5 : return 0;
1854 : : }
1855 [ - + ]: 7692 : if (!PyArg_ParseTuple(args,
1856 : : "O&i;AF_INET address must be a pair "
1857 : : "(host, port)",
1858 : : idna_converter, &host, &port))
1859 : : {
1860 : : assert(PyErr_Occurred());
1861 [ # # ]: 0 : if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
1862 : 0 : PyErr_Format(PyExc_OverflowError,
1863 : : "%s(): port must be 0-65535.", caller);
1864 : : }
1865 : 0 : return 0;
1866 : : }
1867 : 7692 : struct sockaddr_in* addr = &addrbuf->in;
1868 : 7692 : result = setipaddr(host.buf, (struct sockaddr *)addr,
1869 : : sizeof(*addr), AF_INET);
1870 : 7692 : idna_cleanup(&host);
1871 [ - + ]: 7692 : if (result < 0)
1872 : 0 : return 0;
1873 [ + + + + ]: 7692 : if (port < 0 || port > 0xffff) {
1874 : 1026 : PyErr_Format(
1875 : : PyExc_OverflowError,
1876 : : "%s(): port must be 0-65535.", caller);
1877 : 1026 : return 0;
1878 : : }
1879 : 6666 : addr->sin_family = AF_INET;
1880 : 6666 : addr->sin_port = htons((short)port);
1881 : 6666 : *len_ret = sizeof *addr;
1882 : 6666 : return 1;
1883 : : }
1884 : :
1885 : : #ifdef ENABLE_IPV6
1886 : 1125 : case AF_INET6:
1887 : : {
1888 : 1125 : struct maybe_idna host = {NULL, NULL};
1889 : : int port, result;
1890 : : unsigned int flowinfo, scope_id;
1891 : 1125 : flowinfo = scope_id = 0;
1892 [ + + ]: 1125 : if (!PyTuple_Check(args)) {
1893 : 2 : PyErr_Format(
1894 : : PyExc_TypeError,
1895 : : "%s(): AF_INET6 address must be tuple, not %.500s",
1896 : 2 : caller, Py_TYPE(args)->tp_name);
1897 : 2 : return 0;
1898 : : }
1899 [ - + ]: 1123 : if (!PyArg_ParseTuple(args,
1900 : : "O&i|II;AF_INET6 address must be a tuple "
1901 : : "(host, port[, flowinfo[, scopeid]])",
1902 : : idna_converter, &host, &port, &flowinfo,
1903 : : &scope_id))
1904 : : {
1905 : : assert(PyErr_Occurred());
1906 [ # # ]: 0 : if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
1907 : 0 : PyErr_Format(PyExc_OverflowError,
1908 : : "%s(): port must be 0-65535.", caller);
1909 : : }
1910 : 0 : return 0;
1911 : : }
1912 : 1123 : struct sockaddr_in6* addr = &addrbuf->in6;
1913 : 1123 : result = setipaddr(host.buf, (struct sockaddr *)addr,
1914 : : sizeof(*addr), AF_INET6);
1915 : 1123 : idna_cleanup(&host);
1916 [ - + ]: 1123 : if (result < 0)
1917 : 0 : return 0;
1918 [ + - - + ]: 1123 : if (port < 0 || port > 0xffff) {
1919 : 0 : PyErr_Format(
1920 : : PyExc_OverflowError,
1921 : : "%s(): port must be 0-65535.", caller);
1922 : 0 : return 0;
1923 : : }
1924 [ + + ]: 1123 : if (flowinfo > 0xfffff) {
1925 : 1 : PyErr_Format(
1926 : : PyExc_OverflowError,
1927 : : "%s(): flowinfo must be 0-1048575.", caller);
1928 : 1 : return 0;
1929 : : }
1930 : 1122 : addr->sin6_family = s->sock_family;
1931 : 1122 : addr->sin6_port = htons((short)port);
1932 : 1122 : addr->sin6_flowinfo = htonl(flowinfo);
1933 : 1122 : addr->sin6_scope_id = scope_id;
1934 : 1122 : *len_ret = sizeof *addr;
1935 : 1122 : return 1;
1936 : : }
1937 : : #endif /* ENABLE_IPV6 */
1938 : :
1939 : : #ifdef USE_BLUETOOTH
1940 : 0 : case AF_BLUETOOTH:
1941 : : {
1942 [ # # # # : 0 : switch (s->sock_proto) {
# ]
1943 : : #ifdef BTPROTO_L2CAP
1944 : 0 : case BTPROTO_L2CAP:
1945 : : {
1946 : : const char *straddr;
1947 : :
1948 : 0 : struct sockaddr_l2 *addr = &addrbuf->bt_l2;
1949 : 0 : memset(addr, 0, sizeof(struct sockaddr_l2));
1950 : 0 : _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1951 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "si", &straddr,
1952 : : &_BT_L2_MEMB(addr, psm))) {
1953 : 0 : PyErr_Format(PyExc_OSError,
1954 : : "%s(): wrong format", caller);
1955 : 0 : return 0;
1956 : : }
1957 [ # # ]: 0 : if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1958 : 0 : return 0;
1959 : :
1960 : 0 : *len_ret = sizeof *addr;
1961 : 0 : return 1;
1962 : : }
1963 : : #endif /* BTPROTO_L2CAP */
1964 : 0 : case BTPROTO_RFCOMM:
1965 : : {
1966 : : const char *straddr;
1967 : 0 : struct sockaddr_rc *addr = &addrbuf->bt_rc;
1968 : 0 : _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1969 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "si", &straddr,
1970 : : &_BT_RC_MEMB(addr, channel))) {
1971 : 0 : PyErr_Format(PyExc_OSError,
1972 : : "%s(): wrong format", caller);
1973 : 0 : return 0;
1974 : : }
1975 [ # # ]: 0 : if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1976 : 0 : return 0;
1977 : :
1978 : 0 : *len_ret = sizeof *addr;
1979 : 0 : return 1;
1980 : : }
1981 : : #ifdef BTPROTO_HCI
1982 : 0 : case BTPROTO_HCI:
1983 : : {
1984 : 0 : struct sockaddr_hci *addr = &addrbuf->bt_hci;
1985 : : #if defined(__NetBSD__) || defined(__DragonFly__)
1986 : : const char *straddr;
1987 : : _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1988 : : if (!PyBytes_Check(args)) {
1989 : : PyErr_Format(PyExc_OSError, "%s: "
1990 : : "wrong format", caller);
1991 : : return 0;
1992 : : }
1993 : : straddr = PyBytes_AS_STRING(args);
1994 : : if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)
1995 : : return 0;
1996 : : #else /* __NetBSD__ || __DragonFly__ */
1997 : 0 : _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1998 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
1999 : 0 : PyErr_Format(PyExc_OSError,
2000 : : "%s(): wrong format", caller);
2001 : 0 : return 0;
2002 : : }
2003 : : #endif /* !(__NetBSD__ || __DragonFly__) */
2004 : 0 : *len_ret = sizeof *addr;
2005 : 0 : return 1;
2006 : : }
2007 : : #if !defined(__FreeBSD__)
2008 : 0 : case BTPROTO_SCO:
2009 : : {
2010 : : const char *straddr;
2011 : :
2012 : 0 : struct sockaddr_sco *addr = &addrbuf->bt_sco;
2013 : 0 : _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
2014 [ # # ]: 0 : if (!PyBytes_Check(args)) {
2015 : 0 : PyErr_Format(PyExc_OSError,
2016 : : "%s(): wrong format", caller);
2017 : 0 : return 0;
2018 : : }
2019 : 0 : straddr = PyBytes_AS_STRING(args);
2020 [ # # ]: 0 : if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
2021 : 0 : return 0;
2022 : :
2023 : 0 : *len_ret = sizeof *addr;
2024 : 0 : return 1;
2025 : : }
2026 : : #endif /* !__FreeBSD__ */
2027 : : #endif /* BTPROTO_HCI */
2028 : 0 : default:
2029 : 0 : PyErr_Format(PyExc_OSError,
2030 : : "%s(): unknown Bluetooth protocol", caller);
2031 : 0 : return 0;
2032 : : }
2033 : : }
2034 : : #endif /* USE_BLUETOOTH */
2035 : :
2036 : : #if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)
2037 : 0 : case AF_PACKET:
2038 : : {
2039 : : struct ifreq ifr;
2040 : : const char *interfaceName;
2041 : : int protoNumber;
2042 : 0 : int hatype = 0;
2043 : 0 : int pkttype = PACKET_HOST;
2044 : 0 : Py_buffer haddr = {NULL, NULL};
2045 : :
2046 [ # # ]: 0 : if (!PyTuple_Check(args)) {
2047 : 0 : PyErr_Format(
2048 : : PyExc_TypeError,
2049 : : "%s(): AF_PACKET address must be tuple, not %.500s",
2050 : 0 : caller, Py_TYPE(args)->tp_name);
2051 : 0 : return 0;
2052 : : }
2053 : : /* XXX: improve the default error message according to the
2054 : : documentation of AF_PACKET, which would be added as part
2055 : : of bpo-25041. */
2056 [ # # ]: 0 : if (!PyArg_ParseTuple(args,
2057 : : "si|iiy*;AF_PACKET address must be a tuple of "
2058 : : "two to five elements",
2059 : : &interfaceName, &protoNumber, &pkttype, &hatype,
2060 : : &haddr))
2061 : : {
2062 : : assert(PyErr_Occurred());
2063 [ # # ]: 0 : if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
2064 : 0 : PyErr_Format(PyExc_OverflowError,
2065 : : "%s(): address argument out of range", caller);
2066 : : }
2067 : 0 : return 0;
2068 : : }
2069 : 0 : strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
2070 : 0 : ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
2071 [ # # ]: 0 : if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
2072 : 0 : s->errorhandler();
2073 : 0 : PyBuffer_Release(&haddr);
2074 : 0 : return 0;
2075 : : }
2076 [ # # # # ]: 0 : if (haddr.buf && haddr.len > 8) {
2077 : 0 : PyErr_SetString(PyExc_ValueError,
2078 : : "Hardware address must be 8 bytes or less");
2079 : 0 : PyBuffer_Release(&haddr);
2080 : 0 : return 0;
2081 : : }
2082 [ # # # # ]: 0 : if (protoNumber < 0 || protoNumber > 0xffff) {
2083 : 0 : PyErr_Format(
2084 : : PyExc_OverflowError,
2085 : : "%s(): proto must be 0-65535.", caller);
2086 : 0 : PyBuffer_Release(&haddr);
2087 : 0 : return 0;
2088 : : }
2089 : 0 : struct sockaddr_ll* addr = &addrbuf->ll;
2090 : 0 : addr->sll_family = AF_PACKET;
2091 : 0 : addr->sll_protocol = htons((short)protoNumber);
2092 : 0 : addr->sll_ifindex = ifr.ifr_ifindex;
2093 : 0 : addr->sll_pkttype = pkttype;
2094 : 0 : addr->sll_hatype = hatype;
2095 [ # # ]: 0 : if (haddr.buf) {
2096 : 0 : memcpy(&addr->sll_addr, haddr.buf, haddr.len);
2097 : 0 : addr->sll_halen = haddr.len;
2098 : : }
2099 : : else
2100 : 0 : addr->sll_halen = 0;
2101 : 0 : *len_ret = sizeof *addr;
2102 : 0 : PyBuffer_Release(&haddr);
2103 : 0 : return 1;
2104 : : }
2105 : : #endif /* HAVE_NETPACKET_PACKET_H && SIOCGIFINDEX */
2106 : :
2107 : : #ifdef HAVE_LINUX_TIPC_H
2108 : 0 : case AF_TIPC:
2109 : : {
2110 : : unsigned int atype, v1, v2, v3;
2111 : 0 : unsigned int scope = TIPC_CLUSTER_SCOPE;
2112 : :
2113 [ # # ]: 0 : if (!PyTuple_Check(args)) {
2114 : 0 : PyErr_Format(
2115 : : PyExc_TypeError,
2116 : : "%s(): AF_TIPC address must be tuple, not %.500s",
2117 : 0 : caller, Py_TYPE(args)->tp_name);
2118 : 0 : return 0;
2119 : : }
2120 : :
2121 [ # # ]: 0 : if (!PyArg_ParseTuple(args,
2122 : : "IIII|I;AF_TIPC address must be a tuple "
2123 : : "(addr_type, v1, v2, v3[, scope])",
2124 : : &atype, &v1, &v2, &v3, &scope))
2125 : : {
2126 : 0 : return 0;
2127 : : }
2128 : :
2129 : 0 : struct sockaddr_tipc *addr = &addrbuf->tipc;
2130 : 0 : memset(addr, 0, sizeof(struct sockaddr_tipc));
2131 : :
2132 : 0 : addr->family = AF_TIPC;
2133 : 0 : addr->scope = scope;
2134 : 0 : addr->addrtype = atype;
2135 : :
2136 [ # # ]: 0 : if (atype == TIPC_ADDR_NAMESEQ) {
2137 : 0 : addr->addr.nameseq.type = v1;
2138 : 0 : addr->addr.nameseq.lower = v2;
2139 : 0 : addr->addr.nameseq.upper = v3;
2140 [ # # ]: 0 : } else if (atype == TIPC_ADDR_NAME) {
2141 : 0 : addr->addr.name.name.type = v1;
2142 : 0 : addr->addr.name.name.instance = v2;
2143 [ # # ]: 0 : } else if (atype == TIPC_ADDR_ID) {
2144 : 0 : addr->addr.id.node = v1;
2145 : 0 : addr->addr.id.ref = v2;
2146 : : } else {
2147 : : /* Shouldn't happen */
2148 : 0 : PyErr_SetString(PyExc_TypeError, "Invalid address type");
2149 : 0 : return 0;
2150 : : }
2151 : :
2152 : 0 : *len_ret = sizeof(*addr);
2153 : :
2154 : 0 : return 1;
2155 : : }
2156 : : #endif /* HAVE_LINUX_TIPC_H */
2157 : :
2158 : : #if defined(AF_CAN) && defined(SIOCGIFINDEX)
2159 : 13 : case AF_CAN:
2160 [ + + + - ]: 13 : switch (s->sock_proto) {
2161 : : #ifdef CAN_RAW
2162 : 10 : case CAN_RAW:
2163 : : /* fall-through */
2164 : : #endif
2165 : : #ifdef CAN_BCM
2166 : : case CAN_BCM:
2167 : : #endif
2168 : : #if defined(CAN_RAW) || defined(CAN_BCM)
2169 : : {
2170 : : PyObject *interfaceName;
2171 : : struct ifreq ifr;
2172 : : Py_ssize_t len;
2173 : 10 : struct sockaddr_can *addr = &addrbuf->can;
2174 : :
2175 [ - + ]: 10 : if (!PyTuple_Check(args)) {
2176 : 0 : PyErr_Format(PyExc_TypeError,
2177 : : "%s(): AF_CAN address must be tuple, not %.500s",
2178 : 0 : caller, Py_TYPE(args)->tp_name);
2179 : 0 : return 0;
2180 : : }
2181 [ - + ]: 10 : if (!PyArg_ParseTuple(args,
2182 : : "O&;AF_CAN address must be a tuple "
2183 : : "(interface, )",
2184 : : PyUnicode_FSConverter, &interfaceName))
2185 : : {
2186 : 0 : return 0;
2187 : : }
2188 : :
2189 : 10 : len = PyBytes_GET_SIZE(interfaceName);
2190 : :
2191 [ + + ]: 10 : if (len == 0) {
2192 : 1 : ifr.ifr_ifindex = 0;
2193 [ + + ]: 9 : } else if ((size_t)len < sizeof(ifr.ifr_name)) {
2194 : 8 : strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
2195 : 8 : ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
2196 [ + - ]: 8 : if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
2197 : 8 : s->errorhandler();
2198 : 8 : Py_DECREF(interfaceName);
2199 : 8 : return 0;
2200 : : }
2201 : : } else {
2202 : 1 : PyErr_SetString(PyExc_OSError,
2203 : : "AF_CAN interface name too long");
2204 : 1 : Py_DECREF(interfaceName);
2205 : 1 : return 0;
2206 : : }
2207 : :
2208 : 1 : addr->can_family = AF_CAN;
2209 : 1 : addr->can_ifindex = ifr.ifr_ifindex;
2210 : :
2211 : 1 : *len_ret = sizeof(*addr);
2212 : 1 : Py_DECREF(interfaceName);
2213 : 1 : return 1;
2214 : : }
2215 : : #endif /* CAN_RAW || CAN_BCM */
2216 : :
2217 : : #ifdef CAN_ISOTP
2218 : 2 : case CAN_ISOTP:
2219 : : {
2220 : : PyObject *interfaceName;
2221 : : struct ifreq ifr;
2222 : : Py_ssize_t len;
2223 : : unsigned long int rx_id, tx_id;
2224 : :
2225 : 2 : struct sockaddr_can *addr = &addrbuf->can;
2226 : :
2227 [ - + ]: 2 : if (!PyArg_ParseTuple(args, "O&kk", PyUnicode_FSConverter,
2228 : : &interfaceName,
2229 : : &rx_id,
2230 : : &tx_id))
2231 : 0 : return 0;
2232 : :
2233 : 2 : len = PyBytes_GET_SIZE(interfaceName);
2234 : :
2235 [ - + ]: 2 : if (len == 0) {
2236 : 0 : ifr.ifr_ifindex = 0;
2237 [ + + ]: 2 : } else if ((size_t)len < sizeof(ifr.ifr_name)) {
2238 : 1 : strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
2239 : 1 : ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
2240 [ + - ]: 1 : if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
2241 : 1 : s->errorhandler();
2242 : 1 : Py_DECREF(interfaceName);
2243 : 1 : return 0;
2244 : : }
2245 : : } else {
2246 : 1 : PyErr_SetString(PyExc_OSError,
2247 : : "AF_CAN interface name too long");
2248 : 1 : Py_DECREF(interfaceName);
2249 : 1 : return 0;
2250 : : }
2251 : :
2252 : 0 : addr->can_family = AF_CAN;
2253 : 0 : addr->can_ifindex = ifr.ifr_ifindex;
2254 : 0 : addr->can_addr.tp.rx_id = rx_id;
2255 : 0 : addr->can_addr.tp.tx_id = tx_id;
2256 : :
2257 : 0 : *len_ret = sizeof(*addr);
2258 : 0 : Py_DECREF(interfaceName);
2259 : 0 : return 1;
2260 : : }
2261 : : #endif /* CAN_ISOTP */
2262 : : #ifdef CAN_J1939
2263 : 1 : case CAN_J1939:
2264 : : {
2265 : : PyObject *interfaceName;
2266 : : struct ifreq ifr;
2267 : : Py_ssize_t len;
2268 : : unsigned long long j1939_name; /* at least 64 bits */
2269 : : unsigned int j1939_pgn; /* at least 32 bits */
2270 : : uint8_t j1939_addr;
2271 : :
2272 : 1 : struct sockaddr_can *addr = &addrbuf->can;
2273 : :
2274 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O&KIB", PyUnicode_FSConverter,
2275 : : &interfaceName,
2276 : : &j1939_name,
2277 : : &j1939_pgn,
2278 : : &j1939_addr))
2279 : 0 : return 0;
2280 : :
2281 : 1 : len = PyBytes_GET_SIZE(interfaceName);
2282 : :
2283 [ - + ]: 1 : if (len == 0) {
2284 : 0 : ifr.ifr_ifindex = 0;
2285 [ + - ]: 1 : } else if ((size_t)len < sizeof(ifr.ifr_name)) {
2286 : 1 : strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
2287 : 1 : ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
2288 [ + - ]: 1 : if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
2289 : 1 : s->errorhandler();
2290 : 1 : Py_DECREF(interfaceName);
2291 : 1 : return 0;
2292 : : }
2293 : : } else {
2294 : 0 : PyErr_SetString(PyExc_OSError,
2295 : : "AF_CAN interface name too long");
2296 : 0 : Py_DECREF(interfaceName);
2297 : 0 : return 0;
2298 : : }
2299 : :
2300 : 0 : addr->can_family = AF_CAN;
2301 : 0 : addr->can_ifindex = ifr.ifr_ifindex;
2302 : 0 : addr->can_addr.j1939.name = (uint64_t)j1939_name;
2303 : 0 : addr->can_addr.j1939.pgn = (uint32_t)j1939_pgn;
2304 : 0 : addr->can_addr.j1939.addr = j1939_addr;
2305 : :
2306 : 0 : *len_ret = sizeof(*addr);
2307 : 0 : Py_DECREF(interfaceName);
2308 : 0 : return 1;
2309 : : }
2310 : : #endif /* CAN_J1939 */
2311 : 0 : default:
2312 : 0 : PyErr_Format(PyExc_OSError,
2313 : : "%s(): unsupported CAN protocol", caller);
2314 : 0 : return 0;
2315 : : }
2316 : : #endif /* AF_CAN && SIOCGIFINDEX */
2317 : :
2318 : : #ifdef PF_SYSTEM
2319 : : case PF_SYSTEM:
2320 : : switch (s->sock_proto) {
2321 : : #ifdef SYSPROTO_CONTROL
2322 : : case SYSPROTO_CONTROL:
2323 : : {
2324 : : struct sockaddr_ctl *addr = &addrbuf->ctl;
2325 : : addr->sc_family = AF_SYSTEM;
2326 : : addr->ss_sysaddr = AF_SYS_CONTROL;
2327 : :
2328 : : if (PyUnicode_Check(args)) {
2329 : : struct ctl_info info;
2330 : : PyObject *ctl_name;
2331 : :
2332 : : if (!PyArg_Parse(args, "O&",
2333 : : PyUnicode_FSConverter, &ctl_name)) {
2334 : : return 0;
2335 : : }
2336 : :
2337 : : if (PyBytes_GET_SIZE(ctl_name) > (Py_ssize_t)sizeof(info.ctl_name)) {
2338 : : PyErr_SetString(PyExc_ValueError,
2339 : : "provided string is too long");
2340 : : Py_DECREF(ctl_name);
2341 : : return 0;
2342 : : }
2343 : : strncpy(info.ctl_name, PyBytes_AS_STRING(ctl_name),
2344 : : sizeof(info.ctl_name));
2345 : : Py_DECREF(ctl_name);
2346 : :
2347 : : if (ioctl(s->sock_fd, CTLIOCGINFO, &info)) {
2348 : : PyErr_SetString(PyExc_OSError,
2349 : : "cannot find kernel control with provided name");
2350 : : return 0;
2351 : : }
2352 : :
2353 : : addr->sc_id = info.ctl_id;
2354 : : addr->sc_unit = 0;
2355 : : } else if (!PyArg_ParseTuple(args, "II",
2356 : : &(addr->sc_id), &(addr->sc_unit))) {
2357 : : PyErr_Format(PyExc_TypeError,
2358 : : "%s(): PF_SYSTEM address must be a str or "
2359 : : "a pair (id, unit)", caller);
2360 : : return 0;
2361 : : }
2362 : :
2363 : : *len_ret = sizeof(*addr);
2364 : : return 1;
2365 : : }
2366 : : #endif /* SYSPROTO_CONTROL */
2367 : : default:
2368 : : PyErr_Format(PyExc_OSError,
2369 : : "%s(): unsupported PF_SYSTEM protocol", caller);
2370 : : return 0;
2371 : : }
2372 : : #endif /* PF_SYSTEM */
2373 : : #ifdef HAVE_SOCKADDR_ALG
2374 : 9 : case AF_ALG:
2375 : : {
2376 : : const char *type;
2377 : : const char *name;
2378 : 9 : struct sockaddr_alg *sa = &addrbuf->alg;
2379 : :
2380 : 9 : memset(sa, 0, sizeof(*sa));
2381 : 9 : sa->salg_family = AF_ALG;
2382 : :
2383 [ - + ]: 9 : if (!PyTuple_Check(args)) {
2384 : 0 : PyErr_Format(PyExc_TypeError,
2385 : : "%s(): AF_ALG address must be tuple, not %.500s",
2386 : 0 : caller, Py_TYPE(args)->tp_name);
2387 : 0 : return 0;
2388 : : }
2389 [ - + ]: 9 : if (!PyArg_ParseTuple(args,
2390 : : "ss|HH;AF_ALG address must be a tuple "
2391 : : "(type, name[, feat[, mask]])",
2392 : : &type, &name, &sa->salg_feat, &sa->salg_mask))
2393 : : {
2394 : 0 : return 0;
2395 : : }
2396 : : /* sockaddr_alg has fixed-sized char arrays for type, and name
2397 : : * both must be NULL terminated.
2398 : : */
2399 [ + + ]: 9 : if (strlen(type) >= sizeof(sa->salg_type)) {
2400 : 1 : PyErr_SetString(PyExc_ValueError, "AF_ALG type too long.");
2401 : 1 : return 0;
2402 : : }
2403 : 8 : strncpy((char *)sa->salg_type, type, sizeof(sa->salg_type));
2404 [ + + ]: 8 : if (strlen(name) >= sizeof(sa->salg_name)) {
2405 : 1 : PyErr_SetString(PyExc_ValueError, "AF_ALG name too long.");
2406 : 1 : return 0;
2407 : : }
2408 : 7 : strncpy((char *)sa->salg_name, name, sizeof(sa->salg_name));
2409 : :
2410 : 7 : *len_ret = sizeof(*sa);
2411 : 7 : return 1;
2412 : : }
2413 : : #endif /* HAVE_SOCKADDR_ALG */
2414 : : #ifdef HAVE_AF_HYPERV
2415 : : case AF_HYPERV:
2416 : : {
2417 : : switch (s->sock_proto) {
2418 : : case HV_PROTOCOL_RAW:
2419 : : {
2420 : : PyObject *vm_id_obj = NULL;
2421 : : PyObject *service_id_obj = NULL;
2422 : :
2423 : : SOCKADDR_HV *addr = &addrbuf->hv;
2424 : :
2425 : : memset(addr, 0, sizeof(*addr));
2426 : : addr->Family = AF_HYPERV;
2427 : :
2428 : : if (!PyTuple_Check(args)) {
2429 : : PyErr_Format(PyExc_TypeError,
2430 : : "%s(): AF_HYPERV address must be tuple, not %.500s",
2431 : : caller, Py_TYPE(args)->tp_name);
2432 : : return 0;
2433 : : }
2434 : : if (!PyArg_ParseTuple(args,
2435 : : "UU;AF_HYPERV address must be a str tuple (vm_id, service_id)",
2436 : : &vm_id_obj, &service_id_obj))
2437 : : {
2438 : : return 0;
2439 : : }
2440 : :
2441 : : wchar_t *guid_str = PyUnicode_AsWideCharString(vm_id_obj, NULL);
2442 : : if (guid_str == NULL) {
2443 : : PyErr_Format(PyExc_ValueError,
2444 : : "%s(): AF_HYPERV address vm_id is not a valid UUID string",
2445 : : caller);
2446 : : return 0;
2447 : : }
2448 : : RPC_STATUS rc = UuidFromStringW(guid_str, &addr->VmId);
2449 : : PyMem_Free(guid_str);
2450 : : if (rc != RPC_S_OK) {
2451 : : PyErr_Format(PyExc_ValueError,
2452 : : "%s(): AF_HYPERV address vm_id is not a valid UUID string",
2453 : : caller);
2454 : : return 0;
2455 : : }
2456 : :
2457 : : guid_str = PyUnicode_AsWideCharString(service_id_obj, NULL);
2458 : : if (guid_str == NULL) {
2459 : : PyErr_Format(PyExc_ValueError,
2460 : : "%s(): AF_HYPERV address service_id is not a valid UUID string",
2461 : : caller);
2462 : : return 0;
2463 : : }
2464 : : rc = UuidFromStringW(guid_str, &addr->ServiceId);
2465 : : PyMem_Free(guid_str);
2466 : : if (rc != RPC_S_OK) {
2467 : : PyErr_Format(PyExc_ValueError,
2468 : : "%s(): AF_HYPERV address service_id is not a valid UUID string",
2469 : : caller);
2470 : : return 0;
2471 : : }
2472 : :
2473 : : *len_ret = sizeof(*addr);
2474 : : return 1;
2475 : : }
2476 : : default:
2477 : : PyErr_Format(PyExc_OSError,
2478 : : "%s(): unsupported AF_HYPERV protocol: %d",
2479 : : caller, s->sock_proto);
2480 : : return 0;
2481 : : }
2482 : : }
2483 : : #endif /* HAVE_AF_HYPERV */
2484 : :
2485 : : /* More cases here... */
2486 : :
2487 : 0 : default:
2488 : 0 : PyErr_Format(PyExc_OSError, "%s(): bad family", caller);
2489 : 0 : return 0;
2490 : :
2491 : : }
2492 : : }
2493 : :
2494 : :
2495 : : /* Get the address length according to the socket object's address family.
2496 : : Return 1 if the family is known, 0 otherwise. The length is returned
2497 : : through len_ret. */
2498 : :
2499 : : static int
2500 : 9317 : getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
2501 : : {
2502 [ + - + - : 9317 : switch (s->sock_family) {
+ + - - -
+ + + ]
2503 : :
2504 : : #if defined(AF_UNIX)
2505 : 2630 : case AF_UNIX:
2506 : : {
2507 : 2630 : *len_ret = sizeof (struct sockaddr_un);
2508 : 2630 : return 1;
2509 : : }
2510 : : #endif /* AF_UNIX */
2511 : :
2512 : : #if defined(AF_NETLINK)
2513 : 0 : case AF_NETLINK:
2514 : : {
2515 : 0 : *len_ret = sizeof (struct sockaddr_nl);
2516 : 0 : return 1;
2517 : : }
2518 : : #endif /* AF_NETLINK */
2519 : :
2520 : : #if defined(AF_QIPCRTR)
2521 : 5 : case AF_QIPCRTR:
2522 : : {
2523 : 5 : *len_ret = sizeof (struct sockaddr_qrtr);
2524 : 5 : return 1;
2525 : : }
2526 : : #endif /* AF_QIPCRTR */
2527 : :
2528 : : #if defined(AF_VSOCK)
2529 : 0 : case AF_VSOCK:
2530 : : {
2531 : 0 : *len_ret = sizeof (struct sockaddr_vm);
2532 : 0 : return 1;
2533 : : }
2534 : : #endif /* AF_VSOCK */
2535 : :
2536 : : #ifdef AF_RDS
2537 : 5587 : case AF_RDS:
2538 : : /* RDS sockets use sockaddr_in: fall-through */
2539 : : #endif /* AF_RDS */
2540 : :
2541 : : case AF_INET:
2542 : : {
2543 : 5587 : *len_ret = sizeof (struct sockaddr_in);
2544 : 5587 : return 1;
2545 : : }
2546 : :
2547 : : #ifdef ENABLE_IPV6
2548 : 1080 : case AF_INET6:
2549 : : {
2550 : 1080 : *len_ret = sizeof (struct sockaddr_in6);
2551 : 1080 : return 1;
2552 : : }
2553 : : #endif /* ENABLE_IPV6 */
2554 : :
2555 : : #ifdef USE_BLUETOOTH
2556 : 0 : case AF_BLUETOOTH:
2557 : : {
2558 [ # # # # : 0 : switch(s->sock_proto)
# ]
2559 : : {
2560 : :
2561 : : #ifdef BTPROTO_L2CAP
2562 : 0 : case BTPROTO_L2CAP:
2563 : 0 : *len_ret = sizeof (struct sockaddr_l2);
2564 : 0 : return 1;
2565 : : #endif /* BTPROTO_L2CAP */
2566 : 0 : case BTPROTO_RFCOMM:
2567 : 0 : *len_ret = sizeof (struct sockaddr_rc);
2568 : 0 : return 1;
2569 : : #ifdef BTPROTO_HCI
2570 : 0 : case BTPROTO_HCI:
2571 : 0 : *len_ret = sizeof (struct sockaddr_hci);
2572 : 0 : return 1;
2573 : : #if !defined(__FreeBSD__)
2574 : 0 : case BTPROTO_SCO:
2575 : 0 : *len_ret = sizeof (struct sockaddr_sco);
2576 : 0 : return 1;
2577 : : #endif /* !__FreeBSD__ */
2578 : : #endif /* BTPROTO_HCI */
2579 : 0 : default:
2580 : 0 : PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
2581 : : "unknown BT protocol");
2582 : 0 : return 0;
2583 : :
2584 : : }
2585 : : }
2586 : : #endif /* USE_BLUETOOTH */
2587 : :
2588 : : #ifdef HAVE_NETPACKET_PACKET_H
2589 : 0 : case AF_PACKET:
2590 : : {
2591 : 0 : *len_ret = sizeof (struct sockaddr_ll);
2592 : 0 : return 1;
2593 : : }
2594 : : #endif /* HAVE_NETPACKET_PACKET_H */
2595 : :
2596 : : #ifdef HAVE_LINUX_TIPC_H
2597 : 0 : case AF_TIPC:
2598 : : {
2599 : 0 : *len_ret = sizeof (struct sockaddr_tipc);
2600 : 0 : return 1;
2601 : : }
2602 : : #endif /* HAVE_LINUX_TIPC_H */
2603 : :
2604 : : #ifdef AF_CAN
2605 : 1 : case AF_CAN:
2606 : : {
2607 : 1 : *len_ret = sizeof (struct sockaddr_can);
2608 : 1 : return 1;
2609 : : }
2610 : : #endif /* AF_CAN */
2611 : :
2612 : : #ifdef PF_SYSTEM
2613 : : case PF_SYSTEM:
2614 : : switch(s->sock_proto) {
2615 : : #ifdef SYSPROTO_CONTROL
2616 : : case SYSPROTO_CONTROL:
2617 : : *len_ret = sizeof (struct sockaddr_ctl);
2618 : : return 1;
2619 : : #endif /* SYSPROTO_CONTROL */
2620 : : default:
2621 : : PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
2622 : : "unknown PF_SYSTEM protocol");
2623 : : return 0;
2624 : : }
2625 : : #endif /* PF_SYSTEM */
2626 : : #ifdef HAVE_SOCKADDR_ALG
2627 : 12 : case AF_ALG:
2628 : : {
2629 : 12 : *len_ret = sizeof (struct sockaddr_alg);
2630 : 12 : return 1;
2631 : : }
2632 : : #endif /* HAVE_SOCKADDR_ALG */
2633 : : #ifdef HAVE_AF_HYPERV
2634 : : case AF_HYPERV:
2635 : : {
2636 : : *len_ret = sizeof (SOCKADDR_HV);
2637 : : return 1;
2638 : : }
2639 : : #endif /* HAVE_AF_HYPERV */
2640 : :
2641 : : /* More cases here... */
2642 : :
2643 : 2 : default:
2644 : 2 : PyErr_SetString(PyExc_OSError, "getsockaddrlen: bad family");
2645 : 2 : return 0;
2646 : :
2647 : : }
2648 : : }
2649 : :
2650 : :
2651 : : /* Support functions for the sendmsg() and recvmsg[_into]() methods.
2652 : : Currently, these methods are only compiled if the RFC 2292/3542
2653 : : CMSG_LEN() macro is available. Older systems seem to have used
2654 : : sizeof(struct cmsghdr) + (length) where CMSG_LEN() is used now, so
2655 : : it may be possible to define CMSG_LEN() that way if it's not
2656 : : provided. Some architectures might need extra padding after the
2657 : : cmsghdr, however, and CMSG_LEN() would have to take account of
2658 : : this. */
2659 : : #ifdef CMSG_LEN
2660 : : /* If length is in range, set *result to CMSG_LEN(length) and return
2661 : : true; otherwise, return false. */
2662 : : static int
2663 : 2900 : get_CMSG_LEN(size_t length, size_t *result)
2664 : : {
2665 : : size_t tmp;
2666 : :
2667 [ + + ]: 2900 : if (length > (SOCKLEN_T_LIMIT - CMSG_LEN(0)))
2668 : 2 : return 0;
2669 : 2898 : tmp = CMSG_LEN(length);
2670 [ + - - + ]: 2898 : if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2671 : 0 : return 0;
2672 : 2898 : *result = tmp;
2673 : 2898 : return 1;
2674 : : }
2675 : :
2676 : : #ifdef CMSG_SPACE
2677 : : /* If length is in range, set *result to CMSG_SPACE(length) and return
2678 : : true; otherwise, return false. */
2679 : : static int
2680 : 1843 : get_CMSG_SPACE(size_t length, size_t *result)
2681 : : {
2682 : : size_t tmp;
2683 : :
2684 : : /* Use CMSG_SPACE(1) here in order to take account of the padding
2685 : : necessary before *and* after the data. */
2686 [ + + ]: 1843 : if (length > (SOCKLEN_T_LIMIT - CMSG_SPACE(1)))
2687 : 2 : return 0;
2688 : 1841 : tmp = CMSG_SPACE(length);
2689 [ + - - + ]: 1841 : if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2690 : 0 : return 0;
2691 : 1841 : *result = tmp;
2692 : 1841 : return 1;
2693 : : }
2694 : : #endif
2695 : :
2696 : : /* Return true iff msg->msg_controllen is valid, cmsgh is a valid
2697 : : pointer in msg->msg_control with at least "space" bytes after it,
2698 : : and its cmsg_len member inside the buffer. */
2699 : : static int
2700 : 1371 : cmsg_min_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t space)
2701 : : {
2702 : : size_t cmsg_offset;
2703 : : static const size_t cmsg_len_end = (offsetof(struct cmsghdr, cmsg_len) +
2704 : : sizeof(cmsgh->cmsg_len));
2705 : :
2706 : : /* Note that POSIX allows msg_controllen to be of signed type. */
2707 [ + - - + ]: 1371 : if (cmsgh == NULL || msg->msg_control == NULL)
2708 : 0 : return 0;
2709 : : /* Note that POSIX allows msg_controllen to be of a signed type. This is
2710 : : annoying under OS X as it's unsigned there and so it triggers a
2711 : : tautological comparison warning under Clang when compared against 0.
2712 : : Since the check is valid on other platforms, silence the warning under
2713 : : Clang. */
2714 : : #ifdef __clang__
2715 : : #pragma clang diagnostic push
2716 : : #pragma clang diagnostic ignored "-Wtautological-compare"
2717 : : #endif
2718 : : #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
2719 : : #pragma GCC diagnostic push
2720 : : #pragma GCC diagnostic ignored "-Wtype-limits"
2721 : : #endif
2722 : : if (msg->msg_controllen < 0)
2723 : : return 0;
2724 : : #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
2725 : : #pragma GCC diagnostic pop
2726 : : #endif
2727 : : #ifdef __clang__
2728 : : #pragma clang diagnostic pop
2729 : : #endif
2730 [ - + ]: 1371 : if (space < cmsg_len_end)
2731 : 0 : space = cmsg_len_end;
2732 : 1371 : cmsg_offset = (char *)cmsgh - (char *)msg->msg_control;
2733 [ + - ]: 2742 : return (cmsg_offset <= (size_t)-1 - space &&
2734 [ + - ]: 1371 : cmsg_offset + space <= msg->msg_controllen);
2735 : : }
2736 : :
2737 : : /* If pointer CMSG_DATA(cmsgh) is in buffer msg->msg_control, set
2738 : : *space to number of bytes following it in the buffer and return
2739 : : true; otherwise, return false. Assumes cmsgh, msg->msg_control and
2740 : : msg->msg_controllen are valid. */
2741 : : static int
2742 : 1371 : get_cmsg_data_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *space)
2743 : : {
2744 : : size_t data_offset;
2745 : : char *data_ptr;
2746 : :
2747 [ - + ]: 1371 : if ((data_ptr = (char *)CMSG_DATA(cmsgh)) == NULL)
2748 : 0 : return 0;
2749 : 1371 : data_offset = data_ptr - (char *)msg->msg_control;
2750 [ - + ]: 1371 : if (data_offset > msg->msg_controllen)
2751 : 0 : return 0;
2752 : 1371 : *space = msg->msg_controllen - data_offset;
2753 : 1371 : return 1;
2754 : : }
2755 : :
2756 : : /* If cmsgh is invalid or not contained in the buffer pointed to by
2757 : : msg->msg_control, return -1. If cmsgh is valid and its associated
2758 : : data is entirely contained in the buffer, set *data_len to the
2759 : : length of the associated data and return 0. If only part of the
2760 : : associated data is contained in the buffer but cmsgh is otherwise
2761 : : valid, set *data_len to the length contained in the buffer and
2762 : : return 1. */
2763 : : static int
2764 : 562 : get_cmsg_data_len(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *data_len)
2765 : : {
2766 : : size_t space, cmsg_data_len;
2767 : :
2768 [ + - ]: 562 : if (!cmsg_min_space(msg, cmsgh, CMSG_LEN(0)) ||
2769 [ - + ]: 562 : cmsgh->cmsg_len < CMSG_LEN(0))
2770 : 0 : return -1;
2771 : 562 : cmsg_data_len = cmsgh->cmsg_len - CMSG_LEN(0);
2772 [ - + ]: 562 : if (!get_cmsg_data_space(msg, cmsgh, &space))
2773 : 0 : return -1;
2774 [ + - ]: 562 : if (space >= cmsg_data_len) {
2775 : 562 : *data_len = cmsg_data_len;
2776 : 562 : return 0;
2777 : : }
2778 : 0 : *data_len = space;
2779 : 0 : return 1;
2780 : : }
2781 : : #endif /* CMSG_LEN */
2782 : :
2783 : :
2784 : : struct sock_accept {
2785 : : socklen_t *addrlen;
2786 : : sock_addr_t *addrbuf;
2787 : : SOCKET_T result;
2788 : : };
2789 : :
2790 : : #if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2791 : : /* accept4() is available on Linux 2.6.28+ and glibc 2.10 */
2792 : : static int accept4_works = -1;
2793 : : #endif
2794 : :
2795 : : static int
2796 : 3160 : sock_accept_impl(PySocketSockObject *s, void *data)
2797 : : {
2798 : 3160 : struct sock_accept *ctx = data;
2799 : 3160 : struct sockaddr *addr = SAS2SA(ctx->addrbuf);
2800 : 3160 : socklen_t *paddrlen = ctx->addrlen;
2801 : : #ifdef HAVE_SOCKADDR_ALG
2802 : : /* AF_ALG does not support accept() with addr and raises
2803 : : * ECONNABORTED instead. */
2804 [ + + ]: 3160 : if (s->sock_family == AF_ALG) {
2805 : 12 : addr = NULL;
2806 : 12 : paddrlen = NULL;
2807 : 12 : *ctx->addrlen = 0;
2808 : : }
2809 : : #endif
2810 : :
2811 : : #if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2812 [ + - ]: 3160 : if (accept4_works != 0) {
2813 : 3160 : ctx->result = accept4(s->sock_fd, addr, paddrlen,
2814 : : SOCK_CLOEXEC);
2815 [ + + + + ]: 3118 : if (ctx->result == INVALID_SOCKET && accept4_works == -1) {
2816 : : /* On Linux older than 2.6.28, accept4() fails with ENOSYS */
2817 : 5 : accept4_works = (errno != ENOSYS);
2818 : : }
2819 : : }
2820 [ - + ]: 3118 : if (accept4_works == 0)
2821 : 0 : ctx->result = accept(s->sock_fd, addr, paddrlen);
2822 : : #else
2823 : : ctx->result = accept(s->sock_fd, addr, paddrlen);
2824 : : #endif
2825 : :
2826 : : #ifdef MS_WINDOWS
2827 : : return (ctx->result != INVALID_SOCKET);
2828 : : #else
2829 : 3118 : return (ctx->result >= 0);
2830 : : #endif
2831 : : }
2832 : :
2833 : : /* s._accept() -> (fd, address) */
2834 : :
2835 : : static PyObject *
2836 : 3166 : sock_accept(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
2837 : : {
2838 : : sock_addr_t addrbuf;
2839 : : SOCKET_T newfd;
2840 : : socklen_t addrlen;
2841 : 3166 : PyObject *sock = NULL;
2842 : 3166 : PyObject *addr = NULL;
2843 : 3166 : PyObject *res = NULL;
2844 : : struct sock_accept ctx;
2845 : :
2846 [ - + ]: 3166 : if (!getsockaddrlen(s, &addrlen))
2847 : 0 : return NULL;
2848 : 3166 : memset(&addrbuf, 0, addrlen);
2849 : :
2850 : : if (!IS_SELECTABLE(s))
2851 : : return select_error();
2852 : :
2853 : 3166 : ctx.addrlen = &addrlen;
2854 : 3166 : ctx.addrbuf = &addrbuf;
2855 [ + + ]: 3166 : if (sock_call(s, 0, sock_accept_impl, &ctx) < 0)
2856 : 138 : return NULL;
2857 : 2986 : newfd = ctx.result;
2858 : :
2859 : : #ifdef MS_WINDOWS
2860 : : if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
2861 : : PyErr_SetFromWindowsErr(0);
2862 : : SOCKETCLOSE(newfd);
2863 : : goto finally;
2864 : : }
2865 : : #else
2866 : :
2867 : : #if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2868 [ - + ]: 2986 : if (!accept4_works)
2869 : : #endif
2870 : : {
2871 [ # # ]: 0 : if (_Py_set_inheritable(newfd, 0, NULL) < 0) {
2872 : 0 : SOCKETCLOSE(newfd);
2873 : 0 : goto finally;
2874 : : }
2875 : : }
2876 : : #endif
2877 : :
2878 : 2986 : sock = PyLong_FromSocket_t(newfd);
2879 [ - + ]: 2986 : if (sock == NULL) {
2880 : 0 : SOCKETCLOSE(newfd);
2881 : 0 : goto finally;
2882 : : }
2883 : :
2884 : 2986 : addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2885 : : addrlen, s->sock_proto);
2886 [ - + ]: 2986 : if (addr == NULL)
2887 : 0 : goto finally;
2888 : :
2889 : 2986 : res = PyTuple_Pack(2, sock, addr);
2890 : :
2891 : 2986 : finally:
2892 : 2986 : Py_XDECREF(sock);
2893 : 2986 : Py_XDECREF(addr);
2894 : 2986 : return res;
2895 : : }
2896 : :
2897 : : PyDoc_STRVAR(accept_doc,
2898 : : "_accept() -> (integer, address info)\n\
2899 : : \n\
2900 : : Wait for an incoming connection. Return a new socket file descriptor\n\
2901 : : representing the connection, and the address of the client.\n\
2902 : : For IP sockets, the address info is a pair (hostaddr, port).");
2903 : :
2904 : : /* s.setblocking(flag) method. Argument:
2905 : : False -- non-blocking mode; same as settimeout(0)
2906 : : True -- blocking mode; same as settimeout(None)
2907 : : */
2908 : :
2909 : : static PyObject *
2910 : 9002 : sock_setblocking(PySocketSockObject *s, PyObject *arg)
2911 : : {
2912 : : long block;
2913 : :
2914 : 9002 : block = PyLong_AsLong(arg);
2915 [ - + - - ]: 9002 : if (block == -1 && PyErr_Occurred())
2916 : 0 : return NULL;
2917 : :
2918 [ + + ]: 9002 : s->sock_timeout = _PyTime_FromSeconds(block ? -1 : 0);
2919 [ + + ]: 9002 : if (internal_setblocking(s, block) == -1) {
2920 : 1 : return NULL;
2921 : : }
2922 : 9001 : Py_RETURN_NONE;
2923 : : }
2924 : :
2925 : : PyDoc_STRVAR(setblocking_doc,
2926 : : "setblocking(flag)\n\
2927 : : \n\
2928 : : Set the socket to blocking (flag is true) or non-blocking (false).\n\
2929 : : setblocking(True) is equivalent to settimeout(None);\n\
2930 : : setblocking(False) is equivalent to settimeout(0.0).");
2931 : :
2932 : : /* s.getblocking() method.
2933 : : Returns True if socket is in blocking mode,
2934 : : False if it is in non-blocking mode.
2935 : : */
2936 : : static PyObject *
2937 : 17 : sock_getblocking(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
2938 : : {
2939 [ + + ]: 17 : if (s->sock_timeout) {
2940 : 10 : Py_RETURN_TRUE;
2941 : : }
2942 : : else {
2943 : 7 : Py_RETURN_FALSE;
2944 : : }
2945 : : }
2946 : :
2947 : : PyDoc_STRVAR(getblocking_doc,
2948 : : "getblocking()\n\
2949 : : \n\
2950 : : Returns True if socket is in blocking mode, or False if it\n\
2951 : : is in non-blocking mode.");
2952 : :
2953 : : static int
2954 : 3715 : socket_parse_timeout(_PyTime_t *timeout, PyObject *timeout_obj)
2955 : : {
2956 : : #ifdef MS_WINDOWS
2957 : : struct timeval tv;
2958 : : #endif
2959 : : #ifndef HAVE_POLL
2960 : : _PyTime_t ms;
2961 : : #endif
2962 : 3715 : int overflow = 0;
2963 : :
2964 [ + + ]: 3715 : if (timeout_obj == Py_None) {
2965 : 928 : *timeout = _PyTime_FromSeconds(-1);
2966 : 928 : return 0;
2967 : : }
2968 : :
2969 [ + + ]: 2787 : if (_PyTime_FromSecondsObject(timeout,
2970 : : timeout_obj, _PyTime_ROUND_TIMEOUT) < 0)
2971 : 7 : return -1;
2972 : :
2973 [ + + ]: 2780 : if (*timeout < 0) {
2974 : 4 : PyErr_SetString(PyExc_ValueError, "Timeout value out of range");
2975 : 4 : return -1;
2976 : : }
2977 : :
2978 : : #ifdef MS_WINDOWS
2979 : : overflow |= (_PyTime_AsTimeval(*timeout, &tv, _PyTime_ROUND_TIMEOUT) < 0);
2980 : : #endif
2981 : : #ifndef HAVE_POLL
2982 : : ms = _PyTime_AsMilliseconds(*timeout, _PyTime_ROUND_TIMEOUT);
2983 : : overflow |= (ms > INT_MAX);
2984 : : #endif
2985 [ - + ]: 2776 : if (overflow) {
2986 : 0 : PyErr_SetString(PyExc_OverflowError,
2987 : : "timeout doesn't fit into C timeval");
2988 : 0 : return -1;
2989 : : }
2990 : :
2991 : 2776 : return 0;
2992 : : }
2993 : :
2994 : : /* s.settimeout(timeout) method. Argument:
2995 : : None -- no timeout, blocking mode; same as setblocking(True)
2996 : : 0.0 -- non-blocking mode; same as setblocking(False)
2997 : : > 0 -- timeout mode; operations time out after timeout seconds
2998 : : < 0 -- illegal; raises an exception
2999 : : */
3000 : : static PyObject *
3001 : 3503 : sock_settimeout(PySocketSockObject *s, PyObject *arg)
3002 : : {
3003 : : _PyTime_t timeout;
3004 : :
3005 [ + + ]: 3503 : if (socket_parse_timeout(&timeout, arg) < 0)
3006 : 9 : return NULL;
3007 : :
3008 : 3494 : s->sock_timeout = timeout;
3009 : :
3010 : 3494 : int block = timeout < 0;
3011 : : /* Blocking mode for a Python socket object means that operations
3012 : : like :meth:`recv` or :meth:`sendall` will block the execution of
3013 : : the current thread until they are complete or aborted with a
3014 : : `TimeoutError` or `socket.error` errors. When timeout is `None`,
3015 : : the underlying FD is in a blocking mode. When timeout is a positive
3016 : : number, the FD is in a non-blocking mode, and socket ops are
3017 : : implemented with a `select()` call.
3018 : :
3019 : : When timeout is 0.0, the FD is in a non-blocking mode.
3020 : :
3021 : : This table summarizes all states in which the socket object and
3022 : : its underlying FD can be:
3023 : :
3024 : : ==================== ===================== ==============
3025 : : `gettimeout()` `getblocking()` FD
3026 : : ==================== ===================== ==============
3027 : : ``None`` ``True`` blocking
3028 : : ``0.0`` ``False`` non-blocking
3029 : : ``> 0`` ``True`` non-blocking
3030 : : */
3031 : :
3032 [ - + ]: 3494 : if (internal_setblocking(s, block) == -1) {
3033 : 0 : return NULL;
3034 : : }
3035 : 3494 : Py_RETURN_NONE;
3036 : : }
3037 : :
3038 : : PyDoc_STRVAR(settimeout_doc,
3039 : : "settimeout(timeout)\n\
3040 : : \n\
3041 : : Set a timeout on socket operations. 'timeout' can be a float,\n\
3042 : : giving in seconds, or None. Setting a timeout of None disables\n\
3043 : : the timeout feature and is equivalent to setblocking(1).\n\
3044 : : Setting a timeout of zero is the same as setblocking(0).");
3045 : :
3046 : : /* s.gettimeout() method.
3047 : : Returns the timeout associated with a socket. */
3048 : : static PyObject *
3049 : 5998 : sock_gettimeout(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3050 : : {
3051 [ + + ]: 5998 : if (s->sock_timeout < 0) {
3052 : 3340 : Py_RETURN_NONE;
3053 : : }
3054 : : else {
3055 : 2658 : double seconds = _PyTime_AsSecondsDouble(s->sock_timeout);
3056 : 2658 : return PyFloat_FromDouble(seconds);
3057 : : }
3058 : : }
3059 : :
3060 : : PyDoc_STRVAR(gettimeout_doc,
3061 : : "gettimeout() -> timeout\n\
3062 : : \n\
3063 : : Returns the timeout in seconds (float) associated with socket\n\
3064 : : operations. A timeout of None indicates that timeouts on socket\n\
3065 : : operations are disabled.");
3066 : :
3067 : : /* s.setsockopt() method.
3068 : : With an integer third argument, sets an integer optval with optlen=4.
3069 : : With None as third argument and an integer fourth argument, set
3070 : : optval=NULL with unsigned int as optlen.
3071 : : With a string third argument, sets an option from a buffer;
3072 : : use optional built-in module 'struct' to encode the string.
3073 : : */
3074 : :
3075 : : static PyObject *
3076 : 1509 : sock_setsockopt(PySocketSockObject *s, PyObject *args)
3077 : : {
3078 : : int level;
3079 : : int optname;
3080 : : int res;
3081 : : Py_buffer optval;
3082 : : int flag;
3083 : : unsigned int optlen;
3084 : : PyObject *none;
3085 : :
3086 : : #ifdef AF_VSOCK
3087 [ - + ]: 1509 : if (s->sock_family == AF_VSOCK) {
3088 : : uint64_t vflag; // Must be set width of 64 bits
3089 : : /* setsockopt(level, opt, flag) */
3090 [ # # ]: 0 : if (PyArg_ParseTuple(args, "iiK:setsockopt",
3091 : : &level, &optname, &vflag)) {
3092 : : // level should always be set to AF_VSOCK
3093 : 0 : res = setsockopt(s->sock_fd, level, optname,
3094 : : (void*)&vflag, sizeof vflag);
3095 : 0 : goto done;
3096 : : }
3097 : 0 : return NULL;
3098 : : }
3099 : : #endif
3100 : :
3101 : : /* setsockopt(level, opt, flag) */
3102 [ + + ]: 1509 : if (PyArg_ParseTuple(args, "iii:setsockopt",
3103 : : &level, &optname, &flag)) {
3104 : 1498 : res = setsockopt(s->sock_fd, level, optname,
3105 : : (char*)&flag, sizeof flag);
3106 : 1498 : goto done;
3107 : : }
3108 : :
3109 : 11 : PyErr_Clear();
3110 : : /* setsockopt(level, opt, None, flag) */
3111 [ + + ]: 11 : if (PyArg_ParseTuple(args, "iiO!I:setsockopt",
3112 : : &level, &optname, Py_TYPE(Py_None), &none, &optlen)) {
3113 : : assert(sizeof(socklen_t) >= sizeof(unsigned int));
3114 : 1 : res = setsockopt(s->sock_fd, level, optname,
3115 : : NULL, (socklen_t)optlen);
3116 : 1 : goto done;
3117 : : }
3118 : :
3119 : 10 : PyErr_Clear();
3120 : : /* setsockopt(level, opt, buffer) */
3121 [ - + ]: 10 : if (!PyArg_ParseTuple(args, "iiy*:setsockopt",
3122 : : &level, &optname, &optval))
3123 : 0 : return NULL;
3124 : :
3125 : : #ifdef MS_WINDOWS
3126 : : if (optval.len > INT_MAX) {
3127 : : PyBuffer_Release(&optval);
3128 : : PyErr_Format(PyExc_OverflowError,
3129 : : "socket option is larger than %i bytes",
3130 : : INT_MAX);
3131 : : return NULL;
3132 : : }
3133 : : res = setsockopt(s->sock_fd, level, optname,
3134 : : optval.buf, (int)optval.len);
3135 : : #else
3136 : 10 : res = setsockopt(s->sock_fd, level, optname, optval.buf, optval.len);
3137 : : #endif
3138 : 10 : PyBuffer_Release(&optval);
3139 : :
3140 : 1509 : done:
3141 [ - + ]: 1509 : if (res < 0) {
3142 : 0 : return s->errorhandler();
3143 : : }
3144 : :
3145 : 1509 : Py_RETURN_NONE;
3146 : : }
3147 : :
3148 : : PyDoc_STRVAR(setsockopt_doc,
3149 : : "setsockopt(level, option, value: int)\n\
3150 : : setsockopt(level, option, value: buffer)\n\
3151 : : setsockopt(level, option, None, optlen: int)\n\
3152 : : \n\
3153 : : Set a socket option. See the Unix manual for level and option.\n\
3154 : : The value argument can either be an integer, a string buffer, or\n\
3155 : : None, optlen.");
3156 : :
3157 : :
3158 : : /* s.getsockopt() method.
3159 : : With two arguments, retrieves an integer option.
3160 : : With a third integer argument, retrieves a string buffer of that size;
3161 : : use optional built-in module 'struct' to decode the string. */
3162 : :
3163 : : static PyObject *
3164 : 2280 : sock_getsockopt(PySocketSockObject *s, PyObject *args)
3165 : : {
3166 : : int level;
3167 : : int optname;
3168 : : int res;
3169 : : PyObject *buf;
3170 : 2280 : socklen_t buflen = 0;
3171 : 2280 : int flag = 0;
3172 : : socklen_t flagsize;
3173 : :
3174 [ - + ]: 2280 : if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
3175 : : &level, &optname, &buflen))
3176 : 0 : return NULL;
3177 : :
3178 [ + + ]: 2280 : if (buflen == 0) {
3179 : : #ifdef AF_VSOCK
3180 [ - + ]: 2279 : if (s->sock_family == AF_VSOCK) {
3181 : 0 : uint64_t vflag = 0; // Must be set width of 64 bits
3182 : 0 : flagsize = sizeof vflag;
3183 : 0 : res = getsockopt(s->sock_fd, level, optname,
3184 : : (void *)&vflag, &flagsize);
3185 [ # # ]: 0 : if (res < 0)
3186 : 0 : return s->errorhandler();
3187 : 0 : return PyLong_FromUnsignedLong(vflag);
3188 : : }
3189 : : #endif
3190 : 2279 : flagsize = sizeof flag;
3191 : 2279 : res = getsockopt(s->sock_fd, level, optname,
3192 : : (void *)&flag, &flagsize);
3193 [ - + ]: 2279 : if (res < 0)
3194 : 0 : return s->errorhandler();
3195 : 2279 : return PyLong_FromLong(flag);
3196 : : }
3197 : : #ifdef AF_VSOCK
3198 [ - + ]: 1 : if (s->sock_family == AF_VSOCK) {
3199 : 0 : PyErr_SetString(PyExc_OSError,
3200 : : "getsockopt string buffer not allowed");
3201 : 0 : return NULL;
3202 : : }
3203 : : #endif
3204 [ + - - + ]: 1 : if (buflen <= 0 || buflen > 1024) {
3205 : 0 : PyErr_SetString(PyExc_OSError,
3206 : : "getsockopt buflen out of range");
3207 : 0 : return NULL;
3208 : : }
3209 : 1 : buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
3210 [ - + ]: 1 : if (buf == NULL)
3211 : 0 : return NULL;
3212 : 1 : res = getsockopt(s->sock_fd, level, optname,
3213 : 1 : (void *)PyBytes_AS_STRING(buf), &buflen);
3214 [ - + ]: 1 : if (res < 0) {
3215 : 0 : Py_DECREF(buf);
3216 : 0 : return s->errorhandler();
3217 : : }
3218 : 1 : _PyBytes_Resize(&buf, buflen);
3219 : 1 : return buf;
3220 : : }
3221 : :
3222 : : PyDoc_STRVAR(getsockopt_doc,
3223 : : "getsockopt(level, option[, buffersize]) -> value\n\
3224 : : \n\
3225 : : Get a socket option. See the Unix manual for level and option.\n\
3226 : : If a nonzero buffersize argument is given, the return value is a\n\
3227 : : string of that length; otherwise it is an integer.");
3228 : :
3229 : :
3230 : : /* s.bind(sockaddr) method */
3231 : :
3232 : : static PyObject *
3233 : 3642 : sock_bind(PySocketSockObject *s, PyObject *addro)
3234 : : {
3235 : : sock_addr_t addrbuf;
3236 : : int addrlen;
3237 : : int res;
3238 : :
3239 [ + + ]: 3642 : if (!getsockaddrarg(s, addro, &addrbuf, &addrlen, "bind")) {
3240 : 1048 : return NULL;
3241 : : }
3242 : :
3243 [ - + ]: 2594 : if (PySys_Audit("socket.bind", "OO", s, addro) < 0) {
3244 : 0 : return NULL;
3245 : : }
3246 : :
3247 : 2594 : Py_BEGIN_ALLOW_THREADS
3248 : 2594 : res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
3249 : 2594 : Py_END_ALLOW_THREADS
3250 [ + + ]: 2594 : if (res < 0)
3251 : 20 : return s->errorhandler();
3252 : 2574 : Py_RETURN_NONE;
3253 : : }
3254 : :
3255 : : PyDoc_STRVAR(bind_doc,
3256 : : "bind(address)\n\
3257 : : \n\
3258 : : Bind the socket to a local address. For IP sockets, the address is a\n\
3259 : : pair (host, port); the host must refer to the local host. For raw packet\n\
3260 : : sockets the address is a tuple (ifname, proto [,pkttype [,hatype [,addr]]])");
3261 : :
3262 : :
3263 : : /* s.close() method.
3264 : : Set the file descriptor to -1 so operations tried subsequently
3265 : : will surely fail. */
3266 : :
3267 : : static PyObject *
3268 : 143194 : sock_close(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3269 : : {
3270 : : SOCKET_T fd;
3271 : : int res;
3272 : :
3273 : 143194 : fd = s->sock_fd;
3274 [ + + ]: 143194 : if (fd != INVALID_SOCKET) {
3275 : 142577 : s->sock_fd = INVALID_SOCKET;
3276 : :
3277 : : /* We do not want to retry upon EINTR: see
3278 : : http://lwn.net/Articles/576478/ and
3279 : : http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
3280 : : for more details. */
3281 : 142577 : Py_BEGIN_ALLOW_THREADS
3282 : 142577 : res = SOCKETCLOSE(fd);
3283 : 142577 : Py_END_ALLOW_THREADS
3284 : : /* bpo-30319: The peer can already have closed the connection.
3285 : : Python ignores ECONNRESET on close(). */
3286 [ + + + - ]: 142577 : if (res < 0 && errno != ECONNRESET) {
3287 : 2 : return s->errorhandler();
3288 : : }
3289 : : }
3290 : 143192 : Py_RETURN_NONE;
3291 : : }
3292 : :
3293 : : PyDoc_STRVAR(sock_close_doc,
3294 : : "close()\n\
3295 : : \n\
3296 : : Close the socket. It cannot be used after this call.");
3297 : :
3298 : : static PyObject *
3299 : 139342 : sock_detach(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3300 : : {
3301 : 139342 : SOCKET_T fd = s->sock_fd;
3302 : 139342 : s->sock_fd = INVALID_SOCKET;
3303 : 139342 : return PyLong_FromSocket_t(fd);
3304 : : }
3305 : :
3306 : : PyDoc_STRVAR(detach_doc,
3307 : : "detach()\n\
3308 : : \n\
3309 : : Close the socket object without closing the underlying file descriptor.\n\
3310 : : The object cannot be used after this call, but the file descriptor\n\
3311 : : can be reused for other purposes. The file descriptor is returned.");
3312 : :
3313 : : static int
3314 : 504 : sock_connect_impl(PySocketSockObject *s, void* Py_UNUSED(data))
3315 : : {
3316 : : int err;
3317 : 504 : socklen_t size = sizeof err;
3318 : :
3319 [ - + ]: 504 : if (getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR, (void *)&err, &size)) {
3320 : : /* getsockopt() failed */
3321 : 0 : return 0;
3322 : : }
3323 : :
3324 [ - + ]: 504 : if (err == EISCONN)
3325 : 0 : return 1;
3326 [ + + ]: 504 : if (err != 0) {
3327 : : /* sock_call_ex() uses GET_SOCK_ERROR() to get the error code */
3328 : 31 : SET_SOCK_ERROR(err);
3329 : 31 : return 0;
3330 : : }
3331 : 473 : return 1;
3332 : : }
3333 : :
3334 : : static int
3335 : 5189 : internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
3336 : : int raise)
3337 : : {
3338 : : int res, err, wait_connect;
3339 : :
3340 : 5189 : Py_BEGIN_ALLOW_THREADS
3341 : 5189 : res = connect(s->sock_fd, addr, addrlen);
3342 : 5189 : Py_END_ALLOW_THREADS
3343 : :
3344 [ + + ]: 5189 : if (!res) {
3345 : : /* connect() succeeded, the socket is connected */
3346 : 4327 : return 0;
3347 : : }
3348 : :
3349 : : /* connect() failed */
3350 : :
3351 : : /* save error, PyErr_CheckSignals() can replace it */
3352 : 862 : err = GET_SOCK_ERROR;
3353 [ - + ]: 862 : if (CHECK_ERRNO(EINTR)) {
3354 [ # # ]: 0 : if (PyErr_CheckSignals())
3355 : 0 : return -1;
3356 : :
3357 : : /* Issue #23618: when connect() fails with EINTR, the connection is
3358 : : running asynchronously.
3359 : :
3360 : : If the socket is blocking or has a timeout, wait until the
3361 : : connection completes, fails or timed out using select(), and then
3362 : : get the connection status using getsockopt(SO_ERROR).
3363 : :
3364 : : If the socket is non-blocking, raise InterruptedError. The caller is
3365 : : responsible to wait until the connection completes, fails or timed
3366 : : out (it's the case in asyncio for example). */
3367 : 0 : wait_connect = (s->sock_timeout != 0 && IS_SELECTABLE(s));
3368 : : }
3369 : : else {
3370 : 862 : wait_connect = (s->sock_timeout > 0 && err == SOCK_INPROGRESS_ERR
3371 [ + + + + ]: 862 : && IS_SELECTABLE(s));
3372 : : }
3373 : :
3374 [ + + ]: 862 : if (!wait_connect) {
3375 [ + + ]: 357 : if (raise) {
3376 : : /* restore error, maybe replaced by PyErr_CheckSignals() */
3377 : 280 : SET_SOCK_ERROR(err);
3378 : 280 : s->errorhandler();
3379 : 280 : return -1;
3380 : : }
3381 : : else
3382 : 77 : return err;
3383 : : }
3384 : :
3385 [ + + ]: 505 : if (raise) {
3386 : : /* socket.connect() raises an exception on error */
3387 [ + + ]: 504 : if (sock_call_ex(s, 1, sock_connect_impl, NULL,
3388 : : 1, NULL, s->sock_timeout) < 0)
3389 : 31 : return -1;
3390 : : }
3391 : : else {
3392 : : /* socket.connect_ex() returns the error code on error */
3393 [ + - ]: 1 : if (sock_call_ex(s, 1, sock_connect_impl, NULL,
3394 : : 1, &err, s->sock_timeout) < 0)
3395 : 1 : return err;
3396 : : }
3397 : 473 : return 0;
3398 : : }
3399 : :
3400 : : /* s.connect(sockaddr) method */
3401 : :
3402 : : static PyObject *
3403 : 5092 : sock_connect(PySocketSockObject *s, PyObject *addro)
3404 : : {
3405 : : sock_addr_t addrbuf;
3406 : : int addrlen;
3407 : : int res;
3408 : :
3409 [ - + ]: 5092 : if (!getsockaddrarg(s, addro, &addrbuf, &addrlen, "connect")) {
3410 : 0 : return NULL;
3411 : : }
3412 : :
3413 [ - + ]: 5092 : if (PySys_Audit("socket.connect", "OO", s, addro) < 0) {
3414 : 0 : return NULL;
3415 : : }
3416 : :
3417 : 5092 : res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 1);
3418 [ + + ]: 5092 : if (res < 0)
3419 : 311 : return NULL;
3420 : :
3421 : 4781 : Py_RETURN_NONE;
3422 : : }
3423 : :
3424 : : PyDoc_STRVAR(connect_doc,
3425 : : "connect(address)\n\
3426 : : \n\
3427 : : Connect the socket to a remote address. For IP sockets, the address\n\
3428 : : is a pair (host, port).");
3429 : :
3430 : :
3431 : : /* s.connect_ex(sockaddr) method */
3432 : :
3433 : : static PyObject *
3434 : 97 : sock_connect_ex(PySocketSockObject *s, PyObject *addro)
3435 : : {
3436 : : sock_addr_t addrbuf;
3437 : : int addrlen;
3438 : : int res;
3439 : :
3440 [ - + ]: 97 : if (!getsockaddrarg(s, addro, &addrbuf, &addrlen, "connect_ex")) {
3441 : 0 : return NULL;
3442 : : }
3443 : :
3444 [ - + ]: 97 : if (PySys_Audit("socket.connect", "OO", s, addro) < 0) {
3445 : 0 : return NULL;
3446 : : }
3447 : :
3448 : 97 : res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 0);
3449 [ - + ]: 97 : if (res < 0)
3450 : 0 : return NULL;
3451 : :
3452 : 97 : return PyLong_FromLong((long) res);
3453 : : }
3454 : :
3455 : : PyDoc_STRVAR(connect_ex_doc,
3456 : : "connect_ex(address) -> errno\n\
3457 : : \n\
3458 : : This is like connect(address), but returns an error code (the errno value)\n\
3459 : : instead of raising an exception when an error occurs.");
3460 : :
3461 : :
3462 : : /* s.fileno() method */
3463 : :
3464 : : static PyObject *
3465 : 139770 : sock_fileno(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3466 : : {
3467 : 139770 : return PyLong_FromSocket_t(s->sock_fd);
3468 : : }
3469 : :
3470 : : PyDoc_STRVAR(fileno_doc,
3471 : : "fileno() -> integer\n\
3472 : : \n\
3473 : : Return the integer file descriptor of the socket.");
3474 : :
3475 : :
3476 : : /* s.getsockname() method */
3477 : :
3478 : : static PyObject *
3479 : 3496 : sock_getsockname(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3480 : : {
3481 : : sock_addr_t addrbuf;
3482 : : int res;
3483 : : socklen_t addrlen;
3484 : :
3485 [ + + ]: 3496 : if (!getsockaddrlen(s, &addrlen))
3486 : 1 : return NULL;
3487 : 3495 : memset(&addrbuf, 0, addrlen);
3488 : 3495 : Py_BEGIN_ALLOW_THREADS
3489 : 3495 : res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
3490 : 3495 : Py_END_ALLOW_THREADS
3491 [ + + ]: 3495 : if (res < 0)
3492 : 7 : return s->errorhandler();
3493 : 3488 : return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
3494 : : s->sock_proto);
3495 : : }
3496 : :
3497 : : PyDoc_STRVAR(getsockname_doc,
3498 : : "getsockname() -> address info\n\
3499 : : \n\
3500 : : Return the address of the local endpoint. The format depends on the\n\
3501 : : address family. For IPv4 sockets, the address info is a pair\n\
3502 : : (hostaddr, port).");
3503 : :
3504 : :
3505 : : #ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
3506 : : /* s.getpeername() method */
3507 : :
3508 : : static PyObject *
3509 : 1757 : sock_getpeername(PySocketSockObject *s, PyObject *Py_UNUSED(ignored))
3510 : : {
3511 : : sock_addr_t addrbuf;
3512 : : int res;
3513 : : socklen_t addrlen;
3514 : :
3515 [ + + ]: 1757 : if (!getsockaddrlen(s, &addrlen))
3516 : 1 : return NULL;
3517 : 1756 : memset(&addrbuf, 0, addrlen);
3518 : 1756 : Py_BEGIN_ALLOW_THREADS
3519 : 1756 : res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
3520 : 1756 : Py_END_ALLOW_THREADS
3521 [ + + ]: 1756 : if (res < 0)
3522 : 204 : return s->errorhandler();
3523 : 1552 : return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
3524 : : s->sock_proto);
3525 : : }
3526 : :
3527 : : PyDoc_STRVAR(getpeername_doc,
3528 : : "getpeername() -> address info\n\
3529 : : \n\
3530 : : Return the address of the remote endpoint. For IP sockets, the address\n\
3531 : : info is a pair (hostaddr, port).");
3532 : :
3533 : : #endif /* HAVE_GETPEERNAME */
3534 : :
3535 : :
3536 : : /* s.listen(n) method */
3537 : :
3538 : : static PyObject *
3539 : 1493 : sock_listen(PySocketSockObject *s, PyObject *args)
3540 : : {
3541 : : /* We try to choose a default backlog high enough to avoid connection drops
3542 : : * for common workloads, yet not too high to limit resource usage. */
3543 : 1493 : int backlog = Py_MIN(SOMAXCONN, 128);
3544 : : int res;
3545 : :
3546 [ + + ]: 1493 : if (!PyArg_ParseTuple(args, "|i:listen", &backlog))
3547 : 1 : return NULL;
3548 : :
3549 : 1492 : Py_BEGIN_ALLOW_THREADS
3550 : : /* To avoid problems on systems that don't allow a negative backlog
3551 : : * (which doesn't make sense anyway) we force a minimum value of 0. */
3552 [ + + ]: 1492 : if (backlog < 0)
3553 : 1 : backlog = 0;
3554 : 1492 : res = listen(s->sock_fd, backlog);
3555 : 1492 : Py_END_ALLOW_THREADS
3556 [ + + ]: 1492 : if (res < 0)
3557 : 1 : return s->errorhandler();
3558 : 1491 : Py_RETURN_NONE;
3559 : : }
3560 : :
3561 : : PyDoc_STRVAR(listen_doc,
3562 : : "listen([backlog])\n\
3563 : : \n\
3564 : : Enable a server to accept connections. If backlog is specified, it must be\n\
3565 : : at least 0 (if it is lower, it is set to 0); it specifies the number of\n\
3566 : : unaccepted connections that the system will allow before refusing new\n\
3567 : : connections. If not specified, a default reasonable value is chosen.");
3568 : :
3569 : : struct sock_recv {
3570 : : char *cbuf;
3571 : : Py_ssize_t len;
3572 : : int flags;
3573 : : Py_ssize_t result;
3574 : : };
3575 : :
3576 : : static int
3577 : 66573 : sock_recv_impl(PySocketSockObject *s, void *data)
3578 : : {
3579 : 66573 : struct sock_recv *ctx = data;
3580 : :
3581 : : #ifdef MS_WINDOWS
3582 : : if (ctx->len > INT_MAX)
3583 : : ctx->len = INT_MAX;
3584 : : ctx->result = recv(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags);
3585 : : #else
3586 : 66573 : ctx->result = recv(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags);
3587 : : #endif
3588 : 66573 : return (ctx->result >= 0);
3589 : : }
3590 : :
3591 : :
3592 : : /*
3593 : : * This is the guts of the recv() and recv_into() methods, which reads into a
3594 : : * char buffer. If you have any inc/dec ref to do to the objects that contain
3595 : : * the buffer, do it in the caller. This function returns the number of bytes
3596 : : * successfully read. If there was an error, it returns -1. Note that it is
3597 : : * also possible that we return a number of bytes smaller than the request
3598 : : * bytes.
3599 : : */
3600 : :
3601 : : static Py_ssize_t
3602 : 66578 : sock_recv_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags)
3603 : : {
3604 : : struct sock_recv ctx;
3605 : :
3606 : : if (!IS_SELECTABLE(s)) {
3607 : : select_error();
3608 : : return -1;
3609 : : }
3610 [ - + ]: 66578 : if (len == 0) {
3611 : : /* If 0 bytes were requested, do nothing. */
3612 : 0 : return 0;
3613 : : }
3614 : :
3615 : 66578 : ctx.cbuf = cbuf;
3616 : 66578 : ctx.len = len;
3617 : 66578 : ctx.flags = flags;
3618 [ + + ]: 66578 : if (sock_call(s, 0, sock_recv_impl, &ctx) < 0)
3619 : 769 : return -1;
3620 : :
3621 : 65809 : return ctx.result;
3622 : : }
3623 : :
3624 : :
3625 : : /* s.recv(nbytes [,flags]) method */
3626 : :
3627 : : static PyObject *
3628 : 57302 : sock_recv(PySocketSockObject *s, PyObject *args)
3629 : : {
3630 : : Py_ssize_t recvlen, outlen;
3631 : 57302 : int flags = 0;
3632 : : PyObject *buf;
3633 : :
3634 [ - + ]: 57302 : if (!PyArg_ParseTuple(args, "n|i:recv", &recvlen, &flags))
3635 : 0 : return NULL;
3636 : :
3637 [ - + ]: 57302 : if (recvlen < 0) {
3638 : 0 : PyErr_SetString(PyExc_ValueError,
3639 : : "negative buffersize in recv");
3640 : 0 : return NULL;
3641 : : }
3642 : :
3643 : : /* Allocate a new string. */
3644 : 57302 : buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
3645 [ - + ]: 57302 : if (buf == NULL)
3646 : 0 : return NULL;
3647 : :
3648 : : /* Call the guts */
3649 : 57302 : outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
3650 [ + + ]: 57302 : if (outlen < 0) {
3651 : : /* An error occurred, release the string and return an
3652 : : error. */
3653 : 701 : Py_DECREF(buf);
3654 : 701 : return NULL;
3655 : : }
3656 [ + + ]: 56601 : if (outlen != recvlen) {
3657 : : /* We did not read as many bytes as we anticipated, resize the
3658 : : string if possible and be successful. */
3659 : 5810 : _PyBytes_Resize(&buf, outlen);
3660 : : }
3661 : :
3662 : 56601 : return buf;
3663 : : }
3664 : :
3665 : : PyDoc_STRVAR(recv_doc,
3666 : : "recv(buffersize[, flags]) -> data\n\
3667 : : \n\
3668 : : Receive up to buffersize bytes from the socket. For the optional flags\n\
3669 : : argument, see the Unix manual. When no data is available, block until\n\
3670 : : at least one byte is available or until the remote end is closed. When\n\
3671 : : the remote end is closed and all data is read, return the empty string.");
3672 : :
3673 : :
3674 : : /* s.recv_into(buffer, [nbytes [,flags]]) method */
3675 : :
3676 : : static PyObject*
3677 : 9276 : sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
3678 : : {
3679 : : static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
3680 : :
3681 : 9276 : int flags = 0;
3682 : : Py_buffer pbuf;
3683 : : char *buf;
3684 : 9276 : Py_ssize_t buflen, readlen, recvlen = 0;
3685 : :
3686 : : /* Get the buffer's memory */
3687 [ - + ]: 9276 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recv_into", kwlist,
3688 : : &pbuf, &recvlen, &flags))
3689 : 0 : return NULL;
3690 : 9276 : buf = pbuf.buf;
3691 : 9276 : buflen = pbuf.len;
3692 : :
3693 [ - + ]: 9276 : if (recvlen < 0) {
3694 : 0 : PyBuffer_Release(&pbuf);
3695 : 0 : PyErr_SetString(PyExc_ValueError,
3696 : : "negative buffersize in recv_into");
3697 : 0 : return NULL;
3698 : : }
3699 [ + + ]: 9276 : if (recvlen == 0) {
3700 : : /* If nbytes was not specified, use the buffer's length */
3701 : 9275 : recvlen = buflen;
3702 : : }
3703 : :
3704 : : /* Check if the buffer is large enough */
3705 [ - + ]: 9276 : if (buflen < recvlen) {
3706 : 0 : PyBuffer_Release(&pbuf);
3707 : 0 : PyErr_SetString(PyExc_ValueError,
3708 : : "buffer too small for requested bytes");
3709 : 0 : return NULL;
3710 : : }
3711 : :
3712 : : /* Call the guts */
3713 : 9276 : readlen = sock_recv_guts(s, buf, recvlen, flags);
3714 [ + + ]: 9276 : if (readlen < 0) {
3715 : : /* Return an error. */
3716 : 68 : PyBuffer_Release(&pbuf);
3717 : 68 : return NULL;
3718 : : }
3719 : :
3720 : 9208 : PyBuffer_Release(&pbuf);
3721 : : /* Return the number of bytes read. Note that we do not do anything
3722 : : special here in the case that readlen < recvlen. */
3723 : 9208 : return PyLong_FromSsize_t(readlen);
3724 : : }
3725 : :
3726 : : PyDoc_STRVAR(recv_into_doc,
3727 : : "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
3728 : : \n\
3729 : : A version of recv() that stores its data into a buffer rather than creating\n\
3730 : : a new string. Receive up to buffersize bytes from the socket. If buffersize\n\
3731 : : is not specified (or 0), receive up to the size available in the given buffer.\n\
3732 : : \n\
3733 : : See recv() for documentation about the flags.");
3734 : :
3735 : : struct sock_recvfrom {
3736 : : char* cbuf;
3737 : : Py_ssize_t len;
3738 : : int flags;
3739 : : socklen_t *addrlen;
3740 : : sock_addr_t *addrbuf;
3741 : : Py_ssize_t result;
3742 : : };
3743 : :
3744 : : static int
3745 : 105 : sock_recvfrom_impl(PySocketSockObject *s, void *data)
3746 : : {
3747 : 105 : struct sock_recvfrom *ctx = data;
3748 : :
3749 : 105 : memset(ctx->addrbuf, 0, *ctx->addrlen);
3750 : :
3751 : : #ifdef MS_WINDOWS
3752 : : if (ctx->len > INT_MAX)
3753 : : ctx->len = INT_MAX;
3754 : : ctx->result = recvfrom(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags,
3755 : : SAS2SA(ctx->addrbuf), ctx->addrlen);
3756 : : #else
3757 : 210 : ctx->result = recvfrom(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags,
3758 : 105 : SAS2SA(ctx->addrbuf), ctx->addrlen);
3759 : : #endif
3760 : 105 : return (ctx->result >= 0);
3761 : : }
3762 : :
3763 : :
3764 : : /*
3765 : : * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
3766 : : * into a char buffer. If you have any inc/def ref to do to the objects that
3767 : : * contain the buffer, do it in the caller. This function returns the number
3768 : : * of bytes successfully read. If there was an error, it returns -1. Note
3769 : : * that it is also possible that we return a number of bytes smaller than the
3770 : : * request bytes.
3771 : : *
3772 : : * 'addr' is a return value for the address object. Note that you must decref
3773 : : * it yourself.
3774 : : */
3775 : : static Py_ssize_t
3776 : 108 : sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags,
3777 : : PyObject** addr)
3778 : : {
3779 : : sock_addr_t addrbuf;
3780 : : socklen_t addrlen;
3781 : : struct sock_recvfrom ctx;
3782 : :
3783 : 108 : *addr = NULL;
3784 : :
3785 [ - + ]: 108 : if (!getsockaddrlen(s, &addrlen))
3786 : 0 : return -1;
3787 : :
3788 : : if (!IS_SELECTABLE(s)) {
3789 : : select_error();
3790 : : return -1;
3791 : : }
3792 : :
3793 : 108 : ctx.cbuf = cbuf;
3794 : 108 : ctx.len = len;
3795 : 108 : ctx.flags = flags;
3796 : 108 : ctx.addrbuf = &addrbuf;
3797 : 108 : ctx.addrlen = &addrlen;
3798 [ + + ]: 108 : if (sock_call(s, 0, sock_recvfrom_impl, &ctx) < 0)
3799 : 16 : return -1;
3800 : :
3801 : 92 : *addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
3802 : : s->sock_proto);
3803 [ - + ]: 92 : if (*addr == NULL)
3804 : 0 : return -1;
3805 : :
3806 : 92 : return ctx.result;
3807 : : }
3808 : :
3809 : : /* s.recvfrom(nbytes [,flags]) method */
3810 : :
3811 : : static PyObject *
3812 : 91 : sock_recvfrom(PySocketSockObject *s, PyObject *args)
3813 : : {
3814 : 91 : PyObject *buf = NULL;
3815 : 91 : PyObject *addr = NULL;
3816 : 91 : PyObject *ret = NULL;
3817 : 91 : int flags = 0;
3818 : : Py_ssize_t recvlen, outlen;
3819 : :
3820 [ - + ]: 91 : if (!PyArg_ParseTuple(args, "n|i:recvfrom", &recvlen, &flags))
3821 : 0 : return NULL;
3822 : :
3823 [ + + ]: 91 : if (recvlen < 0) {
3824 : 2 : PyErr_SetString(PyExc_ValueError,
3825 : : "negative buffersize in recvfrom");
3826 : 2 : return NULL;
3827 : : }
3828 : :
3829 : 89 : buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
3830 [ - + ]: 89 : if (buf == NULL)
3831 : 0 : return NULL;
3832 : :
3833 : 89 : outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
3834 : : recvlen, flags, &addr);
3835 [ + + ]: 89 : if (outlen < 0) {
3836 : 8 : goto finally;
3837 : : }
3838 : :
3839 [ + + ]: 81 : if (outlen != recvlen) {
3840 : : /* We did not read as many bytes as we anticipated, resize the
3841 : : string if possible and be successful. */
3842 [ - + ]: 59 : if (_PyBytes_Resize(&buf, outlen) < 0)
3843 : : /* Oopsy, not so successful after all. */
3844 : 0 : goto finally;
3845 : : }
3846 : :
3847 : 81 : ret = PyTuple_Pack(2, buf, addr);
3848 : :
3849 : 89 : finally:
3850 : 89 : Py_XDECREF(buf);
3851 : 89 : Py_XDECREF(addr);
3852 : 89 : return ret;
3853 : : }
3854 : :
3855 : : PyDoc_STRVAR(recvfrom_doc,
3856 : : "recvfrom(buffersize[, flags]) -> (data, address info)\n\
3857 : : \n\
3858 : : Like recv(buffersize, flags) but also return the sender's address info.");
3859 : :
3860 : :
3861 : : /* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
3862 : :
3863 : : static PyObject *
3864 : 20 : sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
3865 : : {
3866 : : static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
3867 : :
3868 : 20 : int flags = 0;
3869 : : Py_buffer pbuf;
3870 : : char *buf;
3871 : 20 : Py_ssize_t readlen, buflen, recvlen = 0;
3872 : :
3873 : 20 : PyObject *addr = NULL;
3874 : :
3875 [ - + ]: 20 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recvfrom_into",
3876 : : kwlist, &pbuf,
3877 : : &recvlen, &flags))
3878 : 0 : return NULL;
3879 : 20 : buf = pbuf.buf;
3880 : 20 : buflen = pbuf.len;
3881 : :
3882 [ - + ]: 20 : if (recvlen < 0) {
3883 : 0 : PyBuffer_Release(&pbuf);
3884 : 0 : PyErr_SetString(PyExc_ValueError,
3885 : : "negative buffersize in recvfrom_into");
3886 : 0 : return NULL;
3887 : : }
3888 [ + + ]: 20 : if (recvlen == 0) {
3889 : : /* If nbytes was not specified, use the buffer's length */
3890 : 6 : recvlen = buflen;
3891 [ + + ]: 14 : } else if (recvlen > buflen) {
3892 : 1 : PyBuffer_Release(&pbuf);
3893 : 1 : PyErr_SetString(PyExc_ValueError,
3894 : : "nbytes is greater than the length of the buffer");
3895 : 1 : return NULL;
3896 : : }
3897 : :
3898 : 19 : readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
3899 [ + + ]: 19 : if (readlen < 0) {
3900 : 8 : PyBuffer_Release(&pbuf);
3901 : : /* Return an error */
3902 : 8 : Py_XDECREF(addr);
3903 : 8 : return NULL;
3904 : : }
3905 : :
3906 : 11 : PyBuffer_Release(&pbuf);
3907 : : /* Return the number of bytes read and the address. Note that we do
3908 : : not do anything special here in the case that readlen < recvlen. */
3909 : 11 : return Py_BuildValue("nN", readlen, addr);
3910 : : }
3911 : :
3912 : : PyDoc_STRVAR(recvfrom_into_doc,
3913 : : "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
3914 : : \n\
3915 : : Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
3916 : :
3917 : : /* The sendmsg() and recvmsg[_into]() methods require a working
3918 : : CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3919 : : #ifdef CMSG_LEN
3920 : : struct sock_recvmsg {
3921 : : struct msghdr *msg;
3922 : : int flags;
3923 : : ssize_t result;
3924 : : };
3925 : :
3926 : : static int
3927 : 775 : sock_recvmsg_impl(PySocketSockObject *s, void *data)
3928 : : {
3929 : 775 : struct sock_recvmsg *ctx = data;
3930 : :
3931 : 775 : ctx->result = recvmsg(s->sock_fd, ctx->msg, ctx->flags);
3932 : 775 : return (ctx->result >= 0);
3933 : : }
3934 : :
3935 : : /*
3936 : : * Call recvmsg() with the supplied iovec structures, flags, and
3937 : : * ancillary data buffer size (controllen). Returns the tuple return
3938 : : * value for recvmsg() or recvmsg_into(), with the first item provided
3939 : : * by the supplied makeval() function. makeval() will be called with
3940 : : * the length read and makeval_data as arguments, and must return a
3941 : : * new reference (which will be decrefed if there is a subsequent
3942 : : * error). On error, closes any file descriptors received via
3943 : : * SCM_RIGHTS.
3944 : : */
3945 : : static PyObject *
3946 : 790 : sock_recvmsg_guts(PySocketSockObject *s, struct iovec *iov, int iovlen,
3947 : : int flags, Py_ssize_t controllen,
3948 : : PyObject *(*makeval)(ssize_t, void *), void *makeval_data)
3949 : : {
3950 : : sock_addr_t addrbuf;
3951 : : socklen_t addrbuflen;
3952 : 790 : struct msghdr msg = {0};
3953 : 790 : PyObject *cmsg_list = NULL, *retval = NULL;
3954 : 790 : void *controlbuf = NULL;
3955 : : struct cmsghdr *cmsgh;
3956 : 790 : size_t cmsgdatalen = 0;
3957 : : int cmsg_status;
3958 : : struct sock_recvmsg ctx;
3959 : :
3960 : : /* XXX: POSIX says that msg_name and msg_namelen "shall be
3961 : : ignored" when the socket is connected (Linux fills them in
3962 : : anyway for AF_UNIX sockets at least). Normally msg_namelen
3963 : : seems to be set to 0 if there's no address, but try to
3964 : : initialize msg_name to something that won't be mistaken for a
3965 : : real address if that doesn't happen. */
3966 [ - + ]: 790 : if (!getsockaddrlen(s, &addrbuflen))
3967 : 0 : return NULL;
3968 : 790 : memset(&addrbuf, 0, addrbuflen);
3969 : 790 : SAS2SA(&addrbuf)->sa_family = AF_UNSPEC;
3970 : :
3971 [ + + - + ]: 790 : if (controllen < 0 || controllen > SOCKLEN_T_LIMIT) {
3972 : 12 : PyErr_SetString(PyExc_ValueError,
3973 : : "invalid ancillary data buffer length");
3974 : 12 : return NULL;
3975 : : }
3976 [ + + - + ]: 778 : if (controllen > 0 && (controlbuf = PyMem_Malloc(controllen)) == NULL)
3977 : : return PyErr_NoMemory();
3978 : :
3979 : : /* Make the system call. */
3980 : : if (!IS_SELECTABLE(s)) {
3981 : : select_error();
3982 : : goto finally;
3983 : : }
3984 : :
3985 : 778 : msg.msg_name = SAS2SA(&addrbuf);
3986 : 778 : msg.msg_namelen = addrbuflen;
3987 : 778 : msg.msg_iov = iov;
3988 : 778 : msg.msg_iovlen = iovlen;
3989 : 778 : msg.msg_control = controlbuf;
3990 : 778 : msg.msg_controllen = controllen;
3991 : :
3992 : 778 : ctx.msg = &msg;
3993 : 778 : ctx.flags = flags;
3994 [ + + ]: 778 : if (sock_call(s, 0, sock_recvmsg_impl, &ctx) < 0)
3995 : 26 : goto finally;
3996 : :
3997 : : /* Make list of (level, type, data) tuples from control messages. */
3998 [ - + ]: 752 : if ((cmsg_list = PyList_New(0)) == NULL)
3999 : 0 : goto err_closefds;
4000 : : /* Check for empty ancillary data as old CMSG_FIRSTHDR()
4001 : : implementations didn't do so. */
4002 [ + + + - ]: 752 : for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
4003 [ + + ]: 1314 : cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
4004 : : PyObject *bytes, *tuple;
4005 : : int tmp;
4006 : :
4007 : 562 : cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
4008 [ - + ]: 562 : if (cmsg_status != 0) {
4009 [ # # ]: 0 : if (PyErr_WarnEx(PyExc_RuntimeWarning,
4010 : : "received malformed or improperly-truncated "
4011 : : "ancillary data", 1) == -1)
4012 : 0 : goto err_closefds;
4013 : : }
4014 [ - + ]: 562 : if (cmsg_status < 0)
4015 : 0 : break;
4016 [ - + ]: 562 : if (cmsgdatalen > PY_SSIZE_T_MAX) {
4017 : 0 : PyErr_SetString(PyExc_OSError, "control message too long");
4018 : 0 : goto err_closefds;
4019 : : }
4020 : :
4021 : 562 : bytes = PyBytes_FromStringAndSize((char *)CMSG_DATA(cmsgh),
4022 : : cmsgdatalen);
4023 : 562 : tuple = Py_BuildValue("iiN", (int)cmsgh->cmsg_level,
4024 : : (int)cmsgh->cmsg_type, bytes);
4025 [ - + ]: 562 : if (tuple == NULL)
4026 : 0 : goto err_closefds;
4027 : 562 : tmp = PyList_Append(cmsg_list, tuple);
4028 : 562 : Py_DECREF(tuple);
4029 [ - + ]: 562 : if (tmp != 0)
4030 : 0 : goto err_closefds;
4031 : :
4032 [ - + ]: 562 : if (cmsg_status != 0)
4033 : 0 : break;
4034 : : }
4035 : :
4036 : 752 : retval = Py_BuildValue("NOiN",
4037 : : (*makeval)(ctx.result, makeval_data),
4038 : : cmsg_list,
4039 : : (int)msg.msg_flags,
4040 : : makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
4041 : 752 : ((msg.msg_namelen > addrbuflen) ?
4042 : 752 : addrbuflen : msg.msg_namelen),
4043 : : s->sock_proto));
4044 [ - + ]: 752 : if (retval == NULL)
4045 : 0 : goto err_closefds;
4046 : :
4047 : 752 : finally:
4048 : 778 : Py_XDECREF(cmsg_list);
4049 : 778 : PyMem_Free(controlbuf);
4050 : 778 : return retval;
4051 : :
4052 : 0 : err_closefds:
4053 : : #ifdef SCM_RIGHTS
4054 : : /* Close all descriptors coming from SCM_RIGHTS, so they don't leak. */
4055 [ # # # # ]: 0 : for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
4056 [ # # ]: 0 : cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
4057 : 0 : cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
4058 [ # # ]: 0 : if (cmsg_status < 0)
4059 : 0 : break;
4060 [ # # ]: 0 : if (cmsgh->cmsg_level == SOL_SOCKET &&
4061 [ # # ]: 0 : cmsgh->cmsg_type == SCM_RIGHTS) {
4062 : : size_t numfds;
4063 : : int *fdp;
4064 : :
4065 : 0 : numfds = cmsgdatalen / sizeof(int);
4066 : 0 : fdp = (int *)CMSG_DATA(cmsgh);
4067 [ # # ]: 0 : while (numfds-- > 0)
4068 : 0 : close(*fdp++);
4069 : : }
4070 [ # # ]: 0 : if (cmsg_status != 0)
4071 : 0 : break;
4072 : : }
4073 : : #endif /* SCM_RIGHTS */
4074 : 0 : goto finally;
4075 : : }
4076 : :
4077 : :
4078 : : static PyObject *
4079 : 608 : makeval_recvmsg(ssize_t received, void *data)
4080 : : {
4081 : 608 : PyObject **buf = data;
4082 : :
4083 [ + + ]: 608 : if (received < PyBytes_GET_SIZE(*buf))
4084 : 11 : _PyBytes_Resize(buf, received);
4085 : 608 : Py_XINCREF(*buf);
4086 : 608 : return *buf;
4087 : : }
4088 : :
4089 : : /* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
4090 : :
4091 : : static PyObject *
4092 : 663 : sock_recvmsg(PySocketSockObject *s, PyObject *args)
4093 : : {
4094 : 663 : Py_ssize_t bufsize, ancbufsize = 0;
4095 : 663 : int flags = 0;
4096 : : struct iovec iov;
4097 : 663 : PyObject *buf = NULL, *retval = NULL;
4098 : :
4099 [ + + ]: 663 : if (!PyArg_ParseTuple(args, "n|ni:recvmsg", &bufsize, &ancbufsize, &flags))
4100 : 30 : return NULL;
4101 : :
4102 [ + + ]: 633 : if (bufsize < 0) {
4103 : 6 : PyErr_SetString(PyExc_ValueError, "negative buffer size in recvmsg()");
4104 : 6 : return NULL;
4105 : : }
4106 [ - + ]: 627 : if ((buf = PyBytes_FromStringAndSize(NULL, bufsize)) == NULL)
4107 : 0 : return NULL;
4108 : 627 : iov.iov_base = PyBytes_AS_STRING(buf);
4109 : 627 : iov.iov_len = bufsize;
4110 : :
4111 : : /* Note that we're passing a pointer to *our pointer* to the bytes
4112 : : object here (&buf); makeval_recvmsg() may incref the object, or
4113 : : deallocate it and set our pointer to NULL. */
4114 : 627 : retval = sock_recvmsg_guts(s, &iov, 1, flags, ancbufsize,
4115 : : &makeval_recvmsg, &buf);
4116 : 627 : Py_XDECREF(buf);
4117 : 627 : return retval;
4118 : : }
4119 : :
4120 : : PyDoc_STRVAR(recvmsg_doc,
4121 : : "recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\
4122 : : \n\
4123 : : Receive normal data (up to bufsize bytes) and ancillary data from the\n\
4124 : : socket. The ancbufsize argument sets the size in bytes of the\n\
4125 : : internal buffer used to receive the ancillary data; it defaults to 0,\n\
4126 : : meaning that no ancillary data will be received. Appropriate buffer\n\
4127 : : sizes for ancillary data can be calculated using CMSG_SPACE() or\n\
4128 : : CMSG_LEN(), and items which do not fit into the buffer might be\n\
4129 : : truncated or discarded. The flags argument defaults to 0 and has the\n\
4130 : : same meaning as for recv().\n\
4131 : : \n\
4132 : : The return value is a 4-tuple: (data, ancdata, msg_flags, address).\n\
4133 : : The data item is a bytes object holding the non-ancillary data\n\
4134 : : received. The ancdata item is a list of zero or more tuples\n\
4135 : : (cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n\
4136 : : (control messages) received: cmsg_level and cmsg_type are integers\n\
4137 : : specifying the protocol level and protocol-specific type respectively,\n\
4138 : : and cmsg_data is a bytes object holding the associated data. The\n\
4139 : : msg_flags item is the bitwise OR of various flags indicating\n\
4140 : : conditions on the received message; see your system documentation for\n\
4141 : : details. If the receiving socket is unconnected, address is the\n\
4142 : : address of the sending socket, if available; otherwise, its value is\n\
4143 : : unspecified.\n\
4144 : : \n\
4145 : : If recvmsg() raises an exception after the system call returns, it\n\
4146 : : will first attempt to close any file descriptors received via the\n\
4147 : : SCM_RIGHTS mechanism.");
4148 : :
4149 : :
4150 : : static PyObject *
4151 : 144 : makeval_recvmsg_into(ssize_t received, void *data)
4152 : : {
4153 : 144 : return PyLong_FromSsize_t(received);
4154 : : }
4155 : :
4156 : : /* s.recvmsg_into(buffers[, ancbufsize[, flags]]) method */
4157 : :
4158 : : static PyObject *
4159 : 211 : sock_recvmsg_into(PySocketSockObject *s, PyObject *args)
4160 : : {
4161 : 211 : Py_ssize_t ancbufsize = 0;
4162 : 211 : int flags = 0;
4163 : 211 : struct iovec *iovs = NULL;
4164 : 211 : Py_ssize_t i, nitems, nbufs = 0;
4165 : 211 : Py_buffer *bufs = NULL;
4166 : 211 : PyObject *buffers_arg, *fast, *retval = NULL;
4167 : :
4168 [ + + ]: 211 : if (!PyArg_ParseTuple(args, "O|ni:recvmsg_into",
4169 : : &buffers_arg, &ancbufsize, &flags))
4170 : 18 : return NULL;
4171 : :
4172 [ + + ]: 193 : if ((fast = PySequence_Fast(buffers_arg,
4173 : : "recvmsg_into() argument 1 must be an "
4174 : : "iterable")) == NULL)
4175 : 6 : return NULL;
4176 [ + - ]: 187 : nitems = PySequence_Fast_GET_SIZE(fast);
4177 [ - + ]: 187 : if (nitems > INT_MAX) {
4178 : 0 : PyErr_SetString(PyExc_OSError, "recvmsg_into() argument 1 is too long");
4179 : 0 : goto finally;
4180 : : }
4181 : :
4182 : : /* Fill in an iovec for each item, and save the Py_buffer
4183 : : structs to release afterwards. */
4184 [ + - + - : 187 : if (nitems > 0 && ((iovs = PyMem_New(struct iovec, nitems)) == NULL ||
+ - ]
4185 [ + - - + ]: 187 : (bufs = PyMem_New(Py_buffer, nitems)) == NULL)) {
4186 : : PyErr_NoMemory();
4187 : 0 : goto finally;
4188 : : }
4189 [ + + ]: 368 : for (; nbufs < nitems; nbufs++) {
4190 [ + - + + ]: 205 : if (!PyArg_Parse(PySequence_Fast_GET_ITEM(fast, nbufs),
4191 : : "w*;recvmsg_into() argument 1 must be an iterable "
4192 : : "of single-segment read-write buffers",
4193 : 205 : &bufs[nbufs]))
4194 : 24 : goto finally;
4195 : 181 : iovs[nbufs].iov_base = bufs[nbufs].buf;
4196 : 181 : iovs[nbufs].iov_len = bufs[nbufs].len;
4197 : : }
4198 : :
4199 : 163 : retval = sock_recvmsg_guts(s, iovs, nitems, flags, ancbufsize,
4200 : : &makeval_recvmsg_into, NULL);
4201 : 187 : finally:
4202 [ + + ]: 368 : for (i = 0; i < nbufs; i++)
4203 : 181 : PyBuffer_Release(&bufs[i]);
4204 : 187 : PyMem_Free(bufs);
4205 : 187 : PyMem_Free(iovs);
4206 : 187 : Py_DECREF(fast);
4207 : 187 : return retval;
4208 : : }
4209 : :
4210 : : PyDoc_STRVAR(recvmsg_into_doc,
4211 : : "recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\
4212 : : \n\
4213 : : Receive normal data and ancillary data from the socket, scattering the\n\
4214 : : non-ancillary data into a series of buffers. The buffers argument\n\
4215 : : must be an iterable of objects that export writable buffers\n\
4216 : : (e.g. bytearray objects); these will be filled with successive chunks\n\
4217 : : of the non-ancillary data until it has all been written or there are\n\
4218 : : no more buffers. The ancbufsize argument sets the size in bytes of\n\
4219 : : the internal buffer used to receive the ancillary data; it defaults to\n\
4220 : : 0, meaning that no ancillary data will be received. Appropriate\n\
4221 : : buffer sizes for ancillary data can be calculated using CMSG_SPACE()\n\
4222 : : or CMSG_LEN(), and items which do not fit into the buffer might be\n\
4223 : : truncated or discarded. The flags argument defaults to 0 and has the\n\
4224 : : same meaning as for recv().\n\
4225 : : \n\
4226 : : The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\n\
4227 : : The nbytes item is the total number of bytes of non-ancillary data\n\
4228 : : written into the buffers. The ancdata item is a list of zero or more\n\
4229 : : tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\n\
4230 : : data (control messages) received: cmsg_level and cmsg_type are\n\
4231 : : integers specifying the protocol level and protocol-specific type\n\
4232 : : respectively, and cmsg_data is a bytes object holding the associated\n\
4233 : : data. The msg_flags item is the bitwise OR of various flags\n\
4234 : : indicating conditions on the received message; see your system\n\
4235 : : documentation for details. If the receiving socket is unconnected,\n\
4236 : : address is the address of the sending socket, if available; otherwise,\n\
4237 : : its value is unspecified.\n\
4238 : : \n\
4239 : : If recvmsg_into() raises an exception after the system call returns,\n\
4240 : : it will first attempt to close any file descriptors received via the\n\
4241 : : SCM_RIGHTS mechanism.");
4242 : : #endif /* CMSG_LEN */
4243 : :
4244 : :
4245 : : struct sock_send {
4246 : : char *buf;
4247 : : Py_ssize_t len;
4248 : : int flags;
4249 : : Py_ssize_t result;
4250 : : };
4251 : :
4252 : : static int
4253 : 19738 : sock_send_impl(PySocketSockObject *s, void *data)
4254 : : {
4255 : 19738 : struct sock_send *ctx = data;
4256 : :
4257 : : #ifdef MS_WINDOWS
4258 : : if (ctx->len > INT_MAX)
4259 : : ctx->len = INT_MAX;
4260 : : ctx->result = send(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags);
4261 : : #else
4262 : 19738 : ctx->result = send(s->sock_fd, ctx->buf, ctx->len, ctx->flags);
4263 : : #endif
4264 : 19738 : return (ctx->result >= 0);
4265 : : }
4266 : :
4267 : : /* s.send(data [,flags]) method */
4268 : :
4269 : : static PyObject *
4270 : 15797 : sock_send(PySocketSockObject *s, PyObject *args)
4271 : : {
4272 : 15797 : int flags = 0;
4273 : : Py_buffer pbuf;
4274 : : struct sock_send ctx;
4275 : :
4276 [ - + ]: 15797 : if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
4277 : 0 : return NULL;
4278 : :
4279 : : if (!IS_SELECTABLE(s)) {
4280 : : PyBuffer_Release(&pbuf);
4281 : : return select_error();
4282 : : }
4283 : 15797 : ctx.buf = pbuf.buf;
4284 : 15797 : ctx.len = pbuf.len;
4285 : 15797 : ctx.flags = flags;
4286 [ + + ]: 15797 : if (sock_call(s, 1, sock_send_impl, &ctx) < 0) {
4287 : 75 : PyBuffer_Release(&pbuf);
4288 : 75 : return NULL;
4289 : : }
4290 : 15722 : PyBuffer_Release(&pbuf);
4291 : :
4292 : 15722 : return PyLong_FromSsize_t(ctx.result);
4293 : : }
4294 : :
4295 : : PyDoc_STRVAR(send_doc,
4296 : : "send(data[, flags]) -> count\n\
4297 : : \n\
4298 : : Send a data string to the socket. For the optional flags\n\
4299 : : argument, see the Unix manual. Return the number of bytes\n\
4300 : : sent; this may be less than len(data) if the network is busy.");
4301 : :
4302 : :
4303 : : /* s.sendall(data [,flags]) method */
4304 : :
4305 : : static PyObject *
4306 : 3932 : sock_sendall(PySocketSockObject *s, PyObject *args)
4307 : : {
4308 : : char *buf;
4309 : : Py_ssize_t len, n;
4310 : 3932 : int flags = 0;
4311 : : Py_buffer pbuf;
4312 : : struct sock_send ctx;
4313 : 3932 : int has_timeout = (s->sock_timeout > 0);
4314 : 3932 : _PyTime_t timeout = s->sock_timeout;
4315 : 3932 : _PyTime_t deadline = 0;
4316 : 3932 : int deadline_initialized = 0;
4317 : 3932 : PyObject *res = NULL;
4318 : :
4319 [ - + ]: 3932 : if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
4320 : 0 : return NULL;
4321 : 3932 : buf = pbuf.buf;
4322 : 3932 : len = pbuf.len;
4323 : :
4324 : : if (!IS_SELECTABLE(s)) {
4325 : : PyBuffer_Release(&pbuf);
4326 : : return select_error();
4327 : : }
4328 : :
4329 : : do {
4330 [ + + ]: 3936 : if (has_timeout) {
4331 [ + + ]: 3222 : if (deadline_initialized) {
4332 : : /* recompute the timeout */
4333 : 1 : timeout = _PyDeadline_Get(deadline);
4334 : : }
4335 : : else {
4336 : 3221 : deadline_initialized = 1;
4337 : 3221 : deadline = _PyDeadline_Init(timeout);
4338 : : }
4339 : :
4340 [ - + ]: 3222 : if (timeout <= 0) {
4341 : 0 : PyErr_SetString(PyExc_TimeoutError, "timed out");
4342 : 0 : goto done;
4343 : : }
4344 : : }
4345 : :
4346 : 3936 : ctx.buf = buf;
4347 : 3936 : ctx.len = len;
4348 : 3936 : ctx.flags = flags;
4349 [ + + ]: 3936 : if (sock_call_ex(s, 1, sock_send_impl, &ctx, 0, NULL, timeout) < 0)
4350 : 8 : goto done;
4351 : 3928 : n = ctx.result;
4352 : : assert(n >= 0);
4353 : :
4354 : 3928 : buf += n;
4355 : 3928 : len -= n;
4356 : :
4357 : : /* We must run our signal handlers before looping again.
4358 : : send() can return a successful partial write when it is
4359 : : interrupted, so we can't restrict ourselves to EINTR. */
4360 [ + + ]: 3928 : if (PyErr_CheckSignals())
4361 : 1 : goto done;
4362 [ + + ]: 3927 : } while (len > 0);
4363 : 3923 : PyBuffer_Release(&pbuf);
4364 : :
4365 : 3923 : Py_INCREF(Py_None);
4366 : 3923 : res = Py_None;
4367 : :
4368 : 3932 : done:
4369 : 3932 : PyBuffer_Release(&pbuf);
4370 : 3932 : return res;
4371 : : }
4372 : :
4373 : : PyDoc_STRVAR(sendall_doc,
4374 : : "sendall(data[, flags])\n\
4375 : : \n\
4376 : : Send a data string to the socket. For the optional flags\n\
4377 : : argument, see the Unix manual. This calls send() repeatedly\n\
4378 : : until all data is sent. If an error occurs, it's impossible\n\
4379 : : to tell how much data has been sent.");
4380 : :
4381 : :
4382 : : struct sock_sendto {
4383 : : char *buf;
4384 : : Py_ssize_t len;
4385 : : int flags;
4386 : : int addrlen;
4387 : : sock_addr_t *addrbuf;
4388 : : Py_ssize_t result;
4389 : : };
4390 : :
4391 : : static int
4392 : 3706 : sock_sendto_impl(PySocketSockObject *s, void *data)
4393 : : {
4394 : 3706 : struct sock_sendto *ctx = data;
4395 : :
4396 : : #ifdef MS_WINDOWS
4397 : : if (ctx->len > INT_MAX)
4398 : : ctx->len = INT_MAX;
4399 : : ctx->result = sendto(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags,
4400 : : SAS2SA(ctx->addrbuf), ctx->addrlen);
4401 : : #else
4402 : 7412 : ctx->result = sendto(s->sock_fd, ctx->buf, ctx->len, ctx->flags,
4403 : 3706 : SAS2SA(ctx->addrbuf), ctx->addrlen);
4404 : : #endif
4405 : 3706 : return (ctx->result >= 0);
4406 : : }
4407 : :
4408 : : /* s.sendto(data, [flags,] sockaddr) method */
4409 : :
4410 : : static PyObject *
4411 : 3718 : sock_sendto(PySocketSockObject *s, PyObject *args)
4412 : : {
4413 : : Py_buffer pbuf;
4414 : : PyObject *addro;
4415 : : Py_ssize_t arglen;
4416 : : sock_addr_t addrbuf;
4417 : : int addrlen, flags;
4418 : : struct sock_sendto ctx;
4419 : :
4420 : 3718 : flags = 0;
4421 : 3718 : arglen = PyTuple_Size(args);
4422 [ + + + ]: 3718 : switch (arglen) {
4423 : 3702 : case 2:
4424 [ + + ]: 3702 : if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
4425 : 2 : return NULL;
4426 : : }
4427 : 3700 : break;
4428 : 14 : case 3:
4429 [ + + ]: 14 : if (!PyArg_ParseTuple(args, "y*iO:sendto",
4430 : : &pbuf, &flags, &addro)) {
4431 : 4 : return NULL;
4432 : : }
4433 : 10 : break;
4434 : 2 : default:
4435 : 2 : PyErr_Format(PyExc_TypeError,
4436 : : "sendto() takes 2 or 3 arguments (%zd given)",
4437 : : arglen);
4438 : 2 : return NULL;
4439 : : }
4440 : :
4441 : : if (!IS_SELECTABLE(s)) {
4442 : : PyBuffer_Release(&pbuf);
4443 : : return select_error();
4444 : : }
4445 : :
4446 [ + + ]: 3710 : if (!getsockaddrarg(s, addro, &addrbuf, &addrlen, "sendto")) {
4447 : 2 : PyBuffer_Release(&pbuf);
4448 : 2 : return NULL;
4449 : : }
4450 : :
4451 [ - + ]: 3708 : if (PySys_Audit("socket.sendto", "OO", s, addro) < 0) {
4452 : 0 : return NULL;
4453 : : }
4454 : :
4455 : 3708 : ctx.buf = pbuf.buf;
4456 : 3708 : ctx.len = pbuf.len;
4457 : 3708 : ctx.flags = flags;
4458 : 3708 : ctx.addrlen = addrlen;
4459 : 3708 : ctx.addrbuf = &addrbuf;
4460 [ + + ]: 3708 : if (sock_call(s, 1, sock_sendto_impl, &ctx) < 0) {
4461 : 3 : PyBuffer_Release(&pbuf);
4462 : 3 : return NULL;
4463 : : }
4464 : 3705 : PyBuffer_Release(&pbuf);
4465 : :
4466 : 3705 : return PyLong_FromSsize_t(ctx.result);
4467 : : }
4468 : :
4469 : : PyDoc_STRVAR(sendto_doc,
4470 : : "sendto(data[, flags], address) -> count\n\
4471 : : \n\
4472 : : Like send(data, flags) but allows specifying the destination address.\n\
4473 : : For IP sockets, the address is a pair (hostaddr, port).");
4474 : :
4475 : :
4476 : : /* The sendmsg() and recvmsg[_into]() methods require a working
4477 : : CMSG_LEN(). See the comment near get_CMSG_LEN(). */
4478 : : #ifdef CMSG_LEN
4479 : : struct sock_sendmsg {
4480 : : struct msghdr *msg;
4481 : : int flags;
4482 : : ssize_t result;
4483 : : };
4484 : :
4485 : : static int
4486 : 13180 : sock_sendmsg_iovec(PySocketSockObject *s, PyObject *data_arg,
4487 : : struct msghdr *msg,
4488 : : Py_buffer **databufsout, Py_ssize_t *ndatabufsout) {
4489 : 13180 : Py_ssize_t ndataparts, ndatabufs = 0;
4490 : 13180 : int result = -1;
4491 : 13180 : struct iovec *iovs = NULL;
4492 : 13180 : PyObject *data_fast = NULL;
4493 : 13180 : Py_buffer *databufs = NULL;
4494 : :
4495 : : /* Fill in an iovec for each message part, and save the Py_buffer
4496 : : structs to release afterwards. */
4497 : 13180 : data_fast = PySequence_Fast(data_arg,
4498 : : "sendmsg() argument 1 must be an "
4499 : : "iterable");
4500 [ + + ]: 13180 : if (data_fast == NULL) {
4501 : 6 : goto finally;
4502 : : }
4503 : :
4504 [ + - ]: 13174 : ndataparts = PySequence_Fast_GET_SIZE(data_fast);
4505 [ - + ]: 13174 : if (ndataparts > INT_MAX) {
4506 : 0 : PyErr_SetString(PyExc_OSError, "sendmsg() argument 1 is too long");
4507 : 0 : goto finally;
4508 : : }
4509 : :
4510 : 13174 : msg->msg_iovlen = ndataparts;
4511 [ + - ]: 13174 : if (ndataparts > 0) {
4512 [ + - ]: 13174 : iovs = PyMem_New(struct iovec, ndataparts);
4513 [ - + ]: 13174 : if (iovs == NULL) {
4514 : : PyErr_NoMemory();
4515 : 0 : goto finally;
4516 : : }
4517 : 13174 : msg->msg_iov = iovs;
4518 : :
4519 [ + - ]: 13174 : databufs = PyMem_New(Py_buffer, ndataparts);
4520 [ - + ]: 13174 : if (databufs == NULL) {
4521 : : PyErr_NoMemory();
4522 : 0 : goto finally;
4523 : : }
4524 : : }
4525 [ + + ]: 27377 : for (; ndatabufs < ndataparts; ndatabufs++) {
4526 [ + - + + ]: 14221 : if (!PyArg_Parse(PySequence_Fast_GET_ITEM(data_fast, ndatabufs),
4527 : : "y*;sendmsg() argument 1 must be an iterable of "
4528 : : "bytes-like objects",
4529 : 14221 : &databufs[ndatabufs]))
4530 : 18 : goto finally;
4531 : 14203 : iovs[ndatabufs].iov_base = databufs[ndatabufs].buf;
4532 : 14203 : iovs[ndatabufs].iov_len = databufs[ndatabufs].len;
4533 : : }
4534 : 13156 : result = 0;
4535 : 13180 : finally:
4536 : 13180 : *databufsout = databufs;
4537 : 13180 : *ndatabufsout = ndatabufs;
4538 : 13180 : Py_XDECREF(data_fast);
4539 : 13180 : return result;
4540 : : }
4541 : :
4542 : : static int
4543 : 13106 : sock_sendmsg_impl(PySocketSockObject *s, void *data)
4544 : : {
4545 : 13106 : struct sock_sendmsg *ctx = data;
4546 : :
4547 : 13106 : ctx->result = sendmsg(s->sock_fd, ctx->msg, ctx->flags);
4548 : 13106 : return (ctx->result >= 0);
4549 : : }
4550 : :
4551 : : /* s.sendmsg(buffers[, ancdata[, flags[, address]]]) method */
4552 : :
4553 : : static PyObject *
4554 : 13193 : sock_sendmsg(PySocketSockObject *s, PyObject *args)
4555 : : {
4556 : 13193 : Py_ssize_t i, ndatabufs = 0, ncmsgs, ncmsgbufs = 0;
4557 : 13193 : Py_buffer *databufs = NULL;
4558 : : sock_addr_t addrbuf;
4559 : : struct msghdr msg;
4560 : : struct cmsginfo {
4561 : : int level;
4562 : : int type;
4563 : : Py_buffer data;
4564 : 13193 : } *cmsgs = NULL;
4565 : 13193 : void *controlbuf = NULL;
4566 : : size_t controllen, controllen_last;
4567 : 13193 : int addrlen, flags = 0;
4568 : 13193 : PyObject *data_arg, *cmsg_arg = NULL, *addr_arg = NULL,
4569 : 13193 : *cmsg_fast = NULL, *retval = NULL;
4570 : : struct sock_sendmsg ctx;
4571 : :
4572 [ + + ]: 13193 : if (!PyArg_ParseTuple(args, "O|OiO:sendmsg",
4573 : : &data_arg, &cmsg_arg, &flags, &addr_arg)) {
4574 : 12 : return NULL;
4575 : : }
4576 : :
4577 : 13181 : memset(&msg, 0, sizeof(msg));
4578 : :
4579 : : /* Parse destination address. */
4580 [ + + + + ]: 13181 : if (addr_arg != NULL && addr_arg != Py_None) {
4581 [ + + ]: 106 : if (!getsockaddrarg(s, addr_arg, &addrbuf, &addrlen,
4582 : : "sendmsg"))
4583 : : {
4584 : 6 : goto finally;
4585 : : }
4586 [ - + ]: 100 : if (PySys_Audit("socket.sendmsg", "OO", s, addr_arg) < 0) {
4587 : 0 : return NULL;
4588 : : }
4589 : 100 : msg.msg_name = &addrbuf;
4590 : 100 : msg.msg_namelen = addrlen;
4591 : : } else {
4592 [ - + ]: 13075 : if (PySys_Audit("socket.sendmsg", "OO", s, Py_None) < 0) {
4593 : 0 : return NULL;
4594 : : }
4595 : : }
4596 : :
4597 : : /* Fill in an iovec for each message part, and save the Py_buffer
4598 : : structs to release afterwards. */
4599 [ + + ]: 13175 : if (sock_sendmsg_iovec(s, data_arg, &msg, &databufs, &ndatabufs) == -1) {
4600 : 24 : goto finally;
4601 : : }
4602 : :
4603 [ + + ]: 13151 : if (cmsg_arg == NULL)
4604 : 6965 : ncmsgs = 0;
4605 : : else {
4606 [ + + ]: 6186 : if ((cmsg_fast = PySequence_Fast(cmsg_arg,
4607 : : "sendmsg() argument 2 must be an "
4608 : : "iterable")) == NULL)
4609 : 6 : goto finally;
4610 [ + + ]: 6180 : ncmsgs = PySequence_Fast_GET_SIZE(cmsg_fast);
4611 : : }
4612 : :
4613 : : #ifndef CMSG_SPACE
4614 : : if (ncmsgs > 1) {
4615 : : PyErr_SetString(PyExc_OSError,
4616 : : "sending multiple control messages is not supported "
4617 : : "on this system");
4618 : : goto finally;
4619 : : }
4620 : : #endif
4621 : : /* Save level, type and Py_buffer for each control message,
4622 : : and calculate total size. */
4623 [ + + + - : 13145 : if (ncmsgs > 0 && (cmsgs = PyMem_New(struct cmsginfo, ncmsgs)) == NULL) {
- + ]
4624 : : PyErr_NoMemory();
4625 : 0 : goto finally;
4626 : : }
4627 : 13145 : controllen = controllen_last = 0;
4628 [ + + ]: 13960 : while (ncmsgbufs < ncmsgs) {
4629 : : size_t bufsize, space;
4630 : :
4631 [ + + + + ]: 863 : if (!PyArg_Parse(PySequence_Fast_GET_ITEM(cmsg_fast, ncmsgbufs),
4632 : : "(iiy*):[sendmsg() ancillary data items]",
4633 : 863 : &cmsgs[ncmsgbufs].level,
4634 : 863 : &cmsgs[ncmsgbufs].type,
4635 : 863 : &cmsgs[ncmsgbufs].data))
4636 : 48 : goto finally;
4637 : 815 : bufsize = cmsgs[ncmsgbufs++].data.len;
4638 : :
4639 : : #ifdef CMSG_SPACE
4640 [ - + ]: 815 : if (!get_CMSG_SPACE(bufsize, &space)) {
4641 : : #else
4642 : : if (!get_CMSG_LEN(bufsize, &space)) {
4643 : : #endif
4644 : 0 : PyErr_SetString(PyExc_OSError, "ancillary data item too large");
4645 : 0 : goto finally;
4646 : : }
4647 : 815 : controllen += space;
4648 [ + - - + ]: 815 : if (controllen > SOCKLEN_T_LIMIT || controllen < controllen_last) {
4649 : 0 : PyErr_SetString(PyExc_OSError, "too much ancillary data");
4650 : 0 : goto finally;
4651 : : }
4652 : 815 : controllen_last = controllen;
4653 : : }
4654 : :
4655 : : /* Construct ancillary data block from control message info. */
4656 [ + + ]: 13097 : if (ncmsgbufs > 0) {
4657 : 789 : struct cmsghdr *cmsgh = NULL;
4658 : :
4659 : 789 : controlbuf = PyMem_Malloc(controllen);
4660 [ - + ]: 789 : if (controlbuf == NULL) {
4661 : : PyErr_NoMemory();
4662 : 0 : goto finally;
4663 : : }
4664 : 789 : msg.msg_control = controlbuf;
4665 : :
4666 : 789 : msg.msg_controllen = controllen;
4667 : :
4668 : : /* Need to zero out the buffer as a workaround for glibc's
4669 : : CMSG_NXTHDR() implementation. After getting the pointer to
4670 : : the next header, it checks its (uninitialized) cmsg_len
4671 : : member to see if the "message" fits in the buffer, and
4672 : : returns NULL if it doesn't. Zero-filling the buffer
4673 : : ensures that this doesn't happen. */
4674 : 789 : memset(controlbuf, 0, controllen);
4675 : :
4676 [ + + ]: 1598 : for (i = 0; i < ncmsgbufs; i++) {
4677 : 809 : size_t msg_len, data_len = cmsgs[i].data.len;
4678 : 809 : int enough_space = 0;
4679 : :
4680 [ + + + - ]: 809 : cmsgh = (i == 0) ? CMSG_FIRSTHDR(&msg) : CMSG_NXTHDR(&msg, cmsgh);
4681 [ - + ]: 809 : if (cmsgh == NULL) {
4682 [ # # ]: 0 : PyErr_Format(PyExc_RuntimeError,
4683 : : "unexpected NULL result from %s()",
4684 : : (i == 0) ? "CMSG_FIRSTHDR" : "CMSG_NXTHDR");
4685 : 0 : goto finally;
4686 : : }
4687 [ - + ]: 809 : if (!get_CMSG_LEN(data_len, &msg_len)) {
4688 : 0 : PyErr_SetString(PyExc_RuntimeError,
4689 : : "item size out of range for CMSG_LEN()");
4690 : 0 : goto finally;
4691 : : }
4692 [ + - ]: 809 : if (cmsg_min_space(&msg, cmsgh, msg_len)) {
4693 : : size_t space;
4694 : :
4695 : 809 : cmsgh->cmsg_len = msg_len;
4696 [ + - ]: 809 : if (get_cmsg_data_space(&msg, cmsgh, &space))
4697 : 809 : enough_space = (space >= data_len);
4698 : : }
4699 [ - + ]: 809 : if (!enough_space) {
4700 : 0 : PyErr_SetString(PyExc_RuntimeError,
4701 : : "ancillary data does not fit in calculated "
4702 : : "space");
4703 : 0 : goto finally;
4704 : : }
4705 : 809 : cmsgh->cmsg_level = cmsgs[i].level;
4706 : 809 : cmsgh->cmsg_type = cmsgs[i].type;
4707 : 809 : memcpy(CMSG_DATA(cmsgh), cmsgs[i].data.buf, data_len);
4708 : : }
4709 : : }
4710 : :
4711 : : /* Make the system call. */
4712 : : if (!IS_SELECTABLE(s)) {
4713 : : select_error();
4714 : : goto finally;
4715 : : }
4716 : :
4717 : 13097 : ctx.msg = &msg;
4718 : 13097 : ctx.flags = flags;
4719 [ + + ]: 13097 : if (sock_call(s, 1, sock_sendmsg_impl, &ctx) < 0)
4720 : 23 : goto finally;
4721 : :
4722 : 13074 : retval = PyLong_FromSsize_t(ctx.result);
4723 : :
4724 : 13181 : finally:
4725 : 13181 : PyMem_Free(controlbuf);
4726 [ + + ]: 13996 : for (i = 0; i < ncmsgbufs; i++)
4727 : 815 : PyBuffer_Release(&cmsgs[i].data);
4728 : 13181 : PyMem_Free(cmsgs);
4729 : 13181 : Py_XDECREF(cmsg_fast);
4730 : 13181 : PyMem_Free(msg.msg_iov);
4731 [ + + ]: 26356 : for (i = 0; i < ndatabufs; i++) {
4732 : 13175 : PyBuffer_Release(&databufs[i]);
4733 : : }
4734 : 13181 : PyMem_Free(databufs);
4735 : 13181 : return retval;
4736 : : }
4737 : :
4738 : : PyDoc_STRVAR(sendmsg_doc,
4739 : : "sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\
4740 : : \n\
4741 : : Send normal and ancillary data to the socket, gathering the\n\
4742 : : non-ancillary data from a series of buffers and concatenating it into\n\
4743 : : a single message. The buffers argument specifies the non-ancillary\n\
4744 : : data as an iterable of bytes-like objects (e.g. bytes objects).\n\
4745 : : The ancdata argument specifies the ancillary data (control messages)\n\
4746 : : as an iterable of zero or more tuples (cmsg_level, cmsg_type,\n\
4747 : : cmsg_data), where cmsg_level and cmsg_type are integers specifying the\n\
4748 : : protocol level and protocol-specific type respectively, and cmsg_data\n\
4749 : : is a bytes-like object holding the associated data. The flags\n\
4750 : : argument defaults to 0 and has the same meaning as for send(). If\n\
4751 : : address is supplied and not None, it sets a destination address for\n\
4752 : : the message. The return value is the number of bytes of non-ancillary\n\
4753 : : data sent.");
4754 : : #endif /* CMSG_LEN */
4755 : :
4756 : : #ifdef HAVE_SOCKADDR_ALG
4757 : : static PyObject*
4758 : 12 : sock_sendmsg_afalg(PySocketSockObject *self, PyObject *args, PyObject *kwds)
4759 : : {
4760 : 12 : PyObject *retval = NULL;
4761 : :
4762 : 12 : Py_ssize_t i, ndatabufs = 0;
4763 : 12 : Py_buffer *databufs = NULL;
4764 : 12 : PyObject *data_arg = NULL;
4765 : :
4766 : 12 : Py_buffer iv = {NULL, NULL};
4767 : :
4768 : 12 : PyObject *opobj = NULL;
4769 : 12 : int op = -1;
4770 : :
4771 : 12 : PyObject *assoclenobj = NULL;
4772 : 12 : int assoclen = -1;
4773 : :
4774 : : unsigned int *uiptr;
4775 : 12 : int flags = 0;
4776 : :
4777 : : struct msghdr msg;
4778 : 12 : struct cmsghdr *header = NULL;
4779 : 12 : struct af_alg_iv *alg_iv = NULL;
4780 : : struct sock_sendmsg ctx;
4781 : : Py_ssize_t controllen;
4782 : 12 : void *controlbuf = NULL;
4783 : : static char *keywords[] = {"msg", "op", "iv", "assoclen", "flags", 0};
4784 : :
4785 [ - + ]: 12 : if (self->sock_family != AF_ALG) {
4786 : 0 : PyErr_SetString(PyExc_OSError,
4787 : : "algset is only supported for AF_ALG");
4788 : 0 : return NULL;
4789 : : }
4790 : :
4791 [ + + ]: 12 : if (!PyArg_ParseTupleAndKeywords(args, kwds,
4792 : : "|O$O!y*O!i:sendmsg_afalg", keywords,
4793 : : &data_arg,
4794 : : &PyLong_Type, &opobj, &iv,
4795 : : &PyLong_Type, &assoclenobj, &flags)) {
4796 : 2 : return NULL;
4797 : : }
4798 : :
4799 : 10 : memset(&msg, 0, sizeof(msg));
4800 : :
4801 : : /* op is a required, keyword-only argument >= 0 */
4802 [ + + ]: 10 : if (opobj != NULL) {
4803 : 8 : op = _PyLong_AsInt(opobj);
4804 : : }
4805 [ + + ]: 10 : if (op < 0) {
4806 : : /* override exception from _PyLong_AsInt() */
4807 : 2 : PyErr_SetString(PyExc_TypeError,
4808 : : "Invalid or missing argument 'op'");
4809 : 2 : goto finally;
4810 : : }
4811 : : /* assoclen is optional but must be >= 0 */
4812 [ + + ]: 8 : if (assoclenobj != NULL) {
4813 : 4 : assoclen = _PyLong_AsInt(assoclenobj);
4814 [ + + - + ]: 4 : if (assoclen == -1 && PyErr_Occurred()) {
4815 : 0 : goto finally;
4816 : : }
4817 [ + + ]: 4 : if (assoclen < 0) {
4818 : 1 : PyErr_SetString(PyExc_TypeError,
4819 : : "assoclen must be positive");
4820 : 1 : goto finally;
4821 : : }
4822 : : }
4823 : :
4824 : 7 : controllen = CMSG_SPACE(4);
4825 [ + - ]: 7 : if (iv.buf != NULL) {
4826 : 7 : controllen += CMSG_SPACE(sizeof(*alg_iv) + iv.len);
4827 : : }
4828 [ + + ]: 7 : if (assoclen >= 0) {
4829 : 3 : controllen += CMSG_SPACE(4);
4830 : : }
4831 : :
4832 : 7 : controlbuf = PyMem_Malloc(controllen);
4833 [ - + ]: 7 : if (controlbuf == NULL) {
4834 : : PyErr_NoMemory();
4835 : 0 : goto finally;
4836 : : }
4837 : 7 : memset(controlbuf, 0, controllen);
4838 : :
4839 : 7 : msg.msg_controllen = controllen;
4840 : 7 : msg.msg_control = controlbuf;
4841 : :
4842 : : /* Fill in an iovec for each message part, and save the Py_buffer
4843 : : structs to release afterwards. */
4844 [ + + ]: 7 : if (data_arg != NULL) {
4845 [ - + ]: 5 : if (sock_sendmsg_iovec(self, data_arg, &msg, &databufs, &ndatabufs) == -1) {
4846 : 0 : goto finally;
4847 : : }
4848 : : }
4849 : :
4850 : : /* set operation to encrypt or decrypt */
4851 [ + - ]: 7 : header = CMSG_FIRSTHDR(&msg);
4852 [ - + ]: 7 : if (header == NULL) {
4853 : 0 : PyErr_SetString(PyExc_RuntimeError,
4854 : : "unexpected NULL result from CMSG_FIRSTHDR");
4855 : 0 : goto finally;
4856 : : }
4857 : 7 : header->cmsg_level = SOL_ALG;
4858 : 7 : header->cmsg_type = ALG_SET_OP;
4859 : 7 : header->cmsg_len = CMSG_LEN(4);
4860 : 7 : uiptr = (void*)CMSG_DATA(header);
4861 : 7 : *uiptr = (unsigned int)op;
4862 : :
4863 : : /* set initialization vector */
4864 [ + - ]: 7 : if (iv.buf != NULL) {
4865 : 7 : header = CMSG_NXTHDR(&msg, header);
4866 [ - + ]: 7 : if (header == NULL) {
4867 : 0 : PyErr_SetString(PyExc_RuntimeError,
4868 : : "unexpected NULL result from CMSG_NXTHDR(iv)");
4869 : 0 : goto finally;
4870 : : }
4871 : 7 : header->cmsg_level = SOL_ALG;
4872 : 7 : header->cmsg_type = ALG_SET_IV;
4873 : 7 : header->cmsg_len = CMSG_SPACE(sizeof(*alg_iv) + iv.len);
4874 : 7 : alg_iv = (void*)CMSG_DATA(header);
4875 : 7 : alg_iv->ivlen = iv.len;
4876 : 7 : memcpy(alg_iv->iv, iv.buf, iv.len);
4877 : : }
4878 : :
4879 : : /* set length of associated data for AEAD */
4880 [ + + ]: 7 : if (assoclen >= 0) {
4881 : 3 : header = CMSG_NXTHDR(&msg, header);
4882 [ - + ]: 3 : if (header == NULL) {
4883 : 0 : PyErr_SetString(PyExc_RuntimeError,
4884 : : "unexpected NULL result from CMSG_NXTHDR(assoc)");
4885 : 0 : goto finally;
4886 : : }
4887 : 3 : header->cmsg_level = SOL_ALG;
4888 : 3 : header->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
4889 : 3 : header->cmsg_len = CMSG_LEN(4);
4890 : 3 : uiptr = (void*)CMSG_DATA(header);
4891 : 3 : *uiptr = (unsigned int)assoclen;
4892 : : }
4893 : :
4894 : 7 : ctx.msg = &msg;
4895 : 7 : ctx.flags = flags;
4896 [ - + ]: 7 : if (sock_call(self, 1, sock_sendmsg_impl, &ctx) < 0) {
4897 : 0 : goto finally;
4898 : : }
4899 : :
4900 : 7 : retval = PyLong_FromSsize_t(ctx.result);
4901 : :
4902 : 10 : finally:
4903 : 10 : PyMem_Free(controlbuf);
4904 [ + + ]: 10 : if (iv.buf != NULL) {
4905 : 7 : PyBuffer_Release(&iv);
4906 : : }
4907 : 10 : PyMem_Free(msg.msg_iov);
4908 [ + + ]: 1038 : for (i = 0; i < ndatabufs; i++) {
4909 : 1028 : PyBuffer_Release(&databufs[i]);
4910 : : }
4911 : 10 : PyMem_Free(databufs);
4912 : 10 : return retval;
4913 : : }
4914 : :
4915 : : PyDoc_STRVAR(sendmsg_afalg_doc,
4916 : : "sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])\n\
4917 : : \n\
4918 : : Set operation mode, IV and length of associated data for an AF_ALG\n\
4919 : : operation socket.");
4920 : : #endif
4921 : :
4922 : : #ifdef HAVE_SHUTDOWN
4923 : : /* s.shutdown(how) method */
4924 : :
4925 : : static PyObject *
4926 : 569 : sock_shutdown(PySocketSockObject *s, PyObject *arg)
4927 : : {
4928 : : int how;
4929 : : int res;
4930 : :
4931 : 569 : how = _PyLong_AsInt(arg);
4932 [ + + + - ]: 569 : if (how == -1 && PyErr_Occurred())
4933 : 4 : return NULL;
4934 : 565 : Py_BEGIN_ALLOW_THREADS
4935 : 565 : res = shutdown(s->sock_fd, how);
4936 : 565 : Py_END_ALLOW_THREADS
4937 [ + + ]: 565 : if (res < 0)
4938 : 75 : return s->errorhandler();
4939 : 490 : Py_RETURN_NONE;
4940 : : }
4941 : :
4942 : : PyDoc_STRVAR(shutdown_doc,
4943 : : "shutdown(flag)\n\
4944 : : \n\
4945 : : Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
4946 : : of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
4947 : : #endif
4948 : :
4949 : : #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
4950 : : static PyObject*
4951 : : sock_ioctl(PySocketSockObject *s, PyObject *arg)
4952 : : {
4953 : : unsigned long cmd = SIO_RCVALL;
4954 : : PyObject *argO;
4955 : : DWORD recv;
4956 : :
4957 : : if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
4958 : : return NULL;
4959 : :
4960 : : switch (cmd) {
4961 : : case SIO_RCVALL: {
4962 : : unsigned int option = RCVALL_ON;
4963 : : if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
4964 : : return NULL;
4965 : : if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
4966 : : NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4967 : : return set_error();
4968 : : }
4969 : : return PyLong_FromUnsignedLong(recv); }
4970 : : case SIO_KEEPALIVE_VALS: {
4971 : : struct tcp_keepalive ka;
4972 : : if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
4973 : : &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
4974 : : return NULL;
4975 : : if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
4976 : : NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4977 : : return set_error();
4978 : : }
4979 : : return PyLong_FromUnsignedLong(recv); }
4980 : : #if defined(SIO_LOOPBACK_FAST_PATH)
4981 : : case SIO_LOOPBACK_FAST_PATH: {
4982 : : unsigned int option;
4983 : : if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
4984 : : return NULL;
4985 : : if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
4986 : : NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4987 : : return set_error();
4988 : : }
4989 : : return PyLong_FromUnsignedLong(recv); }
4990 : : #endif
4991 : : default:
4992 : : PyErr_Format(PyExc_ValueError, "invalid ioctl command %lu", cmd);
4993 : : return NULL;
4994 : : }
4995 : : }
4996 : : PyDoc_STRVAR(sock_ioctl_doc,
4997 : : "ioctl(cmd, option) -> long\n\
4998 : : \n\
4999 : : Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
5000 : : SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
5001 : : SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).\n\
5002 : : SIO_LOOPBACK_FAST_PATH: 'option' is a boolean value, and is disabled by default");
5003 : : #endif
5004 : :
5005 : : #if defined(MS_WINDOWS)
5006 : : static PyObject*
5007 : : sock_share(PySocketSockObject *s, PyObject *arg)
5008 : : {
5009 : : WSAPROTOCOL_INFOW info;
5010 : : DWORD processId;
5011 : : int result;
5012 : :
5013 : : if (!PyArg_ParseTuple(arg, "I", &processId))
5014 : : return NULL;
5015 : :
5016 : : Py_BEGIN_ALLOW_THREADS
5017 : : result = WSADuplicateSocketW(s->sock_fd, processId, &info);
5018 : : Py_END_ALLOW_THREADS
5019 : : if (result == SOCKET_ERROR)
5020 : : return set_error();
5021 : : return PyBytes_FromStringAndSize((const char*)&info, sizeof(info));
5022 : : }
5023 : : PyDoc_STRVAR(sock_share_doc,
5024 : : "share(process_id) -> bytes\n\
5025 : : \n\
5026 : : Share the socket with another process. The target process id\n\
5027 : : must be provided and the resulting bytes object passed to the target\n\
5028 : : process. There the shared socket can be instantiated by calling\n\
5029 : : socket.fromshare().");
5030 : :
5031 : :
5032 : : #endif
5033 : :
5034 : : /* List of methods for socket objects */
5035 : :
5036 : : static PyMethodDef sock_methods[] = {
5037 : : {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
5038 : : accept_doc},
5039 : : {"bind", (PyCFunction)sock_bind, METH_O,
5040 : : bind_doc},
5041 : : {"close", (PyCFunction)sock_close, METH_NOARGS,
5042 : : sock_close_doc},
5043 : : {"connect", (PyCFunction)sock_connect, METH_O,
5044 : : connect_doc},
5045 : : {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
5046 : : connect_ex_doc},
5047 : : {"detach", (PyCFunction)sock_detach, METH_NOARGS,
5048 : : detach_doc},
5049 : : {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
5050 : : fileno_doc},
5051 : : #ifdef HAVE_GETPEERNAME
5052 : : {"getpeername", (PyCFunction)sock_getpeername,
5053 : : METH_NOARGS, getpeername_doc},
5054 : : #endif
5055 : : {"getsockname", (PyCFunction)sock_getsockname,
5056 : : METH_NOARGS, getsockname_doc},
5057 : : {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
5058 : : getsockopt_doc},
5059 : : #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
5060 : : {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
5061 : : sock_ioctl_doc},
5062 : : #endif
5063 : : #if defined(MS_WINDOWS)
5064 : : {"share", (PyCFunction)sock_share, METH_VARARGS,
5065 : : sock_share_doc},
5066 : : #endif
5067 : : {"listen", (PyCFunction)sock_listen, METH_VARARGS,
5068 : : listen_doc},
5069 : : {"recv", (PyCFunction)sock_recv, METH_VARARGS,
5070 : : recv_doc},
5071 : : {"recv_into", _PyCFunction_CAST(sock_recv_into), METH_VARARGS | METH_KEYWORDS,
5072 : : recv_into_doc},
5073 : : {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
5074 : : recvfrom_doc},
5075 : : {"recvfrom_into", _PyCFunction_CAST(sock_recvfrom_into), METH_VARARGS | METH_KEYWORDS,
5076 : : recvfrom_into_doc},
5077 : : {"send", (PyCFunction)sock_send, METH_VARARGS,
5078 : : send_doc},
5079 : : {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
5080 : : sendall_doc},
5081 : : {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
5082 : : sendto_doc},
5083 : : {"setblocking", (PyCFunction)sock_setblocking, METH_O,
5084 : : setblocking_doc},
5085 : : {"getblocking", (PyCFunction)sock_getblocking, METH_NOARGS,
5086 : : getblocking_doc},
5087 : : {"settimeout", (PyCFunction)sock_settimeout, METH_O,
5088 : : settimeout_doc},
5089 : : {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
5090 : : gettimeout_doc},
5091 : : {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
5092 : : setsockopt_doc},
5093 : : #ifdef HAVE_SHUTDOWN
5094 : : {"shutdown", (PyCFunction)sock_shutdown, METH_O,
5095 : : shutdown_doc},
5096 : : #endif
5097 : : #ifdef CMSG_LEN
5098 : : {"recvmsg", (PyCFunction)sock_recvmsg, METH_VARARGS,
5099 : : recvmsg_doc},
5100 : : {"recvmsg_into", (PyCFunction)sock_recvmsg_into, METH_VARARGS,
5101 : : recvmsg_into_doc,},
5102 : : {"sendmsg", (PyCFunction)sock_sendmsg, METH_VARARGS,
5103 : : sendmsg_doc},
5104 : : #endif
5105 : : #ifdef HAVE_SOCKADDR_ALG
5106 : : {"sendmsg_afalg", _PyCFunction_CAST(sock_sendmsg_afalg), METH_VARARGS | METH_KEYWORDS,
5107 : : sendmsg_afalg_doc},
5108 : : #endif
5109 : : {NULL, NULL} /* sentinel */
5110 : : };
5111 : :
5112 : : /* SockObject members */
5113 : : static PyMemberDef sock_memberlist[] = {
5114 : : {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
5115 : : {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
5116 : : {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
5117 : : {0},
5118 : : };
5119 : :
5120 : : static PyGetSetDef sock_getsetlist[] = {
5121 : : {"timeout", (getter)sock_gettimeout, NULL, PyDoc_STR("the socket timeout")},
5122 : : {NULL} /* sentinel */
5123 : : };
5124 : :
5125 : : /* Deallocate a socket object in response to the last Py_DECREF().
5126 : : First close the file description. */
5127 : :
5128 : : static void
5129 : 281952 : sock_finalize(PySocketSockObject *s)
5130 : : {
5131 : : SOCKET_T fd;
5132 : : PyObject *error_type, *error_value, *error_traceback;
5133 : :
5134 : : /* Save the current exception, if any. */
5135 : 281952 : PyErr_Fetch(&error_type, &error_value, &error_traceback);
5136 : :
5137 [ + + ]: 281952 : if (s->sock_fd != INVALID_SOCKET) {
5138 [ + + ]: 18 : if (PyErr_ResourceWarning((PyObject *)s, 1, "unclosed %R", s)) {
5139 : : /* Spurious errors can appear at shutdown */
5140 [ - + ]: 12 : if (PyErr_ExceptionMatches(PyExc_Warning)) {
5141 : 0 : PyErr_WriteUnraisable((PyObject *)s);
5142 : : }
5143 : : }
5144 : :
5145 : : /* Only close the socket *after* logging the ResourceWarning warning
5146 : : to allow the logger to call socket methods like
5147 : : socket.getsockname(). If the socket is closed before, socket
5148 : : methods fails with the EBADF error. */
5149 : 18 : fd = s->sock_fd;
5150 : 18 : s->sock_fd = INVALID_SOCKET;
5151 : :
5152 : : /* We do not want to retry upon EINTR: see sock_close() */
5153 : 18 : Py_BEGIN_ALLOW_THREADS
5154 : 18 : (void) SOCKETCLOSE(fd);
5155 : 18 : Py_END_ALLOW_THREADS
5156 : : }
5157 : :
5158 : : /* Restore the saved exception. */
5159 : 281952 : PyErr_Restore(error_type, error_value, error_traceback);
5160 : 281952 : }
5161 : :
5162 : : static void
5163 : 281952 : sock_dealloc(PySocketSockObject *s)
5164 : : {
5165 [ - + ]: 281952 : if (PyObject_CallFinalizerFromDealloc((PyObject *)s) < 0)
5166 : 0 : return;
5167 : :
5168 : 281952 : Py_TYPE(s)->tp_free((PyObject *)s);
5169 : : }
5170 : :
5171 : :
5172 : : static PyObject *
5173 : 2 : sock_repr(PySocketSockObject *s)
5174 : : {
5175 : : long sock_fd;
5176 : : /* On Windows, this test is needed because SOCKET_T is unsigned */
5177 [ + + ]: 2 : if (s->sock_fd == INVALID_SOCKET) {
5178 : 1 : sock_fd = -1;
5179 : : }
5180 : : #if SIZEOF_SOCKET_T > SIZEOF_LONG
5181 : : else if (s->sock_fd > LONG_MAX) {
5182 : : /* this can occur on Win64, and actually there is a special
5183 : : ugly printf formatter for decimal pointer length integer
5184 : : printing, only bother if necessary*/
5185 : : PyErr_SetString(PyExc_OverflowError,
5186 : : "no printf formatter to display "
5187 : : "the socket descriptor in decimal");
5188 : : return NULL;
5189 : : }
5190 : : #endif
5191 : : else
5192 : 1 : sock_fd = (long)s->sock_fd;
5193 : 2 : return PyUnicode_FromFormat(
5194 : : "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
5195 : : sock_fd, s->sock_family,
5196 : : s->sock_type,
5197 : : s->sock_proto);
5198 : : }
5199 : :
5200 : :
5201 : : /* Create a new, uninitialized socket object. */
5202 : :
5203 : : static PyObject *
5204 : 147438 : sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
5205 : : {
5206 : : PyObject *new;
5207 : :
5208 : 147438 : new = type->tp_alloc(type, 0);
5209 [ + - ]: 147438 : if (new != NULL) {
5210 : 147438 : ((PySocketSockObject *)new)->sock_fd = INVALID_SOCKET;
5211 : 147438 : ((PySocketSockObject *)new)->sock_timeout = _PyTime_FromSeconds(-1);
5212 : 147438 : ((PySocketSockObject *)new)->errorhandler = &set_error;
5213 : : }
5214 : 147438 : return new;
5215 : : }
5216 : :
5217 : :
5218 : : /* Initialize a new socket object. */
5219 : :
5220 : : #ifdef SOCK_CLOEXEC
5221 : : /* socket() and socketpair() fail with EINVAL on Linux kernel older
5222 : : * than 2.6.27 if SOCK_CLOEXEC flag is set in the socket type. */
5223 : : static int sock_cloexec_works = -1;
5224 : : #endif
5225 : :
5226 : : /*ARGSUSED*/
5227 : :
5228 : : /*[clinic input]
5229 : : _socket.socket.__init__ as sock_initobj
5230 : : family: int = -1
5231 : : type: int = -1
5232 : : proto: int = -1
5233 : : fileno as fdobj: object = NULL
5234 : : [clinic start generated code]*/
5235 : :
5236 : : static int
5237 : 147435 : sock_initobj_impl(PySocketSockObject *self, int family, int type, int proto,
5238 : : PyObject *fdobj)
5239 : : /*[clinic end generated code: output=d114d026b9a9a810 input=04cfc32953f5cc25]*/
5240 : : {
5241 : :
5242 : 147435 : SOCKET_T fd = INVALID_SOCKET;
5243 : :
5244 : : #ifndef MS_WINDOWS
5245 : : #ifdef SOCK_CLOEXEC
5246 : 147435 : int *atomic_flag_works = &sock_cloexec_works;
5247 : : #else
5248 : : int *atomic_flag_works = NULL;
5249 : : #endif
5250 : : #endif
5251 : :
5252 : : #ifdef MS_WINDOWS
5253 : : /* In this case, we don't use the family, type and proto args */
5254 : : if (fdobj == NULL || fdobj == Py_None)
5255 : : #endif
5256 : : {
5257 [ - + ]: 147435 : if (PySys_Audit("socket.__new__", "Oiii",
5258 : : self, family, type, proto) < 0) {
5259 : 0 : return -1;
5260 : : }
5261 : : }
5262 : :
5263 [ + + + + ]: 147435 : if (fdobj != NULL && fdobj != Py_None) {
5264 : : #ifdef MS_WINDOWS
5265 : : /* recreate a socket that was duplicated */
5266 : : if (PyBytes_Check(fdobj)) {
5267 : : WSAPROTOCOL_INFOW info;
5268 : : if (PyBytes_GET_SIZE(fdobj) != sizeof(info)) {
5269 : : PyErr_Format(PyExc_ValueError,
5270 : : "socket descriptor string has wrong size, "
5271 : : "should be %zu bytes.", sizeof(info));
5272 : : return -1;
5273 : : }
5274 : : memcpy(&info, PyBytes_AS_STRING(fdobj), sizeof(info));
5275 : :
5276 : : if (PySys_Audit("socket.__new__", "Oiii", self,
5277 : : info.iAddressFamily, info.iSocketType,
5278 : : info.iProtocol) < 0) {
5279 : : return -1;
5280 : : }
5281 : :
5282 : : Py_BEGIN_ALLOW_THREADS
5283 : : fd = WSASocketW(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
5284 : : FROM_PROTOCOL_INFO, &info, 0, WSA_FLAG_OVERLAPPED);
5285 : : Py_END_ALLOW_THREADS
5286 : : if (fd == INVALID_SOCKET) {
5287 : : set_error();
5288 : : return -1;
5289 : : }
5290 : : family = info.iAddressFamily;
5291 : : type = info.iSocketType;
5292 : : proto = info.iProtocol;
5293 : : }
5294 : : else
5295 : : #endif
5296 : 138497 : {
5297 : 138505 : fd = PyLong_AsSocket_t(fdobj);
5298 [ + + + + ]: 138505 : if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
5299 : 8 : return -1;
5300 : : #ifdef MS_WINDOWS
5301 : : if (fd == INVALID_SOCKET) {
5302 : : #else
5303 [ + + ]: 138503 : if (fd < 0) {
5304 : : #endif
5305 : 2 : PyErr_SetString(PyExc_ValueError, "negative file descriptor");
5306 : 2 : return -1;
5307 : : }
5308 : :
5309 : : /* validate that passed file descriptor is valid and a socket. */
5310 : : sock_addr_t addrbuf;
5311 : 138501 : socklen_t addrlen = sizeof(sock_addr_t);
5312 : :
5313 : 138501 : memset(&addrbuf, 0, addrlen);
5314 [ + + ]: 138501 : if (getsockname(fd, SAS2SA(&addrbuf), &addrlen) == 0) {
5315 [ + + ]: 138485 : if (family == -1) {
5316 : 6 : family = SAS2SA(&addrbuf)->sa_family;
5317 : : }
5318 : : } else {
5319 : : #ifdef MS_WINDOWS
5320 : : /* getsockname() on an unbound socket is an error on Windows.
5321 : : Invalid descriptor and not a socket is same error code.
5322 : : Error out if family must be resolved, or bad descriptor. */
5323 : : if (family == -1 || CHECK_ERRNO(ENOTSOCK)) {
5324 : : #else
5325 : : /* getsockname() is not supported for SOL_ALG on Linux. */
5326 [ + + + + : 16 : if (family == -1 || CHECK_ERRNO(EBADF) || CHECK_ERRNO(ENOTSOCK)) {
+ + ]
5327 : : #endif
5328 : 4 : set_error();
5329 : 4 : return -1;
5330 : : }
5331 : : }
5332 : : #ifdef SO_TYPE
5333 [ + + ]: 138497 : if (type == -1) {
5334 : : int tmp;
5335 : 39 : socklen_t slen = sizeof(tmp);
5336 [ + - ]: 39 : if (getsockopt(fd, SOL_SOCKET, SO_TYPE,
5337 : : (void *)&tmp, &slen) == 0)
5338 : : {
5339 : 39 : type = tmp;
5340 : : } else {
5341 : 0 : set_error();
5342 : 0 : return -1;
5343 : : }
5344 : : }
5345 : : #else
5346 : : type = SOCK_STREAM;
5347 : : #endif
5348 : : #ifdef SO_PROTOCOL
5349 [ + + ]: 138497 : if (proto == -1) {
5350 : : int tmp;
5351 : 41 : socklen_t slen = sizeof(tmp);
5352 [ + - ]: 41 : if (getsockopt(fd, SOL_SOCKET, SO_PROTOCOL,
5353 : : (void *)&tmp, &slen) == 0)
5354 : : {
5355 : 41 : proto = tmp;
5356 : : } else {
5357 : 0 : set_error();
5358 : 0 : return -1;
5359 : : }
5360 : : }
5361 : : #else
5362 : : proto = 0;
5363 : : #endif
5364 : : }
5365 : : }
5366 : : else {
5367 : : /* No fd, default to AF_INET and SOCK_STREAM */
5368 [ - + ]: 8930 : if (family == -1) {
5369 : 0 : family = AF_INET;
5370 : : }
5371 [ - + ]: 8930 : if (type == -1) {
5372 : 0 : type = SOCK_STREAM;
5373 : : }
5374 [ + + ]: 8930 : if (proto == -1) {
5375 : 1 : proto = 0;
5376 : : }
5377 : : #ifdef MS_WINDOWS
5378 : : /* Windows implementation */
5379 : : #ifndef WSA_FLAG_NO_HANDLE_INHERIT
5380 : : #define WSA_FLAG_NO_HANDLE_INHERIT 0x80
5381 : : #endif
5382 : :
5383 : : Py_BEGIN_ALLOW_THREADS
5384 : : if (support_wsa_no_inherit) {
5385 : : fd = WSASocketW(family, type, proto,
5386 : : NULL, 0,
5387 : : WSA_FLAG_OVERLAPPED | WSA_FLAG_NO_HANDLE_INHERIT);
5388 : : if (fd == INVALID_SOCKET) {
5389 : : /* Windows 7 or Windows 2008 R2 without SP1 or the hotfix */
5390 : : support_wsa_no_inherit = 0;
5391 : : fd = socket(family, type, proto);
5392 : : }
5393 : : }
5394 : : else {
5395 : : fd = socket(family, type, proto);
5396 : : }
5397 : : Py_END_ALLOW_THREADS
5398 : :
5399 : : if (fd == INVALID_SOCKET) {
5400 : : set_error();
5401 : : return -1;
5402 : : }
5403 : :
5404 : : if (!support_wsa_no_inherit) {
5405 : : if (!SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0)) {
5406 : : closesocket(fd);
5407 : : PyErr_SetFromWindowsErr(0);
5408 : : return -1;
5409 : : }
5410 : : }
5411 : : #else
5412 : : /* UNIX */
5413 : 8930 : Py_BEGIN_ALLOW_THREADS
5414 : : #ifdef SOCK_CLOEXEC
5415 [ + - ]: 8930 : if (sock_cloexec_works != 0) {
5416 : 8930 : fd = socket(family, type | SOCK_CLOEXEC, proto);
5417 [ + + ]: 8930 : if (sock_cloexec_works == -1) {
5418 [ + - ]: 406 : if (fd >= 0) {
5419 : 406 : sock_cloexec_works = 1;
5420 : : }
5421 [ # # ]: 0 : else if (errno == EINVAL) {
5422 : : /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
5423 : 0 : sock_cloexec_works = 0;
5424 : 0 : fd = socket(family, type, proto);
5425 : : }
5426 : : }
5427 : : }
5428 : : else
5429 : : #endif
5430 : : {
5431 : 0 : fd = socket(family, type, proto);
5432 : : }
5433 : 8930 : Py_END_ALLOW_THREADS
5434 : :
5435 [ + + ]: 8930 : if (fd == INVALID_SOCKET) {
5436 : 4 : set_error();
5437 : 4 : return -1;
5438 : : }
5439 : :
5440 [ - + ]: 8926 : if (_Py_set_inheritable(fd, 0, atomic_flag_works) < 0) {
5441 : 0 : SOCKETCLOSE(fd);
5442 : 0 : return -1;
5443 : : }
5444 : : #endif
5445 : : }
5446 [ - + ]: 147423 : if (init_sockobject(self, fd, family, type, proto) == -1) {
5447 : 0 : SOCKETCLOSE(fd);
5448 : 0 : return -1;
5449 : : }
5450 : :
5451 : 147423 : return 0;
5452 : :
5453 : : }
5454 : :
5455 : :
5456 : : /* Type object for socket objects. */
5457 : :
5458 : : static PyTypeObject sock_type = {
5459 : : PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
5460 : : "_socket.socket", /* tp_name */
5461 : : sizeof(PySocketSockObject), /* tp_basicsize */
5462 : : 0, /* tp_itemsize */
5463 : : (destructor)sock_dealloc, /* tp_dealloc */
5464 : : 0, /* tp_vectorcall_offset */
5465 : : 0, /* tp_getattr */
5466 : : 0, /* tp_setattr */
5467 : : 0, /* tp_as_async */
5468 : : (reprfunc)sock_repr, /* tp_repr */
5469 : : 0, /* tp_as_number */
5470 : : 0, /* tp_as_sequence */
5471 : : 0, /* tp_as_mapping */
5472 : : 0, /* tp_hash */
5473 : : 0, /* tp_call */
5474 : : 0, /* tp_str */
5475 : : PyObject_GenericGetAttr, /* tp_getattro */
5476 : : 0, /* tp_setattro */
5477 : : 0, /* tp_as_buffer */
5478 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
5479 : : sock_doc, /* tp_doc */
5480 : : 0, /* tp_traverse */
5481 : : 0, /* tp_clear */
5482 : : 0, /* tp_richcompare */
5483 : : 0, /* tp_weaklistoffset */
5484 : : 0, /* tp_iter */
5485 : : 0, /* tp_iternext */
5486 : : sock_methods, /* tp_methods */
5487 : : sock_memberlist, /* tp_members */
5488 : : sock_getsetlist, /* tp_getset */
5489 : : 0, /* tp_base */
5490 : : 0, /* tp_dict */
5491 : : 0, /* tp_descr_get */
5492 : : 0, /* tp_descr_set */
5493 : : 0, /* tp_dictoffset */
5494 : : sock_initobj, /* tp_init */
5495 : : PyType_GenericAlloc, /* tp_alloc */
5496 : : sock_new, /* tp_new */
5497 : : PyObject_Del, /* tp_free */
5498 : : 0, /* tp_is_gc */
5499 : : 0, /* tp_bases */
5500 : : 0, /* tp_mro */
5501 : : 0, /* tp_cache */
5502 : : 0, /* tp_subclasses */
5503 : : 0, /* tp_weaklist */
5504 : : 0, /* tp_del */
5505 : : 0, /* tp_version_tag */
5506 : : (destructor)sock_finalize, /* tp_finalize */
5507 : : };
5508 : :
5509 : :
5510 : : /* Python interface to gethostname(). */
5511 : :
5512 : : /*ARGSUSED*/
5513 : : static PyObject *
5514 : 276 : socket_gethostname(PyObject *self, PyObject *unused)
5515 : : {
5516 [ - + ]: 276 : if (PySys_Audit("socket.gethostname", NULL) < 0) {
5517 : 0 : return NULL;
5518 : : }
5519 : :
5520 : : #ifdef MS_WINDOWS
5521 : : /* Don't use winsock's gethostname, as this returns the ANSI
5522 : : version of the hostname, whereas we need a Unicode string.
5523 : : Otherwise, gethostname apparently also returns the DNS name. */
5524 : : wchar_t buf[MAX_COMPUTERNAME_LENGTH + 1];
5525 : : DWORD size = Py_ARRAY_LENGTH(buf);
5526 : : wchar_t *name;
5527 : : PyObject *result;
5528 : :
5529 : : if (GetComputerNameExW(ComputerNamePhysicalDnsHostname, buf, &size))
5530 : : return PyUnicode_FromWideChar(buf, size);
5531 : :
5532 : : if (GetLastError() != ERROR_MORE_DATA)
5533 : : return PyErr_SetFromWindowsErr(0);
5534 : :
5535 : : if (size == 0)
5536 : : return PyUnicode_New(0, 0);
5537 : :
5538 : : /* MSDN says ERROR_MORE_DATA may occur because DNS allows longer
5539 : : names */
5540 : : name = PyMem_New(wchar_t, size);
5541 : : if (!name) {
5542 : : PyErr_NoMemory();
5543 : : return NULL;
5544 : : }
5545 : : if (!GetComputerNameExW(ComputerNamePhysicalDnsHostname,
5546 : : name,
5547 : : &size))
5548 : : {
5549 : : PyMem_Free(name);
5550 : : return PyErr_SetFromWindowsErr(0);
5551 : : }
5552 : :
5553 : : result = PyUnicode_FromWideChar(name, size);
5554 : : PyMem_Free(name);
5555 : : return result;
5556 : : #else
5557 : : char buf[1024];
5558 : : int res;
5559 : 276 : Py_BEGIN_ALLOW_THREADS
5560 : 276 : res = gethostname(buf, (int) sizeof buf - 1);
5561 : 276 : Py_END_ALLOW_THREADS
5562 [ - + ]: 276 : if (res < 0)
5563 : 0 : return set_error();
5564 : 276 : buf[sizeof buf - 1] = '\0';
5565 : 276 : return PyUnicode_DecodeFSDefault(buf);
5566 : : #endif
5567 : : }
5568 : :
5569 : : PyDoc_STRVAR(gethostname_doc,
5570 : : "gethostname() -> string\n\
5571 : : \n\
5572 : : Return the current host name.");
5573 : :
5574 : : #ifdef HAVE_SETHOSTNAME
5575 : : PyDoc_STRVAR(sethostname_doc,
5576 : : "sethostname(name)\n\n\
5577 : : Sets the hostname to name.");
5578 : :
5579 : : static PyObject *
5580 : 1 : socket_sethostname(PyObject *self, PyObject *args)
5581 : : {
5582 : : PyObject *hnobj;
5583 : : Py_buffer buf;
5584 : 1 : int res, flag = 0;
5585 : :
5586 : : #ifdef _AIX
5587 : : /* issue #18259, not declared in any useful header file */
5588 : : extern int sethostname(const char *, size_t);
5589 : : #endif
5590 : :
5591 [ + - ]: 1 : if (!PyArg_ParseTuple(args, "S:sethostname", &hnobj)) {
5592 : 1 : PyErr_Clear();
5593 [ - + ]: 1 : if (!PyArg_ParseTuple(args, "O&:sethostname",
5594 : : PyUnicode_FSConverter, &hnobj))
5595 : 0 : return NULL;
5596 : 1 : flag = 1;
5597 : : }
5598 : :
5599 [ - + ]: 1 : if (PySys_Audit("socket.sethostname", "(O)", hnobj) < 0) {
5600 : 0 : return NULL;
5601 : : }
5602 : :
5603 : 1 : res = PyObject_GetBuffer(hnobj, &buf, PyBUF_SIMPLE);
5604 [ + - ]: 1 : if (!res) {
5605 : 1 : res = sethostname(buf.buf, buf.len);
5606 : 1 : PyBuffer_Release(&buf);
5607 : : }
5608 [ + - ]: 1 : if (flag)
5609 : 1 : Py_DECREF(hnobj);
5610 [ + - ]: 1 : if (res)
5611 : 1 : return set_error();
5612 : 0 : Py_RETURN_NONE;
5613 : : }
5614 : : #endif
5615 : :
5616 : : /* Python interface to gethostbyname(name). */
5617 : :
5618 : : /*ARGSUSED*/
5619 : : static PyObject *
5620 : 47 : socket_gethostbyname(PyObject *self, PyObject *args)
5621 : : {
5622 : : char *name;
5623 : : struct sockaddr_in addrbuf;
5624 : 47 : PyObject *ret = NULL;
5625 : :
5626 [ - + ]: 47 : if (!PyArg_ParseTuple(args, "et:gethostbyname", "idna", &name))
5627 : 0 : return NULL;
5628 [ - + ]: 47 : if (PySys_Audit("socket.gethostbyname", "O", args) < 0) {
5629 : 0 : goto finally;
5630 : : }
5631 [ + + ]: 47 : if (setipaddr(name, (struct sockaddr *)&addrbuf, sizeof(addrbuf), AF_INET) < 0)
5632 : 7 : goto finally;
5633 : 40 : ret = make_ipv4_addr(&addrbuf);
5634 : 47 : finally:
5635 : 47 : PyMem_Free(name);
5636 : 47 : return ret;
5637 : : }
5638 : :
5639 : : PyDoc_STRVAR(gethostbyname_doc,
5640 : : "gethostbyname(host) -> address\n\
5641 : : \n\
5642 : : Return the IP address (a string of the form '255.255.255.255') for a host.");
5643 : :
5644 : :
5645 : : static PyObject*
5646 : 140 : sock_decode_hostname(const char *name)
5647 : : {
5648 : : #ifdef MS_WINDOWS
5649 : : /* Issue #26227: gethostbyaddr() returns a string encoded
5650 : : * to the ANSI code page */
5651 : : return PyUnicode_DecodeMBCS(name, strlen(name), "surrogatepass");
5652 : : #else
5653 : : /* Decode from UTF-8 */
5654 : 140 : return PyUnicode_FromString(name);
5655 : : #endif
5656 : : }
5657 : :
5658 : : /* Convenience function common to gethostbyname_ex and gethostbyaddr */
5659 : :
5660 : : static PyObject *
5661 : 133 : gethost_common(struct hostent *h, struct sockaddr *addr, size_t alen, int af)
5662 : : {
5663 : : char **pch;
5664 : 133 : PyObject *rtn_tuple = (PyObject *)NULL;
5665 : 133 : PyObject *name_list = (PyObject *)NULL;
5666 : 133 : PyObject *addr_list = (PyObject *)NULL;
5667 : : PyObject *tmp;
5668 : : PyObject *name;
5669 : :
5670 [ - + ]: 133 : if (h == NULL) {
5671 : : /* Let's get real error message to return */
5672 : 0 : set_herror(h_errno);
5673 : 0 : return NULL;
5674 : : }
5675 : :
5676 [ - + ]: 133 : if (h->h_addrtype != af) {
5677 : : /* Let's get real error message to return */
5678 : 0 : errno = EAFNOSUPPORT;
5679 : 0 : PyErr_SetFromErrno(PyExc_OSError);
5680 : 0 : return NULL;
5681 : : }
5682 : :
5683 [ + + - ]: 133 : switch (af) {
5684 : :
5685 : 122 : case AF_INET:
5686 [ - + ]: 122 : if (alen < sizeof(struct sockaddr_in))
5687 : 0 : return NULL;
5688 : 122 : break;
5689 : :
5690 : : #ifdef ENABLE_IPV6
5691 : 11 : case AF_INET6:
5692 [ - + ]: 11 : if (alen < sizeof(struct sockaddr_in6))
5693 : 0 : return NULL;
5694 : 11 : break;
5695 : : #endif
5696 : :
5697 : : }
5698 : :
5699 [ - + ]: 133 : if ((name_list = PyList_New(0)) == NULL)
5700 : 0 : goto err;
5701 : :
5702 [ - + ]: 133 : if ((addr_list = PyList_New(0)) == NULL)
5703 : 0 : goto err;
5704 : :
5705 : : /* SF #1511317: h_aliases can be NULL */
5706 [ + - ]: 133 : if (h->h_aliases) {
5707 [ + + ]: 487 : for (pch = h->h_aliases; *pch != NULL; pch++) {
5708 : : int status;
5709 : 354 : tmp = PyUnicode_FromString(*pch);
5710 [ - + ]: 354 : if (tmp == NULL)
5711 : 0 : goto err;
5712 : :
5713 : 354 : status = PyList_Append(name_list, tmp);
5714 : 354 : Py_DECREF(tmp);
5715 : :
5716 [ - + ]: 354 : if (status)
5717 : 0 : goto err;
5718 : : }
5719 : : }
5720 : :
5721 [ + + ]: 308 : for (pch = h->h_addr_list; *pch != NULL; pch++) {
5722 : : int status;
5723 : :
5724 [ + + - ]: 175 : switch (af) {
5725 : :
5726 : 131 : case AF_INET:
5727 : : {
5728 : : struct sockaddr_in sin;
5729 : 131 : memset(&sin, 0, sizeof(sin));
5730 : 131 : sin.sin_family = af;
5731 : : #ifdef HAVE_SOCKADDR_SA_LEN
5732 : : sin.sin_len = sizeof(sin);
5733 : : #endif
5734 : 131 : memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
5735 : 131 : tmp = make_ipv4_addr(&sin);
5736 : :
5737 [ + + + - ]: 131 : if (pch == h->h_addr_list && alen >= sizeof(sin))
5738 : 122 : memcpy((char *) addr, &sin, sizeof(sin));
5739 : 131 : break;
5740 : : }
5741 : :
5742 : : #ifdef ENABLE_IPV6
5743 : 44 : case AF_INET6:
5744 : : {
5745 : : struct sockaddr_in6 sin6;
5746 : 44 : memset(&sin6, 0, sizeof(sin6));
5747 : 44 : sin6.sin6_family = af;
5748 : : #ifdef HAVE_SOCKADDR_SA_LEN
5749 : : sin6.sin6_len = sizeof(sin6);
5750 : : #endif
5751 : 44 : memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
5752 : 44 : tmp = make_ipv6_addr(&sin6);
5753 : :
5754 [ + + + - ]: 44 : if (pch == h->h_addr_list && alen >= sizeof(sin6))
5755 : 11 : memcpy((char *) addr, &sin6, sizeof(sin6));
5756 : 44 : break;
5757 : : }
5758 : : #endif
5759 : :
5760 : 0 : default: /* can't happen */
5761 : 0 : PyErr_SetString(PyExc_OSError,
5762 : : "unsupported address family");
5763 : 0 : return NULL;
5764 : : }
5765 : :
5766 [ - + ]: 175 : if (tmp == NULL)
5767 : 0 : goto err;
5768 : :
5769 : 175 : status = PyList_Append(addr_list, tmp);
5770 : 175 : Py_DECREF(tmp);
5771 : :
5772 [ - + ]: 175 : if (status)
5773 : 0 : goto err;
5774 : : }
5775 : :
5776 : 133 : name = sock_decode_hostname(h->h_name);
5777 [ - + ]: 133 : if (name == NULL)
5778 : 0 : goto err;
5779 : 133 : rtn_tuple = Py_BuildValue("NOO", name, name_list, addr_list);
5780 : :
5781 : 133 : err:
5782 : 133 : Py_XDECREF(name_list);
5783 : 133 : Py_XDECREF(addr_list);
5784 : 133 : return rtn_tuple;
5785 : : }
5786 : :
5787 : :
5788 : : /* Python interface to gethostbyname_ex(name). */
5789 : :
5790 : : /*ARGSUSED*/
5791 : : static PyObject *
5792 : 4 : socket_gethostbyname_ex(PyObject *self, PyObject *args)
5793 : : {
5794 : : char *name;
5795 : : struct hostent *h;
5796 : : sock_addr_t addr;
5797 : : struct sockaddr *sa;
5798 : 4 : PyObject *ret = NULL;
5799 : : #ifdef HAVE_GETHOSTBYNAME_R
5800 : : struct hostent hp_allocated;
5801 : : #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
5802 : : struct hostent_data data;
5803 : : #else
5804 : : char buf[16384];
5805 : 4 : int buf_len = (sizeof buf) - 1;
5806 : : int errnop;
5807 : : #endif
5808 : : #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
5809 : : int result;
5810 : : #endif
5811 : : #endif /* HAVE_GETHOSTBYNAME_R */
5812 : :
5813 [ - + ]: 4 : if (!PyArg_ParseTuple(args, "et:gethostbyname_ex", "idna", &name))
5814 : 0 : return NULL;
5815 [ - + ]: 4 : if (PySys_Audit("socket.gethostbyname", "O", args) < 0) {
5816 : 0 : goto finally;
5817 : : }
5818 [ - + ]: 4 : if (setipaddr(name, SAS2SA(&addr), sizeof(addr), AF_INET) < 0)
5819 : 0 : goto finally;
5820 : 4 : Py_BEGIN_ALLOW_THREADS
5821 : : #ifdef HAVE_GETHOSTBYNAME_R
5822 : : #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
5823 : 4 : gethostbyname_r(name, &hp_allocated, buf, buf_len,
5824 : : &h, &errnop);
5825 : : #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
5826 : : h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
5827 : : #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
5828 : : memset((void *) &data, '\0', sizeof(data));
5829 : : result = gethostbyname_r(name, &hp_allocated, &data);
5830 : : h = (result != 0) ? NULL : &hp_allocated;
5831 : : #endif
5832 : : #else /* not HAVE_GETHOSTBYNAME_R */
5833 : : #ifdef USE_GETHOSTBYNAME_LOCK
5834 : : PyThread_acquire_lock(netdb_lock, 1);
5835 : : #endif
5836 : : SUPPRESS_DEPRECATED_CALL
5837 : : h = gethostbyname(name);
5838 : : #endif /* HAVE_GETHOSTBYNAME_R */
5839 : 4 : Py_END_ALLOW_THREADS
5840 : : /* Some C libraries would require addr.__ss_family instead of
5841 : : addr.ss_family.
5842 : : Therefore, we cast the sockaddr_storage into sockaddr to
5843 : : access sa_family. */
5844 : 4 : sa = SAS2SA(&addr);
5845 : 4 : ret = gethost_common(h, SAS2SA(&addr), sizeof(addr),
5846 : 4 : sa->sa_family);
5847 : : #ifdef USE_GETHOSTBYNAME_LOCK
5848 : : PyThread_release_lock(netdb_lock);
5849 : : #endif
5850 : 4 : finally:
5851 : 4 : PyMem_Free(name);
5852 : 4 : return ret;
5853 : : }
5854 : :
5855 : : PyDoc_STRVAR(ghbn_ex_doc,
5856 : : "gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
5857 : : \n\
5858 : : Return the true host name, a list of aliases, and a list of IP addresses,\n\
5859 : : for a host. The host argument is a string giving a host name or IP number.");
5860 : :
5861 : :
5862 : : /* Python interface to gethostbyaddr(IP). */
5863 : :
5864 : : /*ARGSUSED*/
5865 : : static PyObject *
5866 : 134 : socket_gethostbyaddr(PyObject *self, PyObject *args)
5867 : : {
5868 : : sock_addr_t addr;
5869 : 134 : struct sockaddr *sa = SAS2SA(&addr);
5870 : : char *ip_num;
5871 : : struct hostent *h;
5872 : 134 : PyObject *ret = NULL;
5873 : : #ifdef HAVE_GETHOSTBYNAME_R
5874 : : struct hostent hp_allocated;
5875 : : #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
5876 : : struct hostent_data data;
5877 : : #else
5878 : : /* glibcs up to 2.10 assume that the buf argument to
5879 : : gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
5880 : : does not ensure. The attribute below instructs the compiler
5881 : : to maintain this alignment. */
5882 : : char buf[16384] Py_ALIGNED(8);
5883 : 134 : int buf_len = (sizeof buf) - 1;
5884 : : int errnop;
5885 : : #endif
5886 : : #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
5887 : : int result;
5888 : : #endif
5889 : : #endif /* HAVE_GETHOSTBYNAME_R */
5890 : : const char *ap;
5891 : : int al;
5892 : : int af;
5893 : :
5894 [ - + ]: 134 : if (!PyArg_ParseTuple(args, "et:gethostbyaddr", "idna", &ip_num))
5895 : 0 : return NULL;
5896 [ - + ]: 134 : if (PySys_Audit("socket.gethostbyaddr", "O", args) < 0) {
5897 : 0 : goto finally;
5898 : : }
5899 : 134 : af = AF_UNSPEC;
5900 [ + + ]: 134 : if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
5901 : 5 : goto finally;
5902 : 129 : af = sa->sa_family;
5903 : 129 : ap = NULL;
5904 : : /* al = 0; */
5905 [ + + - ]: 129 : switch (af) {
5906 : 118 : case AF_INET:
5907 : 118 : ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
5908 : 118 : al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
5909 : 118 : break;
5910 : : #ifdef ENABLE_IPV6
5911 : 11 : case AF_INET6:
5912 : 11 : ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
5913 : 11 : al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
5914 : 11 : break;
5915 : : #endif
5916 : 0 : default:
5917 : 0 : PyErr_SetString(PyExc_OSError, "unsupported address family");
5918 : 0 : goto finally;
5919 : : }
5920 : 129 : Py_BEGIN_ALLOW_THREADS
5921 : : #ifdef HAVE_GETHOSTBYNAME_R
5922 : : #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
5923 : 129 : gethostbyaddr_r(ap, al, af,
5924 : : &hp_allocated, buf, buf_len,
5925 : : &h, &errnop);
5926 : : #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
5927 : : h = gethostbyaddr_r(ap, al, af,
5928 : : &hp_allocated, buf, buf_len, &errnop);
5929 : : #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
5930 : : memset((void *) &data, '\0', sizeof(data));
5931 : : result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
5932 : : h = (result != 0) ? NULL : &hp_allocated;
5933 : : #endif
5934 : : #else /* not HAVE_GETHOSTBYNAME_R */
5935 : : #ifdef USE_GETHOSTBYNAME_LOCK
5936 : : PyThread_acquire_lock(netdb_lock, 1);
5937 : : #endif
5938 : : SUPPRESS_DEPRECATED_CALL
5939 : : h = gethostbyaddr(ap, al, af);
5940 : : #endif /* HAVE_GETHOSTBYNAME_R */
5941 : 129 : Py_END_ALLOW_THREADS
5942 : 129 : ret = gethost_common(h, SAS2SA(&addr), sizeof(addr), af);
5943 : : #ifdef USE_GETHOSTBYNAME_LOCK
5944 : : PyThread_release_lock(netdb_lock);
5945 : : #endif
5946 : 134 : finally:
5947 : 134 : PyMem_Free(ip_num);
5948 : 134 : return ret;
5949 : : }
5950 : :
5951 : : PyDoc_STRVAR(gethostbyaddr_doc,
5952 : : "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
5953 : : \n\
5954 : : Return the true host name, a list of aliases, and a list of IP addresses,\n\
5955 : : for a host. The host argument is a string giving a host name or IP number.");
5956 : :
5957 : :
5958 : : /* Python interface to getservbyname(name).
5959 : : This only returns the port number, since the other info is already
5960 : : known or not useful (like the list of aliases). */
5961 : :
5962 : : /*ARGSUSED*/
5963 : : static PyObject *
5964 : 3 : socket_getservbyname(PyObject *self, PyObject *args)
5965 : : {
5966 : 3 : const char *name, *proto=NULL;
5967 : : struct servent *sp;
5968 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
5969 : 0 : return NULL;
5970 : :
5971 [ - + ]: 3 : if (PySys_Audit("socket.getservbyname", "ss", name, proto) < 0) {
5972 : 0 : return NULL;
5973 : : }
5974 : :
5975 : 3 : Py_BEGIN_ALLOW_THREADS
5976 : 3 : sp = getservbyname(name, proto);
5977 : 3 : Py_END_ALLOW_THREADS
5978 [ - + ]: 3 : if (sp == NULL) {
5979 : 0 : PyErr_SetString(PyExc_OSError, "service/proto not found");
5980 : 0 : return NULL;
5981 : : }
5982 : 3 : return PyLong_FromLong((long) ntohs(sp->s_port));
5983 : : }
5984 : :
5985 : : PyDoc_STRVAR(getservbyname_doc,
5986 : : "getservbyname(servicename[, protocolname]) -> integer\n\
5987 : : \n\
5988 : : Return a port number from a service name and protocol name.\n\
5989 : : The optional protocol name, if given, should be 'tcp' or 'udp',\n\
5990 : : otherwise any protocol will match.");
5991 : :
5992 : :
5993 : : /* Python interface to getservbyport(port).
5994 : : This only returns the service name, since the other info is already
5995 : : known or not useful (like the list of aliases). */
5996 : :
5997 : : /*ARGSUSED*/
5998 : : static PyObject *
5999 : 5 : socket_getservbyport(PyObject *self, PyObject *args)
6000 : : {
6001 : : int port;
6002 : 5 : const char *proto=NULL;
6003 : : struct servent *sp;
6004 [ - + ]: 5 : if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
6005 : 0 : return NULL;
6006 [ + + + + ]: 5 : if (port < 0 || port > 0xffff) {
6007 : 2 : PyErr_SetString(
6008 : : PyExc_OverflowError,
6009 : : "getservbyport: port must be 0-65535.");
6010 : 2 : return NULL;
6011 : : }
6012 : :
6013 [ - + ]: 3 : if (PySys_Audit("socket.getservbyport", "is", port, proto) < 0) {
6014 : 0 : return NULL;
6015 : : }
6016 : :
6017 : 3 : Py_BEGIN_ALLOW_THREADS
6018 : 3 : sp = getservbyport(htons((short)port), proto);
6019 : 3 : Py_END_ALLOW_THREADS
6020 [ - + ]: 3 : if (sp == NULL) {
6021 : 0 : PyErr_SetString(PyExc_OSError, "port/proto not found");
6022 : 0 : return NULL;
6023 : : }
6024 : 3 : return PyUnicode_FromString(sp->s_name);
6025 : : }
6026 : :
6027 : : PyDoc_STRVAR(getservbyport_doc,
6028 : : "getservbyport(port[, protocolname]) -> string\n\
6029 : : \n\
6030 : : Return the service name from a port number and protocol name.\n\
6031 : : The optional protocol name, if given, should be 'tcp' or 'udp',\n\
6032 : : otherwise any protocol will match.");
6033 : :
6034 : : /* Python interface to getprotobyname(name).
6035 : : This only returns the protocol number, since the other info is
6036 : : already known or not useful (like the list of aliases). */
6037 : :
6038 : : /*ARGSUSED*/
6039 : : static PyObject *
6040 : 0 : socket_getprotobyname(PyObject *self, PyObject *args)
6041 : : {
6042 : : const char *name;
6043 : : struct protoent *sp;
6044 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
6045 : 0 : return NULL;
6046 : 0 : Py_BEGIN_ALLOW_THREADS
6047 : 0 : sp = getprotobyname(name);
6048 : 0 : Py_END_ALLOW_THREADS
6049 [ # # ]: 0 : if (sp == NULL) {
6050 : 0 : PyErr_SetString(PyExc_OSError, "protocol not found");
6051 : 0 : return NULL;
6052 : : }
6053 : 0 : return PyLong_FromLong((long) sp->p_proto);
6054 : : }
6055 : :
6056 : : PyDoc_STRVAR(getprotobyname_doc,
6057 : : "getprotobyname(name) -> integer\n\
6058 : : \n\
6059 : : Return the protocol number for the named protocol. (Rarely used.)");
6060 : :
6061 : : static PyObject *
6062 : 3 : socket_close(PyObject *self, PyObject *fdobj)
6063 : : {
6064 : : SOCKET_T fd;
6065 : : int res;
6066 : :
6067 : 3 : fd = PyLong_AsSocket_t(fdobj);
6068 [ + + + + ]: 3 : if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
6069 : 1 : return NULL;
6070 : 2 : Py_BEGIN_ALLOW_THREADS
6071 : 2 : res = SOCKETCLOSE(fd);
6072 : 2 : Py_END_ALLOW_THREADS
6073 : : /* bpo-30319: The peer can already have closed the connection.
6074 : : Python ignores ECONNRESET on close(). */
6075 [ + + + - ]: 2 : if (res < 0 && !CHECK_ERRNO(ECONNRESET)) {
6076 : 1 : return set_error();
6077 : : }
6078 : 1 : Py_RETURN_NONE;
6079 : : }
6080 : :
6081 : : PyDoc_STRVAR(close_doc,
6082 : : "close(integer) -> None\n\
6083 : : \n\
6084 : : Close an integer socket file descriptor. This is like os.close(), but for\n\
6085 : : sockets; on some platforms os.close() won't work for socket file descriptors.");
6086 : :
6087 : : #ifndef NO_DUP
6088 : : /* dup() function for socket fds */
6089 : :
6090 : : static PyObject *
6091 : 44 : socket_dup(PyObject *self, PyObject *fdobj)
6092 : : {
6093 : : SOCKET_T fd, newfd;
6094 : : PyObject *newfdobj;
6095 : : #ifdef MS_WINDOWS
6096 : : WSAPROTOCOL_INFOW info;
6097 : : #endif
6098 : :
6099 : 44 : fd = PyLong_AsSocket_t(fdobj);
6100 [ - + - - ]: 44 : if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
6101 : 0 : return NULL;
6102 : :
6103 : : #ifdef MS_WINDOWS
6104 : : if (WSADuplicateSocketW(fd, GetCurrentProcessId(), &info))
6105 : : return set_error();
6106 : :
6107 : : newfd = WSASocketW(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
6108 : : FROM_PROTOCOL_INFO,
6109 : : &info, 0, WSA_FLAG_OVERLAPPED);
6110 : : if (newfd == INVALID_SOCKET)
6111 : : return set_error();
6112 : :
6113 : : if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
6114 : : closesocket(newfd);
6115 : : PyErr_SetFromWindowsErr(0);
6116 : : return NULL;
6117 : : }
6118 : : #else
6119 : : /* On UNIX, dup can be used to duplicate the file descriptor of a socket */
6120 : 44 : newfd = _Py_dup(fd);
6121 [ + + ]: 44 : if (newfd == INVALID_SOCKET)
6122 : 1 : return NULL;
6123 : : #endif
6124 : :
6125 : 43 : newfdobj = PyLong_FromSocket_t(newfd);
6126 [ - + ]: 43 : if (newfdobj == NULL)
6127 : 0 : SOCKETCLOSE(newfd);
6128 : 43 : return newfdobj;
6129 : : }
6130 : :
6131 : : PyDoc_STRVAR(dup_doc,
6132 : : "dup(integer) -> integer\n\
6133 : : \n\
6134 : : Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
6135 : : sockets; on some platforms os.dup() won't work for socket file descriptors.");
6136 : : #endif
6137 : :
6138 : :
6139 : : #ifdef HAVE_SOCKETPAIR
6140 : : /* Create a pair of sockets using the socketpair() function.
6141 : : Arguments as for socket() except the default family is AF_UNIX if
6142 : : defined on the platform; otherwise, the default is AF_INET. */
6143 : :
6144 : : /*ARGSUSED*/
6145 : : static PyObject *
6146 : 67279 : socket_socketpair(PyObject *self, PyObject *args)
6147 : : {
6148 : 67279 : PySocketSockObject *s0 = NULL, *s1 = NULL;
6149 : : SOCKET_T sv[2];
6150 : 67279 : int family, type = SOCK_STREAM, proto = 0;
6151 : 67279 : PyObject *res = NULL;
6152 : : #ifdef SOCK_CLOEXEC
6153 : 67279 : int *atomic_flag_works = &sock_cloexec_works;
6154 : : #else
6155 : : int *atomic_flag_works = NULL;
6156 : : #endif
6157 : : int ret;
6158 : :
6159 : : #if defined(AF_UNIX)
6160 : 67279 : family = AF_UNIX;
6161 : : #else
6162 : : family = AF_INET;
6163 : : #endif
6164 [ - + ]: 67279 : if (!PyArg_ParseTuple(args, "|iii:socketpair",
6165 : : &family, &type, &proto))
6166 : 0 : return NULL;
6167 : :
6168 : : /* Create a pair of socket fds */
6169 : 67279 : Py_BEGIN_ALLOW_THREADS
6170 : : #ifdef SOCK_CLOEXEC
6171 [ + - ]: 67279 : if (sock_cloexec_works != 0) {
6172 : 67279 : ret = socketpair(family, type | SOCK_CLOEXEC, proto, sv);
6173 [ + + ]: 67279 : if (sock_cloexec_works == -1) {
6174 [ + - ]: 18 : if (ret >= 0) {
6175 : 18 : sock_cloexec_works = 1;
6176 : : }
6177 [ # # ]: 0 : else if (errno == EINVAL) {
6178 : : /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
6179 : 0 : sock_cloexec_works = 0;
6180 : 0 : ret = socketpair(family, type, proto, sv);
6181 : : }
6182 : : }
6183 : : }
6184 : : else
6185 : : #endif
6186 : : {
6187 : 0 : ret = socketpair(family, type, proto, sv);
6188 : : }
6189 : 67279 : Py_END_ALLOW_THREADS
6190 : :
6191 [ - + ]: 67279 : if (ret < 0)
6192 : 0 : return set_error();
6193 : :
6194 [ - + ]: 67279 : if (_Py_set_inheritable(sv[0], 0, atomic_flag_works) < 0)
6195 : 0 : goto finally;
6196 [ - + ]: 67279 : if (_Py_set_inheritable(sv[1], 0, atomic_flag_works) < 0)
6197 : 0 : goto finally;
6198 : :
6199 : 67279 : s0 = new_sockobject(sv[0], family, type, proto);
6200 [ - + ]: 67279 : if (s0 == NULL)
6201 : 0 : goto finally;
6202 : 67279 : s1 = new_sockobject(sv[1], family, type, proto);
6203 [ - + ]: 67279 : if (s1 == NULL)
6204 : 0 : goto finally;
6205 : 67279 : res = PyTuple_Pack(2, s0, s1);
6206 : :
6207 : 67279 : finally:
6208 [ - + ]: 67279 : if (res == NULL) {
6209 [ # # ]: 0 : if (s0 == NULL)
6210 : 0 : SOCKETCLOSE(sv[0]);
6211 [ # # ]: 0 : if (s1 == NULL)
6212 : 0 : SOCKETCLOSE(sv[1]);
6213 : : }
6214 : 67279 : Py_XDECREF(s0);
6215 : 67279 : Py_XDECREF(s1);
6216 : 67279 : return res;
6217 : : }
6218 : :
6219 : : PyDoc_STRVAR(socketpair_doc,
6220 : : "socketpair([family[, type [, proto]]]) -> (socket object, socket object)\n\
6221 : : \n\
6222 : : Create a pair of socket objects from the sockets returned by the platform\n\
6223 : : socketpair() function.\n\
6224 : : The arguments are the same as for socket() except the default family is\n\
6225 : : AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
6226 : :
6227 : : #endif /* HAVE_SOCKETPAIR */
6228 : :
6229 : :
6230 : : static PyObject *
6231 : 28 : socket_ntohs(PyObject *self, PyObject *args)
6232 : : {
6233 : : int x;
6234 : :
6235 [ + + ]: 28 : if (!PyArg_ParseTuple(args, "i:ntohs", &x)) {
6236 : 5 : return NULL;
6237 : : }
6238 [ + + ]: 23 : if (x < 0) {
6239 : 2 : PyErr_SetString(PyExc_OverflowError,
6240 : : "ntohs: can't convert negative Python int to C "
6241 : : "16-bit unsigned integer");
6242 : 2 : return NULL;
6243 : : }
6244 [ + + ]: 21 : if (x > 0xffff) {
6245 : 2 : PyErr_SetString(PyExc_OverflowError,
6246 : : "ntohs: Python int too large to convert to C "
6247 : : "16-bit unsigned integer");
6248 : 2 : return NULL;
6249 : : }
6250 : 19 : return PyLong_FromUnsignedLong(ntohs((unsigned short)x));
6251 : : }
6252 : :
6253 : : PyDoc_STRVAR(ntohs_doc,
6254 : : "ntohs(integer) -> integer\n\
6255 : : \n\
6256 : : Convert a 16-bit unsigned integer from network to host byte order.");
6257 : :
6258 : :
6259 : : static PyObject *
6260 : 25 : socket_ntohl(PyObject *self, PyObject *arg)
6261 : : {
6262 : : unsigned long x;
6263 : :
6264 [ + - ]: 25 : if (PyLong_Check(arg)) {
6265 : 25 : x = PyLong_AsUnsignedLong(arg);
6266 [ + + + - ]: 25 : if (x == (unsigned long) -1 && PyErr_Occurred())
6267 : 3 : return NULL;
6268 : : #if SIZEOF_LONG > 4
6269 : : {
6270 : : unsigned long y;
6271 : : /* only want the trailing 32 bits */
6272 : 22 : y = x & 0xFFFFFFFFUL;
6273 [ + + ]: 22 : if (y ^ x)
6274 : 2 : return PyErr_Format(PyExc_OverflowError,
6275 : : "int larger than 32 bits");
6276 : 20 : x = y;
6277 : : }
6278 : : #endif
6279 : : }
6280 : : else
6281 : 0 : return PyErr_Format(PyExc_TypeError,
6282 : : "expected int, %s found",
6283 : 0 : Py_TYPE(arg)->tp_name);
6284 : 20 : return PyLong_FromUnsignedLong(ntohl(x));
6285 : : }
6286 : :
6287 : : PyDoc_STRVAR(ntohl_doc,
6288 : : "ntohl(integer) -> integer\n\
6289 : : \n\
6290 : : Convert a 32-bit integer from network to host byte order.");
6291 : :
6292 : :
6293 : : static PyObject *
6294 : 28 : socket_htons(PyObject *self, PyObject *args)
6295 : : {
6296 : : int x;
6297 : :
6298 [ + + ]: 28 : if (!PyArg_ParseTuple(args, "i:htons", &x)) {
6299 : 5 : return NULL;
6300 : : }
6301 [ + + ]: 23 : if (x < 0) {
6302 : 2 : PyErr_SetString(PyExc_OverflowError,
6303 : : "htons: can't convert negative Python int to C "
6304 : : "16-bit unsigned integer");
6305 : 2 : return NULL;
6306 : : }
6307 [ + + ]: 21 : if (x > 0xffff) {
6308 : 2 : PyErr_SetString(PyExc_OverflowError,
6309 : : "htons: Python int too large to convert to C "
6310 : : "16-bit unsigned integer");
6311 : 2 : return NULL;
6312 : : }
6313 : 19 : return PyLong_FromUnsignedLong(htons((unsigned short)x));
6314 : : }
6315 : :
6316 : : PyDoc_STRVAR(htons_doc,
6317 : : "htons(integer) -> integer\n\
6318 : : \n\
6319 : : Convert a 16-bit unsigned integer from host to network byte order.");
6320 : :
6321 : :
6322 : : static PyObject *
6323 : 25 : socket_htonl(PyObject *self, PyObject *arg)
6324 : : {
6325 : : unsigned long x;
6326 : :
6327 [ + - ]: 25 : if (PyLong_Check(arg)) {
6328 : 25 : x = PyLong_AsUnsignedLong(arg);
6329 [ + + + - ]: 25 : if (x == (unsigned long) -1 && PyErr_Occurred())
6330 : 3 : return NULL;
6331 : : #if SIZEOF_LONG > 4
6332 : : {
6333 : : unsigned long y;
6334 : : /* only want the trailing 32 bits */
6335 : 22 : y = x & 0xFFFFFFFFUL;
6336 [ + + ]: 22 : if (y ^ x)
6337 : 2 : return PyErr_Format(PyExc_OverflowError,
6338 : : "int larger than 32 bits");
6339 : 20 : x = y;
6340 : : }
6341 : : #endif
6342 : : }
6343 : : else
6344 : 0 : return PyErr_Format(PyExc_TypeError,
6345 : : "expected int, %s found",
6346 : 0 : Py_TYPE(arg)->tp_name);
6347 : 20 : return PyLong_FromUnsignedLong(htonl((unsigned long)x));
6348 : : }
6349 : :
6350 : : PyDoc_STRVAR(htonl_doc,
6351 : : "htonl(integer) -> integer\n\
6352 : : \n\
6353 : : Convert a 32-bit integer from host to network byte order.");
6354 : :
6355 : : /* socket.inet_aton() and socket.inet_ntoa() functions. */
6356 : :
6357 : : PyDoc_STRVAR(inet_aton_doc,
6358 : : "inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
6359 : : \n\
6360 : : Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
6361 : : binary format used in low-level network functions.");
6362 : :
6363 : : static PyObject*
6364 : 12 : socket_inet_aton(PyObject *self, PyObject *args)
6365 : : {
6366 : : #ifdef HAVE_INET_ATON
6367 : : struct in_addr buf;
6368 : : #endif
6369 : :
6370 : : #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
6371 : : #if (SIZEOF_INT != 4)
6372 : : #error "Not sure if in_addr_t exists and int is not 32-bits."
6373 : : #endif
6374 : : /* Have to use inet_addr() instead */
6375 : : unsigned int packed_addr;
6376 : : #endif
6377 : : const char *ip_addr;
6378 : :
6379 [ - + ]: 12 : if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
6380 : 0 : return NULL;
6381 : :
6382 : :
6383 : : #ifdef HAVE_INET_ATON
6384 : :
6385 : : #ifdef USE_INET_ATON_WEAKLINK
6386 : : if (inet_aton != NULL) {
6387 : : #endif
6388 [ + + ]: 12 : if (inet_aton(ip_addr, &buf))
6389 : 7 : return PyBytes_FromStringAndSize((char *)(&buf),
6390 : : sizeof(buf));
6391 : :
6392 : 5 : PyErr_SetString(PyExc_OSError,
6393 : : "illegal IP address string passed to inet_aton");
6394 : 5 : return NULL;
6395 : :
6396 : : #ifdef USE_INET_ATON_WEAKLINK
6397 : : } else {
6398 : : #endif
6399 : :
6400 : : #endif
6401 : :
6402 : : #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
6403 : :
6404 : : /* special-case this address as inet_addr might return INADDR_NONE
6405 : : * for this */
6406 : : if (strcmp(ip_addr, "255.255.255.255") == 0) {
6407 : : packed_addr = INADDR_BROADCAST;
6408 : : } else {
6409 : :
6410 : : SUPPRESS_DEPRECATED_CALL
6411 : : packed_addr = inet_addr(ip_addr);
6412 : :
6413 : : if (packed_addr == INADDR_NONE) { /* invalid address */
6414 : : PyErr_SetString(PyExc_OSError,
6415 : : "illegal IP address string passed to inet_aton");
6416 : : return NULL;
6417 : : }
6418 : : }
6419 : : return PyBytes_FromStringAndSize((char *) &packed_addr,
6420 : : sizeof(packed_addr));
6421 : :
6422 : : #ifdef USE_INET_ATON_WEAKLINK
6423 : : }
6424 : : #endif
6425 : :
6426 : : #endif
6427 : : }
6428 : :
6429 : : PyDoc_STRVAR(inet_ntoa_doc,
6430 : : "inet_ntoa(packed_ip) -> ip_address_string\n\
6431 : : \n\
6432 : : Convert an IP address from 32-bit packed binary format to string format");
6433 : :
6434 : : static PyObject*
6435 : 8 : socket_inet_ntoa(PyObject *self, PyObject *args)
6436 : : {
6437 : : Py_buffer packed_ip;
6438 : : struct in_addr packed_addr;
6439 : :
6440 [ - + ]: 8 : if (!PyArg_ParseTuple(args, "y*:inet_ntoa", &packed_ip)) {
6441 : 0 : return NULL;
6442 : : }
6443 : :
6444 [ + + ]: 8 : if (packed_ip.len != sizeof(packed_addr)) {
6445 : 3 : PyErr_SetString(PyExc_OSError,
6446 : : "packed IP wrong length for inet_ntoa");
6447 : 3 : PyBuffer_Release(&packed_ip);
6448 : 3 : return NULL;
6449 : : }
6450 : :
6451 : 5 : memcpy(&packed_addr, packed_ip.buf, packed_ip.len);
6452 : 5 : PyBuffer_Release(&packed_ip);
6453 : :
6454 : : SUPPRESS_DEPRECATED_CALL
6455 : 5 : return PyUnicode_FromString(inet_ntoa(packed_addr));
6456 : : }
6457 : :
6458 : : #ifdef HAVE_INET_PTON
6459 : :
6460 : : PyDoc_STRVAR(inet_pton_doc,
6461 : : "inet_pton(af, ip) -> packed IP address string\n\
6462 : : \n\
6463 : : Convert an IP address from string format to a packed string suitable\n\
6464 : : for use with low-level network functions.");
6465 : :
6466 : : static PyObject *
6467 : 468 : socket_inet_pton(PyObject *self, PyObject *args)
6468 : : {
6469 : : int af;
6470 : : const char* ip;
6471 : : int retval;
6472 : : #ifdef ENABLE_IPV6
6473 : : char packed[Py_MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
6474 : : #else
6475 : : char packed[sizeof(struct in_addr)];
6476 : : #endif
6477 [ - + ]: 468 : if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
6478 : 0 : return NULL;
6479 : : }
6480 : :
6481 : : #if !defined(ENABLE_IPV6) && defined(AF_INET6)
6482 : : if(af == AF_INET6) {
6483 : : PyErr_SetString(PyExc_OSError,
6484 : : "can't use AF_INET6, IPv6 is disabled");
6485 : : return NULL;
6486 : : }
6487 : : #endif
6488 : :
6489 : 468 : retval = inet_pton(af, ip, packed);
6490 [ - + ]: 468 : if (retval < 0) {
6491 : 0 : PyErr_SetFromErrno(PyExc_OSError);
6492 : 0 : return NULL;
6493 [ + + ]: 468 : } else if (retval == 0) {
6494 : 65 : PyErr_SetString(PyExc_OSError,
6495 : : "illegal IP address string passed to inet_pton");
6496 : 65 : return NULL;
6497 [ + + ]: 403 : } else if (af == AF_INET) {
6498 : 378 : return PyBytes_FromStringAndSize(packed,
6499 : : sizeof(struct in_addr));
6500 : : #ifdef ENABLE_IPV6
6501 [ + - ]: 25 : } else if (af == AF_INET6) {
6502 : 25 : return PyBytes_FromStringAndSize(packed,
6503 : : sizeof(struct in6_addr));
6504 : : #endif
6505 : : } else {
6506 : 0 : PyErr_SetString(PyExc_OSError, "unknown address family");
6507 : 0 : return NULL;
6508 : : }
6509 : : }
6510 : :
6511 : : PyDoc_STRVAR(inet_ntop_doc,
6512 : : "inet_ntop(af, packed_ip) -> string formatted IP address\n\
6513 : : \n\
6514 : : Convert a packed IP address of the given family to string format.");
6515 : :
6516 : : static PyObject *
6517 : 14 : socket_inet_ntop(PyObject *self, PyObject *args)
6518 : : {
6519 : : int af;
6520 : : Py_buffer packed_ip;
6521 : : const char* retval;
6522 : : #ifdef ENABLE_IPV6
6523 : : char ip[Py_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
6524 : : #else
6525 : : char ip[INET_ADDRSTRLEN];
6526 : : #endif
6527 : :
6528 [ - + ]: 14 : if (!PyArg_ParseTuple(args, "iy*:inet_ntop", &af, &packed_ip)) {
6529 : 0 : return NULL;
6530 : : }
6531 : :
6532 [ + + ]: 14 : if (af == AF_INET) {
6533 [ + + ]: 7 : if (packed_ip.len != sizeof(struct in_addr)) {
6534 : 3 : PyErr_SetString(PyExc_ValueError,
6535 : : "invalid length of packed IP address string");
6536 : 3 : PyBuffer_Release(&packed_ip);
6537 : 3 : return NULL;
6538 : : }
6539 : : #ifdef ENABLE_IPV6
6540 [ + - ]: 7 : } else if (af == AF_INET6) {
6541 [ + + ]: 7 : if (packed_ip.len != sizeof(struct in6_addr)) {
6542 : 3 : PyErr_SetString(PyExc_ValueError,
6543 : : "invalid length of packed IP address string");
6544 : 3 : PyBuffer_Release(&packed_ip);
6545 : 3 : return NULL;
6546 : : }
6547 : : #endif
6548 : : } else {
6549 : 0 : PyErr_Format(PyExc_ValueError,
6550 : : "unknown address family %d", af);
6551 : 0 : PyBuffer_Release(&packed_ip);
6552 : 0 : return NULL;
6553 : : }
6554 : :
6555 : : /* inet_ntop guarantee NUL-termination of resulting string. */
6556 : 8 : retval = inet_ntop(af, packed_ip.buf, ip, sizeof(ip));
6557 : 8 : PyBuffer_Release(&packed_ip);
6558 [ - + ]: 8 : if (!retval) {
6559 : 0 : PyErr_SetFromErrno(PyExc_OSError);
6560 : 0 : return NULL;
6561 : : } else {
6562 : 8 : return PyUnicode_FromString(retval);
6563 : : }
6564 : : }
6565 : :
6566 : : #endif /* HAVE_INET_PTON */
6567 : :
6568 : : /* Python interface to getaddrinfo(host, port). */
6569 : :
6570 : : /*ARGSUSED*/
6571 : : static PyObject *
6572 : 1088 : socket_getaddrinfo(PyObject *self, PyObject *args, PyObject* kwargs)
6573 : : {
6574 : : static char* kwnames[] = {"host", "port", "family", "type", "proto",
6575 : : "flags", 0};
6576 : : struct addrinfo hints, *res;
6577 : 1088 : struct addrinfo *res0 = NULL;
6578 : 1088 : PyObject *hobj = NULL;
6579 : 1088 : PyObject *pobj = (PyObject *)NULL;
6580 : : char pbuf[30];
6581 : : const char *hptr, *pptr;
6582 : : int family, socktype, protocol, flags;
6583 : : int error;
6584 : 1088 : PyObject *all = (PyObject *)NULL;
6585 : 1088 : PyObject *idna = NULL;
6586 : :
6587 : 1088 : socktype = protocol = flags = 0;
6588 : 1088 : family = AF_UNSPEC;
6589 [ - + ]: 1088 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iiii:getaddrinfo",
6590 : : kwnames, &hobj, &pobj, &family, &socktype,
6591 : : &protocol, &flags)) {
6592 : 0 : return NULL;
6593 : : }
6594 [ + + ]: 1088 : if (hobj == Py_None) {
6595 : 9 : hptr = NULL;
6596 [ + - ]: 1079 : } else if (PyUnicode_Check(hobj)) {
6597 : 1079 : idna = PyUnicode_AsEncodedString(hobj, "idna", NULL);
6598 [ - + ]: 1079 : if (!idna)
6599 : 0 : return NULL;
6600 : : assert(PyBytes_Check(idna));
6601 : 1079 : hptr = PyBytes_AS_STRING(idna);
6602 [ # # ]: 0 : } else if (PyBytes_Check(hobj)) {
6603 : 0 : hptr = PyBytes_AsString(hobj);
6604 : : } else {
6605 : 0 : PyErr_SetString(PyExc_TypeError,
6606 : : "getaddrinfo() argument 1 must be string or None");
6607 : 0 : return NULL;
6608 : : }
6609 [ + + ]: 1088 : if (PyLong_CheckExact(pobj)) {
6610 : 1065 : long value = PyLong_AsLong(pobj);
6611 [ - + - - ]: 1065 : if (value == -1 && PyErr_Occurred())
6612 : 0 : goto err;
6613 : 1065 : PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
6614 : 1065 : pptr = pbuf;
6615 [ + + ]: 23 : } else if (PyUnicode_Check(pobj)) {
6616 : 5 : pptr = PyUnicode_AsUTF8(pobj);
6617 [ + + ]: 5 : if (pptr == NULL)
6618 : 1 : goto err;
6619 [ + + ]: 18 : } else if (PyBytes_Check(pobj)) {
6620 : 2 : pptr = PyBytes_AS_STRING(pobj);
6621 [ + - ]: 16 : } else if (pobj == Py_None) {
6622 : 16 : pptr = (char *)NULL;
6623 : : } else {
6624 : 0 : PyErr_SetString(PyExc_OSError, "Int or String expected");
6625 : 0 : goto err;
6626 : : }
6627 : : #if defined(__APPLE__) && defined(AI_NUMERICSERV)
6628 : : if ((flags & AI_NUMERICSERV) && (pptr == NULL || (pptr[0] == '0' && pptr[1] == 0))) {
6629 : : /* On OSX up to at least OSX 10.8 getaddrinfo crashes
6630 : : * if AI_NUMERICSERV is set and the servname is NULL or "0".
6631 : : * This workaround avoids a segfault in libsystem.
6632 : : */
6633 : : pptr = "00";
6634 : : }
6635 : : #endif
6636 : :
6637 [ - + ]: 1087 : if (PySys_Audit("socket.getaddrinfo", "OOiii",
6638 : : hobj, pobj, family, socktype, protocol) < 0) {
6639 : 0 : return NULL;
6640 : : }
6641 : :
6642 : 1087 : memset(&hints, 0, sizeof(hints));
6643 : 1087 : hints.ai_family = family;
6644 : 1087 : hints.ai_socktype = socktype;
6645 : 1087 : hints.ai_protocol = protocol;
6646 : 1087 : hints.ai_flags = flags;
6647 : 1087 : Py_BEGIN_ALLOW_THREADS
6648 : 1087 : error = getaddrinfo(hptr, pptr, &hints, &res0);
6649 : 1087 : Py_END_ALLOW_THREADS
6650 [ + + ]: 1087 : if (error) {
6651 : 4 : set_gaierror(error);
6652 : 4 : goto err;
6653 : : }
6654 : :
6655 : 1083 : all = PyList_New(0);
6656 [ - + ]: 1083 : if (all == NULL)
6657 : 0 : goto err;
6658 [ + + ]: 2597 : for (res = res0; res; res = res->ai_next) {
6659 : : PyObject *single;
6660 : : PyObject *addr =
6661 : 1514 : makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
6662 [ - + ]: 1514 : if (addr == NULL)
6663 : 0 : goto err;
6664 : 1514 : single = Py_BuildValue("iiisO", res->ai_family,
6665 : : res->ai_socktype, res->ai_protocol,
6666 [ - + ]: 1514 : res->ai_canonname ? res->ai_canonname : "",
6667 : : addr);
6668 : 1514 : Py_DECREF(addr);
6669 [ - + ]: 1514 : if (single == NULL)
6670 : 0 : goto err;
6671 : :
6672 [ - + ]: 1514 : if (PyList_Append(all, single)) {
6673 : 0 : Py_DECREF(single);
6674 : 0 : goto err;
6675 : : }
6676 : 1514 : Py_DECREF(single);
6677 : : }
6678 : 1083 : Py_XDECREF(idna);
6679 [ + - ]: 1083 : if (res0)
6680 : 1083 : freeaddrinfo(res0);
6681 : 1083 : return all;
6682 : 5 : err:
6683 : 5 : Py_XDECREF(all);
6684 : 5 : Py_XDECREF(idna);
6685 [ - + ]: 5 : if (res0)
6686 : 0 : freeaddrinfo(res0);
6687 : 5 : return (PyObject *)NULL;
6688 : : }
6689 : :
6690 : : PyDoc_STRVAR(getaddrinfo_doc,
6691 : : "getaddrinfo(host, port [, family, type, proto, flags])\n\
6692 : : -> list of (family, type, proto, canonname, sockaddr)\n\
6693 : : \n\
6694 : : Resolve host and port into addrinfo struct.");
6695 : :
6696 : : /* Python interface to getnameinfo(sa, flags). */
6697 : :
6698 : : /*ARGSUSED*/
6699 : : static PyObject *
6700 : 11 : socket_getnameinfo(PyObject *self, PyObject *args)
6701 : : {
6702 : 11 : PyObject *sa = (PyObject *)NULL;
6703 : : int flags;
6704 : : const char *hostp;
6705 : : int port;
6706 : : unsigned int flowinfo, scope_id;
6707 : : char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
6708 : 11 : struct addrinfo hints, *res = NULL;
6709 : : int error;
6710 : 11 : PyObject *ret = (PyObject *)NULL;
6711 : : PyObject *name;
6712 : :
6713 : 11 : flags = flowinfo = scope_id = 0;
6714 [ - + ]: 11 : if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
6715 : 0 : return NULL;
6716 [ + + ]: 11 : if (!PyTuple_Check(sa)) {
6717 : 1 : PyErr_SetString(PyExc_TypeError,
6718 : : "getnameinfo() argument 1 must be a tuple");
6719 : 1 : return NULL;
6720 : : }
6721 [ - + ]: 10 : if (!PyArg_ParseTuple(sa, "si|II;getnameinfo(): illegal sockaddr argument",
6722 : : &hostp, &port, &flowinfo, &scope_id))
6723 : : {
6724 : 0 : return NULL;
6725 : : }
6726 [ + + ]: 10 : if (flowinfo > 0xfffff) {
6727 : 1 : PyErr_SetString(PyExc_OverflowError,
6728 : : "getnameinfo(): flowinfo must be 0-1048575.");
6729 : 1 : return NULL;
6730 : : }
6731 : :
6732 [ - + ]: 9 : if (PySys_Audit("socket.getnameinfo", "(O)", sa) < 0) {
6733 : 0 : return NULL;
6734 : : }
6735 : :
6736 : 9 : PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
6737 : 9 : memset(&hints, 0, sizeof(hints));
6738 : 9 : hints.ai_family = AF_UNSPEC;
6739 : 9 : hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
6740 : 9 : hints.ai_flags = AI_NUMERICHOST; /* don't do any name resolution */
6741 : 9 : Py_BEGIN_ALLOW_THREADS
6742 : 9 : error = getaddrinfo(hostp, pbuf, &hints, &res);
6743 : 9 : Py_END_ALLOW_THREADS
6744 [ + + ]: 9 : if (error) {
6745 : 2 : set_gaierror(error);
6746 : 2 : goto fail;
6747 : : }
6748 [ - + ]: 7 : if (res->ai_next) {
6749 : 0 : PyErr_SetString(PyExc_OSError,
6750 : : "sockaddr resolved to multiple addresses");
6751 : 0 : goto fail;
6752 : : }
6753 [ + + - ]: 7 : switch (res->ai_family) {
6754 : 3 : case AF_INET:
6755 : : {
6756 [ - + ]: 3 : if (PyTuple_GET_SIZE(sa) != 2) {
6757 : 0 : PyErr_SetString(PyExc_OSError,
6758 : : "IPv4 sockaddr must be 2 tuple");
6759 : 0 : goto fail;
6760 : : }
6761 : 3 : break;
6762 : : }
6763 : : #ifdef ENABLE_IPV6
6764 : 4 : case AF_INET6:
6765 : : {
6766 : : struct sockaddr_in6 *sin6;
6767 : 4 : sin6 = (struct sockaddr_in6 *)res->ai_addr;
6768 : 4 : sin6->sin6_flowinfo = htonl(flowinfo);
6769 : 4 : sin6->sin6_scope_id = scope_id;
6770 : 4 : break;
6771 : : }
6772 : : #endif
6773 : : }
6774 : 7 : error = getnameinfo(res->ai_addr, (socklen_t) res->ai_addrlen,
6775 : : hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
6776 [ - + ]: 7 : if (error) {
6777 : 0 : set_gaierror(error);
6778 : 0 : goto fail;
6779 : : }
6780 : :
6781 : 7 : name = sock_decode_hostname(hbuf);
6782 [ - + ]: 7 : if (name == NULL)
6783 : 0 : goto fail;
6784 : 7 : ret = Py_BuildValue("Ns", name, pbuf);
6785 : :
6786 : 9 : fail:
6787 [ + + ]: 9 : if (res)
6788 : 7 : freeaddrinfo(res);
6789 : 9 : return ret;
6790 : : }
6791 : :
6792 : : PyDoc_STRVAR(getnameinfo_doc,
6793 : : "getnameinfo(sockaddr, flags) --> (host, port)\n\
6794 : : \n\
6795 : : Get host and port for a sockaddr.");
6796 : :
6797 : :
6798 : : /* Python API to getting and setting the default timeout value. */
6799 : :
6800 : : static PyObject *
6801 : 3094 : socket_getdefaulttimeout(PyObject *self, PyObject *Py_UNUSED(ignored))
6802 : : {
6803 [ + + ]: 3094 : if (defaulttimeout < 0) {
6804 : 3082 : Py_RETURN_NONE;
6805 : : }
6806 : : else {
6807 : 12 : double seconds = _PyTime_AsSecondsDouble(defaulttimeout);
6808 : 12 : return PyFloat_FromDouble(seconds);
6809 : : }
6810 : : }
6811 : :
6812 : : PyDoc_STRVAR(getdefaulttimeout_doc,
6813 : : "getdefaulttimeout() -> timeout\n\
6814 : : \n\
6815 : : Returns the default timeout in seconds (float) for new socket objects.\n\
6816 : : A value of None indicates that new socket objects have no timeout.\n\
6817 : : When the socket module is first imported, the default is None.");
6818 : :
6819 : : static PyObject *
6820 : 212 : socket_setdefaulttimeout(PyObject *self, PyObject *arg)
6821 : : {
6822 : : _PyTime_t timeout;
6823 : :
6824 [ + + ]: 212 : if (socket_parse_timeout(&timeout, arg) < 0)
6825 : 2 : return NULL;
6826 : :
6827 : 210 : defaulttimeout = timeout;
6828 : :
6829 : 210 : Py_RETURN_NONE;
6830 : : }
6831 : :
6832 : : PyDoc_STRVAR(setdefaulttimeout_doc,
6833 : : "setdefaulttimeout(timeout)\n\
6834 : : \n\
6835 : : Set the default timeout in seconds (float) for new socket objects.\n\
6836 : : A value of None indicates that new socket objects have no timeout.\n\
6837 : : When the socket module is first imported, the default is None.");
6838 : :
6839 : : #if defined(HAVE_IF_NAMEINDEX) || defined(MS_WINDOWS)
6840 : : /* Python API for getting interface indices and names */
6841 : :
6842 : : static PyObject *
6843 : 3 : socket_if_nameindex(PyObject *self, PyObject *arg)
6844 : : {
6845 : 3 : PyObject *list = PyList_New(0);
6846 [ - + ]: 3 : if (list == NULL) {
6847 : 0 : return NULL;
6848 : : }
6849 : : #ifdef MS_WINDOWS
6850 : : PMIB_IF_TABLE2 tbl;
6851 : : int ret;
6852 : : if ((ret = GetIfTable2Ex(MibIfTableRaw, &tbl)) != NO_ERROR) {
6853 : : Py_DECREF(list);
6854 : : // ret is used instead of GetLastError()
6855 : : return PyErr_SetFromWindowsErr(ret);
6856 : : }
6857 : : for (ULONG i = 0; i < tbl->NumEntries; ++i) {
6858 : : MIB_IF_ROW2 r = tbl->Table[i];
6859 : : WCHAR buf[NDIS_IF_MAX_STRING_SIZE + 1];
6860 : : if ((ret = ConvertInterfaceLuidToNameW(&r.InterfaceLuid, buf,
6861 : : Py_ARRAY_LENGTH(buf)))) {
6862 : : Py_DECREF(list);
6863 : : FreeMibTable(tbl);
6864 : : // ret is used instead of GetLastError()
6865 : : return PyErr_SetFromWindowsErr(ret);
6866 : : }
6867 : : PyObject *tuple = Py_BuildValue("Iu", r.InterfaceIndex, buf);
6868 : : if (tuple == NULL || PyList_Append(list, tuple) == -1) {
6869 : : Py_XDECREF(tuple);
6870 : : Py_DECREF(list);
6871 : : FreeMibTable(tbl);
6872 : : return NULL;
6873 : : }
6874 : : Py_DECREF(tuple);
6875 : : }
6876 : : FreeMibTable(tbl);
6877 : : return list;
6878 : : #else
6879 : : int i;
6880 : : struct if_nameindex *ni;
6881 : :
6882 : 3 : ni = if_nameindex();
6883 [ - + ]: 3 : if (ni == NULL) {
6884 : 0 : Py_DECREF(list);
6885 : 0 : PyErr_SetFromErrno(PyExc_OSError);
6886 : 0 : return NULL;
6887 : : }
6888 : :
6889 : : #ifdef _Py_MEMORY_SANITIZER
6890 : : __msan_unpoison(ni, sizeof(ni));
6891 : : __msan_unpoison(&ni[0], sizeof(ni[0]));
6892 : : #endif
6893 [ + + + - ]: 21 : for (i = 0; ni[i].if_index != 0 && i < INT_MAX; i++) {
6894 : : #ifdef _Py_MEMORY_SANITIZER
6895 : : /* This one isn't the end sentinel, the next one must exist. */
6896 : : __msan_unpoison(&ni[i+1], sizeof(ni[0]));
6897 : : /* Otherwise Py_BuildValue internals are flagged by MSan when
6898 : : they access the not-msan-tracked if_name string data. */
6899 : : {
6900 : : char *to_sanitize = ni[i].if_name;
6901 : : do {
6902 : : __msan_unpoison(to_sanitize, 1);
6903 : : } while (*to_sanitize++ != '\0');
6904 : : }
6905 : : #endif
6906 : 18 : PyObject *ni_tuple = Py_BuildValue("IO&",
6907 : 18 : ni[i].if_index, PyUnicode_DecodeFSDefault, ni[i].if_name);
6908 : :
6909 [ + - - + ]: 18 : if (ni_tuple == NULL || PyList_Append(list, ni_tuple) == -1) {
6910 : 0 : Py_XDECREF(ni_tuple);
6911 : 0 : Py_DECREF(list);
6912 : 0 : if_freenameindex(ni);
6913 : 0 : return NULL;
6914 : : }
6915 : 18 : Py_DECREF(ni_tuple);
6916 : : }
6917 : :
6918 : 3 : if_freenameindex(ni);
6919 : 3 : return list;
6920 : : #endif
6921 : : }
6922 : :
6923 : : PyDoc_STRVAR(if_nameindex_doc,
6924 : : "if_nameindex()\n\
6925 : : \n\
6926 : : Returns a list of network interface information (index, name) tuples.");
6927 : :
6928 : : static PyObject *
6929 : 8 : socket_if_nametoindex(PyObject *self, PyObject *args)
6930 : : {
6931 : : PyObject *oname;
6932 : : #ifdef MS_WINDOWS
6933 : : NET_IFINDEX index;
6934 : : #else
6935 : : unsigned long index;
6936 : : #endif
6937 [ + + ]: 8 : if (!PyArg_ParseTuple(args, "O&:if_nametoindex",
6938 : : PyUnicode_FSConverter, &oname))
6939 : 1 : return NULL;
6940 : :
6941 : 7 : index = if_nametoindex(PyBytes_AS_STRING(oname));
6942 : 7 : Py_DECREF(oname);
6943 [ + + ]: 7 : if (index == 0) {
6944 : : /* if_nametoindex() doesn't set errno */
6945 : 1 : PyErr_SetString(PyExc_OSError, "no interface with this name");
6946 : 1 : return NULL;
6947 : : }
6948 : :
6949 : 6 : return PyLong_FromUnsignedLong(index);
6950 : : }
6951 : :
6952 : : PyDoc_STRVAR(if_nametoindex_doc,
6953 : : "if_nametoindex(if_name)\n\
6954 : : \n\
6955 : : Returns the interface index corresponding to the interface name if_name.");
6956 : :
6957 : : static PyObject *
6958 : 8 : socket_if_indextoname(PyObject *self, PyObject *arg)
6959 : : {
6960 : : #ifdef MS_WINDOWS
6961 : : NET_IFINDEX index;
6962 : : #else
6963 : : unsigned long index;
6964 : : #endif
6965 : : char name[IF_NAMESIZE + 1];
6966 : :
6967 : 8 : index = PyLong_AsUnsignedLong(arg);
6968 [ + + ]: 8 : if (index == (unsigned long) -1)
6969 : 1 : return NULL;
6970 : :
6971 [ + + ]: 7 : if (if_indextoname(index, name) == NULL) {
6972 : 1 : PyErr_SetFromErrno(PyExc_OSError);
6973 : 1 : return NULL;
6974 : : }
6975 : :
6976 : 6 : return PyUnicode_DecodeFSDefault(name);
6977 : : }
6978 : :
6979 : : PyDoc_STRVAR(if_indextoname_doc,
6980 : : "if_indextoname(if_index)\n\
6981 : : \n\
6982 : : Returns the interface name corresponding to the interface index if_index.");
6983 : :
6984 : : #endif // defined(HAVE_IF_NAMEINDEX) || defined(MS_WINDOWS)
6985 : :
6986 : :
6987 : : #ifdef CMSG_LEN
6988 : : /* Python interface to CMSG_LEN(length). */
6989 : :
6990 : : static PyObject *
6991 : 2092 : socket_CMSG_LEN(PyObject *self, PyObject *args)
6992 : : {
6993 : : Py_ssize_t length;
6994 : : size_t result;
6995 : :
6996 [ - + ]: 2092 : if (!PyArg_ParseTuple(args, "n:CMSG_LEN", &length))
6997 : 0 : return NULL;
6998 [ + + + + ]: 2092 : if (length < 0 || !get_CMSG_LEN(length, &result)) {
6999 : 3 : PyErr_Format(PyExc_OverflowError, "CMSG_LEN() argument out of range");
7000 : 3 : return NULL;
7001 : : }
7002 : 2089 : return PyLong_FromSize_t(result);
7003 : : }
7004 : :
7005 : : PyDoc_STRVAR(CMSG_LEN_doc,
7006 : : "CMSG_LEN(length) -> control message length\n\
7007 : : \n\
7008 : : Return the total length, without trailing padding, of an ancillary\n\
7009 : : data item with associated data of the given length. This value can\n\
7010 : : often be used as the buffer size for recvmsg() to receive a single\n\
7011 : : item of ancillary data, but RFC 3542 requires portable applications to\n\
7012 : : use CMSG_SPACE() and thus include space for padding, even when the\n\
7013 : : item will be the last in the buffer. Raises OverflowError if length\n\
7014 : : is outside the permissible range of values.");
7015 : :
7016 : :
7017 : : #ifdef CMSG_SPACE
7018 : : /* Python interface to CMSG_SPACE(length). */
7019 : :
7020 : : static PyObject *
7021 : 1029 : socket_CMSG_SPACE(PyObject *self, PyObject *args)
7022 : : {
7023 : : Py_ssize_t length;
7024 : : size_t result;
7025 : :
7026 [ - + ]: 1029 : if (!PyArg_ParseTuple(args, "n:CMSG_SPACE", &length))
7027 : 0 : return NULL;
7028 [ + + + + ]: 1029 : if (length < 0 || !get_CMSG_SPACE(length, &result)) {
7029 : 3 : PyErr_SetString(PyExc_OverflowError,
7030 : : "CMSG_SPACE() argument out of range");
7031 : 3 : return NULL;
7032 : : }
7033 : 1026 : return PyLong_FromSize_t(result);
7034 : : }
7035 : :
7036 : : PyDoc_STRVAR(CMSG_SPACE_doc,
7037 : : "CMSG_SPACE(length) -> buffer size\n\
7038 : : \n\
7039 : : Return the buffer size needed for recvmsg() to receive an ancillary\n\
7040 : : data item with associated data of the given length, along with any\n\
7041 : : trailing padding. The buffer space needed to receive multiple items\n\
7042 : : is the sum of the CMSG_SPACE() values for their associated data\n\
7043 : : lengths. Raises OverflowError if length is outside the permissible\n\
7044 : : range of values.");
7045 : : #endif /* CMSG_SPACE */
7046 : : #endif /* CMSG_LEN */
7047 : :
7048 : :
7049 : : /* List of functions exported by this module. */
7050 : :
7051 : : static PyMethodDef socket_methods[] = {
7052 : : {"gethostbyname", socket_gethostbyname,
7053 : : METH_VARARGS, gethostbyname_doc},
7054 : : {"gethostbyname_ex", socket_gethostbyname_ex,
7055 : : METH_VARARGS, ghbn_ex_doc},
7056 : : {"gethostbyaddr", socket_gethostbyaddr,
7057 : : METH_VARARGS, gethostbyaddr_doc},
7058 : : {"gethostname", socket_gethostname,
7059 : : METH_NOARGS, gethostname_doc},
7060 : : #ifdef HAVE_SETHOSTNAME
7061 : : {"sethostname", socket_sethostname,
7062 : : METH_VARARGS, sethostname_doc},
7063 : : #endif
7064 : : {"getservbyname", socket_getservbyname,
7065 : : METH_VARARGS, getservbyname_doc},
7066 : : {"getservbyport", socket_getservbyport,
7067 : : METH_VARARGS, getservbyport_doc},
7068 : : {"getprotobyname", socket_getprotobyname,
7069 : : METH_VARARGS, getprotobyname_doc},
7070 : : {"close", socket_close,
7071 : : METH_O, close_doc},
7072 : : #ifndef NO_DUP
7073 : : {"dup", socket_dup,
7074 : : METH_O, dup_doc},
7075 : : #endif
7076 : : #ifdef HAVE_SOCKETPAIR
7077 : : {"socketpair", socket_socketpair,
7078 : : METH_VARARGS, socketpair_doc},
7079 : : #endif
7080 : : {"ntohs", socket_ntohs,
7081 : : METH_VARARGS, ntohs_doc},
7082 : : {"ntohl", socket_ntohl,
7083 : : METH_O, ntohl_doc},
7084 : : {"htons", socket_htons,
7085 : : METH_VARARGS, htons_doc},
7086 : : {"htonl", socket_htonl,
7087 : : METH_O, htonl_doc},
7088 : : {"inet_aton", socket_inet_aton,
7089 : : METH_VARARGS, inet_aton_doc},
7090 : : {"inet_ntoa", socket_inet_ntoa,
7091 : : METH_VARARGS, inet_ntoa_doc},
7092 : : #ifdef HAVE_INET_PTON
7093 : : {"inet_pton", socket_inet_pton,
7094 : : METH_VARARGS, inet_pton_doc},
7095 : : {"inet_ntop", socket_inet_ntop,
7096 : : METH_VARARGS, inet_ntop_doc},
7097 : : #endif
7098 : : {"getaddrinfo", _PyCFunction_CAST(socket_getaddrinfo),
7099 : : METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
7100 : : {"getnameinfo", socket_getnameinfo,
7101 : : METH_VARARGS, getnameinfo_doc},
7102 : : {"getdefaulttimeout", socket_getdefaulttimeout,
7103 : : METH_NOARGS, getdefaulttimeout_doc},
7104 : : {"setdefaulttimeout", socket_setdefaulttimeout,
7105 : : METH_O, setdefaulttimeout_doc},
7106 : : #if defined(HAVE_IF_NAMEINDEX) || defined(MS_WINDOWS)
7107 : : {"if_nameindex", socket_if_nameindex,
7108 : : METH_NOARGS, if_nameindex_doc},
7109 : : {"if_nametoindex", socket_if_nametoindex,
7110 : : METH_VARARGS, if_nametoindex_doc},
7111 : : {"if_indextoname", socket_if_indextoname,
7112 : : METH_O, if_indextoname_doc},
7113 : : #endif
7114 : : #ifdef CMSG_LEN
7115 : : {"CMSG_LEN", socket_CMSG_LEN,
7116 : : METH_VARARGS, CMSG_LEN_doc},
7117 : : #ifdef CMSG_SPACE
7118 : : {"CMSG_SPACE", socket_CMSG_SPACE,
7119 : : METH_VARARGS, CMSG_SPACE_doc},
7120 : : #endif
7121 : : #endif
7122 : : {NULL, NULL} /* Sentinel */
7123 : : };
7124 : :
7125 : :
7126 : : #ifdef MS_WINDOWS
7127 : : #define OS_INIT_DEFINED
7128 : :
7129 : : /* Additional initialization and cleanup for Windows */
7130 : :
7131 : : static void
7132 : : os_cleanup(void)
7133 : : {
7134 : : WSACleanup();
7135 : : }
7136 : :
7137 : : static int
7138 : : os_init(void)
7139 : : {
7140 : : WSADATA WSAData;
7141 : : int ret;
7142 : : ret = WSAStartup(0x0101, &WSAData);
7143 : : switch (ret) {
7144 : : case 0: /* No error */
7145 : : Py_AtExit(os_cleanup);
7146 : : return 1; /* Success */
7147 : : case WSASYSNOTREADY:
7148 : : PyErr_SetString(PyExc_ImportError,
7149 : : "WSAStartup failed: network not ready");
7150 : : break;
7151 : : case WSAVERNOTSUPPORTED:
7152 : : case WSAEINVAL:
7153 : : PyErr_SetString(
7154 : : PyExc_ImportError,
7155 : : "WSAStartup failed: requested version not supported");
7156 : : break;
7157 : : default:
7158 : : PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
7159 : : break;
7160 : : }
7161 : : return 0; /* Failure */
7162 : : }
7163 : :
7164 : : #endif /* MS_WINDOWS */
7165 : :
7166 : :
7167 : :
7168 : : #ifndef OS_INIT_DEFINED
7169 : : static int
7170 : 781 : os_init(void)
7171 : : {
7172 : 781 : return 1; /* Success */
7173 : : }
7174 : : #endif
7175 : :
7176 : : static void
7177 : 751 : sock_free_api(PySocketModule_APIObject *capi)
7178 : : {
7179 : 751 : Py_DECREF(capi->Sock_Type);
7180 : 751 : Py_DECREF(capi->error);
7181 : 751 : Py_DECREF(capi->timeout_error);
7182 : 751 : PyMem_Free(capi);
7183 : 751 : }
7184 : :
7185 : : static void
7186 : 751 : sock_destroy_api(PyObject *capsule)
7187 : : {
7188 : 751 : void *capi = PyCapsule_GetPointer(capsule, PySocket_CAPSULE_NAME);
7189 : 751 : sock_free_api(capi);
7190 : 751 : }
7191 : :
7192 : : static PySocketModule_APIObject *
7193 : 781 : sock_get_api(void)
7194 : : {
7195 : 781 : PySocketModule_APIObject *capi = PyMem_Malloc(sizeof(PySocketModule_APIObject));
7196 [ - + ]: 781 : if (capi == NULL) {
7197 : : PyErr_NoMemory();
7198 : 0 : return NULL;
7199 : : }
7200 : :
7201 : 781 : capi->Sock_Type = (PyTypeObject *)Py_NewRef(&sock_type);
7202 : 781 : capi->error = Py_NewRef(PyExc_OSError);
7203 : 781 : capi->timeout_error = Py_NewRef(PyExc_TimeoutError);
7204 : 781 : return capi;
7205 : : }
7206 : :
7207 : :
7208 : : /* Initialize the _socket module.
7209 : :
7210 : : This module is actually called "_socket", and there's a wrapper
7211 : : "socket.py" which implements some additional functionality.
7212 : : The import of "_socket" may fail with an ImportError exception if
7213 : : os-specific initialization fails. On Windows, this does WINSOCK
7214 : : initialization. When WINSOCK is initialized successfully, a call to
7215 : : WSACleanup() is scheduled to be made at exit time.
7216 : : */
7217 : :
7218 : : PyDoc_STRVAR(socket_doc,
7219 : : "Implementation module for socket operations.\n\
7220 : : \n\
7221 : : See the socket module for documentation.");
7222 : :
7223 : : static struct PyModuleDef socketmodule = {
7224 : : PyModuleDef_HEAD_INIT,
7225 : : PySocket_MODULE_NAME,
7226 : : socket_doc,
7227 : : -1,
7228 : : socket_methods,
7229 : : NULL,
7230 : : NULL,
7231 : : NULL,
7232 : : NULL
7233 : : };
7234 : :
7235 : : PyMODINIT_FUNC
7236 : 781 : PyInit__socket(void)
7237 : : {
7238 : : PyObject *m, *has_ipv6;
7239 : :
7240 [ - + ]: 781 : if (!os_init())
7241 : 0 : return NULL;
7242 : :
7243 : : #ifdef MS_WINDOWS
7244 : : if (support_wsa_no_inherit == -1) {
7245 : : support_wsa_no_inherit = IsWindows7SP1OrGreater();
7246 : : }
7247 : : #endif
7248 : :
7249 : 781 : Py_SET_TYPE(&sock_type, &PyType_Type);
7250 : 781 : m = PyModule_Create(&socketmodule);
7251 [ - + ]: 781 : if (m == NULL)
7252 : 0 : return NULL;
7253 : :
7254 : 781 : Py_INCREF(PyExc_OSError);
7255 : 781 : PyModule_AddObject(m, "error", PyExc_OSError);
7256 : 781 : socket_herror = PyErr_NewException("socket.herror",
7257 : : PyExc_OSError, NULL);
7258 [ - + ]: 781 : if (socket_herror == NULL)
7259 : 0 : return NULL;
7260 : 781 : Py_INCREF(socket_herror);
7261 : 781 : PyModule_AddObject(m, "herror", socket_herror);
7262 : 781 : socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
7263 : : NULL);
7264 [ - + ]: 781 : if (socket_gaierror == NULL)
7265 : 0 : return NULL;
7266 : 781 : Py_INCREF(socket_gaierror);
7267 : 781 : PyModule_AddObject(m, "gaierror", socket_gaierror);
7268 : 781 : PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError);
7269 : :
7270 : 781 : Py_INCREF((PyObject *)&sock_type);
7271 [ - + ]: 781 : if (PyModule_AddObject(m, "SocketType",
7272 : : (PyObject *)&sock_type) != 0)
7273 : 0 : return NULL;
7274 : 781 : Py_INCREF((PyObject *)&sock_type);
7275 [ - + ]: 781 : if (PyModule_AddObject(m, "socket",
7276 : : (PyObject *)&sock_type) != 0)
7277 : 0 : return NULL;
7278 : :
7279 : : #ifdef ENABLE_IPV6
7280 : 781 : has_ipv6 = Py_True;
7281 : : #else
7282 : : has_ipv6 = Py_False;
7283 : : #endif
7284 : 781 : Py_INCREF(has_ipv6);
7285 : 781 : PyModule_AddObject(m, "has_ipv6", has_ipv6);
7286 : :
7287 : : /* Export C API */
7288 : 781 : PySocketModule_APIObject *capi = sock_get_api();
7289 [ - + ]: 781 : if (capi == NULL) {
7290 : 0 : Py_DECREF(m);
7291 : 0 : return NULL;
7292 : : }
7293 : 781 : PyObject *capsule = PyCapsule_New(capi,
7294 : : PySocket_CAPSULE_NAME,
7295 : : sock_destroy_api);
7296 [ - + ]: 781 : if (capsule == NULL) {
7297 : 0 : sock_free_api(capi);
7298 : 0 : Py_DECREF(m);
7299 : 0 : return NULL;
7300 : : }
7301 [ - + ]: 781 : if (PyModule_AddObject(m, PySocket_CAPI_NAME, capsule) < 0) {
7302 : 0 : Py_DECREF(capsule);
7303 : 0 : Py_DECREF(m);
7304 : 0 : return NULL;
7305 : : }
7306 : :
7307 : : /* Address families (we only support AF_INET and AF_UNIX) */
7308 : : #ifdef AF_UNSPEC
7309 : 781 : PyModule_AddIntMacro(m, AF_UNSPEC);
7310 : : #endif
7311 : 781 : PyModule_AddIntMacro(m, AF_INET);
7312 : : #if defined(AF_UNIX)
7313 : 781 : PyModule_AddIntMacro(m, AF_UNIX);
7314 : : #endif /* AF_UNIX */
7315 : : #ifdef AF_AX25
7316 : : /* Amateur Radio AX.25 */
7317 : 781 : PyModule_AddIntMacro(m, AF_AX25);
7318 : : #endif
7319 : : #ifdef AF_IPX
7320 : 781 : PyModule_AddIntMacro(m, AF_IPX); /* Novell IPX */
7321 : : #endif
7322 : : #ifdef AF_APPLETALK
7323 : : /* Appletalk DDP */
7324 : 781 : PyModule_AddIntMacro(m, AF_APPLETALK);
7325 : : #endif
7326 : : #ifdef AF_NETROM
7327 : : /* Amateur radio NetROM */
7328 : 781 : PyModule_AddIntMacro(m, AF_NETROM);
7329 : : #endif
7330 : : #ifdef AF_BRIDGE
7331 : : /* Multiprotocol bridge */
7332 : 781 : PyModule_AddIntMacro(m, AF_BRIDGE);
7333 : : #endif
7334 : : #ifdef AF_ATMPVC
7335 : : /* ATM PVCs */
7336 : 781 : PyModule_AddIntMacro(m, AF_ATMPVC);
7337 : : #endif
7338 : : #ifdef AF_AAL5
7339 : : /* Reserved for Werner's ATM */
7340 : : PyModule_AddIntMacro(m, AF_AAL5);
7341 : : #endif
7342 : : #ifdef HAVE_SOCKADDR_ALG
7343 : 781 : PyModule_AddIntMacro(m, AF_ALG); /* Linux crypto */
7344 : : #endif
7345 : : #ifdef AF_X25
7346 : : /* Reserved for X.25 project */
7347 : 781 : PyModule_AddIntMacro(m, AF_X25);
7348 : : #endif
7349 : : #ifdef AF_INET6
7350 : 781 : PyModule_AddIntMacro(m, AF_INET6); /* IP version 6 */
7351 : : #endif
7352 : : #ifdef AF_ROSE
7353 : : /* Amateur Radio X.25 PLP */
7354 : 781 : PyModule_AddIntMacro(m, AF_ROSE);
7355 : : #endif
7356 : : #ifdef AF_DECnet
7357 : : /* Reserved for DECnet project */
7358 : 781 : PyModule_AddIntMacro(m, AF_DECnet);
7359 : : #endif
7360 : : #ifdef AF_NETBEUI
7361 : : /* Reserved for 802.2LLC project */
7362 : 781 : PyModule_AddIntMacro(m, AF_NETBEUI);
7363 : : #endif
7364 : : #ifdef AF_SECURITY
7365 : : /* Security callback pseudo AF */
7366 : 781 : PyModule_AddIntMacro(m, AF_SECURITY);
7367 : : #endif
7368 : : #ifdef AF_KEY
7369 : : /* PF_KEY key management API */
7370 : 781 : PyModule_AddIntMacro(m, AF_KEY);
7371 : : #endif
7372 : : #ifdef AF_NETLINK
7373 : : /* */
7374 : 781 : PyModule_AddIntMacro(m, AF_NETLINK);
7375 : 781 : PyModule_AddIntMacro(m, NETLINK_ROUTE);
7376 : : #ifdef NETLINK_SKIP
7377 : : PyModule_AddIntMacro(m, NETLINK_SKIP);
7378 : : #endif
7379 : : #ifdef NETLINK_W1
7380 : : PyModule_AddIntMacro(m, NETLINK_W1);
7381 : : #endif
7382 : 781 : PyModule_AddIntMacro(m, NETLINK_USERSOCK);
7383 : 781 : PyModule_AddIntMacro(m, NETLINK_FIREWALL);
7384 : : #ifdef NETLINK_TCPDIAG
7385 : : PyModule_AddIntMacro(m, NETLINK_TCPDIAG);
7386 : : #endif
7387 : : #ifdef NETLINK_NFLOG
7388 : 781 : PyModule_AddIntMacro(m, NETLINK_NFLOG);
7389 : : #endif
7390 : : #ifdef NETLINK_XFRM
7391 : 781 : PyModule_AddIntMacro(m, NETLINK_XFRM);
7392 : : #endif
7393 : : #ifdef NETLINK_ARPD
7394 : : PyModule_AddIntMacro(m, NETLINK_ARPD);
7395 : : #endif
7396 : : #ifdef NETLINK_ROUTE6
7397 : : PyModule_AddIntMacro(m, NETLINK_ROUTE6);
7398 : : #endif
7399 : 781 : PyModule_AddIntMacro(m, NETLINK_IP6_FW);
7400 : : #ifdef NETLINK_DNRTMSG
7401 : 781 : PyModule_AddIntMacro(m, NETLINK_DNRTMSG);
7402 : : #endif
7403 : : #ifdef NETLINK_TAPBASE
7404 : : PyModule_AddIntMacro(m, NETLINK_TAPBASE);
7405 : : #endif
7406 : : #ifdef NETLINK_CRYPTO
7407 : 781 : PyModule_AddIntMacro(m, NETLINK_CRYPTO);
7408 : : #endif
7409 : : #endif /* AF_NETLINK */
7410 : :
7411 : : #ifdef AF_QIPCRTR
7412 : : /* Qualcomm IPCROUTER */
7413 : 781 : PyModule_AddIntMacro(m, AF_QIPCRTR);
7414 : : #endif
7415 : :
7416 : : #ifdef AF_VSOCK
7417 : 781 : PyModule_AddIntConstant(m, "AF_VSOCK", AF_VSOCK);
7418 : 781 : PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_SIZE", 0);
7419 : 781 : PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_MIN_SIZE", 1);
7420 : 781 : PyModule_AddIntConstant(m, "SO_VM_SOCKETS_BUFFER_MAX_SIZE", 2);
7421 : 781 : PyModule_AddIntConstant(m, "VMADDR_CID_ANY", 0xffffffff);
7422 : 781 : PyModule_AddIntConstant(m, "VMADDR_PORT_ANY", 0xffffffff);
7423 : 781 : PyModule_AddIntConstant(m, "VMADDR_CID_HOST", 2);
7424 : 781 : PyModule_AddIntConstant(m, "VM_SOCKETS_INVALID_VERSION", 0xffffffff);
7425 : 781 : PyModule_AddIntConstant(m, "IOCTL_VM_SOCKETS_GET_LOCAL_CID", _IO(7, 0xb9));
7426 : : #endif
7427 : :
7428 : : #ifdef AF_ROUTE
7429 : : /* Alias to emulate 4.4BSD */
7430 : 781 : PyModule_AddIntMacro(m, AF_ROUTE);
7431 : : #endif
7432 : : #ifdef AF_LINK
7433 : : PyModule_AddIntMacro(m, AF_LINK);
7434 : : #endif
7435 : : #ifdef AF_ASH
7436 : : /* Ash */
7437 : 781 : PyModule_AddIntMacro(m, AF_ASH);
7438 : : #endif
7439 : : #ifdef AF_ECONET
7440 : : /* Acorn Econet */
7441 : 781 : PyModule_AddIntMacro(m, AF_ECONET);
7442 : : #endif
7443 : : #ifdef AF_ATMSVC
7444 : : /* ATM SVCs */
7445 : 781 : PyModule_AddIntMacro(m, AF_ATMSVC);
7446 : : #endif
7447 : : #ifdef AF_SNA
7448 : : /* Linux SNA Project (nutters!) */
7449 : 781 : PyModule_AddIntMacro(m, AF_SNA);
7450 : : #endif
7451 : : #ifdef AF_IRDA
7452 : : /* IRDA sockets */
7453 : 781 : PyModule_AddIntMacro(m, AF_IRDA);
7454 : : #endif
7455 : : #ifdef AF_PPPOX
7456 : : /* PPPoX sockets */
7457 : 781 : PyModule_AddIntMacro(m, AF_PPPOX);
7458 : : #endif
7459 : : #ifdef AF_WANPIPE
7460 : : /* Wanpipe API Sockets */
7461 : 781 : PyModule_AddIntMacro(m, AF_WANPIPE);
7462 : : #endif
7463 : : #ifdef AF_LLC
7464 : : /* Linux LLC */
7465 : 781 : PyModule_AddIntMacro(m, AF_LLC);
7466 : : #endif
7467 : : #ifdef HAVE_AF_HYPERV
7468 : : /* Hyper-V sockets */
7469 : : PyModule_AddIntMacro(m, AF_HYPERV);
7470 : :
7471 : : /* for proto */
7472 : : PyModule_AddIntMacro(m, HV_PROTOCOL_RAW);
7473 : :
7474 : : /* for setsockopt() */
7475 : : PyModule_AddIntMacro(m, HVSOCKET_CONNECT_TIMEOUT);
7476 : : PyModule_AddIntMacro(m, HVSOCKET_CONNECT_TIMEOUT_MAX);
7477 : : PyModule_AddIntMacro(m, HVSOCKET_CONNECTED_SUSPEND);
7478 : : PyModule_AddIntMacro(m, HVSOCKET_ADDRESS_FLAG_PASSTHRU);
7479 : :
7480 : : /* for bind() or connect() */
7481 : : PyModule_AddStringConstant(m, "HV_GUID_ZERO", "00000000-0000-0000-0000-000000000000");
7482 : : PyModule_AddStringConstant(m, "HV_GUID_WILDCARD", "00000000-0000-0000-0000-000000000000");
7483 : : PyModule_AddStringConstant(m, "HV_GUID_BROADCAST", "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
7484 : : PyModule_AddStringConstant(m, "HV_GUID_CHILDREN", "90DB8B89-0D35-4F79-8CE9-49EA0AC8B7CD");
7485 : : PyModule_AddStringConstant(m, "HV_GUID_LOOPBACK", "E0E16197-DD56-4A10-9195-5EE7A155A838");
7486 : : PyModule_AddStringConstant(m, "HV_GUID_PARENT", "A42E7CDA-D03F-480C-9CC2-A4DE20ABB878");
7487 : : #endif /* HAVE_AF_HYPERV */
7488 : :
7489 : : #ifdef USE_BLUETOOTH
7490 : 781 : PyModule_AddIntMacro(m, AF_BLUETOOTH);
7491 : : #ifdef BTPROTO_L2CAP
7492 : 781 : PyModule_AddIntMacro(m, BTPROTO_L2CAP);
7493 : : #endif /* BTPROTO_L2CAP */
7494 : : #ifdef BTPROTO_HCI
7495 : 781 : PyModule_AddIntMacro(m, BTPROTO_HCI);
7496 : 781 : PyModule_AddIntMacro(m, SOL_HCI);
7497 : : #if !defined(__NetBSD__) && !defined(__DragonFly__)
7498 : 781 : PyModule_AddIntMacro(m, HCI_FILTER);
7499 : : #if !defined(__FreeBSD__)
7500 : 781 : PyModule_AddIntMacro(m, HCI_TIME_STAMP);
7501 : 781 : PyModule_AddIntMacro(m, HCI_DATA_DIR);
7502 : : #endif /* !__FreeBSD__ */
7503 : : #endif /* !__NetBSD__ && !__DragonFly__ */
7504 : : #endif /* BTPROTO_HCI */
7505 : : #ifdef BTPROTO_RFCOMM
7506 : 781 : PyModule_AddIntMacro(m, BTPROTO_RFCOMM);
7507 : : #endif /* BTPROTO_RFCOMM */
7508 : 781 : PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
7509 : 781 : PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
7510 : : #ifdef BTPROTO_SCO
7511 : 781 : PyModule_AddIntMacro(m, BTPROTO_SCO);
7512 : : #endif /* BTPROTO_SCO */
7513 : : #endif /* USE_BLUETOOTH */
7514 : :
7515 : : #ifdef AF_CAN
7516 : : /* Controller Area Network */
7517 : 781 : PyModule_AddIntMacro(m, AF_CAN);
7518 : : #endif
7519 : : #ifdef PF_CAN
7520 : : /* Controller Area Network */
7521 : 781 : PyModule_AddIntMacro(m, PF_CAN);
7522 : : #endif
7523 : :
7524 : : /* Reliable Datagram Sockets */
7525 : : #ifdef AF_RDS
7526 : 781 : PyModule_AddIntMacro(m, AF_RDS);
7527 : : #endif
7528 : : #ifdef PF_RDS
7529 : 781 : PyModule_AddIntMacro(m, PF_RDS);
7530 : : #endif
7531 : :
7532 : : /* Kernel event messages */
7533 : : #ifdef PF_SYSTEM
7534 : : PyModule_AddIntMacro(m, PF_SYSTEM);
7535 : : #endif
7536 : : #ifdef AF_SYSTEM
7537 : : PyModule_AddIntMacro(m, AF_SYSTEM);
7538 : : #endif
7539 : :
7540 : : #ifdef AF_PACKET
7541 : 781 : PyModule_AddIntMacro(m, AF_PACKET);
7542 : : #endif
7543 : : #ifdef PF_PACKET
7544 : 781 : PyModule_AddIntMacro(m, PF_PACKET);
7545 : : #endif
7546 : : #ifdef PACKET_HOST
7547 : 781 : PyModule_AddIntMacro(m, PACKET_HOST);
7548 : : #endif
7549 : : #ifdef PACKET_BROADCAST
7550 : 781 : PyModule_AddIntMacro(m, PACKET_BROADCAST);
7551 : : #endif
7552 : : #ifdef PACKET_MULTICAST
7553 : 781 : PyModule_AddIntMacro(m, PACKET_MULTICAST);
7554 : : #endif
7555 : : #ifdef PACKET_OTHERHOST
7556 : 781 : PyModule_AddIntMacro(m, PACKET_OTHERHOST);
7557 : : #endif
7558 : : #ifdef PACKET_OUTGOING
7559 : 781 : PyModule_AddIntMacro(m, PACKET_OUTGOING);
7560 : : #endif
7561 : : #ifdef PACKET_LOOPBACK
7562 : 781 : PyModule_AddIntMacro(m, PACKET_LOOPBACK);
7563 : : #endif
7564 : : #ifdef PACKET_FASTROUTE
7565 : 781 : PyModule_AddIntMacro(m, PACKET_FASTROUTE);
7566 : : #endif
7567 : :
7568 : : #ifdef HAVE_LINUX_TIPC_H
7569 : 781 : PyModule_AddIntMacro(m, AF_TIPC);
7570 : :
7571 : : /* for addresses */
7572 : 781 : PyModule_AddIntMacro(m, TIPC_ADDR_NAMESEQ);
7573 : 781 : PyModule_AddIntMacro(m, TIPC_ADDR_NAME);
7574 : 781 : PyModule_AddIntMacro(m, TIPC_ADDR_ID);
7575 : :
7576 : 781 : PyModule_AddIntMacro(m, TIPC_ZONE_SCOPE);
7577 : 781 : PyModule_AddIntMacro(m, TIPC_CLUSTER_SCOPE);
7578 : 781 : PyModule_AddIntMacro(m, TIPC_NODE_SCOPE);
7579 : :
7580 : : /* for setsockopt() */
7581 : 781 : PyModule_AddIntMacro(m, SOL_TIPC);
7582 : 781 : PyModule_AddIntMacro(m, TIPC_IMPORTANCE);
7583 : 781 : PyModule_AddIntMacro(m, TIPC_SRC_DROPPABLE);
7584 : 781 : PyModule_AddIntMacro(m, TIPC_DEST_DROPPABLE);
7585 : 781 : PyModule_AddIntMacro(m, TIPC_CONN_TIMEOUT);
7586 : :
7587 : 781 : PyModule_AddIntMacro(m, TIPC_LOW_IMPORTANCE);
7588 : 781 : PyModule_AddIntMacro(m, TIPC_MEDIUM_IMPORTANCE);
7589 : 781 : PyModule_AddIntMacro(m, TIPC_HIGH_IMPORTANCE);
7590 : 781 : PyModule_AddIntMacro(m, TIPC_CRITICAL_IMPORTANCE);
7591 : :
7592 : : /* for subscriptions */
7593 : 781 : PyModule_AddIntMacro(m, TIPC_SUB_PORTS);
7594 : 781 : PyModule_AddIntMacro(m, TIPC_SUB_SERVICE);
7595 : : #ifdef TIPC_SUB_CANCEL
7596 : : /* doesn't seem to be available everywhere */
7597 : 781 : PyModule_AddIntMacro(m, TIPC_SUB_CANCEL);
7598 : : #endif
7599 : 781 : PyModule_AddIntMacro(m, TIPC_WAIT_FOREVER);
7600 : 781 : PyModule_AddIntMacro(m, TIPC_PUBLISHED);
7601 : 781 : PyModule_AddIntMacro(m, TIPC_WITHDRAWN);
7602 : 781 : PyModule_AddIntMacro(m, TIPC_SUBSCR_TIMEOUT);
7603 : 781 : PyModule_AddIntMacro(m, TIPC_CFG_SRV);
7604 : 781 : PyModule_AddIntMacro(m, TIPC_TOP_SRV);
7605 : : #endif
7606 : :
7607 : : #ifdef HAVE_SOCKADDR_ALG
7608 : : /* Socket options */
7609 : 781 : PyModule_AddIntMacro(m, ALG_SET_KEY);
7610 : 781 : PyModule_AddIntMacro(m, ALG_SET_IV);
7611 : 781 : PyModule_AddIntMacro(m, ALG_SET_OP);
7612 : 781 : PyModule_AddIntMacro(m, ALG_SET_AEAD_ASSOCLEN);
7613 : 781 : PyModule_AddIntMacro(m, ALG_SET_AEAD_AUTHSIZE);
7614 : 781 : PyModule_AddIntMacro(m, ALG_SET_PUBKEY);
7615 : :
7616 : : /* Operations */
7617 : 781 : PyModule_AddIntMacro(m, ALG_OP_DECRYPT);
7618 : 781 : PyModule_AddIntMacro(m, ALG_OP_ENCRYPT);
7619 : 781 : PyModule_AddIntMacro(m, ALG_OP_SIGN);
7620 : 781 : PyModule_AddIntMacro(m, ALG_OP_VERIFY);
7621 : : #endif
7622 : :
7623 : : /* Socket types */
7624 : 781 : PyModule_AddIntMacro(m, SOCK_STREAM);
7625 : 781 : PyModule_AddIntMacro(m, SOCK_DGRAM);
7626 : : /* We have incomplete socket support. */
7627 : : #ifdef SOCK_RAW
7628 : : /* SOCK_RAW is marked as optional in the POSIX specification */
7629 : 781 : PyModule_AddIntMacro(m, SOCK_RAW);
7630 : : #endif
7631 : 781 : PyModule_AddIntMacro(m, SOCK_SEQPACKET);
7632 : : #if defined(SOCK_RDM)
7633 : 781 : PyModule_AddIntMacro(m, SOCK_RDM);
7634 : : #endif
7635 : : #ifdef SOCK_CLOEXEC
7636 : 781 : PyModule_AddIntMacro(m, SOCK_CLOEXEC);
7637 : : #endif
7638 : : #ifdef SOCK_NONBLOCK
7639 : 781 : PyModule_AddIntMacro(m, SOCK_NONBLOCK);
7640 : : #endif
7641 : :
7642 : : #ifdef SO_DEBUG
7643 : 781 : PyModule_AddIntMacro(m, SO_DEBUG);
7644 : : #endif
7645 : : #ifdef SO_ACCEPTCONN
7646 : 781 : PyModule_AddIntMacro(m, SO_ACCEPTCONN);
7647 : : #endif
7648 : : #ifdef SO_REUSEADDR
7649 : 781 : PyModule_AddIntMacro(m, SO_REUSEADDR);
7650 : : #endif
7651 : : #ifdef SO_EXCLUSIVEADDRUSE
7652 : : PyModule_AddIntMacro(m, SO_EXCLUSIVEADDRUSE);
7653 : : #endif
7654 : : #ifdef SO_INCOMING_CPU
7655 : 781 : PyModule_AddIntMacro(m, SO_INCOMING_CPU);
7656 : : #endif
7657 : :
7658 : : #ifdef SO_KEEPALIVE
7659 : 781 : PyModule_AddIntMacro(m, SO_KEEPALIVE);
7660 : : #endif
7661 : : #ifdef SO_DONTROUTE
7662 : 781 : PyModule_AddIntMacro(m, SO_DONTROUTE);
7663 : : #endif
7664 : : #ifdef SO_BROADCAST
7665 : 781 : PyModule_AddIntMacro(m, SO_BROADCAST);
7666 : : #endif
7667 : : #ifdef SO_USELOOPBACK
7668 : : PyModule_AddIntMacro(m, SO_USELOOPBACK);
7669 : : #endif
7670 : : #ifdef SO_LINGER
7671 : 781 : PyModule_AddIntMacro(m, SO_LINGER);
7672 : : #endif
7673 : : #ifdef SO_OOBINLINE
7674 : 781 : PyModule_AddIntMacro(m, SO_OOBINLINE);
7675 : : #endif
7676 : : #ifndef __GNU__
7677 : : #ifdef SO_REUSEPORT
7678 : 781 : PyModule_AddIntMacro(m, SO_REUSEPORT);
7679 : : #endif
7680 : : #endif
7681 : : #ifdef SO_SNDBUF
7682 : 781 : PyModule_AddIntMacro(m, SO_SNDBUF);
7683 : : #endif
7684 : : #ifdef SO_RCVBUF
7685 : 781 : PyModule_AddIntMacro(m, SO_RCVBUF);
7686 : : #endif
7687 : : #ifdef SO_SNDLOWAT
7688 : 781 : PyModule_AddIntMacro(m, SO_SNDLOWAT);
7689 : : #endif
7690 : : #ifdef SO_RCVLOWAT
7691 : 781 : PyModule_AddIntMacro(m, SO_RCVLOWAT);
7692 : : #endif
7693 : : #ifdef SO_SNDTIMEO
7694 : 781 : PyModule_AddIntMacro(m, SO_SNDTIMEO);
7695 : : #endif
7696 : : #ifdef SO_RCVTIMEO
7697 : 781 : PyModule_AddIntMacro(m, SO_RCVTIMEO);
7698 : : #endif
7699 : : #ifdef SO_ERROR
7700 : 781 : PyModule_AddIntMacro(m, SO_ERROR);
7701 : : #endif
7702 : : #ifdef SO_TYPE
7703 : 781 : PyModule_AddIntMacro(m, SO_TYPE);
7704 : : #endif
7705 : : #ifdef SO_SETFIB
7706 : : PyModule_AddIntMacro(m, SO_SETFIB);
7707 : : #endif
7708 : : #ifdef SO_PASSCRED
7709 : 781 : PyModule_AddIntMacro(m, SO_PASSCRED);
7710 : : #endif
7711 : : #ifdef SO_PEERCRED
7712 : 781 : PyModule_AddIntMacro(m, SO_PEERCRED);
7713 : : #endif
7714 : : #ifdef LOCAL_PEERCRED
7715 : : PyModule_AddIntMacro(m, LOCAL_PEERCRED);
7716 : : #endif
7717 : : #ifdef SO_PASSSEC
7718 : 781 : PyModule_AddIntMacro(m, SO_PASSSEC);
7719 : : #endif
7720 : : #ifdef SO_PEERSEC
7721 : 781 : PyModule_AddIntMacro(m, SO_PEERSEC);
7722 : : #endif
7723 : : #ifdef SO_BINDTODEVICE
7724 : 781 : PyModule_AddIntMacro(m, SO_BINDTODEVICE);
7725 : : #endif
7726 : : #ifdef SO_PRIORITY
7727 : 781 : PyModule_AddIntMacro(m, SO_PRIORITY);
7728 : : #endif
7729 : : #ifdef SO_MARK
7730 : 781 : PyModule_AddIntMacro(m, SO_MARK);
7731 : : #endif
7732 : : #ifdef SO_USER_COOKIE
7733 : : PyModule_AddIntMacro(m, SO_USER_COOKIE);
7734 : : #endif
7735 : : #ifdef SO_RTABLE
7736 : : PyModule_AddIntMacro(m, SO_RTABLE);
7737 : : #endif
7738 : : #ifdef SO_DOMAIN
7739 : 781 : PyModule_AddIntMacro(m, SO_DOMAIN);
7740 : : #endif
7741 : : #ifdef SO_PROTOCOL
7742 : 781 : PyModule_AddIntMacro(m, SO_PROTOCOL);
7743 : : #endif
7744 : : #ifdef LOCAL_CREDS
7745 : : PyModule_AddIntMacro(m, LOCAL_CREDS);
7746 : : #endif
7747 : : #ifdef LOCAL_CREDS_PERSISTENT
7748 : : PyModule_AddIntMacro(m, LOCAL_CREDS_PERSISTENT);
7749 : : #endif
7750 : :
7751 : : /* Maximum number of connections for "listen" */
7752 : : #ifdef SOMAXCONN
7753 : 781 : PyModule_AddIntMacro(m, SOMAXCONN);
7754 : : #else
7755 : : PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
7756 : : #endif
7757 : :
7758 : : /* Ancillary message types */
7759 : : #ifdef SCM_RIGHTS
7760 : 781 : PyModule_AddIntMacro(m, SCM_RIGHTS);
7761 : : #endif
7762 : : #ifdef SCM_CREDENTIALS
7763 : 781 : PyModule_AddIntMacro(m, SCM_CREDENTIALS);
7764 : : #endif
7765 : : #ifdef SCM_CREDS
7766 : : PyModule_AddIntMacro(m, SCM_CREDS);
7767 : : #endif
7768 : : #ifdef SCM_CREDS2
7769 : : PyModule_AddIntMacro(m, SCM_CREDS2);
7770 : : #endif
7771 : :
7772 : : /* Flags for send, recv */
7773 : : #ifdef MSG_OOB
7774 : 781 : PyModule_AddIntMacro(m, MSG_OOB);
7775 : : #endif
7776 : : #ifdef MSG_PEEK
7777 : 781 : PyModule_AddIntMacro(m, MSG_PEEK);
7778 : : #endif
7779 : : #ifdef MSG_DONTROUTE
7780 : 781 : PyModule_AddIntMacro(m, MSG_DONTROUTE);
7781 : : #endif
7782 : : #ifdef MSG_DONTWAIT
7783 : 781 : PyModule_AddIntMacro(m, MSG_DONTWAIT);
7784 : : #endif
7785 : : #ifdef MSG_EOR
7786 : 781 : PyModule_AddIntMacro(m, MSG_EOR);
7787 : : #endif
7788 : : #ifdef MSG_TRUNC
7789 : 781 : PyModule_AddIntMacro(m, MSG_TRUNC);
7790 : : #endif
7791 : : #ifdef MSG_CTRUNC
7792 : 781 : PyModule_AddIntMacro(m, MSG_CTRUNC);
7793 : : #endif
7794 : : #ifdef MSG_WAITALL
7795 : 781 : PyModule_AddIntMacro(m, MSG_WAITALL);
7796 : : #endif
7797 : : #ifdef MSG_BTAG
7798 : : PyModule_AddIntMacro(m, MSG_BTAG);
7799 : : #endif
7800 : : #ifdef MSG_ETAG
7801 : : PyModule_AddIntMacro(m, MSG_ETAG);
7802 : : #endif
7803 : : #ifdef MSG_NOSIGNAL
7804 : 781 : PyModule_AddIntMacro(m, MSG_NOSIGNAL);
7805 : : #endif
7806 : : #ifdef MSG_NOTIFICATION
7807 : : PyModule_AddIntMacro(m, MSG_NOTIFICATION);
7808 : : #endif
7809 : : #ifdef MSG_CMSG_CLOEXEC
7810 : 781 : PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
7811 : : #endif
7812 : : #ifdef MSG_ERRQUEUE
7813 : 781 : PyModule_AddIntMacro(m, MSG_ERRQUEUE);
7814 : : #endif
7815 : : #ifdef MSG_CONFIRM
7816 : 781 : PyModule_AddIntMacro(m, MSG_CONFIRM);
7817 : : #endif
7818 : : #ifdef MSG_MORE
7819 : 781 : PyModule_AddIntMacro(m, MSG_MORE);
7820 : : #endif
7821 : : #ifdef MSG_EOF
7822 : : PyModule_AddIntMacro(m, MSG_EOF);
7823 : : #endif
7824 : : #ifdef MSG_BCAST
7825 : : PyModule_AddIntMacro(m, MSG_BCAST);
7826 : : #endif
7827 : : #ifdef MSG_MCAST
7828 : : PyModule_AddIntMacro(m, MSG_MCAST);
7829 : : #endif
7830 : : #ifdef MSG_FASTOPEN
7831 : 781 : PyModule_AddIntMacro(m, MSG_FASTOPEN);
7832 : : #endif
7833 : :
7834 : : /* Protocol level and numbers, usable for [gs]etsockopt */
7835 : : #ifdef SOL_SOCKET
7836 : 781 : PyModule_AddIntMacro(m, SOL_SOCKET);
7837 : : #endif
7838 : : #ifdef SOL_IP
7839 : 781 : PyModule_AddIntMacro(m, SOL_IP);
7840 : : #else
7841 : : PyModule_AddIntConstant(m, "SOL_IP", 0);
7842 : : #endif
7843 : : #ifdef SOL_IPX
7844 : : PyModule_AddIntMacro(m, SOL_IPX);
7845 : : #endif
7846 : : #ifdef SOL_AX25
7847 : : PyModule_AddIntMacro(m, SOL_AX25);
7848 : : #endif
7849 : : #ifdef SOL_ATALK
7850 : : PyModule_AddIntMacro(m, SOL_ATALK);
7851 : : #endif
7852 : : #ifdef SOL_NETROM
7853 : : PyModule_AddIntMacro(m, SOL_NETROM);
7854 : : #endif
7855 : : #ifdef SOL_ROSE
7856 : : PyModule_AddIntMacro(m, SOL_ROSE);
7857 : : #endif
7858 : : #ifdef SOL_TCP
7859 : 781 : PyModule_AddIntMacro(m, SOL_TCP);
7860 : : #else
7861 : : PyModule_AddIntConstant(m, "SOL_TCP", 6);
7862 : : #endif
7863 : : #ifdef SOL_UDP
7864 : : PyModule_AddIntMacro(m, SOL_UDP);
7865 : : #else
7866 : 781 : PyModule_AddIntConstant(m, "SOL_UDP", 17);
7867 : : #endif
7868 : : #ifdef SOL_CAN_BASE
7869 : 781 : PyModule_AddIntMacro(m, SOL_CAN_BASE);
7870 : : #endif
7871 : : #ifdef SOL_CAN_RAW
7872 : 781 : PyModule_AddIntMacro(m, SOL_CAN_RAW);
7873 : 781 : PyModule_AddIntMacro(m, CAN_RAW);
7874 : : #endif
7875 : : #if defined(HAVE_LINUX_CAN_H) || defined(HAVE_NETCAN_CAN_H)
7876 : 781 : PyModule_AddIntMacro(m, CAN_EFF_FLAG);
7877 : 781 : PyModule_AddIntMacro(m, CAN_RTR_FLAG);
7878 : 781 : PyModule_AddIntMacro(m, CAN_ERR_FLAG);
7879 : :
7880 : 781 : PyModule_AddIntMacro(m, CAN_SFF_MASK);
7881 : 781 : PyModule_AddIntMacro(m, CAN_EFF_MASK);
7882 : 781 : PyModule_AddIntMacro(m, CAN_ERR_MASK);
7883 : : #ifdef CAN_ISOTP
7884 : 781 : PyModule_AddIntMacro(m, CAN_ISOTP);
7885 : : #endif
7886 : : #ifdef CAN_J1939
7887 : 781 : PyModule_AddIntMacro(m, CAN_J1939);
7888 : : #endif
7889 : : #endif
7890 : : #if defined(HAVE_LINUX_CAN_RAW_H) || defined(HAVE_NETCAN_CAN_H)
7891 : 781 : PyModule_AddIntMacro(m, CAN_RAW_FILTER);
7892 : : #ifdef CAN_RAW_ERR_FILTER
7893 : : PyModule_AddIntMacro(m, CAN_RAW_ERR_FILTER);
7894 : : #endif
7895 : 781 : PyModule_AddIntMacro(m, CAN_RAW_LOOPBACK);
7896 : 781 : PyModule_AddIntMacro(m, CAN_RAW_RECV_OWN_MSGS);
7897 : : #endif
7898 : : #ifdef HAVE_LINUX_CAN_RAW_FD_FRAMES
7899 : 781 : PyModule_AddIntMacro(m, CAN_RAW_FD_FRAMES);
7900 : : #endif
7901 : : #ifdef HAVE_LINUX_CAN_RAW_JOIN_FILTERS
7902 : 781 : PyModule_AddIntMacro(m, CAN_RAW_JOIN_FILTERS);
7903 : : #endif
7904 : : #ifdef HAVE_LINUX_CAN_BCM_H
7905 : 781 : PyModule_AddIntMacro(m, CAN_BCM);
7906 : :
7907 : : /* BCM opcodes */
7908 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_SETUP", TX_SETUP);
7909 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_DELETE", TX_DELETE);
7910 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_READ", TX_READ);
7911 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_SEND", TX_SEND);
7912 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_SETUP", RX_SETUP);
7913 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_DELETE", RX_DELETE);
7914 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_READ", RX_READ);
7915 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_STATUS", TX_STATUS);
7916 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_EXPIRED", TX_EXPIRED);
7917 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_STATUS", RX_STATUS);
7918 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_TIMEOUT", RX_TIMEOUT);
7919 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
7920 : :
7921 : : /* BCM flags */
7922 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_SETTIMER", SETTIMER);
7923 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_STARTTIMER", STARTTIMER);
7924 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_COUNTEVT", TX_COUNTEVT);
7925 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_ANNOUNCE", TX_ANNOUNCE);
7926 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_CP_CAN_ID", TX_CP_CAN_ID);
7927 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_FILTER_ID", RX_FILTER_ID);
7928 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_CHECK_DLC", RX_CHECK_DLC);
7929 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_NO_AUTOTIMER", RX_NO_AUTOTIMER);
7930 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_ANNOUNCE_RESUME", RX_ANNOUNCE_RESUME);
7931 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_TX_RESET_MULTI_IDX", TX_RESET_MULTI_IDX);
7932 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_RX_RTR_FRAME", RX_RTR_FRAME);
7933 : : #ifdef CAN_FD_FRAME
7934 : : /* CAN_FD_FRAME was only introduced in the 4.8.x kernel series */
7935 : 781 : PyModule_AddIntConstant(m, "CAN_BCM_CAN_FD_FRAME", CAN_FD_FRAME);
7936 : : #endif
7937 : : #endif
7938 : : #ifdef HAVE_LINUX_CAN_J1939_H
7939 : 781 : PyModule_AddIntMacro(m, J1939_MAX_UNICAST_ADDR);
7940 : 781 : PyModule_AddIntMacro(m, J1939_IDLE_ADDR);
7941 : 781 : PyModule_AddIntMacro(m, J1939_NO_ADDR);
7942 : 781 : PyModule_AddIntMacro(m, J1939_NO_NAME);
7943 : 781 : PyModule_AddIntMacro(m, J1939_PGN_REQUEST);
7944 : 781 : PyModule_AddIntMacro(m, J1939_PGN_ADDRESS_CLAIMED);
7945 : 781 : PyModule_AddIntMacro(m, J1939_PGN_ADDRESS_COMMANDED);
7946 : 781 : PyModule_AddIntMacro(m, J1939_PGN_PDU1_MAX);
7947 : 781 : PyModule_AddIntMacro(m, J1939_PGN_MAX);
7948 : 781 : PyModule_AddIntMacro(m, J1939_NO_PGN);
7949 : :
7950 : : /* J1939 socket options */
7951 : 781 : PyModule_AddIntMacro(m, SO_J1939_FILTER);
7952 : 781 : PyModule_AddIntMacro(m, SO_J1939_PROMISC);
7953 : 781 : PyModule_AddIntMacro(m, SO_J1939_SEND_PRIO);
7954 : 781 : PyModule_AddIntMacro(m, SO_J1939_ERRQUEUE);
7955 : :
7956 : 781 : PyModule_AddIntMacro(m, SCM_J1939_DEST_ADDR);
7957 : 781 : PyModule_AddIntMacro(m, SCM_J1939_DEST_NAME);
7958 : 781 : PyModule_AddIntMacro(m, SCM_J1939_PRIO);
7959 : 781 : PyModule_AddIntMacro(m, SCM_J1939_ERRQUEUE);
7960 : :
7961 : 781 : PyModule_AddIntMacro(m, J1939_NLA_PAD);
7962 : 781 : PyModule_AddIntMacro(m, J1939_NLA_BYTES_ACKED);
7963 : :
7964 : 781 : PyModule_AddIntMacro(m, J1939_EE_INFO_NONE);
7965 : 781 : PyModule_AddIntMacro(m, J1939_EE_INFO_TX_ABORT);
7966 : :
7967 : 781 : PyModule_AddIntMacro(m, J1939_FILTER_MAX);
7968 : : #endif
7969 : : #ifdef SOL_RDS
7970 : 781 : PyModule_AddIntMacro(m, SOL_RDS);
7971 : : #endif
7972 : : #ifdef HAVE_SOCKADDR_ALG
7973 : 781 : PyModule_AddIntMacro(m, SOL_ALG);
7974 : : #endif
7975 : : #ifdef RDS_CANCEL_SENT_TO
7976 : : PyModule_AddIntMacro(m, RDS_CANCEL_SENT_TO);
7977 : : #endif
7978 : : #ifdef RDS_GET_MR
7979 : : PyModule_AddIntMacro(m, RDS_GET_MR);
7980 : : #endif
7981 : : #ifdef RDS_FREE_MR
7982 : : PyModule_AddIntMacro(m, RDS_FREE_MR);
7983 : : #endif
7984 : : #ifdef RDS_RECVERR
7985 : : PyModule_AddIntMacro(m, RDS_RECVERR);
7986 : : #endif
7987 : : #ifdef RDS_CONG_MONITOR
7988 : : PyModule_AddIntMacro(m, RDS_CONG_MONITOR);
7989 : : #endif
7990 : : #ifdef RDS_GET_MR_FOR_DEST
7991 : : PyModule_AddIntMacro(m, RDS_GET_MR_FOR_DEST);
7992 : : #endif
7993 : : #ifdef IPPROTO_IP
7994 : 781 : PyModule_AddIntMacro(m, IPPROTO_IP);
7995 : : #else
7996 : : PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
7997 : : #endif
7998 : : #ifdef IPPROTO_HOPOPTS
7999 : 781 : PyModule_AddIntMacro(m, IPPROTO_HOPOPTS);
8000 : : #endif
8001 : : #ifdef IPPROTO_ICMP
8002 : 781 : PyModule_AddIntMacro(m, IPPROTO_ICMP);
8003 : : #else
8004 : : PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
8005 : : #endif
8006 : : #ifdef IPPROTO_IGMP
8007 : 781 : PyModule_AddIntMacro(m, IPPROTO_IGMP);
8008 : : #endif
8009 : : #ifdef IPPROTO_GGP
8010 : : PyModule_AddIntMacro(m, IPPROTO_GGP);
8011 : : #endif
8012 : : #ifdef IPPROTO_IPV4
8013 : : PyModule_AddIntMacro(m, IPPROTO_IPV4);
8014 : : #endif
8015 : : #ifdef IPPROTO_IPV6
8016 : 781 : PyModule_AddIntMacro(m, IPPROTO_IPV6);
8017 : : #endif
8018 : : #ifdef IPPROTO_IPIP
8019 : 781 : PyModule_AddIntMacro(m, IPPROTO_IPIP);
8020 : : #endif
8021 : : #ifdef IPPROTO_TCP
8022 : 781 : PyModule_AddIntMacro(m, IPPROTO_TCP);
8023 : : #else
8024 : : PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
8025 : : #endif
8026 : : #ifdef IPPROTO_EGP
8027 : 781 : PyModule_AddIntMacro(m, IPPROTO_EGP);
8028 : : #endif
8029 : : #ifdef IPPROTO_PUP
8030 : 781 : PyModule_AddIntMacro(m, IPPROTO_PUP);
8031 : : #endif
8032 : : #ifdef IPPROTO_UDP
8033 : 781 : PyModule_AddIntMacro(m, IPPROTO_UDP);
8034 : : #else
8035 : : PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
8036 : : #endif
8037 : : #ifdef IPPROTO_UDPLITE
8038 : 781 : PyModule_AddIntMacro(m, IPPROTO_UDPLITE);
8039 : : #ifndef UDPLITE_SEND_CSCOV
8040 : : #define UDPLITE_SEND_CSCOV 10
8041 : : #endif
8042 : 781 : PyModule_AddIntMacro(m, UDPLITE_SEND_CSCOV);
8043 : : #ifndef UDPLITE_RECV_CSCOV
8044 : : #define UDPLITE_RECV_CSCOV 11
8045 : : #endif
8046 : 781 : PyModule_AddIntMacro(m, UDPLITE_RECV_CSCOV);
8047 : : #endif
8048 : : #ifdef IPPROTO_IDP
8049 : 781 : PyModule_AddIntMacro(m, IPPROTO_IDP);
8050 : : #endif
8051 : : #ifdef IPPROTO_HELLO
8052 : : PyModule_AddIntMacro(m, IPPROTO_HELLO);
8053 : : #endif
8054 : : #ifdef IPPROTO_ND
8055 : : PyModule_AddIntMacro(m, IPPROTO_ND);
8056 : : #endif
8057 : : #ifdef IPPROTO_TP
8058 : 781 : PyModule_AddIntMacro(m, IPPROTO_TP);
8059 : : #endif
8060 : : #ifdef IPPROTO_ROUTING
8061 : 781 : PyModule_AddIntMacro(m, IPPROTO_ROUTING);
8062 : : #endif
8063 : : #ifdef IPPROTO_FRAGMENT
8064 : 781 : PyModule_AddIntMacro(m, IPPROTO_FRAGMENT);
8065 : : #endif
8066 : : #ifdef IPPROTO_RSVP
8067 : 781 : PyModule_AddIntMacro(m, IPPROTO_RSVP);
8068 : : #endif
8069 : : #ifdef IPPROTO_GRE
8070 : 781 : PyModule_AddIntMacro(m, IPPROTO_GRE);
8071 : : #endif
8072 : : #ifdef IPPROTO_ESP
8073 : 781 : PyModule_AddIntMacro(m, IPPROTO_ESP);
8074 : : #endif
8075 : : #ifdef IPPROTO_AH
8076 : 781 : PyModule_AddIntMacro(m, IPPROTO_AH);
8077 : : #endif
8078 : : #ifdef IPPROTO_MOBILE
8079 : : PyModule_AddIntMacro(m, IPPROTO_MOBILE);
8080 : : #endif
8081 : : #ifdef IPPROTO_ICMPV6
8082 : 781 : PyModule_AddIntMacro(m, IPPROTO_ICMPV6);
8083 : : #endif
8084 : : #ifdef IPPROTO_NONE
8085 : 781 : PyModule_AddIntMacro(m, IPPROTO_NONE);
8086 : : #endif
8087 : : #ifdef IPPROTO_DSTOPTS
8088 : 781 : PyModule_AddIntMacro(m, IPPROTO_DSTOPTS);
8089 : : #endif
8090 : : #ifdef IPPROTO_XTP
8091 : : PyModule_AddIntMacro(m, IPPROTO_XTP);
8092 : : #endif
8093 : : #ifdef IPPROTO_EON
8094 : : PyModule_AddIntMacro(m, IPPROTO_EON);
8095 : : #endif
8096 : : #ifdef IPPROTO_PIM
8097 : 781 : PyModule_AddIntMacro(m, IPPROTO_PIM);
8098 : : #endif
8099 : : #ifdef IPPROTO_IPCOMP
8100 : : PyModule_AddIntMacro(m, IPPROTO_IPCOMP);
8101 : : #endif
8102 : : #ifdef IPPROTO_VRRP
8103 : : PyModule_AddIntMacro(m, IPPROTO_VRRP);
8104 : : #endif
8105 : : #ifdef IPPROTO_SCTP
8106 : 781 : PyModule_AddIntMacro(m, IPPROTO_SCTP);
8107 : : #endif
8108 : : #ifdef IPPROTO_BIP
8109 : : PyModule_AddIntMacro(m, IPPROTO_BIP);
8110 : : #endif
8111 : : #ifdef IPPROTO_MPTCP
8112 : 781 : PyModule_AddIntMacro(m, IPPROTO_MPTCP);
8113 : : #endif
8114 : : /**/
8115 : : #ifdef IPPROTO_RAW
8116 : 781 : PyModule_AddIntMacro(m, IPPROTO_RAW);
8117 : : #else
8118 : : PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
8119 : : #endif
8120 : : #ifdef IPPROTO_MAX
8121 : : PyModule_AddIntMacro(m, IPPROTO_MAX);
8122 : : #endif
8123 : :
8124 : : #ifdef MS_WINDOWS
8125 : : PyModule_AddIntMacro(m, IPPROTO_ICLFXBM);
8126 : : PyModule_AddIntMacro(m, IPPROTO_ST);
8127 : : PyModule_AddIntMacro(m, IPPROTO_CBT);
8128 : : PyModule_AddIntMacro(m, IPPROTO_IGP);
8129 : : PyModule_AddIntMacro(m, IPPROTO_RDP);
8130 : : PyModule_AddIntMacro(m, IPPROTO_PGM);
8131 : : PyModule_AddIntMacro(m, IPPROTO_L2TP);
8132 : : PyModule_AddIntMacro(m, IPPROTO_SCTP);
8133 : : #endif
8134 : :
8135 : : #ifdef SYSPROTO_CONTROL
8136 : : PyModule_AddIntMacro(m, SYSPROTO_CONTROL);
8137 : : #endif
8138 : :
8139 : : /* Some port configuration */
8140 : : #ifdef IPPORT_RESERVED
8141 : 781 : PyModule_AddIntMacro(m, IPPORT_RESERVED);
8142 : : #else
8143 : : PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
8144 : : #endif
8145 : : #ifdef IPPORT_USERRESERVED
8146 : : PyModule_AddIntMacro(m, IPPORT_USERRESERVED);
8147 : : #else
8148 : 781 : PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
8149 : : #endif
8150 : :
8151 : : /* Some reserved IP v.4 addresses */
8152 : : #ifdef INADDR_ANY
8153 : 781 : PyModule_AddIntMacro(m, INADDR_ANY);
8154 : : #else
8155 : : PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
8156 : : #endif
8157 : : #ifdef INADDR_BROADCAST
8158 : 781 : PyModule_AddIntMacro(m, INADDR_BROADCAST);
8159 : : #else
8160 : : PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
8161 : : #endif
8162 : : #ifdef INADDR_LOOPBACK
8163 : 781 : PyModule_AddIntMacro(m, INADDR_LOOPBACK);
8164 : : #else
8165 : : PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
8166 : : #endif
8167 : : #ifdef INADDR_UNSPEC_GROUP
8168 : 781 : PyModule_AddIntMacro(m, INADDR_UNSPEC_GROUP);
8169 : : #else
8170 : : PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
8171 : : #endif
8172 : : #ifdef INADDR_ALLHOSTS_GROUP
8173 : 781 : PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
8174 : : INADDR_ALLHOSTS_GROUP);
8175 : : #else
8176 : : PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
8177 : : #endif
8178 : : #ifdef INADDR_MAX_LOCAL_GROUP
8179 : 781 : PyModule_AddIntMacro(m, INADDR_MAX_LOCAL_GROUP);
8180 : : #else
8181 : : PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
8182 : : #endif
8183 : : #ifdef INADDR_NONE
8184 : 781 : PyModule_AddIntMacro(m, INADDR_NONE);
8185 : : #else
8186 : : PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
8187 : : #endif
8188 : :
8189 : : /* IPv4 [gs]etsockopt options */
8190 : : #ifdef IP_OPTIONS
8191 : 781 : PyModule_AddIntMacro(m, IP_OPTIONS);
8192 : : #endif
8193 : : #ifdef IP_HDRINCL
8194 : 781 : PyModule_AddIntMacro(m, IP_HDRINCL);
8195 : : #endif
8196 : : #ifdef IP_TOS
8197 : 781 : PyModule_AddIntMacro(m, IP_TOS);
8198 : : #endif
8199 : : #ifdef IP_TTL
8200 : 781 : PyModule_AddIntMacro(m, IP_TTL);
8201 : : #endif
8202 : : #ifdef IP_RECVOPTS
8203 : 781 : PyModule_AddIntMacro(m, IP_RECVOPTS);
8204 : : #endif
8205 : : #ifdef IP_RECVRETOPTS
8206 : 781 : PyModule_AddIntMacro(m, IP_RECVRETOPTS);
8207 : : #endif
8208 : : #ifdef IP_RECVTOS
8209 : 781 : PyModule_AddIntMacro(m, IP_RECVTOS);
8210 : : #endif
8211 : : #ifdef IP_RECVDSTADDR
8212 : : PyModule_AddIntMacro(m, IP_RECVDSTADDR);
8213 : : #endif
8214 : : #ifdef IP_RETOPTS
8215 : 781 : PyModule_AddIntMacro(m, IP_RETOPTS);
8216 : : #endif
8217 : : #ifdef IP_MULTICAST_IF
8218 : 781 : PyModule_AddIntMacro(m, IP_MULTICAST_IF);
8219 : : #endif
8220 : : #ifdef IP_MULTICAST_TTL
8221 : 781 : PyModule_AddIntMacro(m, IP_MULTICAST_TTL);
8222 : : #endif
8223 : : #ifdef IP_MULTICAST_LOOP
8224 : 781 : PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
8225 : : #endif
8226 : : #ifdef IP_ADD_MEMBERSHIP
8227 : 781 : PyModule_AddIntMacro(m, IP_ADD_MEMBERSHIP);
8228 : : #endif
8229 : : #ifdef IP_DROP_MEMBERSHIP
8230 : 781 : PyModule_AddIntMacro(m, IP_DROP_MEMBERSHIP);
8231 : : #endif
8232 : : #ifdef IP_DEFAULT_MULTICAST_TTL
8233 : 781 : PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
8234 : : #endif
8235 : : #ifdef IP_DEFAULT_MULTICAST_LOOP
8236 : 781 : PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
8237 : : #endif
8238 : : #ifdef IP_MAX_MEMBERSHIPS
8239 : 781 : PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
8240 : : #endif
8241 : : #ifdef IP_TRANSPARENT
8242 : 781 : PyModule_AddIntMacro(m, IP_TRANSPARENT);
8243 : : #endif
8244 : : #ifdef IP_BIND_ADDRESS_NO_PORT
8245 : 781 : PyModule_AddIntMacro(m, IP_BIND_ADDRESS_NO_PORT);
8246 : : #endif
8247 : :
8248 : : /* IPv6 [gs]etsockopt options, defined in RFC2553 */
8249 : : #ifdef IPV6_JOIN_GROUP
8250 : 781 : PyModule_AddIntMacro(m, IPV6_JOIN_GROUP);
8251 : : #endif
8252 : : #ifdef IPV6_LEAVE_GROUP
8253 : 781 : PyModule_AddIntMacro(m, IPV6_LEAVE_GROUP);
8254 : : #endif
8255 : : #ifdef IPV6_MULTICAST_HOPS
8256 : 781 : PyModule_AddIntMacro(m, IPV6_MULTICAST_HOPS);
8257 : : #endif
8258 : : #ifdef IPV6_MULTICAST_IF
8259 : 781 : PyModule_AddIntMacro(m, IPV6_MULTICAST_IF);
8260 : : #endif
8261 : : #ifdef IPV6_MULTICAST_LOOP
8262 : 781 : PyModule_AddIntMacro(m, IPV6_MULTICAST_LOOP);
8263 : : #endif
8264 : : #ifdef IPV6_UNICAST_HOPS
8265 : 781 : PyModule_AddIntMacro(m, IPV6_UNICAST_HOPS);
8266 : : #endif
8267 : : /* Additional IPV6 socket options, defined in RFC 3493 */
8268 : : #ifdef IPV6_V6ONLY
8269 : 781 : PyModule_AddIntMacro(m, IPV6_V6ONLY);
8270 : : #endif
8271 : : /* Advanced IPV6 socket options, from RFC 3542 */
8272 : : #ifdef IPV6_CHECKSUM
8273 : 781 : PyModule_AddIntMacro(m, IPV6_CHECKSUM);
8274 : : #endif
8275 : : #ifdef IPV6_DONTFRAG
8276 : 781 : PyModule_AddIntMacro(m, IPV6_DONTFRAG);
8277 : : #endif
8278 : : #ifdef IPV6_DSTOPTS
8279 : 781 : PyModule_AddIntMacro(m, IPV6_DSTOPTS);
8280 : : #endif
8281 : : #ifdef IPV6_HOPLIMIT
8282 : 781 : PyModule_AddIntMacro(m, IPV6_HOPLIMIT);
8283 : : #endif
8284 : : #ifdef IPV6_HOPOPTS
8285 : 781 : PyModule_AddIntMacro(m, IPV6_HOPOPTS);
8286 : : #endif
8287 : : #ifdef IPV6_NEXTHOP
8288 : 781 : PyModule_AddIntMacro(m, IPV6_NEXTHOP);
8289 : : #endif
8290 : : #ifdef IPV6_PATHMTU
8291 : 781 : PyModule_AddIntMacro(m, IPV6_PATHMTU);
8292 : : #endif
8293 : : #ifdef IPV6_PKTINFO
8294 : 781 : PyModule_AddIntMacro(m, IPV6_PKTINFO);
8295 : : #endif
8296 : : #ifdef IPV6_RECVDSTOPTS
8297 : 781 : PyModule_AddIntMacro(m, IPV6_RECVDSTOPTS);
8298 : : #endif
8299 : : #ifdef IPV6_RECVHOPLIMIT
8300 : 781 : PyModule_AddIntMacro(m, IPV6_RECVHOPLIMIT);
8301 : : #endif
8302 : : #ifdef IPV6_RECVHOPOPTS
8303 : 781 : PyModule_AddIntMacro(m, IPV6_RECVHOPOPTS);
8304 : : #endif
8305 : : #ifdef IPV6_RECVPKTINFO
8306 : 781 : PyModule_AddIntMacro(m, IPV6_RECVPKTINFO);
8307 : : #endif
8308 : : #ifdef IPV6_RECVRTHDR
8309 : 781 : PyModule_AddIntMacro(m, IPV6_RECVRTHDR);
8310 : : #endif
8311 : : #ifdef IPV6_RECVTCLASS
8312 : 781 : PyModule_AddIntMacro(m, IPV6_RECVTCLASS);
8313 : : #endif
8314 : : #ifdef IPV6_RTHDR
8315 : 781 : PyModule_AddIntMacro(m, IPV6_RTHDR);
8316 : : #endif
8317 : : #ifdef IPV6_RTHDRDSTOPTS
8318 : 781 : PyModule_AddIntMacro(m, IPV6_RTHDRDSTOPTS);
8319 : : #endif
8320 : : #ifdef IPV6_RTHDR_TYPE_0
8321 : 781 : PyModule_AddIntMacro(m, IPV6_RTHDR_TYPE_0);
8322 : : #endif
8323 : : #ifdef IPV6_RECVPATHMTU
8324 : 781 : PyModule_AddIntMacro(m, IPV6_RECVPATHMTU);
8325 : : #endif
8326 : : #ifdef IPV6_TCLASS
8327 : 781 : PyModule_AddIntMacro(m, IPV6_TCLASS);
8328 : : #endif
8329 : : #ifdef IPV6_USE_MIN_MTU
8330 : : PyModule_AddIntMacro(m, IPV6_USE_MIN_MTU);
8331 : : #endif
8332 : :
8333 : : /* TCP options */
8334 : : #ifdef TCP_NODELAY
8335 : 781 : PyModule_AddIntMacro(m, TCP_NODELAY);
8336 : : #endif
8337 : : #ifdef TCP_MAXSEG
8338 : 781 : PyModule_AddIntMacro(m, TCP_MAXSEG);
8339 : : #endif
8340 : : #ifdef TCP_CORK
8341 : 781 : PyModule_AddIntMacro(m, TCP_CORK);
8342 : : #endif
8343 : : #ifdef TCP_KEEPIDLE
8344 : 781 : PyModule_AddIntMacro(m, TCP_KEEPIDLE);
8345 : : #endif
8346 : : /* TCP_KEEPALIVE is OSX's TCP_KEEPIDLE equivalent */
8347 : : #if defined(__APPLE__) && defined(TCP_KEEPALIVE)
8348 : : PyModule_AddIntMacro(m, TCP_KEEPALIVE);
8349 : : #endif
8350 : : #ifdef TCP_KEEPINTVL
8351 : 781 : PyModule_AddIntMacro(m, TCP_KEEPINTVL);
8352 : : #endif
8353 : : #ifdef TCP_KEEPCNT
8354 : 781 : PyModule_AddIntMacro(m, TCP_KEEPCNT);
8355 : : #endif
8356 : : #ifdef TCP_SYNCNT
8357 : 781 : PyModule_AddIntMacro(m, TCP_SYNCNT);
8358 : : #endif
8359 : : #ifdef TCP_LINGER2
8360 : 781 : PyModule_AddIntMacro(m, TCP_LINGER2);
8361 : : #endif
8362 : : #ifdef TCP_DEFER_ACCEPT
8363 : 781 : PyModule_AddIntMacro(m, TCP_DEFER_ACCEPT);
8364 : : #endif
8365 : : #ifdef TCP_WINDOW_CLAMP
8366 : 781 : PyModule_AddIntMacro(m, TCP_WINDOW_CLAMP);
8367 : : #endif
8368 : : #ifdef TCP_INFO
8369 : 781 : PyModule_AddIntMacro(m, TCP_INFO);
8370 : : #endif
8371 : : #ifdef TCP_CONNECTION_INFO
8372 : : PyModule_AddIntMacro(m, TCP_CONNECTION_INFO);
8373 : : #endif
8374 : : #ifdef TCP_QUICKACK
8375 : 781 : PyModule_AddIntMacro(m, TCP_QUICKACK);
8376 : : #endif
8377 : : #ifdef TCP_FASTOPEN
8378 : 781 : PyModule_AddIntMacro(m, TCP_FASTOPEN);
8379 : : #endif
8380 : : #ifdef TCP_CONGESTION
8381 : 781 : PyModule_AddIntMacro(m, TCP_CONGESTION);
8382 : : #endif
8383 : : #ifdef TCP_USER_TIMEOUT
8384 : 781 : PyModule_AddIntMacro(m, TCP_USER_TIMEOUT);
8385 : : #endif
8386 : : #ifdef TCP_NOTSENT_LOWAT
8387 : 781 : PyModule_AddIntMacro(m, TCP_NOTSENT_LOWAT);
8388 : : #endif
8389 : :
8390 : : /* IPX options */
8391 : : #ifdef IPX_TYPE
8392 : : PyModule_AddIntMacro(m, IPX_TYPE);
8393 : : #endif
8394 : :
8395 : : /* Reliable Datagram Sockets */
8396 : : #ifdef RDS_CMSG_RDMA_ARGS
8397 : : PyModule_AddIntMacro(m, RDS_CMSG_RDMA_ARGS);
8398 : : #endif
8399 : : #ifdef RDS_CMSG_RDMA_DEST
8400 : : PyModule_AddIntMacro(m, RDS_CMSG_RDMA_DEST);
8401 : : #endif
8402 : : #ifdef RDS_CMSG_RDMA_MAP
8403 : : PyModule_AddIntMacro(m, RDS_CMSG_RDMA_MAP);
8404 : : #endif
8405 : : #ifdef RDS_CMSG_RDMA_STATUS
8406 : : PyModule_AddIntMacro(m, RDS_CMSG_RDMA_STATUS);
8407 : : #endif
8408 : : #ifdef RDS_CMSG_RDMA_UPDATE
8409 : : PyModule_AddIntMacro(m, RDS_CMSG_RDMA_UPDATE);
8410 : : #endif
8411 : : #ifdef RDS_RDMA_READWRITE
8412 : : PyModule_AddIntMacro(m, RDS_RDMA_READWRITE);
8413 : : #endif
8414 : : #ifdef RDS_RDMA_FENCE
8415 : : PyModule_AddIntMacro(m, RDS_RDMA_FENCE);
8416 : : #endif
8417 : : #ifdef RDS_RDMA_INVALIDATE
8418 : : PyModule_AddIntMacro(m, RDS_RDMA_INVALIDATE);
8419 : : #endif
8420 : : #ifdef RDS_RDMA_USE_ONCE
8421 : : PyModule_AddIntMacro(m, RDS_RDMA_USE_ONCE);
8422 : : #endif
8423 : : #ifdef RDS_RDMA_DONTWAIT
8424 : : PyModule_AddIntMacro(m, RDS_RDMA_DONTWAIT);
8425 : : #endif
8426 : : #ifdef RDS_RDMA_NOTIFY_ME
8427 : : PyModule_AddIntMacro(m, RDS_RDMA_NOTIFY_ME);
8428 : : #endif
8429 : : #ifdef RDS_RDMA_SILENT
8430 : : PyModule_AddIntMacro(m, RDS_RDMA_SILENT);
8431 : : #endif
8432 : :
8433 : : /* get{addr,name}info parameters */
8434 : : #ifdef EAI_ADDRFAMILY
8435 : 781 : PyModule_AddIntMacro(m, EAI_ADDRFAMILY);
8436 : : #endif
8437 : : #ifdef EAI_AGAIN
8438 : 781 : PyModule_AddIntMacro(m, EAI_AGAIN);
8439 : : #endif
8440 : : #ifdef EAI_BADFLAGS
8441 : 781 : PyModule_AddIntMacro(m, EAI_BADFLAGS);
8442 : : #endif
8443 : : #ifdef EAI_FAIL
8444 : 781 : PyModule_AddIntMacro(m, EAI_FAIL);
8445 : : #endif
8446 : : #ifdef EAI_FAMILY
8447 : 781 : PyModule_AddIntMacro(m, EAI_FAMILY);
8448 : : #endif
8449 : : #ifdef EAI_MEMORY
8450 : 781 : PyModule_AddIntMacro(m, EAI_MEMORY);
8451 : : #endif
8452 : : #ifdef EAI_NODATA
8453 : 781 : PyModule_AddIntMacro(m, EAI_NODATA);
8454 : : #endif
8455 : : #ifdef EAI_NONAME
8456 : 781 : PyModule_AddIntMacro(m, EAI_NONAME);
8457 : : #endif
8458 : : #ifdef EAI_OVERFLOW
8459 : 781 : PyModule_AddIntMacro(m, EAI_OVERFLOW);
8460 : : #endif
8461 : : #ifdef EAI_SERVICE
8462 : 781 : PyModule_AddIntMacro(m, EAI_SERVICE);
8463 : : #endif
8464 : : #ifdef EAI_SOCKTYPE
8465 : 781 : PyModule_AddIntMacro(m, EAI_SOCKTYPE);
8466 : : #endif
8467 : : #ifdef EAI_SYSTEM
8468 : 781 : PyModule_AddIntMacro(m, EAI_SYSTEM);
8469 : : #endif
8470 : : #ifdef EAI_BADHINTS
8471 : : PyModule_AddIntMacro(m, EAI_BADHINTS);
8472 : : #endif
8473 : : #ifdef EAI_PROTOCOL
8474 : : PyModule_AddIntMacro(m, EAI_PROTOCOL);
8475 : : #endif
8476 : : #ifdef EAI_MAX
8477 : : PyModule_AddIntMacro(m, EAI_MAX);
8478 : : #endif
8479 : : #ifdef AI_PASSIVE
8480 : 781 : PyModule_AddIntMacro(m, AI_PASSIVE);
8481 : : #endif
8482 : : #ifdef AI_CANONNAME
8483 : 781 : PyModule_AddIntMacro(m, AI_CANONNAME);
8484 : : #endif
8485 : : #ifdef AI_NUMERICHOST
8486 : 781 : PyModule_AddIntMacro(m, AI_NUMERICHOST);
8487 : : #endif
8488 : : #ifdef AI_NUMERICSERV
8489 : 781 : PyModule_AddIntMacro(m, AI_NUMERICSERV);
8490 : : #endif
8491 : : #ifdef AI_MASK
8492 : : PyModule_AddIntMacro(m, AI_MASK);
8493 : : #endif
8494 : : #ifdef AI_ALL
8495 : 781 : PyModule_AddIntMacro(m, AI_ALL);
8496 : : #endif
8497 : : #ifdef AI_V4MAPPED_CFG
8498 : : PyModule_AddIntMacro(m, AI_V4MAPPED_CFG);
8499 : : #endif
8500 : : #ifdef AI_ADDRCONFIG
8501 : 781 : PyModule_AddIntMacro(m, AI_ADDRCONFIG);
8502 : : #endif
8503 : : #ifdef AI_V4MAPPED
8504 : 781 : PyModule_AddIntMacro(m, AI_V4MAPPED);
8505 : : #endif
8506 : : #ifdef AI_DEFAULT
8507 : : PyModule_AddIntMacro(m, AI_DEFAULT);
8508 : : #endif
8509 : : #ifdef NI_MAXHOST
8510 : 781 : PyModule_AddIntMacro(m, NI_MAXHOST);
8511 : : #endif
8512 : : #ifdef NI_MAXSERV
8513 : 781 : PyModule_AddIntMacro(m, NI_MAXSERV);
8514 : : #endif
8515 : : #ifdef NI_NOFQDN
8516 : 781 : PyModule_AddIntMacro(m, NI_NOFQDN);
8517 : : #endif
8518 : : #ifdef NI_NUMERICHOST
8519 : 781 : PyModule_AddIntMacro(m, NI_NUMERICHOST);
8520 : : #endif
8521 : : #ifdef NI_NAMEREQD
8522 : 781 : PyModule_AddIntMacro(m, NI_NAMEREQD);
8523 : : #endif
8524 : : #ifdef NI_NUMERICSERV
8525 : 781 : PyModule_AddIntMacro(m, NI_NUMERICSERV);
8526 : : #endif
8527 : : #ifdef NI_DGRAM
8528 : 781 : PyModule_AddIntMacro(m, NI_DGRAM);
8529 : : #endif
8530 : :
8531 : : /* shutdown() parameters */
8532 : : #ifdef SHUT_RD
8533 : 781 : PyModule_AddIntMacro(m, SHUT_RD);
8534 : : #elif defined(SD_RECEIVE)
8535 : : PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
8536 : : #else
8537 : : PyModule_AddIntConstant(m, "SHUT_RD", 0);
8538 : : #endif
8539 : : #ifdef SHUT_WR
8540 : 781 : PyModule_AddIntMacro(m, SHUT_WR);
8541 : : #elif defined(SD_SEND)
8542 : : PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
8543 : : #else
8544 : : PyModule_AddIntConstant(m, "SHUT_WR", 1);
8545 : : #endif
8546 : : #ifdef SHUT_RDWR
8547 : 781 : PyModule_AddIntMacro(m, SHUT_RDWR);
8548 : : #elif defined(SD_BOTH)
8549 : : PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
8550 : : #else
8551 : : PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
8552 : : #endif
8553 : :
8554 : : #ifdef SIO_RCVALL
8555 : : {
8556 : : DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS,
8557 : : #if defined(SIO_LOOPBACK_FAST_PATH)
8558 : : SIO_LOOPBACK_FAST_PATH
8559 : : #endif
8560 : : };
8561 : : const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS",
8562 : : #if defined(SIO_LOOPBACK_FAST_PATH)
8563 : : "SIO_LOOPBACK_FAST_PATH"
8564 : : #endif
8565 : : };
8566 : : int i;
8567 : : for(i = 0; i<Py_ARRAY_LENGTH(codes); ++i) {
8568 : : PyObject *tmp;
8569 : : tmp = PyLong_FromUnsignedLong(codes[i]);
8570 : : if (tmp == NULL)
8571 : : return NULL;
8572 : : PyModule_AddObject(m, names[i], tmp);
8573 : : }
8574 : : }
8575 : : PyModule_AddIntMacro(m, RCVALL_OFF);
8576 : : PyModule_AddIntMacro(m, RCVALL_ON);
8577 : : PyModule_AddIntMacro(m, RCVALL_SOCKETLEVELONLY);
8578 : : #ifdef RCVALL_IPLEVEL
8579 : : PyModule_AddIntMacro(m, RCVALL_IPLEVEL);
8580 : : #endif
8581 : : #ifdef RCVALL_MAX
8582 : : PyModule_AddIntMacro(m, RCVALL_MAX);
8583 : : #endif
8584 : : #endif /* _MSTCPIP_ */
8585 : :
8586 : : /* Initialize gethostbyname lock */
8587 : : #if defined(USE_GETHOSTBYNAME_LOCK)
8588 : : netdb_lock = PyThread_allocate_lock();
8589 : : #endif
8590 : :
8591 : : #ifdef MS_WINDOWS
8592 : : /* remove some flags on older version Windows during run-time */
8593 : : if (remove_unusable_flags(m) < 0) {
8594 : : Py_DECREF(m);
8595 : : return NULL;
8596 : : }
8597 : : #endif
8598 : :
8599 : 781 : return m;
8600 : : }
|
