unix

NOM

SYNOPSIS

#include <sys/socket.h>
#include <sys/un.h>

unix_socket = socket(AF_UNIX, type, 0);
error = socketpair(AF_UNIX, type, 0, int *sv);

DESCRIPTION

Format d'adresse

struct sockaddr_un {
    sa_family_t sun_family;               /* AF_UNIX */
    char        sun_path[108];            /* Chemin d’accès */
};

pathname

a UNIX domain socket can be bound to a null-terminated filesystem pathname using bind(2). When the address of a pathname socket is returned (by one of the system calls noted above), its length is

offsetof(struct sockaddr_un, sun_path) + strlen(sun_path) + 1
    

et sun_path contient le chemin avec un octet NULL final. (Dans Linux, l’expression ci-dessus offsetof() est égale à la même valeur que sizeof(sa_family_t), mais quelques autres implémentations incluent d’autres champs avant sun_path, aussi l’expression offsetof() plus portable décrit la taille de la structure d’adresse.)

Pour plus de détails sur les sockets chemin, voir ci-après.

unnamed

A stream socket that has not been bound to a pathname using bind(2) has no name. Likewise, the two sockets created by socketpair(2) are unnamed. When the address of an unnamed socket is returned, its length is sizeof(sa_family_t), and sun_path should not be inspected.

abstract

an abstract socket address is distinguished (from a pathname socket) by the fact that sun_path[0] is a null byte ('\0'). The socket's address in this namespace is given by the additional bytes in sun_path that are covered by the specified length of the address structure. (Null bytes in the name have no special significance.) The name has no connection with filesystem pathnames. When the address of an abstract socket is returned, the returned addrlen is greater than sizeof(sa_family_t) (i.e., greater than 2), and the name of the socket is contained in the first (addrlen - sizeof(sa_family_t)) bytes of sun_path.

Sockets chemin d’accès

•

Le chemin dans sun_path doit être terminé par un octet NULL ;

•

La taille du chemin, y compris l’octet NULL final, ne doit pas excéder la taille de sun_path ;

•

L’argument addrlen décrivant la structure enfermant sockaddr_un doit avoir une valeur d’au moins :

offsetof(struct sockaddr_un, sun_path)+strlen(addr.sun_path)+1
    

ou, plus simplement, addrlen peut être indiqué comme sizeof(struct sockaddr_un).

Permissions et appartenance des sockets chemin d’accès

Sockets abstraits

Options de socket

SO_PASSCRED

Activer cette option de socket provoque la réception des accréditations du processus émetteur dans un message SCM_CREDENTIALS annexe dans chaque message reçu ultérieur. Les accréditations renvoyées sont celles indiquées par l’émetteur en utilisant SCM_CREDENTIALS ou celles par défaut qui incluent le PID, l’ID utilisateur réel et l’ID groupe réel de l’émetteur si celui-ci ne précise pas les données auxiliaires SCM_CREDENTIALS.

Lorsque cette option est active et le socket non encore connecté, un nom unique dans l'espace de noms abstrait sera généré automatiquement.

La valeur donnée comme argument pour setsockopt(2) et renvoyée comme résultat de getsockopt(2) est un indicateur booléen entier.

SO_PASSSEC

Activer la réception de l’étiquette de sécurité SELinux du socket pair dans un message annexe de type SCM_SECURITY (voir ci-dessous).

La valeur donnée comme argument pour setsockopt(2) et renvoyée comme résultat de getsockopt(2) est un indicateur booléen entier.

L’option SO_PASSSEC est gérée par les sockets datagramme de domaine UNIX depuis Linux 2.6.18. La prise en charge pour les sockets flux de domaine UNIX a été ajoutée dans Linux 4.2.

SO_PEEK_OFF

Consulter socket(7).

SO_PEERCRED

Cette option de socket en lecture exclusivement renvoie les accréditations du processus pair connecté à ce socket. Les accréditations renvoyées sont celles effectives au moment de l’appel à connect(2) ou socketpair(2).

L’argument de getsockopt(2) est un pointeur vers une structure ucred. Est définie la macro de test de fonctionnalité _GNU_SOURCE pour obtenir la définition de cette structure à partir de <sys/socket.h>.

L’utilisation de cette option est possible seulement pour les sockets flux AF_UNIX connectés et pour les pairs de sockets flux et datagramme AF_UNIX créés en utilisant socketpair(2).

SO_PEERSEC

Cette option de socket en lecture exclusivement renvoie le contexte de sécurité du socket pair connecté à ce socket. Par défaut, cela sera le même que le contexte de sécurité du processus ayant créé le socket pair à moins qu’il ne soit écrasé par la politique ou par un processus ayant les permissions requises.

