Provided by: manpages-fr_3.32d0.2p4-1_all bug

NOM

       tcp - Protocole TCP

SYNOPSIS

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

       tcp_socket = socket(AF_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 prend en charge 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 gérer 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 fichiers
       /proc/sys/net/ipv4/tcp_wmem et /proc/sys/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 valeurs des fichiers /proc/sys/net/core/rmem_max  et  /proc/sys/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 valeurs des  fichiers  de
       /proc  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. Consultez socket(7) pour plus de détails.

       TCP  permet de d'indiquer des 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  la  prise  en  charge d'émission sans copie avec sendfile(2), la notification de
       congestion explicite (ECN),  la  nouvelle  gestion  des  sockets  TIME_WAIT,  les  options
       « keep-alive » et la prise en charge des extensions SACK dupliqués.

   Formats d'adresse
       TCP  est  construit  au-dessus de IP (consultez ip(7)). Les formats d'adresse définis pour
       ip(7) s'appliquent pour  TCP.  TCP  ne  gère  que  les  communications  point-à-point.  Le
       broadcast et le multicast ne sont pas gérés.

   Interfaces /proc
       Les   paramètres  TCP  du  système  sont  accessibles  avec  les  fichiers  du  répertoire
       /proc/sys/net/ipv4/. De plus, la plupart des interfaces /proc  d'IP  s'appliquent  à  TCP.
       Consultez 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_abc (entier ; 0 par défaut ; depuis Linux 2.6.15)
              Contrôler  l'ABC (« Appropriate Byte Count » : décompte d'octets approprié), défini
              dans la RFC 3465. ABC est une façon d'augmenter la fenêtre  de  congestion  (cwnd :
              « congestion  window)  plus  lentement en réponse à des acquittements partiels. Les
              valeurs possibles sont :

              0  augment cwnd une fois par acquittement (pas d'ABC)

              1  augmenter cwnd une fois par acquittement d'un paquet complet

              2  permettre l'augmentation de cwnd par deux si l'acquittement  correspond  à  deux
                 segments, pour compenser les acquittements avec délais.

       tcp_abort_on_overflow (booléen ; désactivé par défaut ; depuis Linux 2.4)
              Valider 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 ; depuis Linux 2.4)
              Calculer le surplus du tampon comme bytes/2^tcp_adv_win_scale, si tcp_adv_win_scale
              est supérieur à 0 ; ou bytes-bytes/2^(-tcp_adv_win_scale), si tcp_adv_win_scale est
              inférieur ou égal à zéro.

              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_allowed_congestion_control (chaîne ; voir le texte pour la valeur par défaut ;  depuis
       Linux 2.4.20)
              Afficher  ou  définir les choix d'algorithmes de contrôle de congestion disponibles
              pour les processus non privilégiés (voir la description de l'option  TCP_CONGESTION
              pour  les  sockets).  La  liste  est  un  sous-ensemble des algorithmes de la liste
              tcp_available_congestion_control.  La  valeur  par  défaut  est  « reno »  plus  le
              paramètre par défaut de tcp_congestion_control.

       tcp_available_congestion_control (chaîne ; lecture seule ; depuis Linux 2.4.20)
              Afficher  une liste des algorithmes de contrôle de congestion qui sont enregistrés.
              Cette  liste   limite   l'ensemble   des   algorithmes   permis   pour   la   liste
              tcp_allowed_congestion_control.   Plus  d'algorithmes  de  contrôle  de  congestion
              peuvent être disponible sous forme de modules, mais non chargés.

       tcp_app_win (entier ; 31 par défaut ; depuis Linux 2.4)
              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_base_mss (entier ; 512 par défaut ; depuis Linux 2.6.17)
              La valeur initiale de search_low à utiliser pour la découverte  du  MTU  du  chemin
              dans la couche de transport (mise en paquets). SI la découverte du MTU est activée,
              il s'agit du MSS de départ utilisé par la connexion.

       tcp_bic (booléen ; désactivé par défaut ; Linux 2.4.27/2.6.6 à 2.6.13)
              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 ; Linux 2.4.27/2.6.6 à 2.6.13)
              Fixer  la  fenêtre  limite (en paquets) pour laquelle BIC TCP commence à ajuster 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 ; Linux 2.4.27/2.6.6 à 2.6.13)
              Forcer  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_congestion_control (chaîne ;  voir  le  texte  pour  la  valeur  par  défaut ;  depuis
       Linux 2.4.13)
              Définir  l'algorithme  de  contrôle  de  congestion  à  utiliser pour les nouvelles
              connexions.  L'algorithme  « reno »  est  toujours  disponible,  mais   des   choix
              supplémentaires  sont  disponibles  en  fonction  de  la configuration du noyau. La
              valeur par défaut pour ce fichier est définie dans la configuration du noyau.

       tcp_dma_copybreak (entier ; 4096 par défaut ; depuis Linux 2.6.24)
              La limite inférieure, en octets, de la taille  des  lectures  sur  une  socket  qui
              seront délestées sur le moteur de copie DMA, s'il y en a un sur le système et si le
              noyau a été configuré avec l'option CONFIG_NET_DMA.

       tcp_dsack (booléen ; activé par défaut ; depuis Linux 2.4)
              Valide la prise en charge TCP SACK dupliqué de la RFC 2883.

       tcp_ecn (booléen ; désactivé par défaut ; depuis Linux 2.4)
              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 ; depuis Linux 2.4)
              Valide la prise en charge TCP Forward Acknowledgement.

       tcp_fin_timeout (entier ; 60 par défaut ; depuis Linux 2.2)
              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 (entier ; 0 par défaut ; depuis Linux 2.4.21/2.6)
              Activer F-RTO, un algorithme amélioré de récupération pour  les  temporisations  de
              retransmission  TCP  (RTO :  « retransmission  timeouts »). 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. Consultez la RFC 4138 pour plus de détails.

              Ce fichier peut prendre une des valeurs suivantes :

              0  Désactivé.

              1  La version de base de l'algorithme F-RTO est activée.

              2  Active la version améliorée de F-RTO avec des SACK, si le flux utilise des SACK.
                 La  version  de base peut aussi être utilisée quand des SACK sont utilisés, même
                 si dans ce cas des scénarios existent dans lesquels F-RTO interagit mal avec  le
                 comptage de paquets du flux TCP utilisant des SACK.

              Avant  Linux 2.6.22,  ce  paramètre  était  une valeur booléenne, qui ne prenait en
              charge que les valeurs 0 et 1 ci-dessous.

       tcp_frto_response (entier ; 0 par défaut ; depuis Linux 2.6.22)
              Quand F-RTO a détecté  une  fausse  expiration  d'une  temporisation  (c'est-à-dire
              qu'elle  aurait  pu  être  évitée  si  TCP avait eu un délai de retransmission plus
              long), TCP a plusieurs options sur ce qu'il faut faire par la  suite.  Les  valeurs
              possibles sont :

              0  Diminution  de  moitié du débit ; une réponse douce et conservatrice qui résulte
                 en une diminution de moitié de la fenêtre de congestion (cwnd) et  du  seuil  de
                 démarrage   lent   (ssthresh,   « slow-start   threshold »)   après   un   délai
                 d'aller-retour (RTT).

              1  Réponse très conservatrice ; pas recommandée parce que bien que  correcte,  elle
                 interagit  mal  avec le reste de TCP sous Linux ; réduction de moitié de cwnd et
                 de ssthresh immédiatement.

              2  Réponse agressive ; supprime les mesures de  contrôle  de  congestion  qui  sont
                 connues  pour  ne pas être nécessaire (en ignorant la possibilité d'une perte de
                 retransmission qui forcerait TCP à être plus prudent) ; cwnd  et  ssthresh  sont
                 remis aux valeurs antérieures à l'expiration du délai.

       tcp_keepalive_intvl (entier ; 75 par défaut ; depuis Linux 2.4)
              L'intervalle en secondes entre deux messages TCP keep-alive.

       tcp_keepalive_probes (entier ; 9 par défaut ; depuis Linux 2.2)
              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 ; depuis Linux 2.2)
              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 ; depuis Linux 2.4.21/2.6)
              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 ; depuis Linux 2.4)
              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 ; depuis Linux 2.2)
              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 ; depuis Linux 2.4)
              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_moderate_rcvbuf (booléen ; activé par défaut ; Linux 2.4.17/2.6.7)
              S'il  est  activé,  TCP  effectue un réglage automatique du tampon de réception, en
              essayant  de  trouver  la  bonne  taille  automatiquement  (pas  plus   grand   que
              tcp_rmem[2])  pour correspondre à la taille nécessaire pour un débit maximal sur le
              chemin.

       tcp_mem (depuis Linux 2.4)
              Il s'agit d'un vecteur  de  trois  entiers :  [bas,  charge,  haut].  Ces  limites,
              mesurées  dans  une  unité  qui  correspond  à  la  taille  des pages système, 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 mémoire 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.)

              low       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

              pressure  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.

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

       tcp_mtu_probing (entier ; 0 par défaut ; Linux 2.6.17)
              Ce paramètre contrôle la découverte du MTU du chemin de la couche transport  (« TCP
              Packetization-Layer  Path  MTU  Discovery »).  Le  fichier peut prendre les valeurs
              suivantes :

              0  Désactivé

              1  Désactivé par défaut, activé quand un trou noir ICMP est détecté

              2  Toujours activé, utilise le MSS de départ de tcp_base_mss.

       tcp_no_metrics_save (booléen ; désactivé par défaut ; depuis Linux 2.6.6)
              Par défaut, TCP sauve différentes métriques sur la  connexion  dans  la  cache  des
              routes  quand  la  connexion est fermée, de telle sorte que les connexions ouvertes
              rapidement après puissent les utiliser comme conditions initiales. D'habitude, ceci
              augmente globalement les performances, mais peut parfois dégrader les performances.
              Si tcp_no_metrics_save est activé, TCP ne sauvera pas de  métrique  dans  la  cache
              lors de la fermeture des connexions.

       tcp_orphan_retries (entier ; 8 par défaut ; depuis Linux 2.4)
              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 ; depuis Linux 2.4)
              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 ; depuis Linux 2.2)
              Essayer d'envoyer des paquets de tailles complètes durant les réémissions.

       tcp_retries1 (entier ; 3 par défaut ; depuis Linux 2.2)
              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 ; depuis Linux 2.2)
              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 ; depuis Linux 2.2)
              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 (depuis Linux 2.4)
              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
              valeurs, 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 la taille des pages du système (sous Linux 2.4,  la
                        valeur  par  défaut  est  de  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.

              default   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 (sous Linux 2.4, elle 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 calculé par la
                        formule :

                            max(87380, min(4MB, tcp_mem[1]*PAGE_SIZE/128))

                        (Sous Linux 2.4, la valeur par défaut est de 87380*2 octets, et descendre
                        à 87380 sur les systèmes avec peu de mémoire)

       tcp_sack (booléen ; activé par défaut ; depuis Linux 2.2)
              Activer l'acquittement TCP sélectif (RFC 2018).

       tcp_slow_start_after_idle (booléen ; activé par défaut ; depuis Linux 2.6.18)
              S'il  est  activé,  le  comportement  de  la  RFC 2861 est fournit et la fenêtre de
              congestion expire après une période  d'inactivité.  Une  période  d'inactivité  est
              définie  comme  le  RTO  (« retransmission timeout » : le délai de retransmission).
              S'il est désactivé, la fenêtre de  congestion  n'expirera  pas  après  une  période
              d'inactivité.

       tcp_stdurg (booléen ; désactivé par défaut ; depuis Linux 2.2)
              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_syn_retries (entier ; 5 par défaut ; depuis Linux 2.2)
              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_synack_retries (entier ; 5 par défaut ; depuis Linux 2.2)
              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 ; depuis Linux 2.2)
              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,  consultez  tcp_max_syn_backlog,
              tcp_synack_retries, tcp_abort_on_overflow.

       tcp_timestamps (booléen ; activé par défaut ; depuis Linux 2.2)
              Activer les horodatages TCP (RFC 1323).

       tcp_tso_win_divisor (entier ; 3 par défaut ; depuis Linux 2.6.9)
              Ce paramètre contrôle quel pourcentage  de  la  fenêtre  de  congestion  peut  être
              utilisé  par une unique trame de segmentation (TSO : « TCP Segmentation Offload »).
              La valeur de ce paramètre est un compromis entre une transmission  par  rafales  et
              construire des trames avec un TSO plus importants.

       tcp_tw_recycle (booléen ; désactivé par défaut ; depuis Linux 2.4)
              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 ; depuis Linux 2.4.19/2.6)
              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_vegas_cong_avoid (booléen ; désactivé par défaut ; Linux 2.2 à 2.6.13)
              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 ; Linux 2.4.26/2.6.3 à 2.6.13)
              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_window_scaling (booléen ; activé par défaut ; depuis Linux 2.2)
              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 prend en charge. 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_wmem (depuis Linux 2.4)
              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 de  ces  valeurs,
              en fonction de la mémoire disponible.

              min       La taille minimale du tampon d'émission utilisé par chaque socket TCP. La
                        valeur par défaut est la taille des pages du systeème (sous Linux 2.4, la
                        valeur par défaut est de 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.

              default   La taille par défaut du tampon d'émission  pour  une  socket  TCP.  Cette
                        valeur    surcharge    la   taille   par   défaut   de   valeur   globale
                        /proc/sys/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, /proc/sys/net/ipv4/tcp_window_scaling
                        doit être positionné à une valeur non nulle (par défaut).

              max       max - la taille maximale du tampon d'émission utilisé par  chaque  socket
                        TCP.  Cette  valeur ne surcharge pas la valeur globale qui se trouve dans
                        /proc/sys/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 calculée avec la formule :

                            max(65536, min(4MB, tcp_mem[1]*PAGE_SIZE/128))

                        Sous Linux 2.4, la valeur par défaut est de 128 Ko et descendre  à  64 Ko
                        sur les systèmes avec peu de mémoire)

       tcp_workaround_signed_windows (booléen ; désactivé par défaut ; depuis Linux 2.6.26)
              S'il   est   activé,   supposer   que   l'absence  de  réception  d'une  option  de
              dimensionnement de la fenêtre signifie que la pile TCP distante n'est pas  correcte
              et  traite  la  fenêtre comme une quantité signée. S'il est désactivé, supposer que
              les piles TCP distantes ne sont jamais disfonctionnelles même si aucune  option  de
              dimensionnement de la fenêtre n'est reçue de leur part.

   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 (depuis Linux 2.2)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              La durée des sockets orphelines dans l'état FIN_WAIT2. Cette option peut  servir  à
              surcharger      la      valeur      du     paramètre     système     du     fichier
              /proc/sys/net/ipv4/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 (depuis Linux 2.4.4)
              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 (depuis Linux 2.4)
              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 (depuis Linux 2.4)
              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.

   API des sockets
       TCP fourni une prise en charge limitée des données hors-bande, sous la  forme  de  données
       urgentes (un seul octet). 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 /proc/sys/net/ipv4/tcp_stdurg.

       Il est possible de jeter un coup d'œil aux  données  hors-bande  en  utilisant  l'attribut
       MSG_PEEK de recv(2).

       Depuis  la version 2.4, Linux prend en charge l'utilisation de MSG_TRUNC dans le paramètre
       flags de recv(2) (et recvmsg(2)). Cet attribut a pour effet  que  les  octets  de  données
       reçus  sont  ignorés,  plutôt  que  fournit  au  tampon  fournit  par  l'appelant.  Depuis
       Linux 2.4.4, MSG_PEEK a également un effet lorsqu'il est combiné à MSG_OOB  pour  recevoir
       les données hors-bande.

   Ioctls
       Les ioctl(2)s suivants 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.
              SIOCINQ  est  défini  dans  <linux/sockios.h>.  Une  alternative  est d'utiliser le
              synonyme FIONREAD, défini dans <sys/ioctl.h>.

       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.
              SIOCOUTQ est défini dans  <linux/sockios.h>.  Une  alternative  est  d'utiliser  le
              synonyme TIOCOUTQ, défini dans <sys/ioctl.h>.

   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

       La  prise  en  charge de 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.  La  prise  en  charge  du Forward Acknowledgement (FACK), le
       recyclage de TIME_WAIT et  les  options  keepalive  des  sockets  par  connexion  ont  été
       introduits dans Linux 2.3.

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), 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 3.32 du projet man-pages Linux.  Une  description
       du  projet  et  des  instructions  pour  signaler  des  anomalies  peuvent être trouvées à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis   2010,   cette   traduction   est   maintenue   à   l'aide   de    l'outil    po4a
       <URL:http://po4a.alioth.debian.org/>  par  l'équipe  de  traduction francophone au sein du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Christophe  Blaess  <URL:http://www.blaess.fr/christophe/>   (1996-2003),   Alain   Portal
       <URL:http://manpagesfr.free.fr/>  (2003-2006).  Julien  Cristau et l'équipe francophone de
       traduction de Debian (2006-2009).

       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> ».