Provided by: manpages-fr_3.23.1-1_all bug

NOM

       socket - Interface Linux aux sockets

SYNOPSIS

       #include <sys/socket.h>

       sockfd = socket(int socket_family, int socket_type, int protocol);

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  AF_INET,  AF_IPX,
       AF_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 AF_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  a  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 AF_UNIX connectées  et  les  paires  de  sockets
              AF_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  fichier  /proc/sys/net/core/rmem_default  et  la valeur
              maximale    autorisée    est    fixée     par     le     fichier
              /proc/sys/net/core/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ème
              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 AF_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  fichier  /proc/sys/net/core/wmem_default  et  la  valeur
              maximale     autorisée     est     fixée    par    le    fichier
              /proc/sys/net/core/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.

   Interfaces /proc
       Les paramètres réseau de base des sockets sont accessibles en utilisant
       les fichiers du répertoire /proc/sys/net/core/.

       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 interfaces /proc ont été introduites dans
       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 valeurs dans les
       fichiers /proc correspondants sont deux fois plus grandes  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), tcp(7), udp(7), unix(7)

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