Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       CMSG_ALIGN,   CMSG_SPACE,  CMSG_NXTHDR,  CMSG_FIRSTHDR  -  Acceder  aux
       informations de service

SYNOPSIS

       #include <sys/socket.h>

       struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *msgh);
       struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg);
       size_t CMSG_ALIGN(size_t length);
       size_t CMSG_SPACE(size_t length);
       size_t CMSG_LEN(size_t length);
       unsigned char *CMSG_DATA(struct cmsghdr *cmsg);

       struct cmsghdr {
           socklen_t cmsg_len;    /* Nombre d'octets de donnees, incluant l'en-tete */
           int       cmsg_level;  /* Protocole d'origine */
           int       cmsg_type;   /* Type specifique au protocole */
           /* suivi par unsigned char cmsg_data[]; */
       };

DESCRIPTION

       Ces macros sont  utilisees  pour  creer  et  acceder  aux  messages  de
       controle  (aussi appele informations de service) qui ne font pas partie
       du trafic normal des sockets.  Ces  informations  de  controle  peuvent
       inclure  l'interface  sur  laquelle  le  paquet  a ete recu, des champs
       d'en-tete rarement employes, des descriptions d'erreur approfondies, un
       ensemble  de  descripteurs de fichiers ou des identificateurs Unix. Par
       exemple, les messages de controle peuvent etre  utilises  pour  envoyer
       des  champs  d'en-tete  supplementaires  tels  que  des options IP. Les
       donnees  de  service  sont  emises  avec  sendmsg(2)  et  recues   avec
       recvmsg(2).  Reportez-vous  a  leur page de manuel respective pour plus
       d'informations.

       Une information de service est une sequence de structures cmsghdr  avec
       des donnees ajoutees. Cette sequence ne doit etre manipulee qu'au moyen
       des macros decrites dans cette page de manuel, et  jamais  directement.
       Consultez  les  pages  relatives aux protocoles des types de message de
       commande disponibles. La taille maximale d'un  tampon  de  service  par
       socket  peut  etre  definie  a l'aide de /proc/sys/net/core/optmem_max.
       Consultez socket(7).

       CMSG_FIRSTHDR() renvoie un pointeur sur la premiere cmsghdr  du  tampon
       de donnees de service associe au msghdr passe.

       CMSG_NXTHDR()  renvoie  le  prochain  cmsghdr  valable suivant apres le
       cmsghdr transmis. Elle renvoie NULL s'il n'y a plus assez de place dans
       le tampon.

       CMSG_ALIGN(),  avec  comme  argument une longueur, renvoie l'alignement
       necessaire. C'est une expression constante.

       CMSG_SPACE() renvoie le nombre d'octets d'un element de service avec la
       charge  utile  de la longueur passee en parametre. C'est une expression
       constante.

       CMSG_DATA() renvoie  un  pointeur  sur  une  partie  des  donnees  d'un
       cmsghdr.

       CMSG_LEN()  renvoie  la  valeur a stocker dans le membre cmsg_len de la
       structure cmsghdr, en tenant compte  des  alignements.  Elle  prend  en
       parametre la longueur des donnees. C'est une expression constante.

       Pour  creer des donnees de service, il faut tout d'abord initialiser le
       membre msg_controllen de  la  structure  msghdr  avec  la  longueur  du
       message  de  controle. Utilisez CMSG_FIRSTHDR() sur la structure msghdr
       pour obtenir le premier message de controle, puis  CMSG_NEXTHDR()  pour
       obtenir  les  suivants.  Dans  chaque  message de controle, initialisez
       cmsg_len (avec CMSG_LEN()), les autres champs d'en-tete de cmsghdr,  et
       la partie de donnees avec CMSG_DATA(). Enfin, il faut definir le membre
       msg_controllen de la  structure  msghdr  avec  la  somme  de  tous  les
       messages  de controle dans le tampon renvoye par CMSG_SPACE().Pour plus
       d'informations sur msghdr, consultez recvmsg(2).

       Lorsque le tampon de message de controle est trop  petit  pour  stocker
       tous  les messages, le drapeau MSG_CTRUNC du membre msg_flags de msghdr
       est active.

CONFORMIT'E

       Le modele des  donnees  de  service  est  conforme  a  POSIX.1g  draft,
       BSD 4.4-Lite,  << IPv6  advanced  API >>  decrite  dans  la RFC 2292 et
       SUSv2. CMSG_ALIGN() est une extension Linux.

NOTES

       Pour des questions de portabilite, les donnees de  service  ne  doivent
       etre  manipulees  qu'avec les macros decrites ici. CMSG_ALIGN() est une
       extension Linux  et  ne  doit  pas  etre  utilisee  dans  un  programme
       portable.

       Sous   Linux,   CMSG_LEN(),   CMSG_DATA(),  et  CMSG_ALIGN()  sont  des
       expressions constantes (si leur argument est une constante) ;  on  peut
       donc  les  utiliser pour declarer la taille de variables globales. Cela
       peut neanmoins ne pas etre portable.

EXEMPLE

       Ce code recherche l'option IP_TTL dans un tampon de service recu :

           struct msghdr msgh;
           struct cmsghdr *cmsg;
           int *ttlptr;
           int received_ttl;

           /* Receive auxiliary data in msgh */
           for (cmsg = CMSG_FIRSTHDR(&msgh); cmsg != NULL;
                   cmsg = CMSG_NXTHDR(&msgh,cmsg)) {
               if (cmsg->cmsg_level == IPPROTO_IP
                       && cmsg->cmsg_type == IP_TTL) {
                   ttlptr = (int *) CMSG_DATA(cmsg);
                   received_ttl = *ttlptr;
                   break;
               }
           }
           if (cmsg == NULL) {
               /*
                * Error: IP_TTL not enabled or small buffer
                * or I/O error.
                */
           }

       Ce code, ci-dessous, passe une table  de  descripteurs  de  fichier  au
       travers d'une socket Unix avec SCM_RIGHTS :

           struct msghdr msg = {0};
           struct cmsghdr *cmsg;
           int myfds[NUM_FD]; /* Contains the file descriptors to pass. */
           char buf[CMSG_SPACE(sizeof myfds)];  /* ancillary data buffer */
           int *fdptr;

           msg.msg_control = buf;
           msg.msg_controllen = sizeof buf;
           cmsg = CMSG_FIRSTHDR(&msg);
           cmsg->cmsg_level = SOL_SOCKET;
           cmsg->cmsg_type = SCM_RIGHTS;
           cmsg->cmsg_len = CMSG_LEN(sizeof(int) * NUM_FD);
           /* Initialize the payload: */
           fdptr = (int *) CMSG_DATA(cmsg);
           memcpy(fdptr, myfds, NUM_FD * sizeof(int));
           /* Sum of the length of all control messages in the buffer: */
           msg.msg_controllen = cmsg->cmsg_len;

VOIR AUSSI

       recvmsg(2), sendmsg(2)

       RFC 2292

COLOPHON

       Cette  page  fait  partie  de  la  publication 3.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

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

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

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.