L’argument de getsockopt(2) est un pointeur vers un tampon de la longueur indiquée en octets dans lequel la chaîne de contexte de sécurité sera copiée. Si la taille du tampon est inférieure à celle de la chaîne du contexte de sécurité, alors getsockopt(2) renvoie  -1, définit errno à ERANGE et renvoie la taille requise à l’aide de optlen. L’appelant doit allouer initialement au moins NAME_MAX octets pour le tampon, bien que cela ne soit pas garanti d'être suffisant. Redimensionner le tampon à la taille renvoyée et réessayer peuvent être nécessaires.

La chaîne de contexte de sécurité peut inclure un octet NULL final dans la taille renvoyée, mais il n’est pas garanti que ce soit fait : un contexte de sécurité « abc » peut être représenté soit par {'a','b','c'} de taille 3, ou {'a','b','c','\0'} de taille 4, qui sont considérés comme interchangeables. La chaîne peut être affichée, mais ne contient pas d’octet NULL final, et elle est dans un encodage non précisé (en particulier, il n’est pas garanti que ce soit ASCII ou UTF-8).

L’utilisation de cette option pour les sockets dans la famille d’adresses AF_UNIX est prise en charge depuis Linux 2.6.2 pour les sockets flux connectés et aussi, depuis Linux 4.18, pour les pairs de socket flux et datagramme créés en utilisant socketpair(2).

Fonctionnalité d'autolien (« autobind »)

API des sockets

Messages annexes

SCM_RIGHTS

Envoyer ou recevoir un jeu de descripteurs de fichier ouverts d’un autre processus. La partie données contient un tableau d’entiers de descripteurs de fichier.

Couramment, cette opération est appelée « passage d’un descripteur de fichier » à un autre processus. Cependant, plus précisément, ce qui a été passé est une référence à une description de fichier ouvert (consultez open(2)), et, dans le processus récepteur, il est probable qu’un numéro différent de descripteur de fichier sera utilisé. Sémantiquement, cette opération est équivalente à dupliquer ( dup(2)) un descripteur de fichier dans une table de descripteurs de fichier d’un autre processus.

Si le tampon utilisé pour recevoir les données annexes contenant les descripteurs de fichier est trop petit (ou absent), alors les données annexes sont tronquées (ou ignorées) et les descripteurs de fichier en excès sont automatiquement clos dans le processus récepteur.

Si le nombre de descripteurs de fichier reçus dans les données annexes conduit le processus à dépasser la limite de ressources RLIMIT_NOFILE (consultez getrlimit(2)), les descripteurs de fichier en excès sont automatiquement clos dans le processus récepteur.

The kernel constant SCM_MAX_FD defines a limit on the number of file descriptors in the array. Attempting to send an array larger than this limit causes sendmsg(2) to fail with the error EINVAL. SCM_MAX_FD has the value 253 (or 255 before Linux 2.6.38).

SCM_CREDENTIALS

Envoyer ou recevoir les accréditations UNIX. Cela peut servir à l'authentification. Les accréditations sont passées en message annexe struct ucred. Cette structure est définie dans <sys/socket.h> comme ceci :

struct ucred {
    pid_t pid;    /* PID processus émetteur */
    uid_t uid;    /* UID processus émetteur */
    gid_t gid;    /* GID processus émetteur */
};
    

Depuis la glibc 2.8, la macro de test de fonctionnalités _GNU_SOURCE doit être définie (avant d'inclure tout fichier d'en‐tête) afin d'obtenir la définition de cette structure.

