Le paramètre des attributs¶

MSG_CMSG_CLOEXEC (recvmsg() uniquement ; depuis Linux 2.6.23)

Positionner l'attribut « close-on-exec » pour le descripteur de fichier reçu à l’aide d’un descripteur de fichier de domaine UNIX en utilisant l'opération SCM_RIGHTS (décrite dans unix(7)). Cet attribut est utile pour les mêmes raisons que l'attribut O_CLOEXEC de open(2).

MSG_DONTWAIT (depuis Linux 2.2)

Activer l'opération non bloquante ; si elle bloque, l'appel échoue avec l'erreur EAGAIN ou EWOULDBLOCK. Cela fournit un comportement identique à la définition de l'attribut O_NONBLOCK (à l'aide de l'opération F_SETFL de fcntl(2)), sauf que MSG_DONTWAIT est une option pour chaque appel tandis que O_NONBLOCK est un paramètre sur la description du fichier ouvert (voir open(2)), qui touchera tous les threads du processus appelant ainsi que d'autres processus détenant des descripteurs de fichier se rapportant à la même description de fichier ouvert.

MSG_ERRQUEUE (depuis Linux 2.2)

Cet attribut demande que les erreurs soient reçues depuis la file d'erreur du socket. Les erreurs sont transmises dans un message annexe dont le type dépend du protocole (IP_RECVERR pour IPv4). Il faut alors fournir un tampon de taille suffisante. Consultez cmsg(3) et ip(7) pour plus de détails. Le contenu du paquet original qui a causé l'erreur est passé en tant que données normales dans msg_iovec. L'adresse de destination originale du datagramme ayant causé l'erreur est fournie dans msg_name.

L'erreur est contenue dans une structure sock_extended_err :

#define SO_EE_ORIGIN_NONE    0
#define SO_EE_ORIGIN_LOCAL   1
#define SO_EE_ORIGIN_ICMP    2
#define SO_EE_ORIGIN_ICMP6   3
struct sock_extended_err
{
    uint32_t ee_errno;   /* numéro d'erreur */
    uint8_t  ee_origin;  /* origine de l'erreur */
    uint8_t  ee_type;    /* type */
    uint8_t  ee_code;    /* code */
    uint8_t  ee_pad;     /* remplissage */
    uint32_t ee_info;    /* données supplémentaires */
    uint32_t ee_data;    /* autres données */
    /* Des données supplémentaires peuvent suivre */
};
struct sockaddr *SO_EE_OFFENDER(struct sock_extended_err *);

    

ee_errno contient le code errno de l'erreur en file d’attente. ee_origin est le code d'origine d’où l’erreur provient. Les autres champs sont spécifiques au protocole. La macro SOCK_EE_OFFENDER renvoie un pointeur sur l'adresse de l'objet réseau ayant déclenché l'erreur, en donnant un pointeur sur le message annexe. Si cette adresse n'est pas connue, le membre sa_family de la structure sockaddr contient AF_UNSPEC et les autres champs de la structure sockaddr sont indéfinis. Le contenu du paquet ayant déclenché l'erreur est transmis en données normales.

Pour les erreurs locales, aucune adresse n'est passée (cela peut être vérifié dans le membre cmsg_len de cmsghdr). À la réception d'une erreur, MSG_ERRQUEUE est placé dans msghdr. Après réception d'une erreur, l'erreur en attente sur le socket est régénérée en fonction de la prochaine erreur dans la file et sera transmise lors de l'opération suivante sur le socket.

MSG_OOB

Cette option demande la réception de données hors-bande qui ne seraient pas reçues dans le flux normal de données. Certains protocoles placent ces données hors-bande en tête de la file normale, et cette option n'a pas lieu d'être dans ce cas.

MSG_PEEK

Cette option fait que l’opération de réception renvoie les données du début de la queue de réception sans les enlever de cette file. Ainsi un appel à réception ultérieur renverra à nouveau les mêmes données.

MSG_TRUNC (depuis Linux 2.2)

Pour les sockets bruts (AF_PACKET), de datagrammes Internet (depuis Linux 2.4.27/2.6.8), netlink (depuis Linux 2.6.22) et de datagrammes UNIX (depuis Linux 3.4) : renvoyer la taille réelle du paquet ou datagramme, même quand il est plus grand que le tampon fourni.

Pour une utilisation avec des sockets de flux Internet, consultez tcp(7).

