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

NOM

       socket - Interface Linux aux sockets

SYNOPSIS

       #include <sys/socket.h>

       ma_socket  =  socket(int  famille_de_socket,  int  type_de_socket,  int
       protocole);

DESCRIPTION

       Cette   page   de   manuel   documente   l’interface   utilisateur   de
       l’implémentation  Linux des sockets réseau. Les sockets compatibles BSD
       représentent l’interface uniforme entre le processus utilisateur et les
       piles  de  protocoles  réseau dans le noyau. Les modules des protocoles
       sont  regroupés  en  familles  de  protocoles  comme  PF_INET,  PF_IPX,
       PF_PACKET et en types de sockets comme SOCK_STREAM ou SOCK_DGRAM. Voyez
       socket(2) pour plus d’informations sur les familles  et  les  types  de
       sockets.

   Fonctions du niveau socket
       Ces fonctions servent au processus utilisateur pour envoyer ou recevoir
       des paquets et pour faire d’autres opérations  sur  les  sockets.  Pour
       plus de détails, voyez leurs pages de manuel respectives.

       socket(2) crée une socket, connect(2) connecte une socket à une adresse
       de socket distante, la  fonction  bind(2)  attache  une  socket  à  une
       adresse  locale,  listen(2)  indique  à  la  socket  que  de  nouvelles
       connexions doivent être acceptées, et accept(2)  fournit  une  nouvelle
       socket  avec la nouvelle connexion entrante. socketpair(2) renvoie deux
       sockets  anonymes  connectées  (seulement  implémenté   pour   quelques
       familles locales comme PF_UNIX).

       send(2),  sendto(2), et sendmsg(2) envoient des données sur une socket,
       et recv(2), recvfrom(2) et recvmsg(2) reçoivent  les  données  envoyées
       par une socket. poll(2) et select(2) attendent que des données arrivent
       ou  que   l’émission   soit   possible.   De   plus,   les   opérations
       d’entrée-sortie   standard   comme  write(2),  writev(2),  sendfile(2),
       read(2)  et  readv(2)  peuvent  être  utilisées  pour  la  lecture   et
       l’écriture des données.

       getsockname(2)  renvoie l’adresse de la socket locale et getpeername(2)
       renvoie l’adresse de la socket distante. getsockopt(2) et setsockopt(2)
       servent  à  définir  et  obtenir  les  options  de  la couche socket ou
       protocole. ioctl(2) peut être utilisé  pour  lire  et  écrire  d’autres
       options.

       close(2)  sert  à  fermer  une socket. shutdown(2) ferme une partie des
       connexions d’une socket multiple.

       La recherche ou l’utilisation de pread(2) et pwrite(2) avec un décalage
       non nul n’est pas possible sur les sockets.

       Des  opérations  d’entrée-sortie  non  bloquantes  sur les sockets sont
       possibles en définissant l’attribut O_NONBLOCK  du  descripteur  de  la
       socket  avec  fcntl(2). Toutes les opérations qui devraient normalement
       bloquer se terminent alors avec l’erreur EAGAIN (l’opération devra être
       retentée  ultérieurement).  connect(2)  renverra  l’erreur EINPROGRESS.
       L’utilisateur peut alors attendre divers  événements  avec  poll(2)  ou
       select(2).

       +---------------------------------------------------------------+
       |                        Événements E/S                         |
       +-------------+---------+---------------------------------------+
       |Événement    | Appel   | Circonstance                          |
       +-------------+---------+---------------------------------------+
       |Lecture      | POLLIN  | Arrivée de nouvelles données          |
       +-------------+---------+---------------------------------------+
       |Lecture      | POLLIN  | Configuration d’une connexion achevée |
       |             |         | (pour    les    sockets     orientées |
       |             |         | connexion)                            |
       +-------------+---------+---------------------------------------+
       |Lecture      | POLLHUP | Demande  de  déconnexion  initiée par |
       |             |         | l’autre extrémité                     |
       +-------------+---------+---------------------------------------+
       |Lecture      | POLLHUP | Connexion rompue (seulement pour  les |
       |             |         | protocoles  orientés  connexion) Lors |
       |             |         | de  l’écriture  sur  la  socket,   le |
       |             |         | signal SIGPIPE est aussi émis.        |
       +-------------+---------+---------------------------------------+
       |Écriture     | POLLOUT | La  socket  a  assez de place dans le |
       |             |         | tampon  d’émission  pour  écrire   de |
       |             |         | nouvelles données.                    |
       +-------------+---------+---------------------------------------+
       |Lect./Écrit. | POLLIN| | Un  appel  sortant  à  connect(2) est |
       |             | POLLOUT | terminé.                              |
       +-------------+---------+---------------------------------------+
       |Lect./Écrit. | POLLERR | Une erreur asynchrone s’est produite. |
       +-------------+---------+---------------------------------------+
       |Lect./Écrit. | POLLHUP | Le correspondant à clos  un  sens  de |
       |             |         | communication.                        |
       +-------------+---------+---------------------------------------+
       |Exception    | POLLPRI | Arrivée  de données urgentes.  SIGURG |
       |             |         | est alors envoyé.                     |
       +-------------+---------+---------------------------------------+

       Une alternative à poll(2) et select(2) est de laisser le noyau informer
       l’application  des  événements  par  l’intermédiaire d’un signal SIGIO.
       Pour cela, l’attribut O_ASYNC doit être défini sur  un  descripteur  de
       fichier  de la socket via fcntl(2) et un gestionnaire de signal valable
       pour SIGIO doit être installé avec sigaction(2).  Voyez  les  remarques
       sur les Signaux ci-dessous.

   Options de sockets
       Ces  options  communes  à  toutes  les sockets peuvent être définies en
       utilisant setsockopt(2) et lues avec getsockopt(2) avec  le  niveau  de
       socket positionné à SOL_SOCKET.

       SO_ACCEPTCONN
              Renvoie  une  valeur indiquant si la socket a été déclarée comme
              acceptant les connexions à l’aide  de  listen(2).  La  valeur  0
              indique  que  la socket n’est pas en attente de connexions et la
              valeur 1 indique que la socket  accepte  les  connexions.  Cette
              option ne peut être lue qu’avec getsockopt(2).

       SO_BINDTODEVICE
              Attache  cette socket à un périphérique donné, tel que « eth0 »,
              comme indiqué dans le nom d’interface transmis. Si  le  nom  est
              une  chaîne  vide  ou  si  la longueur de l’option est nulle, la
              socket est détachée du périphérique. L’option transmise est  une
              chaîne  de  longueur  variable  terminée  par  un caractère nul,
              contenant le nom de  l’interface,  la  longueur  maximale  étant
              IFNAMSIZ.  Si une socket est attachée à une interface, seuls les
              paquets reçus de cette interface particulière sont  traités  par
              la  socket.  Cela  ne  fonctionne  que  pour  certains  types de
              sockets, en particulier les sockets AF_INET. Ceci n’est pas géré
              pour les sockets de paquets (utilisez pour cela bind(8)).

       SO_BROADCAST
              Définit  ou  lit  l’attribut de diffusion. Lorsqu’il est activé,
              les sockets de  datagrammes  reçoivent  les  paquets  envoyés  à
              l’adresse  de  diffusion  et  peuvent  envoyer des paquets à une
              adresse de diffusion. Cette  option  n’a  aucun  effet  sur  les
              sockets orientées flux.

       SO_BSDCOMPAT
              Active  la compatibilité BSD bogue-à-bogue. Cela est utilisé par
              le module du protocole  UDP  de  Linux  2.0  et  2.2.  Si  cette
              compatibilité  est  activée,  les  erreurs  ICMP reçues pour une
              socket UDP ne seront pas transmises  au  programme  utilisateur.
              Dans  les versions récentes du noyau, la gestion de cette option
              a   été   abandonnée   progressivement :   Linux 2.4    l’ignore
              silencieusement  et Linux 2.6 génère une alerte noyau (printk())
              si  le  programme  utilise  cette  option.  Linux  2.0  activait
              également   les   options  de  compatibilité  BSD  bogue-à-bogue
              (modification aléatoire des en-têtes, non  prise  en  compte  de
              l’attribut  de  diffusion)  pour  les sockets brutes ayant cette
              option, mais cela a été éliminé dans Linux 2.2.

       SO_DEBUG
              Active le débogage de socket. Cela n’est autorisé que  pour  les
              processus  avec  la  capacité  CAP_NET_ADMIN  ou  un identifiant
              d’utilisateur effectif égal à 0.

       SO_ERROR
              Lit et efface l’erreur en cours sur la socket. Cela n’est valide
              qu’avec getsockopt(2). Demande un entier.

       SO_DONTROUTE
              Ne  pas  émettre par l’intermédiaire d’une passerelle, n’envoyer
              qu’aux hôtes directement connectés.  Le  même  effet  peut  être
              obtenu   avec  l’attribut  MSG_DONTROUTE  durant  une  opération
              send(2) sur la socket. Demande un attribut entier booléen.

       SO_KEEPALIVE
              Active l’émission de  messages  périodiques  gardant  la  socket
              ouverte   pour  les  sockets  orientées  connexion.  Demande  un
              attribut entier booléen.

       SO_LINGER
              Définit  ou  lit  l’option  SO_LINGER.  Le  paramètre  est   une
              structure linger.

                  struct linger {
                      int l_onoff;    /* définition de l’activité */
                      int l_linger;   /* durée d’attente en secondes */
                  };

              Lorsque   ce  paramètre  est  actif,  un  appel  à  close(2)  ou
              shutdown(2) ne se terminera pas avant que tous les  messages  en
              attente  pour  la  socket  aient été correctement émis ou que le
              délai  d’attente  soit  écoulé.  Sinon,   l’appel   se   termine
              immédiatement  et  la  fermeture  est effectuée en arrière-plan.
              Lorsque la socket est fermée au cours d’un exit(2), elle  attend
              toujours en arrière-plan.

       SO_OOBINLINE
              Si cette option est activée, les données hors bande sont placées
              directement dans le flux des données  reçues.  Sinon,  elles  ne
              sont  transmises que si l’attribut MSG_OOB est définit durant la
              réception.

       SO_PASSCRED
              Autorise ou interdit  la  réception  des  messages  de  contrôle
              SCM_CREDENTIALS. Pour plus de détails, voyez unix(7).

       SO_PEERCRED
              Renvoie  les  données  d’authentification  du processus étranger
              connecté à cette  socket.  Cela  n’est  possible  que  pour  les
              sockets  de  flux  PF_UNIX  connectées  et les paires de sockets
              PF_UNIX de flux et de  datagrammes  crées  avec  socketpair(2) ;
              voyez  unix(7).  Les  données retournées sont celles qui étaient
              effectives au moment de l’appel à connect(2)  ou  socketpair(2).
              L’argument  est  une structure ucred. Cette option n’est valable
              qu’avec getsockopt(2).

       SO_PRIORITY
              Fixe la priorité définie par le protocole pour tous les  paquets
              envoyés sur la socket. Linux utilise cette valeur pour trier les
              files réseau : les paquets avec une priorité élevée peuvent être
              traités  d’abord,  en  fonction  de  la gestion des files sur le
              périphérique.  Pour  ip(7),  ceci  fixe  aussi   le   champ   IP
              Type-Of-Service  (TOS)  pour  les  paquets sortants. Établir une
              priorité en dehors de l’intervalle allant de 0 à 6 nécessite  la
              capacité CAP_NET_ADMIN.

       SO_RCVBUF
              Définit  ou  lit  la  taille  maximale  en  octets  du tampon de
              réception.  Le  noyau  double  cette  valeur  (pour  prévoir  de
              l’espace  pour  les opérations de service) lorsque la valeur est
              définie  avec  setsockopt(2),  et  cette  valeur   doublée   est
              retournée  par  getsockopt(2).  La valeur par défaut est définie
              par le sysctl rmem_default et la valeur maximale  autorisée  est
              fixée  par le sysctl rmem_max. La valeur (doublée) minimale pour
              cette option est 256.

       SO_RCVBUFFORCE (depuis Linux 2.6.14)
              En utilisant cette option de  socket,  un  processus  privilégié
              (CAP_NET_ADMIN)  peut exécuter la même tâche que SO_RCVBUF, mais
              la limite rmem_max peut être remplacée.

       SO_RCVLOWAT et SO_SNDLOWAT
              Indique le nombre minimal d’octets dans le tampon  pour  que  la
              couche  socket passe les données au protocole (SO_SNDLOWAT) ou à
              l’utilisateur en réception (SO_RCVLOWAT). Ces deux valeurs  sont
              initialisées    à    1.   SO_SNDLOWAT   n’est   pas   modifiable
              (setsockopt(2) échoue avec  l’erreur  ENOPROTOOPT).  SO_RCVLOWAT
              est  modifiable  seulement depuis Linux 2.4. Les appels systèmes
              select(2) et  poll(2)  ne  respectent  pour  le  moment  pas  la
              définition  de  SO_RCVLOWAT sur Linux, et marque la socket comme
              lisible même lorsqu’un unique octet de données  est  disponible.
              La lecture suivante depuis la socket sera bloquée jusqu’à ce que
              SO_RCVLOWAT octets soient disponibles.

       SO_RCVTIMEO et SO_SNDTIMEO
              Indique le délai maximal d’émission ou  de  réception  avant  de
              signaler  une erreur. Le paramètre est une structure timeval. Si
              une fonction d’entrée ou de sortie bloque pendant cet intervalle
              de  temps  et  que  des  données  ont été envoyées ou reçues, la
              valeur de retour de cette fonction sera la quantité  de  données
              transmises ;  si  aucune donnée n’a été transmise et si le délai
              d’attente est atteint, -1 est renvoyé et errno est positionnée à
              EAGAIN  ou  EWOULDBLOCK,  comme  si  la socket avait été définie
              comme non bloquante. Si le délai d’attente  est  défini  à  zéro
              (valeur par défaut), l’opération ne sera jamais interrompue. Les
              délais n’ont d’effet que pour les appels système faisant des E/S
              sur  des  sockets  (par  exemple  read(2),  recvmsg(2), send(2),
              sendmsg(2)) ; ils n’ont pas  d’effet  pour  select(2),  poll(2),
              epoll_wait(2), etc.

       SO_REUSEADDR
              Indique que les règles utilisées pour la validation des adresses
              fournies  dans  un  appel  à  bind(2)   doivent   autoriser   la
              réutilisation  des  adresses  locales. Pour les sockets PF_INET,
              cela signifie que la  socket  peut  être  attachée  à  n’importe
              quelle  adresse  sauf  lorsqu’une  socket active en écoute y est
              liée. Lorsque la socket en écoute est attachée à INADDR_ANY avec
              un  port  spécifique,  il  n’est pas possible de s’attacher à ce
              port  quelle  que  soit  l’adresse  locale.  L’argument  est  un
              attribut booléen entier.

       SO_SNDBUF
              Définit   ou   lit  la  taille  maximale  en  octets  du  tampon
              d’émission. Le  noyau  double  cette  valeur  (pour  prévoir  de
              l’espace  pour  les opérations de service) lorsque la valeur est
              définie  avec  setsockopt(2),  et  cette  valeur   doublée   est
              retournée  par  getsockopt(2).  La valeur par défaut est définie
              par le sysctl wmem_default et la valeur maximale  autorisée  est
              fixée  par le sysctl wmem_max. La valeur (doublée) minimale pour
              cette option est 2048.

       SO_SNDBUFFORCE (depuis Linux 2.6.14)
              En utilisant cette option de  socket,  un  processus  privilégié
              (CAP_NET_ADMIN)  peut exécuter la même tâche que SO_SNDBUF, mais
              la limite wmem_max peut être remplacée.

       SO_TIMESTAMP
              Active ou  désactive  la  réception  des  messages  de  contrôle
              SO_TIMESTAMP.  Le  message  de  contrôle d’horodatage est envoyé
              avec  le  niveau  SOL_SOCKET  et  le  champ  cmsg_data  est  une
              structure  timeval  indiquant  la  date  de réception du dernier
              paquet fourni à l’utilisateur dans cet appel. Voyez cmsg(3) pour
              plus de détails sur les messages de contrôle.

       SO_TYPE
              Lit  le type de socket, sous forme d’entier (comme SOCK_STREAM).
              Ne peut être lu qu’avec getsockopt(2).

   Signaux
       Lors de l’écriture sur une socket orientée connexion qui a  été  fermée
       (localement  ou  à  l’autre extrémité), le signal SIGPIPE est envoyé au
       processus qui écrivait, et EPIPE  est  renvoyé.  Le  signal  n’est  pas
       envoyé   lorsque   l’appel   d’écriture  indiqué  contenait  l’attribut
       MSG_NOSIGNAL.

       Lorsque  demandé  avec  l’option  FIOSETOWN  de  fcntl(2)  ou  l’option
       SIOCSPGRP  de  ioctl(2),  le signal SIGIO est envoyé quand un événement
       d’entrée-sortie a lieu. Il est possible d’utiliser poll(2) ou select(2)
       dans   le   gestionnaire  de  signal  pour  savoir  sur  quelle  socket
       l’événement s’est produit. Une alternative  (sous  Linux  2.2)  est  de
       définir  un  signal  en  temps  réel  avec  le  fnctl(2)  F_SETSIG.  Le
       gestionnaire du signal en temps réel sera appelé avec le descripteur de
       fichier  dans  le  champ  si_fd  de siginfo_t. Voyez fcntl(2) pour plus
       d’informations.

       Dans certains cas (par exemple, différents processus accédant à la même
       socket),  la  condition ayant déclenché le signal SIGIO peut avoir déjà
       disparu quand le processus réagit au signal. Si  cela  se  produit,  le
       processus  devrait  attendre  à  nouveau  car  Linux renverra ce signal
       ultérieurement.

   Sysctls
       Les sysctls réseau des sockets de base sont  accessibles  en  utilisant
       les fichiers /proc/sys/net/core/* ou avec l’interface sysctl(2).

       rmem_default
              contient  la taille en octets par défaut du tampon de réception.

       rmem_max
              contient la taille maximale en octets  du  tampon  de  réception
              qu’un  utilisateur  peut  définir  avec l’option SO_RCVBUF de la
              socket.

       wmem_default
              contient la taille en octets par défaut du tampon d’émission  de
              la socket.

       wmem_max
              contient la taille maximale en octets du tampon d’émission qu’un
              utilisateur peut définir avec l’option SO_SNDBUF de la socket.

       message_cost et message_burst
              configurent le filtrage par jeton utilisé pour limiter la charge
              des   message   d’avertissement   dus   aux   événements  réseau
              extérieurs.

       netdev_max_backlog
              contient le nombre maximal de  paquets  dans  la  file  d’entrée
              globale.

       optmem_max
              contient la taille maximale par socket des données de service et
              des données de contrôle utilisateur comme les iovecs.

   Ioctls
       Ces opérations sont accessibles en utilisant ioctl(2) :

           error = ioctl(ip_socket, type_ioctl, &valeur_rsultat);

       SIOCGSTAMP
              Renvoie une structure timeval  avec  la  date  de  réception  du
              dernier paquet transmis à l’utilisateur. Cela est utile pour des
              mesures précises du temps  de  cheminement.  Voyez  setitimer(2)
              pour  une  description  de la structure timeval. L’ioctl ne doit
              être utilisé que si l’option SO_TIMESTAMP de la socket n’est pas
              définie.   Sinon,   la   date   du  dernier  paquet  reçu  quand
              SO_TIMESTAMP n’était pas définie  est  renvoyée,  provoquant  un
              échec  s’il  n’exite  pas  de  tels  paquets  (c’est-à-dire  que
              ioctl(2) renvoie -1 avec un errno défini à ENOENT).

       SIOCSPGRP
              Définit le processus ou le groupe de processus à qui envoyer les
              signaux  SIGIO  ou  SIGURG  lorsqu’une opération d’entrée-sortie
              asynchrone  est  terminée  ou  si  des  données  urgentes   sont
              disponibles.  L’argument  est  un  pointeur  sur  un  pid_t.  Si
              l’argument est positif, le signal est  envoyé  à  ce  processus.
              S’il  est  négatif,  le signal est envoyé au groupe de processus
              dont l’identifiant correspond à la valeur absolue de l’argument.
              Un  processus  ne  peut demander que l’émission vers lui-même ou
              son propre groupe, à moins qu’il ait la capacité CAP_KILL ou  un
              identifiant d’utilisateur effectif nul.

       FIOASYNC
              Change  l’attribut  O_ASYNC  pour  activer ou désactiver le mode
              d’entrée-sortie asynchrone de la socket. Un mode d’entrée-sortie
              asynchrone  signifie  que le signal SIGIO ou le signal fixé avec
              F_SETSIG  est  envoyé  quand  un  événement  d’entrée-sortie  se
              produit.

              Le  paramètre  est  un  booléen  entier.  (Cette  opération  est
              synonyme de l’utilisation de fcntl(2)  pour  définir  l’attribut
              O_ASYNC.)

       SIOCGPGRP
              Lit  le  processus  ou le groupe de processus auquel les signaux
              SIGIO ou SIGURG sont envoyés. Zéro est obtenu quand aucun  n’est
              défini.

       Opérations fcntl(2) valables :

       FIOGETOWN
              Identique à l’ioctl(2) SIOCGPGRP.

       FIOSETOWN
              Identique à l’ioctl(2) SIOCSPGRP.

VERSIONS

       SO_BINDTODEVICE  a été introduit dans Linux 2.0.30. SO_PASSCRED est une
       nouveauté de Linux 2.2. Les sysctls sont  nouveaux  depuis  Linux  2.2.
       SO_RCVTIMEO  et SO_SNDTIMEO sont gérés depuis Linux 2.3.41. Auparavant,
       les  délais  d’attente  étaient  définis  dans  les  protocoles  et  ne
       pouvaient être ni lus ni modifiés.

NOTES

       Linux  suppose que la moitié du tampon d’émission/réception est utilisé
       pour les structures internes du noyau. Ainsi les sysctls sont deux fois
       plus grands que ce que l’on peut observer directement sur le câble.

       Linux   ne  permettra  la  réutilisation  des  ports  qu’avec  l’option
       SO_REUSEADDR lorsque celle-ci sera définie à la fois par  le  précédent
       programme qui a effectué un bind(2) sur le port et par le programme qui
       veut réutiliser ce port. Ceci diffère de certaines implémentations (par
       exemple,  sur  FreeBSD)  où  seul  le  dernier  programme  doit définir
       l’option SO_REUSEADDR. Habituellement, cette différence est  invisible,
       puisque,  par  exemple,  un  programme  serveur est conçu pour toujours
       définir cette option.

BOGUES

       Des   options   CONFIG_FILTER   de    socket,    SO_ATTACH_FILTER    et
       SO_DETACH_FILTER,  ne  sont  pas documentées. Pour les utiliser, il est
       conseillé d’utiliser la bibliothèque libpcap.

VOIR AUSSI

       getsockopt(2),  setsockopt(2),  socket(2),   capabilities(7),   ddp(7),
       ip(7), packet(7)

COLOPHON

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

TRADUCTION

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

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

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

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