Provided by: manpages-fr_3.23.1-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 RFC1323.
       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. Voir
       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 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  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.  Voir ip(7). Les variables indiquées
       comme boolennes 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 le support 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 le support 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. Voir  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 mmoire basse pour cela,  qui  est  limitée
              aux  environs  de  900 Mo sur les systèmes 32 bits. Les systèmes
              64bits 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,  voyez  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’oeil 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
       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 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.23  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> ».