#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#ifdef __APPLE__

#define __APPLE_USE_RFC_3542 1

#include <AvailabilityMacros.h>

#ifndef MAC_OS_X_VERSION_10_5

#define MAC_OS_X_VERSION_10_5 1050

/*

# pragma weak inet_aton

#include "Python.h"

#include "pycore_dict.h" // _PyDict_Pop()

#include "pycore_fileutils.h" // _Py_set_inheritable()

#include "pycore_moduleobject.h" // _PyModule_GetState

#ifdef _Py_MEMORY_SANITIZER

# include <sanitizer/msan_interface.h>

PyDoc_STRVAR(sock_doc,

[*] not available on all platforms!");

#ifndef __linux__

# undef HAVE_GETHOSTBYNAME_R_3_ARG

# undef HAVE_GETHOSTBYNAME_R_5_ARG

# undef HAVE_GETHOSTBYNAME_R_6_ARG

#if defined(__OpenBSD__)

# include <sys/uio.h>

#if defined(__ANDROID__) && __ANDROID_API__ < 23

# undef HAVE_GETHOSTBYNAME_R

#ifdef HAVE_GETHOSTBYNAME_R

# if defined(_AIX) && !defined(_LINUX_SOURCE_COMPAT)

# define HAVE_GETHOSTBYNAME_R_3_ARG

# elif defined(__sun) || defined(__sgi)

# define HAVE_GETHOSTBYNAME_R_5_ARG

# elif defined(__linux__)

# elif defined(_LINUX_SOURCE_COMPAT) /* Linux compatibility on AIX */

# define HAVE_GETHOSTBYNAME_R_6_ARG

# undef HAVE_GETHOSTBYNAME_R

#if !defined(HAVE_GETHOSTBYNAME_R) && !defined(MS_WINDOWS)

# define USE_GETHOSTBYNAME_LOCK

#if defined(__APPLE__) || defined(__CYGWIN__) || defined(__NetBSD__)

# include <sys/ioctl.h>

#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI

#undef _SGIAPI /* to avoid warning */

#define _SGIAPI 1

#undef _XOPEN_SOURCE

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#ifdef _SS_ALIGNSIZE

#define HAVE_GETADDRINFO 1

#define HAVE_GETNAMEINFO 1

#define HAVE_INET_PTON

#include <netdb.h>

#endif // __sgi

#if (defined(__sun) && defined(__SVR4)) && !defined(INET_ADDRSTRLEN)

#define INET_ADDRSTRLEN 16

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#ifdef HAVE_NET_IF_H

#include <net/if.h>

#ifdef HAVE_NET_ETHERNET_H

#include <net/ethernet.h>

#define PySocket_BUILDING_SOCKET

#include "socketmodule.h"

#ifndef MS_WINDOWS

#ifdef HAVE_NETDB_H

# include <netdb.h>

# include <unistd.h>

# include <arpa/inet.h>

# include <fcntl.h>

#else /* MS_WINDOWS */

# ifdef HAVE_FCNTL_H

# include <fcntl.h>

# include <Rpc.h>

#define IPPROTO_ICMP IPPROTO_ICMP

#define IPPROTO_IGMP IPPROTO_IGMP

#define IPPROTO_GGP IPPROTO_GGP

#define IPPROTO_TCP IPPROTO_TCP

#define IPPROTO_PUP IPPROTO_PUP

#define IPPROTO_UDP IPPROTO_UDP

#define IPPROTO_IDP IPPROTO_IDP

#define IPPROTO_ND IPPROTO_ND

#define IPPROTO_RAW IPPROTO_RAW

#define IPPROTO_MAX IPPROTO_MAX

#define IPPROTO_HOPOPTS IPPROTO_HOPOPTS

#define IPPROTO_IPV4 IPPROTO_IPV4

#define IPPROTO_IPV6 IPPROTO_IPV6

#define IPPROTO_ROUTING IPPROTO_ROUTING

#define IPPROTO_FRAGMENT IPPROTO_FRAGMENT

