Branch data     Line data    Source code

       1                 :            : /*[clinic input]
       2                 :            : preserve
       3                 :            : [clinic start generated code]*/
       4                 :            : 
       5                 :            : #if defined(MS_WINDOWS)
       6                 :            : 
       7                 :            : PyDoc_STRVAR(_multiprocessing_closesocket__doc__,
       8                 :            : "closesocket($module, handle, /)\n"
       9                 :            : "--\n"
      10                 :            : "\n");
      11                 :            : 
      12                 :            : #define _MULTIPROCESSING_CLOSESOCKET_METHODDEF    \
      13                 :            :     {"closesocket", (PyCFunction)_multiprocessing_closesocket, METH_O, _multiprocessing_closesocket__doc__},
      14                 :            : 
      15                 :            : static PyObject *
      16                 :            : _multiprocessing_closesocket_impl(PyObject *module, HANDLE handle);
      17                 :            : 
      18                 :            : static PyObject *
      19                 :            : _multiprocessing_closesocket(PyObject *module, PyObject *arg)
      20                 :            : {
      21                 :            :     PyObject *return_value = NULL;
      22                 :            :     HANDLE handle;
      23                 :            : 
      24                 :            :     handle = PyLong_AsVoidPtr(arg);
      25                 :            :     if (!handle && PyErr_Occurred()) {
      26                 :            :         goto exit;
      27                 :            :     }
      28                 :            :     return_value = _multiprocessing_closesocket_impl(module, handle);
      29                 :            : 
      30                 :            : exit:
      31                 :            :     return return_value;
      32                 :            : }
      33                 :            : 
      34                 :            : #endif /* defined(MS_WINDOWS) */
      35                 :            : 
      36                 :            : #if defined(MS_WINDOWS)
      37                 :            : 
      38                 :            : PyDoc_STRVAR(_multiprocessing_recv__doc__,
      39                 :            : "recv($module, handle, size, /)\n"
      40                 :            : "--\n"
      41                 :            : "\n");
      42                 :            : 
      43                 :            : #define _MULTIPROCESSING_RECV_METHODDEF    \
      44                 :            :     {"recv", _PyCFunction_CAST(_multiprocessing_recv), METH_FASTCALL, _multiprocessing_recv__doc__},
      45                 :            : 
      46                 :            : static PyObject *
      47                 :            : _multiprocessing_recv_impl(PyObject *module, HANDLE handle, int size);
      48                 :            : 
      49                 :            : static PyObject *
      50                 :            : _multiprocessing_recv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
      51                 :            : {
      52                 :            :     PyObject *return_value = NULL;
      53                 :            :     HANDLE handle;
      54                 :            :     int size;
      55                 :            : 
      56                 :            :     if (!_PyArg_CheckPositional("recv", nargs, 2, 2)) {
      57                 :            :         goto exit;
      58                 :            :     }
      59                 :            :     handle = PyLong_AsVoidPtr(args[0]);
      60                 :            :     if (!handle && PyErr_Occurred()) {
      61                 :            :         goto exit;
      62                 :            :     }
      63                 :            :     size = _PyLong_AsInt(args[1]);
      64                 :            :     if (size == -1 && PyErr_Occurred()) {
      65                 :            :         goto exit;
      66                 :            :     }
      67                 :            :     return_value = _multiprocessing_recv_impl(module, handle, size);
      68                 :            : 
      69                 :            : exit:
      70                 :            :     return return_value;
      71                 :            : }
      72                 :            : 
      73                 :            : #endif /* defined(MS_WINDOWS) */
      74                 :            : 
      75                 :            : #if defined(MS_WINDOWS)
      76                 :            : 
      77                 :            : PyDoc_STRVAR(_multiprocessing_send__doc__,
      78                 :            : "send($module, handle, buf, /)\n"
      79                 :            : "--\n"
      80                 :            : "\n");
      81                 :            : 
      82                 :            : #define _MULTIPROCESSING_SEND_METHODDEF    \
      83                 :            :     {"send", _PyCFunction_CAST(_multiprocessing_send), METH_FASTCALL, _multiprocessing_send__doc__},
      84                 :            : 
      85                 :            : static PyObject *
      86                 :            : _multiprocessing_send_impl(PyObject *module, HANDLE handle, Py_buffer *buf);
      87                 :            : 
      88                 :            : static PyObject *
      89                 :            : _multiprocessing_send(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
      90                 :            : {
      91                 :            :     PyObject *return_value = NULL;
      92                 :            :     HANDLE handle;
      93                 :            :     Py_buffer buf = {NULL, NULL};
      94                 :            : 
      95                 :            :     if (!_PyArg_CheckPositional("send", nargs, 2, 2)) {
      96                 :            :         goto exit;
      97                 :            :     }
      98                 :            :     handle = PyLong_AsVoidPtr(args[0]);
      99                 :            :     if (!handle && PyErr_Occurred()) {
     100                 :            :         goto exit;
     101                 :            :     }
     102                 :            :     if (PyObject_GetBuffer(args[1], &buf, PyBUF_SIMPLE) != 0) {
     103                 :            :         goto exit;
     104                 :            :     }
     105                 :            :     if (!PyBuffer_IsContiguous(&buf, 'C')) {
     106                 :            :         _PyArg_BadArgument("send", "argument 2", "contiguous buffer", args[1]);
     107                 :            :         goto exit;
     108                 :            :     }
     109                 :            :     return_value = _multiprocessing_send_impl(module, handle, &buf);
     110                 :            : 
     111                 :            : exit:
     112                 :            :     /* Cleanup for buf */
     113                 :            :     if (buf.obj) {
     114                 :            :        PyBuffer_Release(&buf);
     115                 :            :     }
     116                 :            : 
     117                 :            :     return return_value;
     118                 :            : }
     119                 :            : 
     120                 :            : #endif /* defined(MS_WINDOWS) */
     121                 :            : 
     122                 :            : PyDoc_STRVAR(_multiprocessing_sem_unlink__doc__,
     123                 :            : "sem_unlink($module, name, /)\n"
     124                 :            : "--\n"
     125                 :            : "\n");
     126                 :            : 
     127                 :            : #define _MULTIPROCESSING_SEM_UNLINK_METHODDEF    \
     128                 :            :     {"sem_unlink", (PyCFunction)_multiprocessing_sem_unlink, METH_O, _multiprocessing_sem_unlink__doc__},
     129                 :            : 
     130                 :            : static PyObject *
     131                 :            : _multiprocessing_sem_unlink_impl(PyObject *module, const char *name);
     132                 :            : 
     133                 :            : static PyObject *
     134                 :       2527 : _multiprocessing_sem_unlink(PyObject *module, PyObject *arg)
     135                 :            : {
     136                 :       2527 :     PyObject *return_value = NULL;
     137                 :            :     const char *name;
     138                 :            : 
     139         [ -  + ]:       2527 :     if (!PyUnicode_Check(arg)) {
     140                 :          0 :         _PyArg_BadArgument("sem_unlink", "argument", "str", arg);
     141                 :          0 :         goto exit;
     142                 :            :     }
     143                 :            :     Py_ssize_t name_length;
     144                 :       2527 :     name = PyUnicode_AsUTF8AndSize(arg, &name_length);
     145         [ -  + ]:       2527 :     if (name == NULL) {
     146                 :          0 :         goto exit;
     147                 :            :     }
     148         [ -  + ]:       2527 :     if (strlen(name) != (size_t)name_length) {
     149                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
     150                 :          0 :         goto exit;
     151                 :            :     }
     152                 :       2527 :     return_value = _multiprocessing_sem_unlink_impl(module, name);
     153                 :            : 
     154                 :       2527 : exit:
     155                 :       2527 :     return return_value;
     156                 :            : }
     157                 :            : 
     158                 :            : #ifndef _MULTIPROCESSING_CLOSESOCKET_METHODDEF
     159                 :            :     #define _MULTIPROCESSING_CLOSESOCKET_METHODDEF
     160                 :            : #endif /* !defined(_MULTIPROCESSING_CLOSESOCKET_METHODDEF) */
     161                 :            : 
     162                 :            : #ifndef _MULTIPROCESSING_RECV_METHODDEF
     163                 :            :     #define _MULTIPROCESSING_RECV_METHODDEF
     164                 :            : #endif /* !defined(_MULTIPROCESSING_RECV_METHODDEF) */
     165                 :            : 
     166                 :            : #ifndef _MULTIPROCESSING_SEND_METHODDEF
     167                 :            :     #define _MULTIPROCESSING_SEND_METHODDEF
     168                 :            : #endif /* !defined(_MULTIPROCESSING_SEND_METHODDEF) */
     169                 :            : /*[clinic end generated code: output=ab64ce752f933c55 input=a9049054013a1b77]*/