Use a monotonic clock to compute timeouts

Modules/socketmodule.c

 /* Socket module */
 
 /*
 
 This module provides an interface to Berkeley socket IPC.
 
 Limitations:
 
 - Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
   portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported
@@ skipping 658 matching lines @@
     Py_END_ALLOW_THREADS
     if (timeout == 1) {
         PyErr_SetString(socket_timeout, "timed out");
         return -1;
     }
     END_SELECT_LOOP(s)
 */
 
 #define BEGIN_SELECT_LOOP(s) \
     { \
-        _PyTimeSpec now, deadline = {0, 0}; \
+        _PyTime_timeval now, deadline = {0, 0}; \
         double interval = s->sock_timeout; \
         int has_timeout = s->sock_timeout > 0.0; \
         if (has_timeout) { \
-            _PyTimeSpec_get_time(&now); \
+            _PyTime_monotonic(&now); \
             deadline = now; \
-            _PyTimeSpec_add_sec(&deadline, s->sock_timeout); \
+            _PyTime_ADD_SECONDS(deadline, s->sock_timeout); \
         } \
         while (1) { \
             errno = 0; \
 
 #define END_SELECT_LOOP(s) \
             if (!has_timeout || \
                 (!CHECK_ERRNO(EWOULDBLOCK) && !CHECK_ERRNO(EAGAIN))) \
                 break; \
-            _PyTimeSpec_get_time(&now); \
-            interval = _PyTimeSpec_interval_sec(&now, &deadline); \
+            _PyTime_monotonic(&now); \
+            interval = _PyTime_INTERVAL(now, deadline); \
         } \
     } \
 
 /* Initialize a new socket object. */
 
 static double defaulttimeout = -1.0; /* Default timeout for new sockets */
 
 static void
 init_sockobject(PySocketSockObject *s,
                 SOCKET_T fd, int family, int type, int proto)
@@ skipping 500 matching lines @@
         /* If we don't know the address family, don't raise an
            exception -- return it as an (int, bytes) tuple. */
         return Py_BuildValue("iy#",
                              addr->sa_family,
                              addr->sa_data,
                              sizeof(addr->sa_data));
 
     }
 }
 