#define IPPROTO_ESP IPPROTO_ESP

#define IPPROTO_AH IPPROTO_AH

#define IPPROTO_ICMPV6 IPPROTO_ICMPV6

#define IPPROTO_NONE IPPROTO_NONE

#define IPPROTO_DSTOPTS IPPROTO_DSTOPTS

#define IPPROTO_EGP IPPROTO_EGP

#define IPPROTO_PIM IPPROTO_PIM

#define IPPROTO_ICLFXBM IPPROTO_ICLFXBM // WinSock2 only

#define IPPROTO_ST IPPROTO_ST // WinSock2 only

#define IPPROTO_CBT IPPROTO_CBT // WinSock2 only

#define IPPROTO_IGP IPPROTO_IGP // WinSock2 only

#define IPPROTO_RDP IPPROTO_RDP // WinSock2 only

#define IPPROTO_PGM IPPROTO_PGM // WinSock2 only

#define IPPROTO_L2TP IPPROTO_L2TP // WinSock2 only

#define IPPROTO_SCTP IPPROTO_SCTP // WinSock2 only

#include <versionhelpers.h>

#include <iphlpapi.h>

typedef struct {

DWORD build_number; /* available starting with this Win10 BuildNumber */

const char flag_name[20];

} FlagRuntimeInfo;

static FlagRuntimeInfo win_runtime_flags[] = {

/* available starting with Windows 10 1709 */

{16299, "TCP_KEEPIDLE"},

{16299, "TCP_KEEPINTVL"},

/* available starting with Windows 10 1703 */

{15063, "TCP_KEEPCNT"},

/* available starting with Windows 10 1607 */

{14393, "TCP_FASTOPEN"}

};

static int

remove_unusable_flags(PyObject *m)

{

PyObject *dict;

OSVERSIONINFOEX info;

dict = PyModule_GetDict(m);

if (dict == NULL) {

return -1;

}

#ifndef MS_WINDOWS_DESKTOP

info.dwOSVersionInfoSize = sizeof(info);

if (!GetVersionEx((OSVERSIONINFO*) &info)) {

PyErr_SetFromWindowsErr(0);

return -1;

}

/* set to Windows 10, except BuildNumber. */

memset(&info, 0, sizeof(info));

info.dwOSVersionInfoSize = sizeof(info);

info.dwMajorVersion = 10;

info.dwMinorVersion = 0;

/* set Condition Mask */

DWORDLONG dwlConditionMask = 0;

VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);

VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);

VER_SET_CONDITION(dwlConditionMask, VER_BUILDNUMBER, VER_GREATER_EQUAL);