Les accréditations que l'émetteur envoie sont vérifiées par le noyau. Un processus privilégié est autorisé à indiquer des valeurs qui ne correspondent pas aux siennes. L'émetteur doit indiquer son propre PID (sauf s'il a la capacité CAP_SYS_ADMIN), auquel cas le PID de n’importe quel processus existants peut être indiqué, son ID utilisateur réel, son ID utilisateur effectif ou son « saved set-user-ID » (sauf s'il a la capacité CAP_SETUID) et son ID groupe réel, son ID groupe effectif ou son « saved set-group-ID » (sauf s'il a la capacité CAP_SETGID).

Pour recevoir un message struct ucred, l’option SO_PASSCRED doit être activée sur le socket.

SCM_SECURITY

Recevoir le contexte de sécurité SELinux (l’étiquette de sécurité) du socket pair. Les données annexes reçues sont une chaîne terminée par un octet NULL final contenant le contexte de sécurité. Le récepteur doit au moins allouer NAME_MAX octets dans la partie données du message annexe pour ces données.

Pour recevoir le contexte de sécurité, l’option SO_PASSSEC doit être activée sur le socket (voir ci-dessus).

Ioctls

int value;
error = ioctl(unix_socket, ioctl_type, &value);

SIOCINQ

Pour les sockets SOCK_STREAM, cet appel renvoie la quantité de données non lues dans le tampon de réception. Le socket ne doit pas être dans l'état LISTEN, sinon l'erreur EINVAL est renvoyée. SIOCINQ est défini dans <linux/sockios.h>. Une alternative est d'utiliser le synonyme FIONREAD défini dans <sys/ioctl.h>. Pour les sockets SOCK_DGRAM, la valeur renvoyée est la même que pour les sockets datagramme de domaine Internet. Consultez udp(7).

ERREURS

EADDRINUSE

L'adresse locale indiquée est déjà utilisée ou l'objet de socket de système de fichiers existe déjà.

EBADF

Cette erreur peut survenir pour sendmsg(2) lors de l’envoi d’un descripteur de fichier pour des données annexes au travers d’un socket de domaine UNIX (consultez la description de SCM_RIGHTS ci-dessus) et indique que le numéro de descripteur de fichier envoyé n’est pas valable (par exemple, ce n’est pas un descripteur de fichier ouvert).

ECONNREFUSED

L'adresse distante indiquée par connect(2) n'était pas un socket en écoute. Cette erreur peut également se produire si le nom de chemin cible n'est pas un socket.

ECONNRESET

Le socket distant a été fermé de manière inattendue.

EFAULT

Adresse mémoire utilisateur incorrecte.

EINVAL

Argument passé non valable. Une cause habituelle est que la valeur de AF_UNIX n'était pas indiquée dans le champ sun_type des adresses passées ou que le socket était dans un état non valable pour l'opération appliquée.

EISCONN

connect(2) a été appelée sur un socket déjà connecté ou l'adresse cible a été indiquée sur un socket connecté.

ENFILE

La limite du nombre total de fichiers ouverts pour le système entier a été atteinte.

ENOENT

Le chemin de l'adresse distante indiquée à connect(2) n'existait pas.

ENOMEM

Plus assez de mémoire.

ENOTCONN

L'opération nécessite une adresse cible, mais le socket n'est pas connecté.

EOPNOTSUPP

Opération de flux appelée sur un socket non orienté flux ou tentative d'utiliser une option de données hors-bande.

EPERM

L'émetteur a transmis des accréditations incorrectes dans struct ucred.

EPIPE

Le socket distant a été fermé à cause d’un socket flux. Si activé, un signal SIGPIPE est émis également. Cela peut être évité en passant l'indicateur MSG_NOSIGNAL dans send(2) ou sendmsg(2).

EPROTONOSUPPORT

Le protocole fourni n'est pas AF_UNIX.

EPROTOTYPE

Le socket distant ne correspond pas au type de socket local ( SOCK_DGRAM versus SOCK_STREAM)

ESOCKTNOSUPPORT

Type de socket inconnu.

ESRCH

Lors de l’envoi d’un message annexe contenant des accréditations ( SCM_CREDENTIALS), l’appelant a indiqué un PID ne correspondant à aucun processus existant.

ETOOMANYREFS

Cette erreur peut se produire pour sendmsg(2) lors de l’envoi d’un descripteur de fichier pour des données annexes à travers un socket de domaine UNIX (consultez la description de SCM_RIGHTS, ci-dessus). Cela se produit si le nombre de descripteurs de fichier « en cours » excède la limite de ressources RLIMIT_NOFILE et si l’appelant n’a pas la capacité CAP_SYS_RESOURCE. Un descripteur de fichier en cours est un descripteur qui a été envoyé en utilisant sendmsg(2) mais qui n’a pas encore été accepté dans le processus récepteur en utilisant recvmsg(2).

Cette erreur est décelée depuis Linux 4.5 (et dans quelques versions précédentes dans lesquelles le correctif a été rétroporté). Dans les versions du noyau précédentes, il était possible d’avoir un nombre illimité de descripteurs de fichier en cours en envoyant chaque descripteur de fichier avec sendmsg(2) et ensuite en fermant le descripteur de fichier de telle façon qu’il ne soit pas pris en compte pour la limite de ressources RLIMIT_NOFILE.

VERSIONS

NOTES

BOGUES

strnlen(addr.sun_path, addrlen - offsetof(sockaddr_un, sun_path))

void *addrp;

addrlen = sizeof(struct sockaddr_un);
addrp = malloc(addrlen + 1);
if (addrp == NULL)
    /* Gérer l’erreur */ ;
memset(addrp, 0, addrlen + 1);

if (getsockname(sfd, (struct sockaddr *) addrp, &addrlen)) == -1)
    /* Gérer l’erreur */ ;

printf("sun_path = %s\n", ((struct sockaddr_un *) addrp)->sun_path);

EXEMPLES

Sortie de l’exemple