MSG_WAITALL (depuis Linux 2.2)

Ce drapeau demande que l'opération de lecture soit bloquée jusqu'à ce que la requête complète soit satisfaite. Toutefois, la lecture peut renvoyer quand même moins de données que prévu si un signal est reçu, si une erreur ou une déconnexion se produisent ou si les données suivantes à recevoir sont d'un type différent de celles renvoyées. Ce drapeau n'a aucun effet sur les sockets de datagramme.

recvfrom()¶

Si src_addr n'est pas NULL, et si le protocole sous-jacent fournit l'adresse de la source, celle-ci y est insérée dans le tampon désigné par src_addr. Dans ce cas, addrlen est un paramètre valeur-résultat. Avant l'appel, il doit être initialisé à la valeur de la taille du tampon associé à src_addr. En retour, addrlen est mis à jour avec la valeur réelle de l'adresse source. Cette adresse est tronquée si le tampon fourni n'a pas une taille suffisante ; dans ce cas addrlen renvoie un valeur supérieure à celle fournie lors de l'appel.

Si le processus appelant n'est pas intéressé par l'adresse de la source, src_addr et addrlen doivent avoir la valeur NULL.

recv()¶

recvfrom(fd, buf, len, flags, NULL, 0);

recvmsg()¶

struct iovec {                    /* Éléments de tableaux
                                     scatter/gather */
    void *iov_base;               /* Adresse de début */
    size_t iov_len;               /* Nombre d'octets à transférer */
};
struct msghdr {
    void         *msg_name;       /* Adresse optionnelle */
    socklen_t     msg_namelen;    /* Taille de l'adresse */
    struct iovec *msg_iov;        /* Tableau scatter/gather */
    size_t        msg_iovlen;     /* Nb. d’éléments dans msg_iov */
    void         *msg_control;    /* Données annexes, voir ci‐dessous */
    size_t        msg_controllen; /* Taille du tampon de données annexe */
    int           msg_flags;      /* Attributs du message reçu */
};

Le champ msg_name pointe vers un tampon alloué par l'appelant et qui est utilisé pour renvoyer l'adresse source lorsque le socket n'est pas connecté. L'appelant doit initialiser msg_namelen avec la taille de ce tampon avant l'appel ; si l'appel s'exécute avec succès, msg_name prend pour valeur la longueur de l'adresse renvoyée. Si l'application n'a pas besoin de connaître l'adresse source, on peut affecter la valeur NULL à msg_name.

Les champs msg_iov et msg_iovlen décrivent les emplacements de dispersion-regroupement (scatter-gather) tels qu'expliqués dans readv(2).

Le champ msg_control, de longueur msg_controllen, pointe sur un tampon utilisé pour les autres messages du protocole relatifs au contrôle, ou à d'autres données annexes. Lorsqu'on invoque recvmsg, msg_controllen doit contenir la longueur du tampon disponible dans msg_control ; lors du retour d’un appel réussi,il contiendra la longueur de la séquence du message de contrôle.

Les messages ont la forme

struct cmsghdr {
    size_t cmsg_len;    /* nombre d'octets de données, y compris l'en-tête
                           (de type socklen_t dans POSIX) */
    int    cmsg_level;   /* protocole d'origine */
    int    cmsg_type;    /* type dépendant du protocole */
/* suivi de
    unsigned char cmsg_data[]; */
};

Les données annexes ne doivent être manipulées qu'avec les macros de cmsg(3).

À titre d'exemple, Linux utilise ce mécanisme pour transmettre des erreurs étendues, des options IP, ou des descripteurs de fichier sur des sockets de domaine UNIX.

Le champ msg_flags du msghdr est rempli au retour de recvmsg(). Il peut contenir plusieurs attributs :

MSG_EOR

indique une fin d'enregistrement, les données reçues terminent un enregistrement (utilisé généralement avec les sockets du type SOCK_SEQPACKET).

MSG_TRUNC

indique que la portion finale du datagramme a été abandonnée car le datagramme était trop long pour le tampon fourni.

MSG_CTRUNC

indique que des données de contrôle ont été abandonnées à cause d'un manque de place dans le tampon de données annexes.

MSG_OOB

est renvoyé pour indiquer que des données prioritaires ou hors-bande ont été reçues.

MSG_ERRQUEUE

indique qu'aucune donnée n'a été reçue, sauf une erreur étendue depuis la file d'erreurs.