for (int i=0; i<sizeof(win_runtime_flags)/sizeof(FlagRuntimeInfo); i++) {

#ifdef MS_WINDOWS_DESKTOP

info.dwBuildNumber = win_runtime_flags[i].build_number;

/* greater than or equal to the specified version?

BOOL isSupported = VerifyVersionInfo(

&info,

VER_MAJORVERSION|VER_MINORVERSION|VER_BUILDNUMBER,

dwlConditionMask);

/* note in this case 'info' is the actual OS version, whereas above

BOOL isSupported = info.dwMajorVersion > 10 ||

(info.dwMajorVersion == 10 && info.dwMinorVersion > 0) ||

(info.dwMajorVersion == 10 && info.dwMinorVersion == 0 &&

info.dwBuildNumber >= win_runtime_flags[i].build_number);

if (isSupported) {

break;

}

else {

PyObject *flag_name = PyUnicode_FromString(win_runtime_flags[i].flag_name);

if (flag_name == NULL) {

return -1;

}

PyObject *v = _PyDict_Pop(dict, flag_name, Py_None);

Py_DECREF(flag_name);

if (v == NULL) {

return -1;

}

Py_DECREF(v);

}

}

return 0;

}

#include <stddef.h>

#ifndef O_NONBLOCK

# define O_NONBLOCK O_NDELAY

#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)

/* Do not include addinfo.h on some newer IRIX versions.

#elif defined(_MSC_VER) && _MSC_VER>1201

/* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and

# include "addrinfo.h"

#ifdef __APPLE__

#ifndef HAVE_GETNAMEINFO

#undef HAVE_GETADDRINFO

#ifdef HAVE_INET_ATON

#define USE_INET_ATON_WEAKLINK

#if !defined(HAVE_GETADDRINFO)

#define getaddrinfo fake_getaddrinfo

#define gai_strerror fake_gai_strerror

#define freeaddrinfo fake_freeaddrinfo

#include "getaddrinfo.c"

#if !defined(HAVE_GETNAMEINFO)

#define getnameinfo fake_getnameinfo

#include "getnameinfo.c"

#endif // HAVE_GETNAMEINFO

#ifdef MS_WINDOWS

#define SOCKETCLOSE closesocket

#ifdef MS_WIN32

# undef EAFNOSUPPORT

# define EAFNOSUPPORT WSAEAFNOSUPPORT

#ifndef SOCKETCLOSE

# define SOCKETCLOSE close

#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)

#define USE_BLUETOOTH 1

#if defined(__FreeBSD__)

#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP

#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM

#define BTPROTO_HCI BLUETOOTH_PROTO_HCI

#define SOL_HCI SOL_HCI_RAW

#define HCI_FILTER SO_HCI_RAW_FILTER

#define sockaddr_l2 sockaddr_l2cap

#define sockaddr_rc sockaddr_rfcomm

#define hci_dev hci_node

#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)

#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)

#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)

#elif defined(__NetBSD__) || defined(__DragonFly__)

#define sockaddr_l2 sockaddr_bt

#define sockaddr_rc sockaddr_bt

#define sockaddr_hci sockaddr_bt

#define sockaddr_sco sockaddr_bt

#define SOL_HCI BTPROTO_HCI

#define HCI_DATA_DIR SO_HCI_DIRECTION

#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)

#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)

#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)

#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)

#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)

#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)

#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)

#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)

#ifdef MS_WINDOWS_DESKTOP

#define sockaddr_rc SOCKADDR_BTH_REDEF

#define USE_BLUETOOTH 1

#define AF_BLUETOOTH AF_BTH

#define BTPROTO_RFCOMM BTHPROTO_RFCOMM

#define _BT_RC_MEMB(sa, memb) ((sa)->memb)

#endif /* MS_WINDOWS_DESKTOP */

#define SAS2SA(x) (&((x)->sa))

#if !defined(NI_MAXHOST)

#define NI_MAXHOST 1025

#if !defined(NI_MAXSERV)

#define NI_MAXSERV 32

#ifndef INVALID_SOCKET /* MS defines this */

#define INVALID_SOCKET (-1)

#ifndef INADDR_NONE

#define INADDR_NONE (-1)

typedef struct _socket_state {

} socket_state;

static inline socket_state *

get_module_state(PyObject *mod)

{

void *state = _PyModule_GetState(mod);

assert(state != NULL);

return (socket_state *)state;

}

static struct PyModuleDef socketmodule;

static inline socket_state *

find_module_state_by_def(PyTypeObject *type)

{

PyObject *mod = PyType_GetModuleByDef(type, &socketmodule);

assert(mod != NULL);

return get_module_state(mod);

}

#define clinic_state() (find_module_state_by_def(type))

#include "clinic/socketmodule.c.h"

#undef clinic_state

#if defined(HAVE_POLL_H)

#include <poll.h>

#elif defined(HAVE_SYS_POLL_H)

#include <sys/poll.h>

#if INT_MAX > 0x7fffffff

#define SOCKLEN_T_LIMIT 0x7fffffff

#define SOCKLEN_T_LIMIT INT_MAX

#ifdef HAVE_POLL

#define IS_SELECTABLE(s) 1

#define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0)

static PyObject*

select_error(void)

{

PyErr_SetString(PyExc_OSError, "unable to select on socket");

return NULL;

}

#ifdef MS_WINDOWS

#ifndef WSAEAGAIN

#define WSAEAGAIN WSAEWOULDBLOCK

#define CHECK_ERRNO(expected) \

(WSAGetLastError() == WSA ## expected)

#define CHECK_ERRNO(expected) \

(errno == expected)

#ifdef MS_WINDOWS

# define GET_SOCK_ERROR WSAGetLastError()

# define SET_SOCK_ERROR(err) WSASetLastError(err)

# define SOCK_TIMEOUT_ERR WSAEWOULDBLOCK

# define SOCK_INPROGRESS_ERR WSAEWOULDBLOCK

# define GET_SOCK_ERROR errno

# define SET_SOCK_ERROR(err) do { errno = err; } while (0)

# define SOCK_TIMEOUT_ERR EWOULDBLOCK

# define SOCK_INPROGRESS_ERR EINPROGRESS

#ifdef _MSC_VER

# define SUPPRESS_DEPRECATED_CALL __pragma(warning(suppress: 4996))

# define SUPPRESS_DEPRECATED_CALL

static PyObject *

set_error(void)

{

#ifdef MS_WINDOWS

int err_no = WSAGetLastError();

/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which

if (err_no)

return PyErr_SetExcFromWindowsErr(PyExc_OSError, err_no);

return PyErr_SetFromErrno(PyExc_OSError);

}

#if defined(HAVE_GETHOSTBYNAME_R) || defined (HAVE_GETHOSTBYNAME) || defined (HAVE_GETHOSTBYADDR)

static PyObject *

set_herror(socket_state *state, int h_error)

{

PyObject *v;

#ifdef HAVE_HSTRERROR

v = Py_BuildValue("(is)", h_error, hstrerror(h_error));

v = Py_BuildValue("(is)", h_error, "host not found");

if (v != NULL) {

PyErr_SetObject(state->socket_herror, v);

Py_DECREF(v);

}

return NULL;

}

#ifdef HAVE_GETADDRINFO

static PyObject *

set_gaierror(socket_state *state, int error)

{

PyObject *v;

#ifdef EAI_SYSTEM

/* EAI_SYSTEM is not available on Windows XP. */

if (error == EAI_SYSTEM)

return set_error();

#ifdef HAVE_GAI_STRERROR

v = Py_BuildValue("(is)", error, gai_strerror(error));

v = Py_BuildValue("(is)", error, "getaddrinfo failed");

if (v != NULL) {

PyErr_SetObject(state->socket_gaierror, v);

Py_DECREF(v);

}

return NULL;

}

static int

internal_setblocking(PySocketSockObject *s, int block)

{

int result = -1;

#ifdef MS_WINDOWS

u_long arg;

#if !defined(MS_WINDOWS) \

&& !((defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO)))

int delay_flag, new_delay_flag;

Py_BEGIN_ALLOW_THREADS

#ifndef MS_WINDOWS

#if (defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO))

block = !block;

if (ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block) == -1)

goto done;

delay_flag = fcntl(s->sock_fd, F_GETFL, 0);

if (delay_flag == -1)

goto done;

if (block)

new_delay_flag = delay_flag & (~O_NONBLOCK);

else

new_delay_flag = delay_flag | O_NONBLOCK;

if (new_delay_flag != delay_flag)

if (fcntl(s->sock_fd, F_SETFL, new_delay_flag) == -1)

goto done;

#else /* MS_WINDOWS */

arg = !block;

if (ioctlsocket(s->sock_fd, FIONBIO, &arg) != 0)

goto done;

#endif /* MS_WINDOWS */

result = 0;

done:

Py_END_ALLOW_THREADS

if (result) {

#ifndef MS_WINDOWS

PyErr_SetFromErrno(PyExc_OSError);

PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());

}

