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   ⟨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 ⟨⟩.