Provided by: manpages-fr_2.80.1-1_all bug

NOM

       tcp - Protocole TCP.

SYNOPSIS

       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <netinet/tcp.h>

       tcp_socket = socket(PF_INET, SOCK_STREAM, 0);

DESCRIPTION

       Il  s’agit  d’une  implémentation  du  protocole  TCP  défini  dans les
       RFC 793, RFC 1122 et RFC 2001 avec les extensions SACK et NewReno. Cela
       fournit  une  connexion  full-duplex  fiable  orientée  flux entre deux
       sockets au-dessus de ip(7), version  4  et  6.  TCP  garantit  que  les
       données  arrivent  dans l’ordre et assure la retransmission des paquets
       perdus. Il calcule et vérifie une somme de  contrôle  par  paquet  pour
       détecter  les  erreurs de transmission. TCP ne préserve pas les limites
       des enregistrements.

       Une socket TCP neuve n’a pas d’adresse locale ou distante et n’est  pas
       complètement  définie.  Pour créer une connexion TCP sortante, utilisez
       connect(2) pour établir la connexion sur une  autre  socket  TCP.  Pour
       recevoir  les  connexions  entrantes,  attachez  d’abord la socket avec
       bind(2) à une adresse locale et un port, puis  appelez  listen(2)  pour
       mettre  la  socket  dans  un  état  d’attente. Après cela, une nouvelle
       socket peut être obtenue pour chaque connexion  entrante  en  utilisant
       accept(2).  Une socket sur laquelle on a appelé accept(2) ou connect(2)
       avec succès est complètement définie et peut transmettre  des  données.
       Les  données  ne  peuvent pas circuler sur les socket en attente ou non
       connectées.

       Linux supporte les extensions TCP à hautes performances RFC 1323.  Cela
       inclut la protection contre les numéros de séquence bouclant (PAWS), la
       modification  de  fenêtre  (« Window  Scaling »)  et  les   horodatages
       (« timestamps »).  Le Window Scaling permet d’utiliser des fenêtres TCP
       larges (> 64K) pour supporter les liaisons  avec  une  latence  ou  une
       bande  passante  élevées.  Pour  les  utiliser, les tailles des tampons
       d’émission et de réception doivent être augmentées. On peut  les  fixer
       globalement  avec les sysctls net.ipv4.tcp_wmem et net.ipv4.tcp_rmem ou
       individuellement  sur  les  sockets  avec  les  options  SO_SNDBUF   et
       SO_RCVBUF de l’appel système setsockopt(2).

       Les  tailles  maximales  pour  les  tampons  déclarés  via SO_SNDBUF et
       SO_RCVBUF sont limitées par les sysctls généraux  net.core.rmem_max  et
       net.core.wmem_max. Notez que TCP alloue en fait deux fois plus de place
       que la taille demandée  avec  l’appel  setsockopt(2),  et  qu’un  appel
       getsockopt(2) réussi ne renverra pas la même taille de tampon que celle
       réclamée  dans  le  setsockopt(2).  TCP  les   utilise   à   des   fins
       administratives  et  pour  des  structures  internes  du  noyau, et les
       variables  sysctls  renvoient  des  tailles  supérieures  à  celle  des
       véritables  fenêtres  TCP. Pour les connexions individuelles, la taille
       du tampon doit être fixée avant les appels listen(2) ou connect(2) pour
       qu’elle soit prise en compte. Voir socket(7) pour plus de détails.

       TCP  supporte  les données urgentes. Elles signalent au récepteur qu’un
       message important est dans le flux de données et qu’il doit être traité
       le  plus  tôt  possible.  Pour  envoyer  des données urgentes, indiquez
       l’option MSG_OOB de send(2). Quand des données urgentes sont reçues, le
       noyau  envoie  un  signal SIGURG au processus ou au groupe de processus
       qui a été indiqué comme propriétaire  de  la  socket  avec  les  ioctls
       SIOCSPGRP  ou FIOSETOWN (ou l’opération F_SETOWN de fcntl(2), spécifiée
       par POSIX.1-2001). Quand l’option de socket SO_OOBINLINE  est  validée,
       les  données  urgentes  sont  mises  dans le flux de données normal (et
       peuvent être détectées avec l’ioctl SIOCATMARK), sinon, on ne peut  les
       recevoir  que  lorsque l’attribut MSG_OOB es positionné pour recv(2) ou
       recvmsg(2).

       Linux 2.4 a introduit un certain nombre de changements  pour  améliorer
       le  débit et l’extensibilité, ainsi que des fonctionnalités améliorées.
       Certaines de ces fonctions incluent le  support  pour  l’émission  sans
       copie  avec sendfile(2), la notification de congestion explicite (ECN),
       la nouvelle gestion des sockets TIME_WAIT, les options "keep-alive"  et
       le support des extensions SACK dupliqués.

   Formats dadresse
       TCP  est  construit au-dessus de IP (voir ip(7)). Les formats d’adresse
       définis pour ip(7) s’appliquent pour  TCP.  TCP  ne  supporte  que  les
       communications  point-à-point. Le broadcast et le multicast ne sont pas
       supportés.

   Sysctls
       Ces variables sont accessibles avec les  fichiers  /proc/sys/net/ipv4/*
       ou  avec  l’interface  sysctl(2).  De plus, la plupart des sysctls d’IP
       s’appliquent  à  TCP.  Voir  ip(7).  Les  variables   indiquées   comme
       booléennes  prennent une valeur entière, une valeur non-nulle indiquant
       que l’option est active, une valeur nulle indiquant  que  l’option  est
       inactive.

       tcp_abort_on_overflow (booléen, désactivé par défaut)
              Valide  la  réinitialisation  des  connexions  si  le service en
              écoute est  trop  lent  et  incapable  de  les  traiter  et  les
              accepter. Cela signifie que si un débordement se produit à cause
              d’une  surcharge  temporaire,  la  connexion  va  se  rattraper.
              N’activez  cette  option  que  si vous êtes SÛRS que le démon en
              écoute ne peut pas être configuré pour accepter  les  connexions
              plus  vite.  Cette  option peut désorienter les clients de votre
              serveur.

       tcp_adv_win_scale (entier, 2 par défaut)
              Calculer le surplus du  tampon  comme  bytes/2^tcp_adv_win_scale
              (si          tcp_adv_win_scale          >          0)         ou
              bytes - bytes/2^(-tcp_adv_win_scale) (si tcp_adv_win_scal <= 0).
              La valeur par défaut est 2.

              L’espace  du  tampon de réception de la socket est partagé entre
              l’application et le noyau. TCP conserve une portion du tampon en
              tant que fenêtre TCP, c’est la taille de la fenêtre de réception
              indiquée au correspondant. Le reste de cet  espace  est  utilisé
              comme  tampon  d’« application »,  pour  isoler  le  réseau  des
              latences de l’ordonnanceur et de l’application.  La  valeur  par
              défaut  (2)  de  tcp_adv_win_scale  indique que l’espace utilisé
              pour le tampon d’application est un quart de l’espace total.

       tcp_app_win (entier, 31 par défaut)
              Cette variable définit combien d’octets de la fenêtre  TCP  sont
              réservés pour le surplus de tampon.

              Un  maximum de (fenetre/2^tcp_app_win, mss) octets de la fenêtre
              est réservé pour  le  tampon  d’application.  Une  valeur  nulle
              indique qu’aucune portion n’est réservée.

       tcp_bic (booléen, désactivé par défaut)
              Activer  l’algorithme de contrôle de congestion TCP BIC. BIC-TCP
              est une modification côté émetteur qui assure une  linéarité  du
              RTT  (Délai d’aller-retour, « Round-Trip Time ») avec de grandes
              fenêtres, tout en permettant un passage à  l’échelle  et  en  se
              bornant à la compatibilité TCP. Le protocole combine deux effets
              appelés augmentation additive et recherche binaire.  Lorsque  la
              fenêtre  de  congestion est grande, l’augmentation additive avec
              un incrément grand assure une linéarité du RTT et un bon passage
              à  l’échelle.  Avec  des  petites  fenêtres  de  congestion,  la
              recherche binaire fournit une compatibilité TCP.

       tcp_bic_low_window (entier, 14 par défaut)
              Fixer la fenêtre limite (en  paquets)  où  BIC  TCP  commence  à
              ajuser  la  fenêtre de congestion. Sous cette limite, BIC TCP se
              comporte comme l’algorithme TCP Reno par défaut.

       tcp_bic_fast_convergence (booléen, activé par défaut)
              Force BIC TCP à répondre plus vite aux changements de fenêtre de
              congestion.  Permet  à deux flux partageant la même connexion de
              converger plus vite.

       tcp_dsack (booléen, activé par défaut)
              Valide le support TCP SACK dupliqué de la RFC 2883.

       tcp_ecn (booléen, désactivé par défaut)
              Valide la notification explicite de congestion de  la  RFC 2884.
              Lorsqu’elle  est  en  service,  la  connectivité  avec certaines
              destinations peut être affectée à cause de  vieux  routeurs  mal
              configurés  le  long  du  trajet, et les connexions peuvent être
              rompues.

       tcp_fack (booléen, activé par défaut)
              Valide le support TCP Forward Acknowledgement.

       tcp_fin_timeout (entier, 60 par défaut)
              Nombre de secondes à attendre un paquet final FIN avant  que  la
              socket  soit  fermée de force. Strictement parlant, ceci est une
              violation des  spécifications  TCP,  mais  est  nécessaire  pour
              empêcher  les attaques par déni de service. La valeur par défaut
              dans les noyaux 2.2 est 180.

       tcp_frto (booléen, désactivé par défaut)
              Active F-RTO, un algorithme amélioré de  récupération  pour  les
              temporisations  de  retransmission  TCP. Il est particulièrement
              intéressant dans des environnements sans fil, où  la  perte  des
              paquets  est typiquement due à des interférences radio aléatoire
              plutôt qu’à la congestion des routeurs intermédiaires.

       tcp_keepalive_intvl (entier, 75 par défaut)
              L’intervalle en secondes entre deux messages TCP keep-alive.

       tcp_keepalive_probes (entier, 9 par défaut)
              Nombre maximal de tentatives  TCP  keep-alive  à  envoyer  avant
              d’abandonner  et  de  tuer  la connexion si aucune réponse n’est
              obtenue de l’autre partie.

       tcp_keepalive_time (entier, 7200 par défaut)
              Nombre  de  secondes  durant  lesquelles  aucune  donnée   n’est
              transmise   sur   la   connexion   avant  d’envoyer  un  message
              keep-alive.  Ces  messages  ne  sont  envoyés  que  si  l’option
              SO_KEEPALIVE  de la socket est validée. La valeur par défaut est
              7200 secondes (2 heures).  Une  connexion  inactive  est  coupée
              environ  11  minutes  plus  tard  (9  tentatives  à  75 secondes
              d’écart).

              Notez que les délais de la couche de transport sous-jacente,  ou
              de l’application peuvent être bien plus courts.

       tcp_low_latency (booléen, désactivé par défaut)
              S’il  est activé, la pile TCP prend des décisions qui favorisent
              une latence plus faible par opposition à un débit plus grand. Si
              cette option est désactivée, un débit plus grand est préféré. Un
              cas où cette valeur par défaut  devrait  être  changée  est  par
              exemple un cluster de calcul Beowulf.

       tcp_max_orphans (entier ; valeur par défaut : voir ci‐dessous)
              Le  nombre  maximal de sockets TCP orphelines (attachées à aucun
              descripteur utilisateur) sur le système.  Quand  ce  nombre  est
              dépassé,  la connexion orpheline est réinitialisée et un message
              d’avertissement est affiché.  Cette  limite  n’existe  que  pour
              éviter  les attaques par déni de service ; la diminuer n’est pas
              recommandé. Certaines situations  peuvent  réclamer  d’augmenter
              cette  limite,  mais  notez  que chaque connexion orpheline peut
              consommer jusqu’à 64 ko de mémoire non-swappable. La valeur  par
              défaut est égale au paramètre NR_FILE du noyau. Elle est ajustée
              en fonction de la mémoire disponible sur le système.

       tcp_max_syn_backlog (entier ; valeur par défaut : voir ci‐dessous)
              Le nombre maximal de requêtes  de  connexions  en  attente,  qui
              n’ont  pas  encore  reçu  d’acquittement de la part du client se
              connectant. Si ce nombre est  atteint,  le  noyau  commencera  à
              abandonner   des  requêtes.  La  valeur  par  défaut,  256,  est
              augmentée jusqu’à 1024 si la mémoire présente est suffisante (>=
              128 Mo)  et  peut être diminuée à 128 sur les systèmes avec très
              peu  de  mémoire  (<=  32 Mo).  Il  est  recommandé,  s’il  faut
              augmenter   cette   valeur   au  dessus  de  1024,  de  modifier
              TCP_SYNQ_HSIZE    dans    include/net/tcp.h    pour    conserver
              TCP_SYNQ_HSIZE  *  16 <= tcp_max_syn_backlog et de recompiler le
              noyau.

       tcp_max_tw_buckets (entier ; valeur par défaut : voir ci‐dessous)
              Le nombre maximal de sockets dans  l’état  TIME_WAIT  autorisées
              sur  le  système.  Cette  limite  n’existe  que  pour éviter les
              attaques  par  déni  de  service.  La  valeur  par  défaut   est
              NR_FILE*2,  ajustée  en fonction de la mémoire disponible. Si ce
              nombre est atteint, la socket est fermée et un avertissement est
              affiché.

       tcp_mem
              Il  s’agit  d’un vecteur de trois entiers : [bas, charge, haut].
              Ces  limites  sont  utilisées  par  TCP   pour   surveiller   sa
              consommation  mémoire.  Les valeurs par défaut sont calculées au
              moment du démarrage à partir de la mémoire disponible.  (TCP  ne
              peut  utiliser  que  la mmoire basse pour cela, qui est limitée
              aux environs de 900 Mo sur les systèmes  32 bits.  Les  systèmes
              64 bits ne souffrent pas de cette limitation.)

              bas - TCP ne cherche pas à réguler ses allocations mémoire quand
              le nombre de pages qu’il a alloué est en-dessous de ce nombre

              charge - lorsque la taille mémoire allouée par  TCP  dépasse  ce
              nombre  de  pages, TCP modère sa consommation mémoire. L’état de
              mémoire chargée se termine lorsque le nombre de  pages  allouées
              descend en dessous de la marque bas.

              haut - le nombre global maximal de pages que TCP allouera. Cette
              valeur surcharge tout autre limite imposée par le noyau.

       tcp_orphan_retries (entier, 8 par défaut)
              Le nombre maximal de tentatives pour accéder à l’autre extrémité
              d’une connexion dont notre côté a été fermé.

       tcp_reordering (entier, 3 par défaut)
              Le  nombre de réorganisations dans un flux TCP avant de supposer
              qu’un paquet est perdu et  reprendre  au  début.  Il  n’est  pas
              conseillé  de  modifier  cette valeur. C’est une métrique sur la
              détection des réordonnancements de paquets conçue pour minimiser
              les  retransmissions  inutiles  provoquées par la réorganisation
              des paquets dans une connexion.

       tcp_retrans_collapse (booléen, activé par défaut)
              Essayer d’envoyer des paquets de tailles  complètes  durant  les
              réémissions.

       tcp_retries1 (entier, 3 par défaut)
              Le  nombre  de  fois que TCP essayera de retransmettre un paquet
              sur  une  connexion  établie  normalement,  sans   demander   de
              contribution  supplémentaire  de la couche réseau concernée. Une
              fois ce nombre atteint, on demande au niveau réseau de  remettre
              à   jour   son   routage,  si  possible  avant  chaque  nouvelle
              transmission. La valeur par défaut, 3, est  le  minimum  indiqué
              dans la RFC.

       tcp_retries2 (entier, 15 par défaut)
              Le  nombre  de  fois  qu’un  paquet  TCP est restransmis sur une
              connexion établie avant d’abandonner. La valeur par  défaut  est
              15, ce qui correspond à une durée entre 13 et 30 minutes suivant
              le délai maximal de retransmission. La limite  minimale  de  100
              secondes  spécifiée  par  la RFC 1122 est typiquement considérée
              comme trop courte.

       tcp_rfc1337 (booléen, désactivé par défaut)
              Activer  le  comportement  TCP  conformément  à   la   RFC 1337.
              Lorsqu’il  n’est  pas  activé,  si  un  RST  est  reçu  en  état
              TIME_WAIT, on ferme la socket immédiatement sans attendre la fin
              de la période TIME_WAIT.

       tcp_rmem
              Il  s’agit  d’un  vecteur de trois entiers : [min, défaut, max].
              Ces paramètres sont utilisés par TCP pour régler  la  taille  du
              tampon de réception. TCP ajuste dynamiquement la taille à partir
              de la valeur par défaut,  dans  l’intervalle  de  ces  variables
              sysctls, en fonction de la mémoire disponible sur le système.

              min - taille minimale du tampon de réception utilisée par chaque
              socket TCP. La valeur par défaut est 4 Ko et descend à PAGE_SIZE
              octets sur les systèmes avec peu de mémoire. Cette valeur assure
              qu’en mode de mémoire chargée,  les  allocations  en-dessous  de
              cette taille réussiront. Elle n’est pas utilisée pour limiter la
              taille du tampon de réception, déclarée  en  utilisant  l’option
              SO_RCVBUF sur la socket.

              dfaut  -  la  taille par défaut du tampon de réception pour une
              socket TCP. Cette valeur écrase la taille  par  défaut  dans  la
              valeur  globale  net.core.rmem_default  définie  pour  tous  les
              protocoles. La valeur par défaut est 87380 octets, et descend  à
              43689  sur  les systèmes avec peu de mémoire. Si une taille plus
              grande  est  désirée,  il  faut  augmenter  cette  valeur  (pour
              affecter  toutes  les sockets). Pour utiliser une grande fenêtre
              TCP, l’option net.ipv4.tcp_window_scaling doit être activée (par
              défaut).

              max  -  la  taille  maximale  du tampon de réception utilisé par
              chaque socket TCP. Cette  valeur  ne  surcharge  pas  la  valeur
              globale  net.core.rmem_max.  Elle  ne  permet  pas de limiter la
              taille du tampon de réception déclarée avec  l’option  SO_RCVBUF
              sur  la  socket. La valeur par défaut est 87380*2 octets et peut
              descendre à 87380 sur les systèmes avec peu de mémoire.

       tcp_sack (booléen, activé par défaut)
              Activer l’acquittement TCP sélectif (RFC 2018).

       tcp_stdurg (booléen, désactivé par défaut)
              Activation   de   l’interprétation   RFC 1122   du   champ   TCP
              Urgent-Pointer.  Selon  cette interprétation, le pointeur urgent
              pointe vers le dernier octet de données urgentes. Par défaut  on
              utilise  une  interprétation  compatible  BSD  de  ce champ, qui
              pointe vers le premier octet après les données urgentes. Valider
              cette  option  peut  poser  des  problèmes  d’interaction  entre
              systèmes.

       tcp_synack_retries (entier, 5 par défaut)
              Le nombre maximal de fois où un segment SYN/ACK sera  retransmis
              sur  une  connexion  TCP passive. Ce nombre ne doit pas dépasser
              255.

       tcp_syncookies (booléen)
              Valider les syncookies TCP. Le  noyau  doit  être  compilé  avec
              l’option  CONFIG_SYN_COOKIES.  Envoie  des syncookies lorsque la
              file d’attente des connexions sur une socket déborde.  Ceci  est
              utilisé pour se protéger d’une attaque de type « SYN flood ». On
              ne doit l’utiliser qu’en dernier ressort. C’est une violation du
              protocole TCP, et entre en conflit avec d’autres fonctions comme
              les extensions TCP. Cela  peut  poser  des  problèmes  avec  les
              clients ou les relais. Ce mécanisme n’est pas considéré comme un
              moyen de réglage sur un serveur très chargé  ou  mal  configuré.
              Pour  des  alternatives  acceptables, voyez tcp_max_syn_backlog,
              tcp_synack_retries, tcp_abort_on_overflow.

       tcp_syn_retries (entier, 5 par défaut)
              Le nombre  maximal  de  fois  où  un  paquet  SYN  initial  sera
              retransmis  pour  une  tentative  de connexion TCP active. Cette
              valeur ne doit pas dépasser 255. La valeur par défaut est 5,  ce
              qui correspond approximativement à 180 secondes.

       tcp_timestamps (booléen, activé par défaut)
              Activer les horodatages TCP (RFC 1323).

       tcp_tw_recycle (booléen, désactivé par défaut)
              Activer  le recyclage rapide des sockets TIME_WAIT. Cette option
              n’est pas recommandée car elle peut poser des problèmes avec les
              redirections NAT (Network Address Translation).

       tcp_tw_reuse (booléen, désactivé par défaut)
              Permet  de  réutiliser  les sockets TIME_WAIT pour les nouvelles
              connexions quand c’est sûr du point de vue du protocole. Cela ne
              devrait  pas  être  modifié  sans l’avis ou la demande d’experts
              techniques.

       tcp_window_scaling (booléen, activé par défaut)
              Activer le dimensionnement de la fenêtre TCP  (RFC 1323).  Cette
              fonctionnalité  permet  d’utiliser  une grande fenêtre (> 64 Ko)
              sur  une  connexion  TCP  si  le  correspondant   le   supporte.
              Normalement,  les  16  bits du champ de longueur de fenêtre dans
              l’en-tête TCP limitent la taille  à  64 Ko.  Si  on  désire  une
              fenêtre  plus  grande, l’application peut augmenter la taille du
              tampon de la socket et activer l’option  tcp_window_scaling.  Si
              tcp_window_scaling   est   inhibée,   TCP   ne   négociera   pas
              l’utilisation  du   dimensionnement   des   fenêtres   avec   le
              correspondant lors de l’initialisation de la connexion.

       tcp_vegas_cong_avoid (booléen, désactivé par défaut)
              Active  l’algorithme  TCP  Vegas  d’évitement de congestion. TCP
              Vegas est une modification côté émetteur de TCP qui anticipe  la
              congestion  en  estimant  la bande passante. TCP Vegas ajuste la
              vitesse d’émission en modifiant la fenêtre  de  congestion.  TCP
              Vegas  devrait fournir moins de perte de paquets, mais n’est pas
              aussi agressif que TCP Reno.

       tcp_westwood (booléen, désactivé par défaut)
              Active l’algorithme TCP Westwood+ de contrôle de congestion. TCP
              Westwood+  est  une  modification  côté  émetteur  de la pile de
              protocole TCP Reno qui optimise la performance  du  contrôle  de
              congestion TCP. Il est basé sur une estimation de bande passante
              de bout en bout pour  fixer  la  fenêtre  de  congestion  et  un
              redémarrage  lent  après un épisode de congestion. Grâce à cette
              estimation, TCP Westwood+ fixe de façon adaptative une limite de
              démarrage  lent  et  une  fenêtre  de congestion qui prennent en
              compte la bande passante utilisée au moment où la congestion  se
              produit.  TCP Westwood+ augmente de façon significative l’équité
              par rapport à TCP Reno dans les réseaux filaires,  et  le  débit
              sur des liens sans fil.

       tcp_wmem
              Il  s’agit  d’un  vecteur de trois entiers : [min, défaut, max].
              Ces paramètres servent à TCP pour réguler la  taille  du  tampon
              d’émission.  La  taille est ajustée dynamiquement à partir de la
              valeur par défaut, dans l’intervalle des  variables  sysctl,  en
              fonction de la mémoire disponible.

              min  -  taille  minimale du tampon d’émission utilisé par chaque
              socket TCP. La valeur par défaut est 4 Ko. Cette  valeur  assure
              qu’en  mode  de  mémoire  chargée, les allocations en-dessous de
              cette taille réussiront. Elle n’est pas utilisée pour limiter la
              taille  du  tampon  de réception, déclarée en utilisant l’option
              SO_SNDBUF sur la socket.

              dfaut - la taille par défaut  du  tampon  d’émission  pour  une
              socket  TCP.  Cette  valeur  écrase la taille par défaut dans la
              valeur  globale  net.core.wmem_default  définie  pour  tous  les
              protocoles.  La  valeur par défaut est 16 Ko. Si une taille plus
              grande  est  désirée,  il  faut  augmenter  cette  valeur  (pour
              affecter  toutes  les sockets). Pour utiliser une grande fenêtre
              TCP, la variable net.ipv4.tcp_window_scaling doit  être  activée
              (par défaut).

              max - la taille maximale du tampon d’émission utilisé par chaque
              socket TCP. Cette valeur ne  surcharge  pas  la  valeur  globale
              net.core.wmem_max.  Elle  ne  permet pas de limiter la taille du
              tampon de réception déclarée  avec  l’option  SO_SNDBUF  sur  la
              socket.  La  valeur  par  défaut  est 128 Ko et peut descendre à
              64 Ko sur les systèmes avec peu de mémoire.

   Options de sockets
       Pour lire ou écrire une option de  socket  TCP,  appeler  getsockopt(2)
       pour  la  lecture  ou  setsockopt(2)  pour  l’écriture, avec l’argument
       niveau de socket valant IPPROTO_TCP. De plus, la plupart des options de
       socket  IPPROTO_IP  sont  valides  sur  les  sockets  TCP. Pour plus de
       détails, voir ip(7).

       TCP_CORK
              Ne  pas  envoyer  de  trames  partielles.  Toutes   les   trames
              partielles  en  attente  sont  envoyées lorsque cette option est
              effacée à nouveau. Ceci permet de préparer  les  en-têtes  avant
              d’appeler   sendfile(2),   ou  pour  optimiser  le  débit.  Avec
              l’implémentation  actuelle,  il  y   a   une   limite   de   200
              millisecondes  au temps pendant lequel des données sont agrégées
              avec TCP_CORK. Si cette limite est atteinte, les  données  mises
              en attente sont automatiquement transmises. Cette option ne peut
              être combinée avec TCP_NODELAY que depuis  Linux  2.5.71.  Cette
              option  ne  doit  pas être utilisée dans du code conçu pour être
              portable.

       TCP_DEFER_ACCEPT
              Permettre à un processus en écoute de n’être réveillé que si des
              données  arrivent  sur  la  socket. Prend une valeur entière (en
              secondes), correspondant au nombre maximal de tentatives que TCP
              fera  pour  terminer la connexion. Cette option ne doit pas être
              utilisée dans du code conçu pour être portable.

       TCP_INFO
              Fournit des informations sur la socket.  Le  noyau  renvoie  une
              structure   struct   tcp_info  comme  définie  dans  le  fichier
              /usr/include/linux/tcp.h. Cette option ne doit pas être utilisée
              dans du code conçu pour être portable.

       TCP_KEEPCNT
              Le  nombre  maximal  de messages keepalive envoyés par TCP avant
              d’abandonner une  connexion.  Cette  option  ne  doit  pas  être
              utilisée dans du code conçu pour être portable.

       TCP_KEEPIDLE
              La  durée (en secondes) d’inactivité sur une connexion avant que
              TCP commence à  envoyer  les  messages  keepalive,  si  l’option
              SO_KEEPALIVE  a  été activée sur la socket. Cette option ne doit
              pas être employée dans du code conçu pour être portable.

       TCP_KEEPINTVL
              Délai (en seconde) entre deux messages keepalive.  Cette  option
              ne doit pas être utilisée dans du code conçu pour être portable.

       TCP_LINGER2
              La durée des sockets orphelines  dans  l’état  FIN_WAIT2.  Cette
              option  peut servir à surcharger la valeur de la variable sysctl
              (globale pour le système) tcp_fin_timeout spécialement  pour  la
              socket.  À  ne  pas  confondre avec l’option SO_LINGER du niveau
              socket(7). Cette option ne doit pas être utilisée dans  du  code
              conçu pour être portable.

       TCP_MAXSEG
              La  taille maximale de segment pour les paquets TCP sortants. Si
              cette options est  fixée  avant  d’établir  la  connexion,  elle
              change  également  la  valeur  MSS annoncée à l’autre extrémité,
              dans le paquet  initial.  Les  valeurs  supérieures  au  MTU  de
              l’interface sont ignorées et n’ont pas d’effet. TCP imposera ses
              limites minimales et maximales plutôt que les valeurs  fournies.

       TCP_NODELAY
              Désactiver  l’algorithme  Nagle.  Ceci  signifie que les paquets
              seront envoyés dès que possible, même s’il n’y a que très peu de
              données.  Sinon,  les données sont conservées jusqu’à ce qu’il y
              en ait un nombre suffisant, pour éviter d’envoyer  de  fréquents
              petits  paquets,  au détriment du réseau. Cette option est moins
              prioritaire que TCP_CORK. Cependant, activer cette option  force
              un  vidage des données actuellement en attente, même si TCP_CORK
              est actif.

       TCP_QUICKACK
              Valider le mode quickack, ou l’inhiber si l’option est nulle. En
              mode  quickack,  les  acquittements  sont  envoyés immédiatement
              plutôt que retardés si  besoin  par  rapport  au  fonctionnement
              normal  de  TCP.  Cet  attribut  n’est  pas permanent, il s’agit
              seulement d’un basculement vers ou depuis le mode quickack.  Les
              opérations   ultérieures  du  protocole  TCP  feront  à  nouveau
              entrer/quitter le mode  quickack  en  fonction  des  traitements
              internes  du  protocole  et  de  facteurs  tels  que  les délais
              d’acquittements retardés, ou les  tranferts  de  données.  Cette
              option  ne  doit  pas être utilisée dans du code conçu pour être
              portable.

       TCP_SYNCNT
              Indique le nombre de retransmissions de SYN que TCP doit envoyer
              avant  d’annuler la tentative de connexion. Ne doit pas dépasser
              255. Cette option ne doit pas être utilisée dans du  code  conçu
              pour être portable.

       TCP_WINDOW_CLAMP
              Limite  la  taille  de  la  fenêtre.  Le noyau impose une taille
              minimale de SOCK_MIN_RCVBUF/2. Cette option  ne  doit  pas  être
              employée dans du code conçu pour être portable.

   Ioctls
       Ces  ioctl(2)s  renvoient  des  informations  dans  valeur.  La syntaxe
       correcte est :

              int valeur;
              error = ioctl(tcp_socket, ioctl_type, &valeur);

       ioctl_type est l’une des valeurs suivantes :

       SIOCINQ
              Renvoie la quantité de données  non  lues  en  attente  dans  le
              tampon  de  réception.  La  socket  ne doit pas être dans l’état
              LISTEN, sinon l’erreur EINVAL est renvoyée.

       SIOCATMARK
              Renvoie vrai (c’est-à-dire une valeur non nulle) si le  flux  de
              données entrantes est à la marque de données urgentes.

              Si  l’option  SO_OOBINLINE  est  activée,  et SIOCATMARK renvoie
              vrai, la prochaine lecture sur la socket  renverra  les  données
              urgentes.   Si  l’option  SO_OOBINLINE  n’est  pas  activée,  et
              SIOCATMARK renvoie vrai, la  prochaine  lecture  sur  la  socket
              renverra  les octets suivant les données urgentes (pour lire les
              données urgentes, il faut utiliser l’option MSG_OOB de  recv()).

              Notez  qu’une  lecture  ne  lit  jamais de part et d’autre de la
              marque de données urgentes. Si une application est  informée  de
              la  présence  de  données  urgentes avec select(2) (en utilisant
              l’argument exceptfds) ou par la réception du signal  SIGURG,  il
              peut  avancer  jusqu’à  la  marque  avec une boucle qui teste de
              façon répétée SIOCATMARK  et  fait  une  lecture  (demandant  un
              nombre quelconque d’octets) tant que SIOCATMARK renvoie faux.

       SIOCOUTQ
              Renvoie  la  quantité de données non envoyées en attente dans le
              tampon d’émission. La  socket  ne  doit  pas  être  dans  l’état
              LISTEN, sinon l’erreur EINVAL est renvoyée.

   Traitement des erreurs
       Quand  une  erreur  réseau se produit, TCP tente de renvoyer le paquet.
       S’il ne réussit pas après un certain  temps,  soit  ETIMEDOUT  soit  la
       dernière erreur reçue sur la connexion est renvoyée.

       Certaines applications demandent une notification d’erreur plus rapide.
       Ceci peut être validé avec l’option  de  socket  IP_RECVERR  de  niveau
       IPPROTO_IP.  Quand cette option est active, toutes les erreurs arrivant
       sont immédiatement passées au  programme  utilisateur.  Employez  cette
       option  avec précaution, elle rend TCP moins tolérant aux modifications
       de routage et autres conditions réseau normales.

ERREURS

       EAFNOTSUPPORT
              Le type d’adresse de la socket passée  dans  sin_family  n’était
              pas AF_INET.

       EPIPE  L’autre  extrémité a fermé inopinément la socket, ou une lecture
              est tentée sur une socket terminée.

       ETIMEDOUT
              L’autre côté n’a pas acquitté les données retransmises après  un
              certain délai.

       Toutes  les  erreurs  définies  dans  ip(7)  ou au niveau générique des
       sockets peuvent aussi se produire avec TCP.

VERSIONS

       Le support pour la notification explicite de congestion, l’émission  de
       fichiers  sans copie avec sendfile(2), le réordonnancement et certaines
       extensions SACK (DSACK) ont été introduits dans Linux 2.4.  Le  support
       du  Forward  Acknowledgement  (FACK),  le  recyclage  de  TIME_WAIT les
       options des  messages  keepalive  et  les  variables  sysctls  ont  été
       introduits dans Linux 2.3.

       Les  valeurs  par  défaut  et  les  descriptions  des variables sysctls
       décrites ci-dessus sont applicables pour les noyaux 2.4.

NOTES

       TCP n’a pas  de  véritables  données  hors-bande ;  il  a  des  données
       urgentes.  Sous  Linux  cela  signifie  que  si  l’autre côté envoie de
       nouvelles données hors-bande, les données urgentes plus anciennes  sont
       insérées   comme   des  données  normales  dans  le  flux  (même  quand
       SO_OOBINLINE n’est pas actif). Cela diffère des piles basées sur BSD.

       Linux utilise par défaut une interprétation  compatible  BSD  du  champ
       Urgent-Pointer.  Ceci  viole  la  RFC 1122, mais est indispensable pour
       l’interopérabilité  avec  les  autres  piles.  On  peut   modifier   ce
       comportement avec le sysctl tcp_stdurg.

BOGUES

       Toutes les erreurs ne sont pas documentées.
       IPv6 n’est pas décrit.

VOIR AUSSI

       accept(2),  bind(2),  connect(2), getsockopt(2), listen(2), recvmsg(2),
       sendfile(2), sendmsg(2), socket(2), sysctl(2), ip(7), socket(7)

       RFC 793 pour les spécifications TCP.
       RFC 1122 pour les nécessités TCP et  une  description  de  l’algorithme
       Nagle.
       RFC 1323 pour les options d’horodatage et la fenêtre TCP.
       RFC 1644 pour une description des dangers de TIME_WAIT.
       RFC 3168   pour   une  description  de  la  notification  explicite  de
       congestion.
       RFC 2581 pour des algorithmes de contrôle de congestion TCP.
       RFC 2018 et RFC 2883 pour SACK et ses extensions.

COLOPHON

       Cette page fait partie de  la  publication  2.80  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Julien Cristau <jcristau@debian.org> et l’équipe
       francophone de traduction de Debian.

       Veuillez  signaler  toute  erreur   de   traduction   en   écrivant   à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document
       en utilisant la commande « man -L C <section> <page_de_man> ».