LCOV - code coverage report
Current view: | top level - Modules - termios.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 26 | 190 | 13.7 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 6 | 14 | 42.9 %
|  |  | Branches: | 9 | 92 | 9.8 %

               Branch data     Line data    Source code
           1                 :            : /* termios.c -- POSIX terminal I/O module implementation.  */
           2                 :            :
           3                 :            : #include "Python.h"
           4                 :            :
           5                 :            : /* Apparently, on SGI, termios.h won't define CTRL if _XOPEN_SOURCE
           6                 :            :    is defined, so we define it here. */
           7                 :            : #if defined(__sgi)
           8                 :            : #define CTRL(c) ((c)&037)
           9                 :            : #endif
          10                 :            :
          11                 :            : #if defined(__sun)
          12                 :            : /* We could do better. Check issue-32660 */
          13                 :            : #include <sys/filio.h>
          14                 :            : #include <sys/sockio.h>
          15                 :            : #endif
          16                 :            :
          17                 :            : #include <termios.h>
          18                 :            : #include <sys/ioctl.h>
          19                 :            :
          20                 :            : /* HP-UX requires that this be included to pick up MDCD, MCTS, MDSR,
          21                 :            :  * MDTR, MRI, and MRTS (apparently used internally by some things
          22                 :            :  * defined as macros; these are not used here directly).
          23                 :            :  */
          24                 :            : #ifdef HAVE_SYS_MODEM_H
          25                 :            : #include <sys/modem.h>
          26                 :            : #endif
          27                 :            : /* HP-UX requires that this be included to pick up TIOCGPGRP and friends */
          28                 :            : #ifdef HAVE_SYS_BSDTTY_H
          29                 :            : #include <sys/bsdtty.h>
          30                 :            : #endif
          31                 :            :
          32                 :            : /*[clinic input]
          33                 :            : module termios
          34                 :            : [clinic start generated code]*/
          35                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=01105c85d0ca7252]*/
          36                 :            :
          37                 :            : #include "clinic/termios.c.h"
          38                 :            :
          39                 :            : PyDoc_STRVAR(termios__doc__,
          40                 :            : "This module provides an interface to the Posix calls for tty I/O control.\n\
          41                 :            : For a complete description of these calls, see the Posix or Unix manual\n\
          42                 :            : pages. It is only available for those Unix versions that support Posix\n\
          43                 :            : termios style tty I/O control.\n\
          44                 :            : \n\
          45                 :            : All functions in this module take a file descriptor fd as their first\n\
          46                 :            : argument. This can be an integer file descriptor, such as returned by\n\
          47                 :            : sys.stdin.fileno(), or a file object, such as sys.stdin itself.");
          48                 :            :
          49                 :            : typedef struct {
          50                 :            :   PyObject *TermiosError;
          51                 :            : } termiosmodulestate;
          52                 :            :
          53                 :            : static inline termiosmodulestate*
          54                 :         85 : get_termios_state(PyObject *module)
          55                 :            : {
          56                 :         85 :     void *state = PyModule_GetState(module);
          57                 :            :     assert(state != NULL);
          58                 :         85 :     return (termiosmodulestate *)state;
          59                 :            : }
          60                 :            :
          61                 :            : static struct PyModuleDef termiosmodule;
          62                 :            :
          63                 :            : /*[clinic input]
          64                 :            : termios.tcgetattr
          65                 :            :
          66                 :            :     fd: fildes
          67                 :            :     /
          68                 :            :
          69                 :            : Get the tty attributes for file descriptor fd.
          70                 :            :
          71                 :            : Returns a list [iflag, oflag, cflag, lflag, ispeed, ospeed, cc]
          72                 :            : where cc is a list of the tty special characters (each a string of
          73                 :            : length 1, except the items with indices VMIN and VTIME, which are
          74                 :            : integers when these fields are defined).  The interpretation of the
          75                 :            : flags and the speeds as well as the indexing in the cc array must be
          76                 :            : done using the symbolic constants defined in this module.
          77                 :            : [clinic start generated code]*/
          78                 :            :
          79                 :            : static PyObject *
          80                 :          0 : termios_tcgetattr_impl(PyObject *module, int fd)
          81                 :            : /*[clinic end generated code: output=2b3da39db870e629 input=54dad9779ebe74b1]*/
          82                 :            : {
          83                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
          84                 :            :     struct termios mode;
          85                 :            :     int r;
          86                 :            :
          87                 :          0 :     Py_BEGIN_ALLOW_THREADS
          88                 :          0 :     r = tcgetattr(fd, &mode);
          89                 :          0 :     Py_END_ALLOW_THREADS
          90         [ #  # ]:          0 :     if (r == -1) {
          91                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
          92                 :            :     }
          93                 :            :
          94                 :          0 :     speed_t ispeed = cfgetispeed(&mode);
          95                 :          0 :     speed_t ospeed = cfgetospeed(&mode);
          96                 :            :
          97                 :          0 :     PyObject *cc = PyList_New(NCCS);
          98         [ #  # ]:          0 :     if (cc == NULL) {
          99                 :          0 :         return NULL;
         100                 :            :     }
         101                 :            :
         102                 :            :     PyObject *v;
         103                 :            :     int i;
         104         [ #  # ]:          0 :     for (i = 0; i < NCCS; i++) {
         105                 :          0 :         char ch = (char)mode.c_cc[i];
         106                 :          0 :         v = PyBytes_FromStringAndSize(&ch, 1);
         107         [ #  # ]:          0 :         if (v == NULL)
         108                 :          0 :             goto err;
         109                 :          0 :         PyList_SetItem(cc, i, v);
         110                 :            :     }
         111                 :            :
         112                 :            :     /* Convert the MIN and TIME slots to integer.  On some systems, the
         113                 :            :        MIN and TIME slots are the same as the EOF and EOL slots.  So we
         114                 :            :        only do this in noncanonical input mode.  */
         115         [ #  # ]:          0 :     if ((mode.c_lflag & ICANON) == 0) {
         116                 :          0 :         v = PyLong_FromLong((long)mode.c_cc[VMIN]);
         117         [ #  # ]:          0 :         if (v == NULL)
         118                 :          0 :             goto err;
         119                 :          0 :         PyList_SetItem(cc, VMIN, v);
         120                 :          0 :         v = PyLong_FromLong((long)mode.c_cc[VTIME]);
         121         [ #  # ]:          0 :         if (v == NULL)
         122                 :          0 :             goto err;
         123                 :          0 :         PyList_SetItem(cc, VTIME, v);
         124                 :            :     }
         125                 :            :
         126         [ #  # ]:          0 :     if (!(v = PyList_New(7)))
         127                 :          0 :         goto err;
         128                 :            :
         129                 :          0 :     PyList_SetItem(v, 0, PyLong_FromLong((long)mode.c_iflag));
         130                 :          0 :     PyList_SetItem(v, 1, PyLong_FromLong((long)mode.c_oflag));
         131                 :          0 :     PyList_SetItem(v, 2, PyLong_FromLong((long)mode.c_cflag));
         132                 :          0 :     PyList_SetItem(v, 3, PyLong_FromLong((long)mode.c_lflag));
         133                 :          0 :     PyList_SetItem(v, 4, PyLong_FromLong((long)ispeed));
         134                 :          0 :     PyList_SetItem(v, 5, PyLong_FromLong((long)ospeed));
         135         [ #  # ]:          0 :     if (PyErr_Occurred()) {
         136                 :          0 :         Py_DECREF(v);
         137                 :          0 :         goto err;
         138                 :            :     }
         139                 :          0 :     PyList_SetItem(v, 6, cc);
         140                 :          0 :     return v;
         141                 :          0 :   err:
         142                 :          0 :     Py_DECREF(cc);
         143                 :          0 :     return NULL;
         144                 :            : }
         145                 :            :
         146                 :            : /*[clinic input]
         147                 :            : termios.tcsetattr
         148                 :            :
         149                 :            :     fd: fildes
         150                 :            :     when: int
         151                 :            :     attributes as term: object
         152                 :            :     /
         153                 :            :
         154                 :            : Set the tty attributes for file descriptor fd.
         155                 :            :
         156                 :            : The attributes to be set are taken from the attributes argument, which
         157                 :            : is a list like the one returned by tcgetattr(). The when argument
         158                 :            : determines when the attributes are changed: termios.TCSANOW to
         159                 :            : change immediately, termios.TCSADRAIN to change after transmitting all
         160                 :            : queued output, or termios.TCSAFLUSH to change after transmitting all
         161                 :            : queued output and discarding all queued input.
         162                 :            : [clinic start generated code]*/
         163                 :            :
         164                 :            : static PyObject *
         165                 :          0 : termios_tcsetattr_impl(PyObject *module, int fd, int when, PyObject *term)
         166                 :            : /*[clinic end generated code: output=bcd2b0a7b98a4bf5 input=5dafabdd5a08f018]*/
         167                 :            : {
         168   [ #  #  #  # ]:          0 :     if (!PyList_Check(term) || PyList_Size(term) != 7) {
         169                 :          0 :         PyErr_SetString(PyExc_TypeError,
         170                 :            :                      "tcsetattr, arg 3: must be 7 element list");
         171                 :          0 :         return NULL;
         172                 :            :     }
         173                 :            :
         174                 :            :     /* Get the old mode, in case there are any hidden fields... */
         175                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         176                 :            :     struct termios mode;
         177                 :            :     int r;
         178                 :            :
         179                 :          0 :     Py_BEGIN_ALLOW_THREADS
         180                 :          0 :     r = tcgetattr(fd, &mode);
         181                 :          0 :     Py_END_ALLOW_THREADS
         182         [ #  # ]:          0 :     if (r == -1) {
         183                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         184                 :            :     }
         185                 :            :
         186                 :          0 :     mode.c_iflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 0));
         187                 :          0 :     mode.c_oflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 1));
         188                 :          0 :     mode.c_cflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 2));
         189                 :          0 :     mode.c_lflag = (tcflag_t) PyLong_AsLong(PyList_GetItem(term, 3));
         190                 :          0 :     speed_t ispeed = (speed_t) PyLong_AsLong(PyList_GetItem(term, 4));
         191                 :          0 :     speed_t ospeed = (speed_t) PyLong_AsLong(PyList_GetItem(term, 5));
         192                 :          0 :     PyObject *cc = PyList_GetItem(term, 6);
         193         [ #  # ]:          0 :     if (PyErr_Occurred()) {
         194                 :          0 :         return NULL;
         195                 :            :     }
         196                 :            :
         197   [ #  #  #  # ]:          0 :     if (!PyList_Check(cc) || PyList_Size(cc) != NCCS) {
         198                 :          0 :         PyErr_Format(PyExc_TypeError,
         199                 :            :             "tcsetattr: attributes[6] must be %d element list",
         200                 :            :                  NCCS);
         201                 :          0 :         return NULL;
         202                 :            :     }
         203                 :            :
         204                 :            :     int i;
         205                 :            :     PyObject *v;
         206         [ #  # ]:          0 :     for (i = 0; i < NCCS; i++) {
         207                 :          0 :         v = PyList_GetItem(cc, i);
         208                 :            :
         209   [ #  #  #  # ]:          0 :         if (PyBytes_Check(v) && PyBytes_Size(v) == 1)
         210                 :          0 :             mode.c_cc[i] = (cc_t) * PyBytes_AsString(v);
         211         [ #  # ]:          0 :         else if (PyLong_Check(v))
         212                 :          0 :             mode.c_cc[i] = (cc_t) PyLong_AsLong(v);
         213                 :            :         else {
         214                 :          0 :             PyErr_SetString(PyExc_TypeError,
         215                 :            :      "tcsetattr: elements of attributes must be characters or integers");
         216                 :          0 :                         return NULL;
         217                 :            :                 }
         218                 :            :     }
         219                 :            :
         220         [ #  # ]:          0 :     if (cfsetispeed(&mode, (speed_t) ispeed) == -1)
         221                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         222         [ #  # ]:          0 :     if (cfsetospeed(&mode, (speed_t) ospeed) == -1)
         223                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         224                 :            :
         225                 :          0 :     Py_BEGIN_ALLOW_THREADS
         226                 :          0 :     r = tcsetattr(fd, when, &mode);
         227                 :          0 :     Py_END_ALLOW_THREADS
         228                 :            :
         229         [ #  # ]:          0 :     if (r == -1)
         230                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         231                 :            :
         232                 :          0 :     Py_RETURN_NONE;
         233                 :            : }
         234                 :            :
         235                 :            : /*[clinic input]
         236                 :            : termios.tcsendbreak
         237                 :            :
         238                 :            :     fd: fildes
         239                 :            :     duration: int
         240                 :            :     /
         241                 :            :
         242                 :            : Send a break on file descriptor fd.
         243                 :            :
         244                 :            : A zero duration sends a break for 0.25-0.5 seconds; a nonzero duration
         245                 :            : has a system dependent meaning.
         246                 :            : [clinic start generated code]*/
         247                 :            :
         248                 :            : static PyObject *
         249                 :          0 : termios_tcsendbreak_impl(PyObject *module, int fd, int duration)
         250                 :            : /*[clinic end generated code: output=5945f589b5d3ac66 input=dc2f32417691f8ed]*/
         251                 :            : {
         252                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         253                 :            :     int r;
         254                 :            :
         255                 :          0 :     Py_BEGIN_ALLOW_THREADS
         256                 :          0 :     r = tcsendbreak(fd, duration);
         257                 :          0 :     Py_END_ALLOW_THREADS
         258                 :            :
         259         [ #  # ]:          0 :     if (r == -1) {
         260                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         261                 :            :     }
         262                 :            :
         263                 :          0 :     Py_RETURN_NONE;
         264                 :            : }
         265                 :            :
         266                 :            : /*[clinic input]
         267                 :            : termios.tcdrain
         268                 :            :
         269                 :            :     fd: fildes
         270                 :            :     /
         271                 :            :
         272                 :            : Wait until all output written to file descriptor fd has been transmitted.
         273                 :            : [clinic start generated code]*/
         274                 :            :
         275                 :            : static PyObject *
         276                 :          0 : termios_tcdrain_impl(PyObject *module, int fd)
         277                 :            : /*[clinic end generated code: output=5fd86944c6255955 input=c99241b140b32447]*/
         278                 :            : {
         279                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         280                 :            :     int r;
         281                 :            :
         282                 :          0 :     Py_BEGIN_ALLOW_THREADS
         283                 :          0 :     r = tcdrain(fd);
         284                 :          0 :     Py_END_ALLOW_THREADS
         285                 :            :
         286         [ #  # ]:          0 :     if (r == -1) {
         287                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         288                 :            :     }
         289                 :            :
         290                 :          0 :     Py_RETURN_NONE;
         291                 :            : }
         292                 :            :
         293                 :            : /*[clinic input]
         294                 :            : termios.tcflush
         295                 :            :
         296                 :            :     fd: fildes
         297                 :            :     queue: int
         298                 :            :     /
         299                 :            :
         300                 :            : Discard queued data on file descriptor fd.
         301                 :            :
         302                 :            : The queue selector specifies which queue: termios.TCIFLUSH for the input
         303                 :            : queue, termios.TCOFLUSH for the output queue, or termios.TCIOFLUSH for
         304                 :            : both queues.
         305                 :            : [clinic start generated code]*/
         306                 :            :
         307                 :            : static PyObject *
         308                 :          0 : termios_tcflush_impl(PyObject *module, int fd, int queue)
         309                 :            : /*[clinic end generated code: output=2424f80312ec2f21 input=0f7d08122ddc07b5]*/
         310                 :            : {
         311                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         312                 :            :     int r;
         313                 :            :
         314                 :          0 :     Py_BEGIN_ALLOW_THREADS
         315                 :          0 :     r = tcflush(fd, queue);
         316                 :          0 :     Py_END_ALLOW_THREADS
         317                 :            :
         318         [ #  # ]:          0 :     if (r == -1) {
         319                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         320                 :            :     }
         321                 :            :
         322                 :          0 :     Py_RETURN_NONE;
         323                 :            : }
         324                 :            :
         325                 :            : /*[clinic input]
         326                 :            : termios.tcflow
         327                 :            :
         328                 :            :     fd: fildes
         329                 :            :     action: int
         330                 :            :     /
         331                 :            :
         332                 :            : Suspend or resume input or output on file descriptor fd.
         333                 :            :
         334                 :            : The action argument can be termios.TCOOFF to suspend output,
         335                 :            : termios.TCOON to restart output, termios.TCIOFF to suspend input,
         336                 :            : or termios.TCION to restart input.
         337                 :            : [clinic start generated code]*/
         338                 :            :
         339                 :            : static PyObject *
         340                 :          0 : termios_tcflow_impl(PyObject *module, int fd, int action)
         341                 :            : /*[clinic end generated code: output=afd10928e6ea66eb input=c6aff0640b6efd9c]*/
         342                 :            : {
         343                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         344                 :            :     int r;
         345                 :            :
         346                 :          0 :     Py_BEGIN_ALLOW_THREADS
         347                 :          0 :     r = tcflow(fd, action);
         348                 :          0 :     Py_END_ALLOW_THREADS
         349                 :            :
         350         [ #  # ]:          0 :     if (r == -1) {
         351                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         352                 :            :     }
         353                 :            :
         354                 :          0 :     Py_RETURN_NONE;
         355                 :            : }
         356                 :            :
         357                 :            : /*[clinic input]
         358                 :            : termios.tcgetwinsize
         359                 :            :
         360                 :            :     fd: fildes
         361                 :            :     /
         362                 :            :
         363                 :            : Get the tty winsize for file descriptor fd.
         364                 :            :
         365                 :            : Returns a tuple (ws_row, ws_col).
         366                 :            : [clinic start generated code]*/
         367                 :            :
         368                 :            : static PyObject *
         369                 :          0 : termios_tcgetwinsize_impl(PyObject *module, int fd)
         370                 :            : /*[clinic end generated code: output=31825977d5325fb6 input=5706c379d7fd984d]*/
         371                 :            : {
         372                 :            : #if defined(TIOCGWINSZ)
         373                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         374                 :            :     struct winsize w;
         375                 :            :     int r;
         376                 :            :
         377                 :          0 :     Py_BEGIN_ALLOW_THREADS
         378                 :          0 :     r = ioctl(fd, TIOCGWINSZ, &w);
         379                 :          0 :     Py_END_ALLOW_THREADS
         380                 :            :
         381         [ #  # ]:          0 :     if (r == -1) {
         382                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         383                 :            :     }
         384                 :            :
         385                 :            :     PyObject *v;
         386         [ #  # ]:          0 :     if (!(v = PyTuple_New(2))) {
         387                 :          0 :         return NULL;
         388                 :            :     }
         389                 :            :
         390                 :          0 :     PyTuple_SetItem(v, 0, PyLong_FromLong((long)w.ws_row));
         391                 :          0 :     PyTuple_SetItem(v, 1, PyLong_FromLong((long)w.ws_col));
         392         [ #  # ]:          0 :     if (PyErr_Occurred()) {
         393                 :          0 :         Py_DECREF(v);
         394                 :          0 :         return NULL;
         395                 :            :     }
         396                 :          0 :     return v;
         397                 :            : #elif defined(TIOCGSIZE)
         398                 :            :     termiosmodulestate *state = PyModule_GetState(module);
         399                 :            :     struct ttysize s;
         400                 :            :     int r;
         401                 :            :
         402                 :            :     Py_BEGIN_ALLOW_THREADS
         403                 :            :     r = ioctl(fd, TIOCGSIZE, &s);
         404                 :            :     Py_END_ALLOW_THREADS
         405                 :            :     if (r == -1) {
         406                 :            :         return PyErr_SetFromErrno(state->TermiosError);
         407                 :            :     }
         408                 :            :
         409                 :            :     PyObject *v;
         410                 :            :     if (!(v = PyTuple_New(2))) {
         411                 :            :         return NULL;
         412                 :            :     }
         413                 :            :
         414                 :            :     PyTuple_SetItem(v, 0, PyLong_FromLong((long)s.ts_lines));
         415                 :            :     PyTuple_SetItem(v, 1, PyLong_FromLong((long)s.ts_cols));
         416                 :            :     if (PyErr_Occurred()) {
         417                 :            :         Py_DECREF(v);
         418                 :            :         return NULL;
         419                 :            :     }
         420                 :            :     return v;
         421                 :            : #else
         422                 :            :     PyErr_SetString(PyExc_NotImplementedError,
         423                 :            :                     "requires termios.TIOCGWINSZ and/or termios.TIOCGSIZE");
         424                 :            :     return NULL;
         425                 :            : #endif /* defined(TIOCGWINSZ) */
         426                 :            : }
         427                 :            :
         428                 :            : /*[clinic input]
         429                 :            : termios.tcsetwinsize
         430                 :            :
         431                 :            :     fd: fildes
         432                 :            :     winsize as winsz: object
         433                 :            :     /
         434                 :            :
         435                 :            : Set the tty winsize for file descriptor fd.
         436                 :            :
         437                 :            : The winsize to be set is taken from the winsize argument, which
         438                 :            : is a two-item tuple (ws_row, ws_col) like the one returned by tcgetwinsize().
         439                 :            : [clinic start generated code]*/
         440                 :            :
         441                 :            : static PyObject *
         442                 :          0 : termios_tcsetwinsize_impl(PyObject *module, int fd, PyObject *winsz)
         443                 :            : /*[clinic end generated code: output=2ac3c9bb6eda83e1 input=4a06424465b24aee]*/
         444                 :            : {
         445   [ #  #  #  # ]:          0 :     if (!PySequence_Check(winsz) || PySequence_Size(winsz) != 2) {
         446                 :          0 :         PyErr_SetString(PyExc_TypeError,
         447                 :            :                      "tcsetwinsize, arg 2: must be a two-item sequence");
         448                 :          0 :         return NULL;
         449                 :            :     }
         450                 :            :
         451                 :            :     PyObject *tmp_item;
         452                 :            :     long winsz_0, winsz_1;
         453                 :          0 :     tmp_item = PySequence_GetItem(winsz, 0);
         454                 :          0 :     winsz_0 = PyLong_AsLong(tmp_item);
         455   [ #  #  #  # ]:          0 :     if (winsz_0 == -1 && PyErr_Occurred()) {
         456                 :          0 :         Py_XDECREF(tmp_item);
         457                 :          0 :         return NULL;
         458                 :            :     }
         459                 :          0 :     Py_XDECREF(tmp_item);
         460                 :          0 :     tmp_item = PySequence_GetItem(winsz, 1);
         461                 :          0 :     winsz_1 = PyLong_AsLong(tmp_item);
         462   [ #  #  #  # ]:          0 :     if (winsz_1 == -1 && PyErr_Occurred()) {
         463                 :          0 :         Py_XDECREF(tmp_item);
         464                 :          0 :         return NULL;
         465                 :            :     }
         466                 :          0 :     Py_XDECREF(tmp_item);
         467                 :            :
         468                 :          0 :     termiosmodulestate *state = PyModule_GetState(module);
         469                 :            :
         470                 :            : #if defined(TIOCGWINSZ) && defined(TIOCSWINSZ)
         471                 :            :     struct winsize w;
         472                 :            :     /* Get the old winsize because it might have
         473                 :            :        more fields such as xpixel, ypixel. */
         474         [ #  # ]:          0 :     if (ioctl(fd, TIOCGWINSZ, &w) == -1) {
         475                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         476                 :            :     }
         477                 :            :
         478                 :          0 :     w.ws_row = (unsigned short) winsz_0;
         479                 :          0 :     w.ws_col = (unsigned short) winsz_1;
         480   [ #  #  #  # ]:          0 :     if ((((long)w.ws_row) != winsz_0) || (((long)w.ws_col) != winsz_1)) {
         481                 :          0 :         PyErr_SetString(PyExc_OverflowError,
         482                 :            :                         "winsize value(s) out of range.");
         483                 :          0 :         return NULL;
         484                 :            :     }
         485                 :            :
         486                 :            :     int r;
         487                 :          0 :     Py_BEGIN_ALLOW_THREADS
         488                 :          0 :     r = ioctl(fd, TIOCSWINSZ, &w);
         489                 :          0 :     Py_END_ALLOW_THREADS
         490                 :            :
         491         [ #  # ]:          0 :     if (r == -1) {
         492                 :          0 :         return PyErr_SetFromErrno(state->TermiosError);
         493                 :            :     }
         494                 :            :
         495                 :          0 :     Py_RETURN_NONE;
         496                 :            : #elif defined(TIOCGSIZE) && defined(TIOCSSIZE)
         497                 :            :     struct ttysize s;
         498                 :            :     int r;
         499                 :            :     /* Get the old ttysize because it might have more fields. */
         500                 :            :     Py_BEGIN_ALLOW_THREADS
         501                 :            :     r = ioctl(fd, TIOCGSIZE, &s);
         502                 :            :     Py_END_ALLOW_THREADS
         503                 :            :
         504                 :            :     if (r == -1) {
         505                 :            :         return PyErr_SetFromErrno(state->TermiosError);
         506                 :            :     }
         507                 :            :
         508                 :            :     s.ts_lines = (int) winsz_0;
         509                 :            :     s.ts_cols = (int) winsz_1;
         510                 :            :     if ((((long)s.ts_lines) != winsz_0) || (((long)s.ts_cols) != winsz_1)) {
         511                 :            :         PyErr_SetString(PyExc_OverflowError,
         512                 :            :                         "winsize value(s) out of range.");
         513                 :            :         return NULL;
         514                 :            :     }
         515                 :            :
         516                 :            :     Py_BEGIN_ALLOW_THREADS
         517                 :            :     r = ioctl(fd, TIOCSSIZE, &s);
         518                 :            :     Py_END_ALLOW_THREADS
         519                 :            :
         520                 :            :     if (r == -1) {
         521                 :            :         return PyErr_SetFromErrno(state->TermiosError);
         522                 :            :     }
         523                 :            :
         524                 :            :     Py_RETURN_NONE;
         525                 :            : #else
         526                 :            :     PyErr_SetString(PyExc_NotImplementedError,
         527                 :            :                     "requires termios.TIOCGWINSZ, termios.TIOCSWINSZ and/or termios.TIOCGSIZE, termios.TIOCSSIZE");
         528                 :            :     return NULL;
         529                 :            : #endif /* defined(TIOCGWINSZ) && defined(TIOCSWINSZ) */
         530                 :            : }
         531                 :            :
         532                 :            : static PyMethodDef termios_methods[] =
         533                 :            : {
         534                 :            :     TERMIOS_TCGETATTR_METHODDEF
         535                 :            :     TERMIOS_TCSETATTR_METHODDEF
         536                 :            :     TERMIOS_TCSENDBREAK_METHODDEF
         537                 :            :     TERMIOS_TCDRAIN_METHODDEF
         538                 :            :     TERMIOS_TCFLUSH_METHODDEF
         539                 :            :     TERMIOS_TCFLOW_METHODDEF
         540                 :            :     TERMIOS_TCGETWINSIZE_METHODDEF
         541                 :            :     TERMIOS_TCSETWINSIZE_METHODDEF
         542                 :            :     {NULL, NULL}
         543                 :            : };
         544                 :            :
         545                 :            :
         546                 :            : #if defined(VSWTCH) && !defined(VSWTC)
         547                 :            : #define VSWTC VSWTCH
         548                 :            : #endif
         549                 :            :
         550                 :            : #if defined(VSWTC) && !defined(VSWTCH)
         551                 :            : #define VSWTCH VSWTC
         552                 :            : #endif
         553                 :            :
         554                 :            : static struct constant {
         555                 :            :     char *name;
         556                 :            :     long value;
         557                 :            : } termios_constants[] = {
         558                 :            :     /* cfgetospeed(), cfsetospeed() constants */
         559                 :            :     {"B0", B0},
         560                 :            :     {"B50", B50},
         561                 :            :     {"B75", B75},
         562                 :            :     {"B110", B110},
         563                 :            :     {"B134", B134},
         564                 :            :     {"B150", B150},
         565                 :            :     {"B200", B200},
         566                 :            :     {"B300", B300},
         567                 :            :     {"B600", B600},
         568                 :            :     {"B1200", B1200},
         569                 :            :     {"B1800", B1800},
         570                 :            :     {"B2400", B2400},
         571                 :            :     {"B4800", B4800},
         572                 :            :     {"B9600", B9600},
         573                 :            :     {"B19200", B19200},
         574                 :            :     {"B38400", B38400},
         575                 :            : #ifdef B57600
         576                 :            :     {"B57600", B57600},
         577                 :            : #endif
         578                 :            : #ifdef B115200
         579                 :            :     {"B115200", B115200},
         580                 :            : #endif
         581                 :            : #ifdef B230400
         582                 :            :     {"B230400", B230400},
         583                 :            : #endif
         584                 :            : #ifdef B460800
         585                 :            :     {"B460800", B460800},
         586                 :            : #endif
         587                 :            : #ifdef B500000
         588                 :            :     {"B500000", B500000},
         589                 :            : #endif
         590                 :            : #ifdef B576000
         591                 :            :     {"B576000", B576000},
         592                 :            : #endif
         593                 :            : #ifdef B921600
         594                 :            :     {"B921600", B921600},
         595                 :            : #endif
         596                 :            : #ifdef B1000000
         597                 :            :     {"B1000000", B1000000},
         598                 :            : #endif
         599                 :            : #ifdef B1152000
         600                 :            :     {"B1152000", B1152000},
         601                 :            : #endif
         602                 :            : #ifdef B1500000
         603                 :            :     {"B1500000", B1500000},
         604                 :            : #endif
         605                 :            : #ifdef B2000000
         606                 :            :     {"B2000000", B2000000},
         607                 :            : #endif
         608                 :            : #ifdef B2500000
         609                 :            :     {"B2500000", B2500000},
         610                 :            : #endif
         611                 :            : #ifdef B3000000
         612                 :            :     {"B3000000", B3000000},
         613                 :            : #endif
         614                 :            : #ifdef B3500000
         615                 :            :     {"B3500000", B3500000},
         616                 :            : #endif
         617                 :            : #ifdef B4000000
         618                 :            :     {"B4000000", B4000000},
         619                 :            : #endif
         620                 :            :
         621                 :            : #ifdef CBAUDEX
         622                 :            :     {"CBAUDEX", CBAUDEX},
         623                 :            : #endif
         624                 :            :
         625                 :            :     /* tcsetattr() constants */
         626                 :            :     {"TCSANOW", TCSANOW},
         627                 :            :     {"TCSADRAIN", TCSADRAIN},
         628                 :            :     {"TCSAFLUSH", TCSAFLUSH},
         629                 :            : #ifdef TCSASOFT
         630                 :            :     {"TCSASOFT", TCSASOFT},
         631                 :            : #endif
         632                 :            :
         633                 :            :     /* tcflush() constants */
         634                 :            :     {"TCIFLUSH", TCIFLUSH},
         635                 :            :     {"TCOFLUSH", TCOFLUSH},
         636                 :            :     {"TCIOFLUSH", TCIOFLUSH},
         637                 :            :
         638                 :            :     /* tcflow() constants */
         639                 :            :     {"TCOOFF", TCOOFF},
         640                 :            :     {"TCOON", TCOON},
         641                 :            :     {"TCIOFF", TCIOFF},
         642                 :            :     {"TCION", TCION},
         643                 :            :
         644                 :            :     /* struct termios.c_iflag constants */
         645                 :            :     {"IGNBRK", IGNBRK},
         646                 :            :     {"BRKINT", BRKINT},
         647                 :            :     {"IGNPAR", IGNPAR},
         648                 :            :     {"PARMRK", PARMRK},
         649                 :            :     {"INPCK", INPCK},
         650                 :            :     {"ISTRIP", ISTRIP},
         651                 :            :     {"INLCR", INLCR},
         652                 :            :     {"IGNCR", IGNCR},
         653                 :            :     {"ICRNL", ICRNL},
         654                 :            : #ifdef IUCLC
         655                 :            :     {"IUCLC", IUCLC},
         656                 :            : #endif
         657                 :            :     {"IXON", IXON},
         658                 :            :     {"IXANY", IXANY},
         659                 :            :     {"IXOFF", IXOFF},
         660                 :            : #ifdef IMAXBEL
         661                 :            :     {"IMAXBEL", IMAXBEL},
         662                 :            : #endif
         663                 :            :
         664                 :            :     /* struct termios.c_oflag constants */
         665                 :            :     {"OPOST", OPOST},
         666                 :            : #ifdef OLCUC
         667                 :            :     {"OLCUC", OLCUC},
         668                 :            : #endif
         669                 :            : #ifdef ONLCR
         670                 :            :     {"ONLCR", ONLCR},
         671                 :            : #endif
         672                 :            : #ifdef OCRNL
         673                 :            :     {"OCRNL", OCRNL},
         674                 :            : #endif
         675                 :            : #ifdef ONOCR
         676                 :            :     {"ONOCR", ONOCR},
         677                 :            : #endif
         678                 :            : #ifdef ONLRET
         679                 :            :     {"ONLRET", ONLRET},
         680                 :            : #endif
         681                 :            : #ifdef OFILL
         682                 :            :     {"OFILL", OFILL},
         683                 :            : #endif
         684                 :            : #ifdef OFDEL
         685                 :            :     {"OFDEL", OFDEL},
         686                 :            : #endif
         687                 :            : #ifdef NLDLY
         688                 :            :     {"NLDLY", NLDLY},
         689                 :            : #endif
         690                 :            : #ifdef CRDLY
         691                 :            :     {"CRDLY", CRDLY},
         692                 :            : #endif
         693                 :            : #ifdef TABDLY
         694                 :            :     {"TABDLY", TABDLY},
         695                 :            : #endif
         696                 :            : #ifdef BSDLY
         697                 :            :     {"BSDLY", BSDLY},
         698                 :            : #endif
         699                 :            : #ifdef VTDLY
         700                 :            :     {"VTDLY", VTDLY},
         701                 :            : #endif
         702                 :            : #ifdef FFDLY
         703                 :            :     {"FFDLY", FFDLY},
         704                 :            : #endif
         705                 :            :
         706                 :            :     /* struct termios.c_oflag-related values (delay mask) */
         707                 :            : #ifdef NL0
         708                 :            :     {"NL0", NL0},
         709                 :            : #endif
         710                 :            : #ifdef NL1
         711                 :            :     {"NL1", NL1},
         712                 :            : #endif
         713                 :            : #ifdef CR0
         714                 :            :     {"CR0", CR0},
         715                 :            : #endif
         716                 :            : #ifdef CR1
         717                 :            :     {"CR1", CR1},
         718                 :            : #endif
         719                 :            : #ifdef CR2
         720                 :            :     {"CR2", CR2},
         721                 :            : #endif
         722                 :            : #ifdef CR3
         723                 :            :     {"CR3", CR3},
         724                 :            : #endif
         725                 :            : #ifdef TAB0
         726                 :            :     {"TAB0", TAB0},
         727                 :            : #endif
         728                 :            : #ifdef TAB1
         729                 :            :     {"TAB1", TAB1},
         730                 :            : #endif
         731                 :            : #ifdef TAB2
         732                 :            :     {"TAB2", TAB2},
         733                 :            : #endif
         734                 :            : #ifdef TAB3
         735                 :            :     {"TAB3", TAB3},
         736                 :            : #endif
         737                 :            : #ifdef XTABS
         738                 :            :     {"XTABS", XTABS},
         739                 :            : #endif
         740                 :            : #ifdef BS0
         741                 :            :     {"BS0", BS0},
         742                 :            : #endif
         743                 :            : #ifdef BS1
         744                 :            :     {"BS1", BS1},
         745                 :            : #endif
         746                 :            : #ifdef VT0
         747                 :            :     {"VT0", VT0},
         748                 :            : #endif
         749                 :            : #ifdef VT1
         750                 :            :     {"VT1", VT1},
         751                 :            : #endif
         752                 :            : #ifdef FF0
         753                 :            :     {"FF0", FF0},
         754                 :            : #endif
         755                 :            : #ifdef FF1
         756                 :            :     {"FF1", FF1},
         757                 :            : #endif
         758                 :            :
         759                 :            :     /* struct termios.c_cflag constants */
         760                 :            :     {"CSIZE", CSIZE},
         761                 :            :     {"CSTOPB", CSTOPB},
         762                 :            :     {"CREAD", CREAD},
         763                 :            :     {"PARENB", PARENB},
         764                 :            :     {"PARODD", PARODD},
         765                 :            :     {"HUPCL", HUPCL},
         766                 :            :     {"CLOCAL", CLOCAL},
         767                 :            : #ifdef CIBAUD
         768                 :            :     {"CIBAUD", CIBAUD},
         769                 :            : #endif
         770                 :            : #ifdef CRTSCTS
         771                 :            :     {"CRTSCTS", (long)CRTSCTS},
         772                 :            : #endif
         773                 :            :
         774                 :            :     /* struct termios.c_cflag-related values (character size) */
         775                 :            :     {"CS5", CS5},
         776                 :            :     {"CS6", CS6},
         777                 :            :     {"CS7", CS7},
         778                 :            :     {"CS8", CS8},
         779                 :            :
         780                 :            :     /* struct termios.c_lflag constants */
         781                 :            :     {"ISIG", ISIG},
         782                 :            :     {"ICANON", ICANON},
         783                 :            : #ifdef XCASE
         784                 :            :     {"XCASE", XCASE},
         785                 :            : #endif
         786                 :            :     {"ECHO", ECHO},
         787                 :            :     {"ECHOE", ECHOE},
         788                 :            :     {"ECHOK", ECHOK},
         789                 :            :     {"ECHONL", ECHONL},
         790                 :            : #ifdef ECHOCTL
         791                 :            :     {"ECHOCTL", ECHOCTL},
         792                 :            : #endif
         793                 :            : #ifdef ECHOPRT
         794                 :            :     {"ECHOPRT", ECHOPRT},
         795                 :            : #endif
         796                 :            : #ifdef ECHOKE
         797                 :            :     {"ECHOKE", ECHOKE},
         798                 :            : #endif
         799                 :            : #ifdef FLUSHO
         800                 :            :     {"FLUSHO", FLUSHO},
         801                 :            : #endif
         802                 :            :     {"NOFLSH", NOFLSH},
         803                 :            :     {"TOSTOP", TOSTOP},
         804                 :            : #ifdef PENDIN
         805                 :            :     {"PENDIN", PENDIN},
         806                 :            : #endif
         807                 :            :     {"IEXTEN", IEXTEN},
         808                 :            :
         809                 :            :     /* indexes into the control chars array returned by tcgetattr() */
         810                 :            :     {"VINTR", VINTR},
         811                 :            :     {"VQUIT", VQUIT},
         812                 :            :     {"VERASE", VERASE},
         813                 :            :     {"VKILL", VKILL},
         814                 :            :     {"VEOF", VEOF},
         815                 :            :     {"VTIME", VTIME},
         816                 :            :     {"VMIN", VMIN},
         817                 :            : #ifdef VSWTC
         818                 :            :     /* The #defines above ensure that if either is defined, both are,
         819                 :            :      * but both may be omitted by the system headers.  ;-(  */
         820                 :            :     {"VSWTC", VSWTC},
         821                 :            :     {"VSWTCH", VSWTCH},
         822                 :            : #endif
         823                 :            :     {"VSTART", VSTART},
         824                 :            :     {"VSTOP", VSTOP},
         825                 :            :     {"VSUSP", VSUSP},
         826                 :            :     {"VEOL", VEOL},
         827                 :            : #ifdef VREPRINT
         828                 :            :     {"VREPRINT", VREPRINT},
         829                 :            : #endif
         830                 :            : #ifdef VDISCARD
         831                 :            :     {"VDISCARD", VDISCARD},
         832                 :            : #endif
         833                 :            : #ifdef VWERASE
         834                 :            :     {"VWERASE", VWERASE},
         835                 :            : #endif
         836                 :            : #ifdef VLNEXT
         837                 :            :     {"VLNEXT", VLNEXT},
         838                 :            : #endif
         839                 :            : #ifdef VEOL2
         840                 :            :     {"VEOL2", VEOL2},
         841                 :            : #endif
         842                 :            :
         843                 :            :
         844                 :            : #ifdef B460800
         845                 :            :     {"B460800", B460800},
         846                 :            : #endif
         847                 :            : #ifdef B500000
         848                 :            :     {"B500000", B500000},
         849                 :            : #endif
         850                 :            : #ifdef B576000
         851                 :            :     { "B576000", B576000},
         852                 :            : #endif
         853                 :            : #ifdef B921600
         854                 :            :     { "B921600", B921600},
         855                 :            : #endif
         856                 :            : #ifdef B1000000
         857                 :            :     { "B1000000", B1000000},
         858                 :            : #endif
         859                 :            : #ifdef B1152000
         860                 :            :     { "B1152000", B1152000},
         861                 :            : #endif
         862                 :            : #ifdef B1500000
         863                 :            :     { "B1500000", B1500000},
         864                 :            : #endif
         865                 :            : #ifdef B2000000
         866                 :            :     { "B2000000", B2000000},
         867                 :            : #endif
         868                 :            : #ifdef B2500000
         869                 :            :     { "B2500000", B2500000},
         870                 :            : #endif
         871                 :            : #ifdef B3000000
         872                 :            :     { "B3000000", B3000000},
         873                 :            : #endif
         874                 :            : #ifdef B3500000
         875                 :            :     { "B3500000", B3500000},
         876                 :            : #endif
         877                 :            : #ifdef B4000000
         878                 :            :     { "B4000000", B4000000},
         879                 :            : #endif
         880                 :            : #ifdef CBAUD
         881                 :            :     {"CBAUD", CBAUD},
         882                 :            : #endif
         883                 :            : #ifdef CDEL
         884                 :            :     {"CDEL", CDEL},
         885                 :            : #endif
         886                 :            : #ifdef CDSUSP
         887                 :            :     {"CDSUSP", CDSUSP},
         888                 :            : #endif
         889                 :            : #ifdef CEOF
         890                 :            :     {"CEOF", CEOF},
         891                 :            : #endif
         892                 :            : #ifdef CEOL
         893                 :            :     {"CEOL", CEOL},
         894                 :            : #endif
         895                 :            : #ifdef CEOL2
         896                 :            :     {"CEOL2", CEOL2},
         897                 :            : #endif
         898                 :            : #ifdef CEOT
         899                 :            :     {"CEOT", CEOT},
         900                 :            : #endif
         901                 :            : #ifdef CERASE
         902                 :            :     {"CERASE", CERASE},
         903                 :            : #endif
         904                 :            : #ifdef CESC
         905                 :            :     {"CESC", CESC},
         906                 :            : #endif
         907                 :            : #ifdef CFLUSH
         908                 :            :     {"CFLUSH", CFLUSH},
         909                 :            : #endif
         910                 :            : #ifdef CINTR
         911                 :            :     {"CINTR", CINTR},
         912                 :            : #endif
         913                 :            : #ifdef CKILL
         914                 :            :     {"CKILL", CKILL},
         915                 :            : #endif
         916                 :            : #ifdef CLNEXT
         917                 :            :     {"CLNEXT", CLNEXT},
         918                 :            : #endif
         919                 :            : #ifdef CNUL
         920                 :            :     {"CNUL", CNUL},
         921                 :            : #endif
         922                 :            : #ifdef COMMON
         923                 :            :     {"COMMON", COMMON},
         924                 :            : #endif
         925                 :            : #ifdef CQUIT
         926                 :            :     {"CQUIT", CQUIT},
         927                 :            : #endif
         928                 :            : #ifdef CRPRNT
         929                 :            :     {"CRPRNT", CRPRNT},
         930                 :            : #endif
         931                 :            : #ifdef CSTART
         932                 :            :     {"CSTART", CSTART},
         933                 :            : #endif
         934                 :            : #ifdef CSTOP
         935                 :            :     {"CSTOP", CSTOP},
         936                 :            : #endif
         937                 :            : #ifdef CSUSP
         938                 :            :     {"CSUSP", CSUSP},
         939                 :            : #endif
         940                 :            : #ifdef CSWTCH
         941                 :            :     {"CSWTCH", CSWTCH},
         942                 :            : #endif
         943                 :            : #ifdef CWERASE
         944                 :            :     {"CWERASE", CWERASE},
         945                 :            : #endif
         946                 :            : #ifdef EXTA
         947                 :            :     {"EXTA", EXTA},
         948                 :            : #endif
         949                 :            : #ifdef EXTB
         950                 :            :     {"EXTB", EXTB},
         951                 :            : #endif
         952                 :            : #ifdef FIOASYNC
         953                 :            :     {"FIOASYNC", FIOASYNC},
         954                 :            : #endif
         955                 :            : #ifdef FIOCLEX
         956                 :            :     {"FIOCLEX", FIOCLEX},
         957                 :            : #endif
         958                 :            : #ifdef FIONBIO
         959                 :            :     {"FIONBIO", FIONBIO},
         960                 :            : #endif
         961                 :            : #ifdef FIONCLEX
         962                 :            :     {"FIONCLEX", FIONCLEX},
         963                 :            : #endif
         964                 :            : #ifdef FIONREAD
         965                 :            :     {"FIONREAD", FIONREAD},
         966                 :            : #endif
         967                 :            : #ifdef IBSHIFT
         968                 :            :     {"IBSHIFT", IBSHIFT},
         969                 :            : #endif
         970                 :            : #ifdef INIT_C_CC
         971                 :            :     {"INIT_C_CC", INIT_C_CC},
         972                 :            : #endif
         973                 :            : #ifdef IOCSIZE_MASK
         974                 :            :     {"IOCSIZE_MASK", IOCSIZE_MASK},
         975                 :            : #endif
         976                 :            : #ifdef IOCSIZE_SHIFT
         977                 :            :     {"IOCSIZE_SHIFT", IOCSIZE_SHIFT},
         978                 :            : #endif
         979                 :            : #ifdef NCC
         980                 :            :     {"NCC", NCC},
         981                 :            : #endif
         982                 :            : #ifdef NCCS
         983                 :            :     {"NCCS", NCCS},
         984                 :            : #endif
         985                 :            : #ifdef NSWTCH
         986                 :            :     {"NSWTCH", NSWTCH},
         987                 :            : #endif
         988                 :            : #ifdef N_MOUSE
         989                 :            :     {"N_MOUSE", N_MOUSE},
         990                 :            : #endif
         991                 :            : #ifdef N_PPP
         992                 :            :     {"N_PPP", N_PPP},
         993                 :            : #endif
         994                 :            : #ifdef N_SLIP
         995                 :            :     {"N_SLIP", N_SLIP},
         996                 :            : #endif
         997                 :            : #ifdef N_STRIP
         998                 :            :     {"N_STRIP", N_STRIP},
         999                 :            : #endif
        1000                 :            : #ifdef N_TTY
        1001                 :            :     {"N_TTY", N_TTY},
        1002                 :            : #endif
        1003                 :            : #ifdef TCFLSH
        1004                 :            :     {"TCFLSH", TCFLSH},
        1005                 :            : #endif
        1006                 :            : #ifdef TCGETA
        1007                 :            :     {"TCGETA", TCGETA},
        1008                 :            : #endif
        1009                 :            : #ifdef TCGETS
        1010                 :            :     {"TCGETS", TCGETS},
        1011                 :            : #endif
        1012                 :            : #ifdef TCSBRK
        1013                 :            :     {"TCSBRK", TCSBRK},
        1014                 :            : #endif
        1015                 :            : #ifdef TCSBRKP
        1016                 :            :     {"TCSBRKP", TCSBRKP},
        1017                 :            : #endif
        1018                 :            : #ifdef TCSETA
        1019                 :            :     {"TCSETA", TCSETA},
        1020                 :            : #endif
        1021                 :            : #ifdef TCSETAF
        1022                 :            :     {"TCSETAF", TCSETAF},
        1023                 :            : #endif
        1024                 :            : #ifdef TCSETAW
        1025                 :            :     {"TCSETAW", TCSETAW},
        1026                 :            : #endif
        1027                 :            : #ifdef TCSETS
        1028                 :            :     {"TCSETS", TCSETS},
        1029                 :            : #endif
        1030                 :            : #ifdef TCSETSF
        1031                 :            :     {"TCSETSF", TCSETSF},
        1032                 :            : #endif
        1033                 :            : #ifdef TCSETSW
        1034                 :            :     {"TCSETSW", TCSETSW},
        1035                 :            : #endif
        1036                 :            : #ifdef TCXONC
        1037                 :            :     {"TCXONC", TCXONC},
        1038                 :            : #endif
        1039                 :            : #ifdef TIOCCONS
        1040                 :            :     {"TIOCCONS", TIOCCONS},
        1041                 :            : #endif
        1042                 :            : #ifdef TIOCEXCL
        1043                 :            :     {"TIOCEXCL", TIOCEXCL},
        1044                 :            : #endif
        1045                 :            : #ifdef TIOCGETD
        1046                 :            :     {"TIOCGETD", TIOCGETD},
        1047                 :            : #endif
        1048                 :            : #ifdef TIOCGICOUNT
        1049                 :            :     {"TIOCGICOUNT", TIOCGICOUNT},
        1050                 :            : #endif
        1051                 :            : #ifdef TIOCGLCKTRMIOS
        1052                 :            :     {"TIOCGLCKTRMIOS", TIOCGLCKTRMIOS},
        1053                 :            : #endif
        1054                 :            : #ifdef TIOCGPGRP
        1055                 :            :     {"TIOCGPGRP", TIOCGPGRP},
        1056                 :            : #endif
        1057                 :            : #ifdef TIOCGSERIAL
        1058                 :            :     {"TIOCGSERIAL", TIOCGSERIAL},
        1059                 :            : #endif
        1060                 :            : #ifdef TIOCGSIZE
        1061                 :            :     {"TIOCGSIZE", TIOCGSIZE},
        1062                 :            : #endif
        1063                 :            : #ifdef TIOCGSOFTCAR
        1064                 :            :     {"TIOCGSOFTCAR", TIOCGSOFTCAR},
        1065                 :            : #endif
        1066                 :            : #ifdef TIOCGWINSZ
        1067                 :            :     {"TIOCGWINSZ", TIOCGWINSZ},
        1068                 :            : #endif
        1069                 :            : #ifdef TIOCINQ
        1070                 :            :     {"TIOCINQ", TIOCINQ},
        1071                 :            : #endif
        1072                 :            : #ifdef TIOCLINUX
        1073                 :            :     {"TIOCLINUX", TIOCLINUX},
        1074                 :            : #endif
        1075                 :            : #ifdef TIOCMBIC
        1076                 :            :     {"TIOCMBIC", TIOCMBIC},
        1077                 :            : #endif
        1078                 :            : #ifdef TIOCMBIS
        1079                 :            :     {"TIOCMBIS", TIOCMBIS},
        1080                 :            : #endif
        1081                 :            : #ifdef TIOCMGET
        1082                 :            :     {"TIOCMGET", TIOCMGET},
        1083                 :            : #endif
        1084                 :            : #ifdef TIOCMIWAIT
        1085                 :            :     {"TIOCMIWAIT", TIOCMIWAIT},
        1086                 :            : #endif
        1087                 :            : #ifdef TIOCMSET
        1088                 :            :     {"TIOCMSET", TIOCMSET},
        1089                 :            : #endif
        1090                 :            : #ifdef TIOCM_CAR
        1091                 :            :     {"TIOCM_CAR", TIOCM_CAR},
        1092                 :            : #endif
        1093                 :            : #ifdef TIOCM_CD
        1094                 :            :     {"TIOCM_CD", TIOCM_CD},
        1095                 :            : #endif
        1096                 :            : #ifdef TIOCM_CTS
        1097                 :            :     {"TIOCM_CTS", TIOCM_CTS},
        1098                 :            : #endif
        1099                 :            : #ifdef TIOCM_DSR
        1100                 :            :     {"TIOCM_DSR", TIOCM_DSR},
        1101                 :            : #endif
        1102                 :            : #ifdef TIOCM_DTR
        1103                 :            :     {"TIOCM_DTR", TIOCM_DTR},
        1104                 :            : #endif
        1105                 :            : #ifdef TIOCM_LE
        1106                 :            :     {"TIOCM_LE", TIOCM_LE},
        1107                 :            : #endif
        1108                 :            : #ifdef TIOCM_RI
        1109                 :            :     {"TIOCM_RI", TIOCM_RI},
        1110                 :            : #endif
        1111                 :            : #ifdef TIOCM_RNG
        1112                 :            :     {"TIOCM_RNG", TIOCM_RNG},
        1113                 :            : #endif
        1114                 :            : #ifdef TIOCM_RTS
        1115                 :            :     {"TIOCM_RTS", TIOCM_RTS},
        1116                 :            : #endif
        1117                 :            : #ifdef TIOCM_SR
        1118                 :            :     {"TIOCM_SR", TIOCM_SR},
        1119                 :            : #endif
        1120                 :            : #ifdef TIOCM_ST
        1121                 :            :     {"TIOCM_ST", TIOCM_ST},
        1122                 :            : #endif
        1123                 :            : #ifdef TIOCNOTTY
        1124                 :            :     {"TIOCNOTTY", TIOCNOTTY},
        1125                 :            : #endif
        1126                 :            : #ifdef TIOCNXCL
        1127                 :            :     {"TIOCNXCL", TIOCNXCL},
        1128                 :            : #endif
        1129                 :            : #ifdef TIOCOUTQ
        1130                 :            :     {"TIOCOUTQ", TIOCOUTQ},
        1131                 :            : #endif
        1132                 :            : #ifdef TIOCPKT
        1133                 :            :     {"TIOCPKT", TIOCPKT},
        1134                 :            : #endif
        1135                 :            : #ifdef TIOCPKT_DATA
        1136                 :            :     {"TIOCPKT_DATA", TIOCPKT_DATA},
        1137                 :            : #endif
        1138                 :            : #ifdef TIOCPKT_DOSTOP
        1139                 :            :     {"TIOCPKT_DOSTOP", TIOCPKT_DOSTOP},
        1140                 :            : #endif
        1141                 :            : #ifdef TIOCPKT_FLUSHREAD
        1142                 :            :     {"TIOCPKT_FLUSHREAD", TIOCPKT_FLUSHREAD},
        1143                 :            : #endif
        1144                 :            : #ifdef TIOCPKT_FLUSHWRITE
        1145                 :            :     {"TIOCPKT_FLUSHWRITE", TIOCPKT_FLUSHWRITE},
        1146                 :            : #endif
        1147                 :            : #ifdef TIOCPKT_NOSTOP
        1148                 :            :     {"TIOCPKT_NOSTOP", TIOCPKT_NOSTOP},
        1149                 :            : #endif
        1150                 :            : #ifdef TIOCPKT_START
        1151                 :            :     {"TIOCPKT_START", TIOCPKT_START},
        1152                 :            : #endif
        1153                 :            : #ifdef TIOCPKT_STOP
        1154                 :            :     {"TIOCPKT_STOP", TIOCPKT_STOP},
        1155                 :            : #endif
        1156                 :            : #ifdef TIOCSCTTY
        1157                 :            :     {"TIOCSCTTY", TIOCSCTTY},
        1158                 :            : #endif
        1159                 :            : #ifdef TIOCSERCONFIG
        1160                 :            :     {"TIOCSERCONFIG", TIOCSERCONFIG},
        1161                 :            : #endif
        1162                 :            : #ifdef TIOCSERGETLSR
        1163                 :            :     {"TIOCSERGETLSR", TIOCSERGETLSR},
        1164                 :            : #endif
        1165                 :            : #ifdef TIOCSERGETMULTI
        1166                 :            :     {"TIOCSERGETMULTI", TIOCSERGETMULTI},
        1167                 :            : #endif
        1168                 :            : #ifdef TIOCSERGSTRUCT
        1169                 :            :     {"TIOCSERGSTRUCT", TIOCSERGSTRUCT},
        1170                 :            : #endif
        1171                 :            : #ifdef TIOCSERGWILD
        1172                 :            :     {"TIOCSERGWILD", TIOCSERGWILD},
        1173                 :            : #endif
        1174                 :            : #ifdef TIOCSERSETMULTI
        1175                 :            :     {"TIOCSERSETMULTI", TIOCSERSETMULTI},
        1176                 :            : #endif
        1177                 :            : #ifdef TIOCSERSWILD
        1178                 :            :     {"TIOCSERSWILD", TIOCSERSWILD},
        1179                 :            : #endif
        1180                 :            : #ifdef TIOCSER_TEMT
        1181                 :            :     {"TIOCSER_TEMT", TIOCSER_TEMT},
        1182                 :            : #endif
        1183                 :            : #ifdef TIOCSETD
        1184                 :            :     {"TIOCSETD", TIOCSETD},
        1185                 :            : #endif
        1186                 :            : #ifdef TIOCSLCKTRMIOS
        1187                 :            :     {"TIOCSLCKTRMIOS", TIOCSLCKTRMIOS},
        1188                 :            : #endif
        1189                 :            : #ifdef TIOCSPGRP
        1190                 :            :     {"TIOCSPGRP", TIOCSPGRP},
        1191                 :            : #endif
        1192                 :            : #ifdef TIOCSSERIAL
        1193                 :            :     {"TIOCSSERIAL", TIOCSSERIAL},
        1194                 :            : #endif
        1195                 :            : #ifdef TIOCSSIZE
        1196                 :            :     {"TIOCSSIZE", TIOCSSIZE},
        1197                 :            : #endif
        1198                 :            : #ifdef TIOCSSOFTCAR
        1199                 :            :     {"TIOCSSOFTCAR", TIOCSSOFTCAR},
        1200                 :            : #endif
        1201                 :            : #ifdef TIOCSTI
        1202                 :            :     {"TIOCSTI", TIOCSTI},
        1203                 :            : #endif
        1204                 :            : #ifdef TIOCSWINSZ
        1205                 :            :     {"TIOCSWINSZ", TIOCSWINSZ},
        1206                 :            : #endif
        1207                 :            : #ifdef TIOCTTYGSTRUCT
        1208                 :            :     {"TIOCTTYGSTRUCT", TIOCTTYGSTRUCT},
        1209                 :            : #endif
        1210                 :            :
        1211                 :            :     /* sentinel */
        1212                 :            :     {NULL, 0}
        1213                 :            : };
        1214                 :            :
        1215                 :         40 : static int termiosmodule_traverse(PyObject *m, visitproc visit, void *arg) {
        1216   [ +  -  -  + ]:         40 :     Py_VISIT(get_termios_state(m)->TermiosError);
        1217                 :         40 :     return 0;
        1218                 :            : }
        1219                 :            :
        1220                 :          3 : static int termiosmodule_clear(PyObject *m) {
        1221         [ +  + ]:          3 :     Py_CLEAR(get_termios_state(m)->TermiosError);
        1222                 :          3 :     return 0;
        1223                 :            : }
        1224                 :            :
        1225                 :          2 : static void termiosmodule_free(void *m) {
        1226                 :          2 :     termiosmodule_clear((PyObject *)m);
        1227                 :          2 : }
        1228                 :            :
        1229                 :            : static int
        1230                 :          2 : termios_exec(PyObject *mod)
        1231                 :            : {
        1232                 :          2 :     struct constant *constant = termios_constants;
        1233                 :          2 :     termiosmodulestate *state = get_termios_state(mod);
        1234                 :          2 :     state->TermiosError = PyErr_NewException("termios.error", NULL, NULL);
        1235         [ -  + ]:          2 :     if (state->TermiosError == NULL) {
        1236                 :          0 :         return -1;
        1237                 :            :     }
        1238                 :          2 :     Py_INCREF(state->TermiosError);
        1239         [ -  + ]:          2 :     if (PyModule_AddObject(mod, "error", state->TermiosError) < 0) {
        1240                 :          0 :         Py_DECREF(state->TermiosError);
        1241                 :          0 :         return -1;
        1242                 :            :     }
        1243                 :            :
        1244         [ +  + ]:        488 :     while (constant->name != NULL) {
        1245         [ -  + ]:        486 :         if (PyModule_AddIntConstant(
        1246                 :        486 :             mod, constant->name, constant->value) < 0) {
        1247                 :          0 :             return -1;
        1248                 :            :         }
        1249                 :        486 :         ++constant;
        1250                 :            :     }
        1251                 :          2 :     return 0;
        1252                 :            : }
        1253                 :            :
        1254                 :            : static PyModuleDef_Slot termios_slots[] = {
        1255                 :            :     {Py_mod_exec, termios_exec},
        1256                 :            :     {0, NULL}
        1257                 :            : };
        1258                 :            :
        1259                 :            : static struct PyModuleDef termiosmodule = {
        1260                 :            :     PyModuleDef_HEAD_INIT,
        1261                 :            :     .m_name = "termios",
        1262                 :            :     .m_doc = termios__doc__,
        1263                 :            :     .m_size = sizeof(termiosmodulestate),
        1264                 :            :     .m_methods = termios_methods,
        1265                 :            :     .m_slots = termios_slots,
        1266                 :            :     .m_traverse = termiosmodule_traverse,
        1267                 :            :     .m_clear = termiosmodule_clear,
        1268                 :            :     .m_free = termiosmodule_free,
        1269                 :            : };
        1270                 :            :
        1271                 :          2 : PyMODINIT_FUNC PyInit_termios(void)
        1272                 :            : {
        1273                 :          2 :     return PyModuleDef_Init(&termiosmodule);
        1274                 :            : }

Generated by: LCOV version 1.14