Provided by: manpages-fr-dev_4.14.0-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  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  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⟩.