Provided by: manpages-fr-dev_4.13-4_all bug

NOM

       ioctl_tty - Ioctls pour les terminaux et lignes série

SYNOPSIS

       #include <termios.h>

       int ioctl(int fd, int cmd, ...);

DESCRIPTION

       Les  appels  système  ioctl(2)  pour  les  terminaux  et  les ports série acceptent différents paramètres
       possibles. La plupart nécessitent un troisième paramètre, d'un type variable, appelé argp ou arg.

       Utiliser des ioctls rend les programmes non  portables.  Utiliser  les  interfaces  POSIX  décrites  dans
       termios(3) si possible.

   Récupérer et positionner les attributs d'un terminal
       TCGETS    struct termios *argp
              Équivalent à tcgetattr(fd, argp).

              Récupérer la configuration du port série courant.

       TCSETS    const struct termios *argp
              Équivalent à tcsetattr(fd, TCSANOW, argp).

              Configurer le port série courant.

       TCSETSW   const struct termios *argp
              Équivalent à tcsetattr(fd, TCSADRAIN, argp).

              Laisser le tampon de sortie se vider, puis configurer le port série courant.

       TCSETSF   const struct termios *argp
              Équivalent à tcsetattr(fd, TCSAFLUSH, argp).

              Laisser  le  tampon  de sortie se vider, abandonner toute entrée en cours, puis configurer le port
              série courant.

       Les quatre ioctls suivants sont équivalents à TCGETS, TCSETS, TCSETSW et TCSETSF,  à  l'exception  qu'ils
       prennent une structure struct termio * plutôt que struct termios *.

              TCGETA    struct termio *argp

              TCSETA    const struct termio *argp

              TCSETAW   const struct termio *argp

              TCSETAF   const struct termio *argp

   Verrouiller une structure termios
       La  structure  termios  d'un  terminal  peut  être  verrouillée.  Le verrou est en lui-même une structure
       termios, dont les bits ou champs non nuls indiquent une valeur verrouillée.

       TIOCGLCKTRMIOS struct termios *argp
              Récupérer l'état du verrou de la structure termios du terminal.

       TIOCSLCKTRMIOS const struct termios *argp
              Définir l'état du verrou de la structure termios du terminal. Seul un processus avec  la  capacité
              CAP_SYS_ADMIN peut faire cela.

   Récupérer et configurer les tailles de fenêtre
       Les  tailles  de  fenêtre sont stockées dans le noyau, mais ne sont pas utilisées par le noyau (sauf pour
       les consoles virtuelles, pour lesquelles le noyau met à jour les tailles de fenêtre quand la taille d'une
       console virtuelle change, par exemple lors du chargement d'une nouvelle fonte).

       Les constantes et structures suivantes sont définies dans <sys/ioctl.h>.

       TIOCGWINSZ     struct winsize *argp
              Récupérer la taille de la fenêtre.

       TIOCSWINSZ     const struct winsize *argp
              Définir la taille de la fenêtre.

       La structure utilisée par ces ioctls est la suivante :

           struct winsize {
               unsigned short ws_row;
               unsigned short ws_col;
               unsigned short ws_xpixel;   /* non utilisé */
               unsigned short ws_ypixel;   /* non utilisé */
           };

       Lorsque la taille d'une fenêtre change, un signal SIGWINCH est envoyé au groupe de processus  au  premier
       plan.

   Envoyer une interruption  break »)
       TCSBRK    int arg
              Équivalent à tcsendbreak(fd, arg).

              Si  le  terminal  utilise  un  mode de transmission série asynchrone et que arg est nul, alors une
              interruption (un flux de bits nuls) est envoyée  pendant  0,25  à  0,5  seconde.  Si  le  terminal
              n'utilise  pas  un mode de transmission série asynchrone, alors soit une interruption est envoyée,
              soit la fonction ne fait rien. Quand arg est non nul, le comportement n'est pas défini.

              (SVr4, UnixWare, Solaris et Linux traitent tcsendbreak(fd,arg) avec un paramètre arg non nul de la
              même façon que tcdrain(fd). SunOS considère arg comme un coefficient multiplicateur et  envoie  un
              flux  de bits arg fois plus long que lorsque arg est nul. DG/UX et AIX traitent arg (lorsqu'il est
              non nul) comme un intervalle de temps exprimé en millisecondes. HP-UX ignore arg.)

       TCSBRKP   int arg
              Ce qu'on appelle la « version POSIX » de TCSBRK. Elle traite le arg non nul comme un intervalle de
              temps mesuré en dixièmes  de  seconde  et  ne  fait  rien  lorsque  le  pilote  ne  gère  pas  les
              interruptions.

       TIOCSBRK  void
              Activer les interruptions, c'est-à-dire commencer à envoyer des bits nuls.

       TIOCCBRK  void
              Désactiver les interruptions, c'est-à-dire arrêter d'envoyer les bits nuls.

   Contrôle de flux logiciel
       TCXONC    int arg
              Équivalent à tcflow(fd, arg).

              Consultez tcflow(3) pour avoir la signification des valeurs TCOOFF, TCOON, TCIOFF et TCION.

   Information sur les tampons et vidage
       FIONREAD  int *argp
              Récupérer le nombre d'octets dans le tampon d'entrée.

       TIOCINQ   int *argp
              Identique à FIONREAD.

       TIOCOUTQ  int *argp
              Récupérer le nombre d'octets dans le tampon de sortie.

       TCFLSH    int arg
              Équivalent à tcflush(fd, arg).

              Consultez tcflush(3) pour la signification de TCIFLUSH, TCOFLUSH et TCIOFLUSH.

   Simuler l'entrée
       TIOCSTI   const char *argp
              Insérer l'octet donné dans la queue d'entrée.

   Rediriger la sortie de la console
       TIOCCONS  void
              Rediriger  la  sortie qui serait allée vers /dev/console ou /dev/tty0 vers un terminal donné. S'il
              s'agit d'un pseudoterminal maître, envoyer à l'esclave. Dans les versions de Linux  antérieures  à
              2.6.10,  n'importe  qui  peut  utiliser  cet  appel  à  condition  que  la sortie ne soit pas déjà
              redirigée ; depuis la version 2.6.10, seul  un  processus  avec  la  capacité  CAP_SYS_ADMIN  peut
              l'utiliser.  Si  elle  a  déjà  été  redirigée,  EBUSY est renvoyée, mais la redirection peut être
              arrêtée en utilisant cet ioctl avec fd pointant vers /dev/console ou /dev/tty0.

   Terminal de contrôle
       TIOCSCTTY int arg
              Faire du terminal donné le terminal de contrôle du processus appelant. Le processus appelant  doit
              être un leader de session et ne doit pas déjà avoir de terminal de contrôle. Dans ce cas, arg doit
              valoir zéro.

              Si  ce terminal est déjà le terminal de contrôle d'une autre session, alors l'ioctl échoue avec le
              code d'erreur EPERM, à moins que l'appelant soit un superutilisateur (plus précisément : qu'il ait
              la capacité CAP_SYS_ADMIN) et que arg vaille 1. Dans ce dernier cas, le terminal est « volé »,  et
              tous les processus pour lesquels c'était le terminal de contrôle le perdent.

       TIOCNOTTY void
              Si  le terminal donné est le terminal de contrôle du processus appelant, abandonner ce terminal de
              contrôle. Si le processus est un leader de session, alors SIGHUP  et  SIGCONT  seront  envoyés  au
              groupe  de processus au premier plan, et tous les processus de la session perdent leur terminal de
              contrôle.

   Groupe de processus et identifiant de session
       TIOCGPGRP pid_t *argp
              En cas de succès, équivalent à *argp = tcgetpgrp(fd).

              Récupérer l'identifiant du groupe de processus au premier plan sur ce terminal.

       TIOCSPGRP const pid_t *argp
              Équivalent à tcsetpgrp(fd, *argp).

              Définir l'identifiant du groupe de processus au premier plan du terminal.

       TIOCGSID  pid_t *argp
              Récupérer l'identifiant de session du terminal donné. L'appel échouera avec pour erreur ENOTTY  si
              le terminal n'est pas un pseudoterminal maître et n'est pas notre terminal de contrôle. Étrange.

   Mode exclusif
       TIOCEXCL  void
              Mettre  le  terminal  en mode exclusif. Plus aucun appel open(2) sur le terminal ne sera autorisé.
              (Ils échoueront avec l'erreur EBUSY, sauf pour un processus ayant la capacité CAP_SYS_ADMIN.)

       TIOCGEXCL int *argp
              (Depuis Linux 3.8) Si le terminal est actuellement en mode exclusif, mettre une valeur positive  à
              l'endroit vers lequel pointe argp ; sinon mettre un zéro dans *argp.

       TIOCNXCL  void
              Désactiver le mode exclusif.

   Paramètres de la ligne  line discipline »)
       TIOCGETD  int *argp
              Récupérer les paramètres de la ligne du terminal.

       TIOCSETD  const int *argp
              Définir les paramètres de la ligne (« line discipline ») du terminal.

   Ioctls pour les pseudoterminaux
       TIOCPKT   const int *argp
              Activer  (quand  *argp  n'est pas nul) ou désactiver le mode paquet. Ne peut être appliqué qu'à la
              partie maître d'un pseudoterminal (renvoie ENOTTY sinon). En mode paquet, chaque  read(2)  suivant
              renverra  un  paquet qui contient soit un seul octet de contrôle non nul, soit un unique octet nul
              ('\0') suivi par les données écrites du côté esclave du pseudoterminal. Si le premier octet  n'est
              pas TIOCPKT_DATA (0), il s'agit d'un OU logique entre les bits suivants :

              TIOCPKT_FLUSHREAD    La file de lecture du terminal est vidée.
              TIOCPKT_FLUSHWRITE   La file d'écriture du terminal est vidée.
              TIOCPKT_STOP         La sortie sur le terminal est arrêtée.
              TIOCPKT_START        La sortie sur le terminal est redémarrée.
              TIOCPKT_DOSTOP       Les caractères de démarrage et d'arrêt sont ^S/^Q.
              TIOCPKT_NOSTOP       Les caractères de démarrage et d'arrêt ne sont pas ^S/^Q.

              Tant  que le mode paquet est utilisé, la présence d'informations d'état de contrôle à lire du côté
              maître peut être détectée avec select(2) pour les conditions exceptionnelles ou  un  poll(2)  pour
              l'événement POLLPRI.

              Ce  mode  est  utilisé par rlogin(1) et rlogind(8) pour implémenter l'envoi distant du contrôle de
              flux (^S/^Q) en local.

       TIOCGPKT  const int *argp
              (Depuis Linux 3.8) Renvoyer le paramètre du mode paquet actuel dans l'entier  vers  lequel  pointe
              argp.

       TIOCSPTLCK     int *argp
              Positionner  (si  *argp  n'est  pas nul) ou effacer (si *argp est zéro) le périphérique esclave du
              pseudoterminal (voir aussi unlockpt(3)).

       TIOCGPTLCK     int *argp
              (Depuis Linux 3.8) Mettre l'état actuel du verrou du périphérique esclave du  terminal  virtuel  à
              l'emplacement vers lequel pointe argp.

       TIOCGPTPEER    int flags
              (Depuis  Linux  4.13)  À  partir  d'un  descripteur de fichier de fd qui se rapporte à un terminal
              virtuel maître, ouvrir (avec les flags donnés à la manière de  open(2))  et  renvoyer  un  nouveau
              descripteur de fichier qui renvoie au terminal virtuel esclave correspondant. Cette opération peut
              être  effectuée  que  le  chemin  du  périphérique esclave soit accessible par l'espace de noms de
              montage du processus appelant ou pas.

              Les programmes soucieux de la  sécurité  qui  interagissent  avec  les  espaces  de  noms  peuvent
              souhaiter utiliser cette opération au lieu de open(2) avec le chemin renvoyé par ptsname(3) et les
              fonctions  de  bibliothèque semblables ayant des APIs non sécurisées (par exemple, il peut y avoir
              des confusions dans certains cas en utilisant ptsname(3) avec un chemin où un système de  fichiers
              devpts a été monté dans un autre espace de noms de montage).

       Les ioctls BSD TIOCSTOP, TIOCSTART, TIOCUCNTL et TIOCREMOTE n'ont pas été implémentés sous Linux.

   Contrôle des modems
       TIOCMGET  int *argp
              Récupérer l'état des bits du modem.

       TIOCMSET  const int *argp
              Définir l'état des bits du modem.

       TIOCMBIC  const int *argp
              Effacer les bits du modem indiqués.

       TIOCMBIS  const int *argp
              Positionner les bits du modem indiqués.

       Les bits suivants sont utilisés par les ioctls ci-dessus :

       TIOCM_LE    DSR (data set ready/ligne activée)
       TIOCM_DTR   DTR (data terminal ready, terminal de données prêt)
       TIOCM_RTS   RTS (request to send, requête à envoyer)
       TIOCM_ST    TXD secondaire (transmit)
       TIOCM_SR    RXD secondaire (receive)
       TIOCM_CTS   CTS (clear to send, vider pour envoyer)
       TIOCM_CAR   DCD (data carrier detect)
       TIOCM_CD    voir TIOCM_CAR
       TIOCM_RNG   RNG (ring)
       TIOCM_RI    voir TIOCM_RNG
       TIOCM_DSR   DSR (data set ready)

       TIOCMIWAIT     int arg
              Attendre  qu'un  des bits de modem (DCD, RI, DSR, CTS) change. Les bits intéressants sont indiqués
              sous la forme de masques de bits dans arg en reliant (opération OR) toutes les  valeurs  de  bits,
              TIOCM_RNG,  TIOCM_DSR,  TIOCM_CD et TIOCM_CTS. L'appelant doit utiliser TIOCGICOUNT pour savoir le
              bit qui a changé.

       TIOCGICOUNT    struct serial_icounter_struct *argp
              Récupérer le nombre d'interruptions de la ligne série d'entrée (DCD, RI, DSR, CTS). Le nombre  est
              écrit dans une structure serial_icounter_struct vers laquelle pointe argp.

              Note : les transitions 1->0 et 0->1 sont prises en compte, sauf pour RI, où seules les transitions
              0->1 sont prises en compte.

   Marquer une ligne comme étant locale
       TIOCGSOFTCAR   int *argp
              (GSOFTCAR :  « Get  SOFTware  CARrier  flag »)  Récupérer  l'état  du drapeau CLOCAL dans le champ
              c_cflag de la structure termios.

       TIOCSSOFTCAR   const int *argp
              (SSOFTCAR : « Set SOFTware CARrier flag ») Positionner le drapeau CLOCAL de la  structure  termios
              si *argp n'est pas nul, et l'effacer dans le cas contraire.

       Si le drapeau CLOCAL d'une ligne est désactivé, le signal de détection de porteuse (DCD) est significatif
       et  un  appel à open(2) sur le terminal correspondant sera bloqué tant que le signal DCD sera maintenu, à
       moins que le drapeau O_NONBLOCK soit fourni. Si CLOCAL est positionné, la ligne se comporte comme si  DCD
       était  maintenu  en permanence. Le drapeau logiciel pour la porteuse est généralement positionné pour les
       périphériques locaux et désactivé pour les lignes par modem.

   Spécifique à Linux
       Pour l'ioctl TIOCLINUX, reportez-vous à ioctl_console(2).

   Débogage du noyau
       #include <linux/tty.h>

       TIOCTTYGSTRUCT struct tty_struct *argp
              Récupérer la structure tty_struct correspondant à fd. Cette commande a été  supprimée  dans  Linux
              2.5.67.

VALEUR RENVOYÉE

       L'appel  système  ioctl(2) renvoie 0 en cas de succès. En cas d'erreur, il renvoie -1 et positionne errno
       comme il faut.

ERREURS

       EINVAL Paramètre de commande non valable.

       ENOIOCTLCMD
              Commande inconnue.

       ENOTTY fd inapproprié.

       EPERM  Droits insuffisants.

EXEMPLES

       Vérifier l’état de DTR sur un port série.

       #include <termios.h>
       #include <fcntl.h>
       #include <sys/ioctl.h>

       int
       main(void)
       {
           int fd, serial;

           fd = open("/dev/ttyS0", O_RDONLY);
           ioctl(fd, TIOCMGET, &serial);
           if (serial & TIOCM_DTR)
               puts("TIOCM_DTR is set");
           else
               puts("TIOCM_DTR is not set");
           close(fd);
       }

VOIR AUSSI

       ldattach(1), ioctl(2), ioctl_console(2), termios(3), pty(7)

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
       instructions pour signaler des anomalies et la dernière version de cette page  peuvent  être  trouvées  à
       l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

       La   traduction   française   de   cette   page   de   manuel   a   été   créée   par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,   Stéphan   Rafin   <stephan.rafin@laposte.net>,   Thierry   Vignaud
       <tvignaud@mandriva.com>,  François  Micaux,  Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard
       <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-luc.coulon@wanadoo.fr>,   Julien   Cristau
       <jcristau@debian.org>,      Thomas      Huriaux      <thomas.huriaux@gmail.com>,     Nicolas     François
       <nicolas.francois@centraliens.net>,    Florentin    Duneau    <fduneau@gmail.com>,     Simon     Paillard
       <simon.paillard@resel.enst-bretagne.fr>,     Denis    Barbier    <barbier@debian.org>,    David    Prévot
       <david@tilapin.org> et Jean-Philippe MENGUAL <jpmengual@debian.org>

       Cette traduction est une documentation libre ; veuillez vous  reporter  à  la  GNU General Public License
       version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si  vous  découvrez  un  bogue  dans la traduction de cette page de manuel, veuillez envoyer un message à
       debian-l10n-french@lists.debian.org.

Linux                                              9 juin 2020                                      IOCTL_TTY(2)