+/* Helper for getsockaddrarg: bypass IDNA for ASCII-only host names
+   (in particular, numeric IP addresses). */
+struct maybe_idna {
+    PyObject *obj;
+    char *buf;
+};
+
+static void
+idna_cleanup(struct maybe_idna *data)
+{
+    Py_CLEAR(data->obj);
+}
+
+static int
+idna_converter(PyObject *obj, struct maybe_idna *data)
+{
+    size_t len;
+    PyObject *obj2, *obj3;
+    if (obj == NULL) {
+        idna_cleanup(data);
+        return 1;
+    }
+    data->obj = NULL;
+    len = -1;
+    if (PyBytes_Check(obj)) {
+        data->buf = PyBytes_AsString(obj);
+        len = PyBytes_Size(obj);
+    }
+    else if (PyByteArray_Check(obj)) {
+        data->buf = PyByteArray_AsString(obj);
+        len = PyByteArray_Size(obj);
+    }
+    else if (PyUnicode_Check(obj) && PyUnicode_READY(obj) == 0 && PyUnicode_IS_COMPACT_ASCII(obj)) {
+        data->buf = PyUnicode_DATA(obj);
+        len = PyUnicode_GET_LENGTH(obj);
+    }
+    else {
+        obj2 = PyUnicode_FromObject(obj);
+        if (!obj2) {
+            PyErr_Format(PyExc_TypeError, "string or unicode text buffer expected, not %s",
+                         obj->ob_type->tp_name);
+            return 0;
+        }
+        obj3 = PyUnicode_AsEncodedString(obj2, "idna", NULL);
+        Py_DECREF(obj2);
+        if (!obj3) {
+            PyErr_SetString(PyExc_TypeError, "encoding of hostname failed");
+            return 0;
+        }
+        if (!PyBytes_Check(obj3)) {
+            Py_DECREF(obj3);
+            PyErr_SetString(PyExc_TypeError, "encoding of hostname failed to return bytes");
+            return 0;
+        }
+        data->obj = obj3;
+        data->buf = PyBytes_AS_STRING(obj3);
+        len = PyBytes_GET_SIZE(obj3);
+    }
+    if (strlen(data->buf) != len) {
+        Py_CLEAR(data->obj);
+        PyErr_SetString(PyExc_TypeError, "host name must not contain NUL character");
+        return 0;
+    }
+    return Py_CLEANUP_SUPPORTED;
+}
 
 /* Parse a socket address argument according to the socket object's
    address family.  Return 1 if the address was in the proper format,
    0 of not.  The address is returned through addr_ret, its length
    through len_ret. */
 
 static int
 getsockaddrarg(PySocketSockObject *s, PyObject *args,
                struct sockaddr *addr_ret, int *len_ret)
 {
@@ skipping 10 matching lines @@
         /* PEP 383.  Not using PyUnicode_FSConverter since we need to
            allow embedded nulls on Linux. */
         if (PyUnicode_Check(args)) {
             if ((args = PyUnicode_EncodeFSDefault(args)) == NULL)
                 return 0;
         }
         else
             Py_INCREF(args);
         if (!PyArg_Parse(args, "y#", &path, &len))
             goto unix_out;
+        assert(len >= 0);
 
         addr = (struct sockaddr_un*)addr_ret;
 #ifdef linux
         if (len > 0 && path[0] == 0) {
             /* Linux abstract namespace extension */
-            if (len > sizeof addr->sun_path) {
+            if ((size_t)len > sizeof addr->sun_path) {
                 PyErr_SetString(PyExc_OSError,
                                 "AF_UNIX path too long");
                 goto unix_out;
             }
         }
         else
 #endif /* linux */
         {
             /* regular NULL-terminated string */
-            if (len >= sizeof addr->sun_path) {
+            if ((size_t)len >= sizeof addr->sun_path) {
                 PyErr_SetString(PyExc_OSError,
                                 "AF_UNIX path too long");
                 goto unix_out;
             }
             addr->sun_path[len] = 0;
         }
         addr->sun_family = s->sock_family;
         memcpy(addr->sun_path, path, len);
         *len_ret = len + offsetof(struct sockaddr_un, sun_path);
         retval = 1;
@@ skipping 28 matching lines @@
 #endif
 
 #ifdef AF_RDS
     case AF_RDS:
         /* RDS sockets use sockaddr_in: fall-through */
 #endif
 
     case AF_INET:
     {
         struct sockaddr_in* addr;
-        char *host;
+        struct maybe_idna host = {NULL, NULL};
         int port, result;
         if (!PyTuple_Check(args)) {
             PyErr_Format(
                 PyExc_TypeError,
                 "getsockaddrarg: "
                 "AF_INET address must be tuple, not %.500s",
                 Py_TYPE(args)->tp_name);
             return 0;
         }
-        if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
-                              "idna", &host, &port))
+        if (!PyArg_ParseTuple(args, "O&i:getsockaddrarg",
+                              idna_converter, &host, &port))
             return 0;
         addr=(struct sockaddr_in*)addr_ret;
-        result = setipaddr(host, (struct sockaddr *)addr,
+        result = setipaddr(host.buf, (struct sockaddr *)addr,
                            sizeof(*addr),  AF_INET);
-        PyMem_Free(host);
+        idna_cleanup(&host);
         if (result < 0)
             return 0;
         if (port < 0 || port > 0xffff) {
             PyErr_SetString(
                 PyExc_OverflowError,
                 "getsockaddrarg: port must be 0-65535.");
             return 0;
         }
         addr->sin_family = AF_INET;
         addr->sin_port = htons((short)port);
         *len_ret = sizeof *addr;
         return 1;
     }
 
 #ifdef ENABLE_IPV6
     case AF_INET6:
     {
         struct sockaddr_in6* addr;
-        char *host;
+        struct maybe_idna host = {NULL, NULL};
         int port, result;
         unsigned int flowinfo, scope_id;
         flowinfo = scope_id = 0;
         if (!PyTuple_Check(args)) {
             PyErr_Format(
                 PyExc_TypeError,
                 "getsockaddrarg: "
                 "AF_INET6 address must be tuple, not %.500s",
                 Py_TYPE(args)->tp_name);
             return 0;
         }
-        if (!PyArg_ParseTuple(args, "eti|II",
-                              "idna", &host, &port, &flowinfo,
+        if (!PyArg_ParseTuple(args, "O&i|II",
+                              idna_converter, &host, &port, &flowinfo,
                               &scope_id)) {
             return 0;
         }
         addr = (struct sockaddr_in6*)addr_ret;
-        result = setipaddr(host, (struct sockaddr *)addr,
+        result = setipaddr(host.buf, (struct sockaddr *)addr,
                            sizeof(*addr), AF_INET6);
-        PyMem_Free(host);
+        idna_cleanup(&host);
         if (result < 0)
             return 0;
         if (port < 0 || port > 0xffff) {
             PyErr_SetString(
                 PyExc_OverflowError,
                 "getsockaddrarg: port must be 0-65535.");
             return 0;
         }
         if (flowinfo > 0xfffff) {
             PyErr_SetString(
@@ skipping 227 matching lines @@
             addr = (struct sockaddr_can *)addr_ret;
 
             if (!PyArg_ParseTuple(args, "O&", PyUnicode_FSConverter,
                                               &interfaceName))
                 return 0;
 
             len = PyBytes_GET_SIZE(interfaceName);
 
             if (len == 0) {
                 ifr.ifr_ifindex = 0;
-            } else if (len < sizeof(ifr.ifr_name)) {
+            } else if ((size_t)len < sizeof(ifr.ifr_name)) {
                 strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
                 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
                 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
                     s->errorhandler();
                     Py_DECREF(interfaceName);
                     return 0;
                 }
             } else {
                 PyErr_SetString(PyExc_OSError,
                                 "AF_CAN interface name too long");
@@ skipping 2594 matching lines @@
 
 PyDoc_STRVAR(gethostbyname_doc,
 "gethostbyname(host) -> address\n\
 \n\
 Return the IP address (a string of the form '255.255.255.255') for a host.");
 
 
 /* Convenience function common to gethostbyname_ex and gethostbyaddr */
 
 static PyObject *
-gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
+gethost_common(struct hostent *h, struct sockaddr *addr, size_t alen, int af)
 {
     char **pch;
     PyObject *rtn_tuple = (PyObject *)NULL;
     PyObject *name_list = (PyObject *)NULL;
     PyObject *addr_list = (PyObject *)NULL;
     PyObject *tmp;
 
     if (h == NULL) {
         /* Let's get real error message to return */
         set_herror(h_errno);
@@ skipping 2699 matching lines @@
             return NULL;
         memcpy(&packed_addr, src, sizeof(packed_addr));
         return strncpy(dst, inet_ntoa(packed_addr), size);
     }
     /* Should set errno to EAFNOSUPPORT */
     return NULL;
 }
 
 #endif
 #endif