$  ./server &
[1] 25887
$  ./client 3 4
Result = 7
$  ./client 11 -5
Result = 6
$  ./client DOWN
Result = 0
[1]+  Done                    ./server
$

Source du programme

/*
 * Fichier connection.h
 */

#define SOCKET_NAME "/tmp/9Lq7BNBnBycd6nxy.socket"
#define BUFFER_SIZE 12

/*
 * Fichier server.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include "connection.h"

int
main(int argc, char *argv[])
{
    struct sockaddr_un name;
    int down_flag = 0;
    int ret;
    int connection_socket;
    int data_socket;
    int result;
    char buffer[BUFFER_SIZE];

    /* Création du socket local. */

    connection_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
    if (connection_socket == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    /*
     * Pour la portabilité effacer la structure entière, puisque
     * quelques implémentations ont des champs (non standard)
     * supplémentaires dans la structure.
     */

    memset(&name, 0, sizeof(name));

    /* Liaison du socket au nom de socket. */

    name.sun_family = AF_UNIX;
    strncpy(name.sun_path, SOCKET_NAME, sizeof(name.sun_path) - 1);

    ret = bind(connection_socket, (const struct sockaddr *) &name,
               sizeof(name));
    if (ret == -1) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    /*
     * Préparation à accepter les connexions. La taille de réserve
     * est réglée à 20. Aussi tandis qu’une requête est traitée,
     * d’autres peuvent être en attente.
     */

    ret = listen(connection_socket, 20);
    if (ret == -1) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    /* Ceci est la boucle principale pour gérer les connexions. */

    for (;;) {

        /* Attendre des connexions entrantes. */

        data_socket = accept(connection_socket, NULL, NULL);
        if (data_socket == -1) {
            perror("accept");
            exit(EXIT_FAILURE);
        }

        result = 0;
        for (;;) {

            /* Attendre le prochain paquet de données. */

            ret = read(data_socket, buffer, sizeof(buffer));
            if (ret == -1) {
                perror("read");
                exit(EXIT_FAILURE);
            }

            /* Assurer que le tampon soit terminé par NULL. */

            buffer[sizeof(buffer) - 1] = 0;

            /* Gérer les commandes. */

            if (!strncmp(buffer, "DOWN", sizeof(buffer))) {
                down_flag = 1;
                break;
            }

            if (!strncmp(buffer, "END", sizeof(buffer))) {
                break;
            }

            /* Faire la somme des termes reçus. */

            result += atoi(buffer);
        }

        /* Envoyer le résultat. */

        sprintf(buffer, "%d", result);
        ret = write(data_socket, buffer, sizeof(buffer));
        if (ret == -1) {
            perror("write");
            exit(EXIT_FAILURE);
        }

        /* Fermer le socket. */

        close(data_socket);

        /* Quitter avec la commande DOWN. */

        if (down_flag) {
            break;
        }
    }

    close(connection_socket);

    /* Délier le socket. */

    unlink(SOCKET_NAME);

    exit(EXIT_SUCCESS);
}

/*
 * Fichier client.c
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include "connection.h"

int
main(int argc, char *argv[])
{
    struct sockaddr_un addr;
    int ret;
    int data_socket;
    char buffer[BUFFER_SIZE];

    /* Création du socket local. */

    data_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
    if (data_socket == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    /*
     * Pour la portabilité effacer la structure entière, puisque
     * quelques implémentations ont des champs (non standard)
     * supplémentaires dans la structure.
     */

    memset(&addr, 0, sizeof(addr));

    /* Connecter le socket à l’adresse de socket. */

    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCKET_NAME, sizeof(addr.sun_path) - 1);

    ret = connect(data_socket, (const struct sockaddr *) &addr,
                   sizeof(addr));
    if (ret == -1) {
        fprintf(stderr, "Le serveur est arrêté.\n");
        exit(EXIT_FAILURE);
    }

    /* Envoyer les arguments. */

    for (size_t i = 1; i < argc; ++i) {
        ret = write(data_socket, argv[i], strlen(argv[i]) + 1);
        if (ret == -1) {
            perror("write");
            break;
        }
    }

    /* Résultat de la requête. */

    strcpy(buffer, "END");
    ret = write(data_socket, buffer, strlen(buffer) + 1);
    if (ret == -1) {
        perror("write");
        exit(EXIT_FAILURE);
    }

    /* Recevoir le résultat. */

    ret = read(data_socket, buffer, sizeof(buffer));
    if (ret == -1) {
        perror("read");
        exit(EXIT_FAILURE);
    }

    /* Assurer que le tampon soit terminé par NULL. */

    buffer[sizeof(buffer) - 1] = 0;

    printf("Result = %s\n", buffer);

    /* Fermer le socket. */

    close(data_socket);

    exit(EXIT_SUCCESS);
}

VOIR AUSSI

TRADUCTION