return result;

}

static int

internal_select(PySocketSockObject *s, int writing, _PyTime_t interval,

int connect)

{

int n;

#ifdef HAVE_POLL

struct pollfd pollfd;

_PyTime_t ms;

fd_set fds, efds;

struct timeval tv, *tvp;

/* must be called with the GIL held */

assert(PyGILState_Check());

/* Error condition is for output only */

assert(!(connect && !writing));

/* Guard against closed socket */

if (s->sock_fd == INVALID_SOCKET)

return 0;

/* Prefer poll, if available, since you can poll() any fd

#ifdef HAVE_POLL

pollfd.fd = s->sock_fd;

pollfd.events = writing ? POLLOUT : POLLIN;

if (connect) {

/* On Windows, the socket becomes writable on connection success,

pollfd.events |= POLLERR;

}

/* s->sock_timeout is in seconds, timeout in ms */

ms = _PyTime_AsMilliseconds(interval, _PyTime_ROUND_CEILING);

assert(ms <= INT_MAX);

/* On some OSes, typically BSD-based ones, the timeout parameter of the

if (ms < 0) {

#ifdef INFTIM

ms = INFTIM;

ms = -1;

}

Py_BEGIN_ALLOW_THREADS;

n = poll(&pollfd, 1, (int)ms);

Py_END_ALLOW_THREADS;

if (interval >= 0) {

_PyTime_AsTimeval_clamp(interval, &tv, _PyTime_ROUND_CEILING);

tvp = &tv;

}

else

tvp = NULL;

FD_ZERO(&fds);

FD_SET(s->sock_fd, &fds);

FD_ZERO(&efds);

if (connect) {

/* On Windows, the socket becomes writable on connection success,

FD_SET(s->sock_fd, &efds);

}

/* See if the socket is ready */

Py_BEGIN_ALLOW_THREADS;

if (writing)

n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),

NULL, &fds, &efds, tvp);

else

n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),

&fds, NULL, &efds, tvp);

Py_END_ALLOW_THREADS;

if (n < 0)

return -1;

if (n == 0)

return 1;

return 0;

}

static int

sock_call_ex(PySocketSockObject *s,

_PyTime_t timeout)

{

int has_timeout = (timeout > 0);

_PyTime_t deadline = 0;

int deadline_initialized = 0;

int res;

/* sock_call() must be called with the GIL held. */

assert(PyGILState_Check());

/* outer loop to retry select() when select() is interrupted by a signal

while (1) {

/* For connect(), poll even for blocking socket. The connection

if (has_timeout || connect) {

if (has_timeout) {

_PyTime_t interval;

if (deadline_initialized) {

/* recompute the timeout */

interval = _PyDeadline_Get(deadline);

}

else {

deadline_initialized = 1;

deadline = _PyDeadline_Init(timeout);

interval = timeout;

}

if (interval >= 0) {

res = internal_select(s, writing, interval, connect);

}

else {

res = 1;

}

}

else {

res = internal_select(s, writing, timeout, connect);

}

if (res == -1) {

if (err)

*err = GET_SOCK_ERROR;

if (CHECK_ERRNO(EINTR)) {

/* select() was interrupted by a signal */

if (PyErr_CheckSignals()) {

if (err)

*err = -1;

return -1;

}

/* retry select() */

continue;

}

/* select() failed */

s->errorhandler();

return -1;

}

if (res == 1) {

if (err)

*err = SOCK_TIMEOUT_ERR;

else

PyErr_SetString(PyExc_TimeoutError, "timed out");

return -1;

}

/* the socket is ready */

}

/* inner loop to retry sock_func() when sock_func() is interrupted

while (1) {

Py_BEGIN_ALLOW_THREADS

res = sock_func(s, data);

Py_END_ALLOW_THREADS

if (res) {

/* sock_func() succeeded */

if (err)

*err = 0;

return 0;

}

if (err)

*err = GET_SOCK_ERROR;

if (!CHECK_ERRNO(EINTR))

break;

/* sock_func() was interrupted by a signal */

if (PyErr_CheckSignals()) {

if (err)

*err = -1;

return -1;

}

/* retry sock_func() */

}

if (s->sock_timeout > 0