perkamon - en to fr translation catalogue (90 entries)

note: type: TH
en: 2019-08-02
fr: 2 août 2019

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: For an overview of namespaces, see B<namespaces>(7).
fr: Pour une présentation générale des espaces de noms, consultez B<namespaces>(7).

note: type: SS
en: Nested namespaces, namespace membership
fr: Espaces de noms imbriqués, appartenance aux espaces de noms

note: type: Plain text
en: User namespaces can be nested; that is, each user namespace\(emexcept the initial ("root")  namespace\(emhas a parent user namespace, and can have zero or more child user namespaces.  The parent user namespace is the user namespace of the process that creates the user namespace via a call to B<unshare>(2)  or B<clone>(2)  with the B<CLONE_NEWUSER> flag.
fr: Les espaces de noms utilisateur peuvent être imbriqués. Cela signifie que chaque espace de noms utilisateur\(emà l'exception de l'espace de nom initial (« root »)\(ema un espace de noms père et peut avoir éventuellement un ou plusieurs espaces de noms utilisateur fils. L'espace de noms utilisateur père est l'espace de noms du processus qui a créé l'espace de noms au moyen de B<unshare>(2) ou de B<clone>(2) invoqué avec l'attribut B<CLONE_NEWUSER>.

note: commit 8742f229b635bf1c1c84a3dfe5e47c814c20b5c8 FIXME Explain the rationale for this limit. (What is the rationale?) type: Plain text
en: The kernel imposes (since version 3.11) a limit of 32 nested levels of user namespaces.  Calls to B<unshare>(2)  or B<clone>(2)  that would cause this limit to be exceeded fail with the error B<EUSERS>.
fr: Le noyau impose (à partir de Linux 3.11) une limite de 32 niveaux d'imbrication pour les espaces de noms utilisateur. Si un appel à B<unshare>(2) ou à B<clone>(2) provoque le dépassement de cette limite, la commande échoue en renvoyant l'erreur B<EUSERS>.

note: type: Plain text
en: Each process is a member of exactly one user namespace.  A process created via B<fork>(2)  or B<clone>(2)  without the B<CLONE_NEWUSER> flag is a member of the same user namespace as its parent.  A single-threaded process can join another user namespace with B<setns>(2)  if it has the B<CAP_SYS_ADMIN> in that namespace; upon doing so, it gains a full set of capabilities in that namespace.
fr: Chaque processus est membre d'exactement un espace de noms utilisateur. Un processus créé par B<fork>(2) ou par B<clone>(2) sans l'attribut B<CLONE_NEWUSER> est membre du même espace de noms que son processus père. Un processus mono-threadé peut rejoindre un autre espace de noms en utilisant B<setns>(2) s'il dispose de la capacité B<CAP_SYS_ADMIN> dans cet espace de noms ; cet action lui octroie un ensemble de capacités dans cet espace de noms.

note: type: Plain text
en: A call to B<clone>(2)  or B<unshare>(2)  with the B<CLONE_NEWUSER> flag makes the new child process (for B<clone>(2))  or the caller (for B<unshare>(2))  a member of the new user namespace created by the call.
fr: Un appel à B<clone>(2) ou à B<unshare>(2) avec l'attribut B<CLONE_NEWUSER> place le nouveau processus fils (pour B<clone>(2)) ou l'appelant (for B<unshare>(2)) dans le nouvel espace de noms utilisateur créé par l'appel.

note: type: SS
en: Capabilities
fr: Capacités

note: type: Plain text
en: The child process created by B<clone>(2)  with the B<CLONE_NEWUSER> flag starts out with a complete set of capabilities in the new user namespace.  Likewise, a process that creates a new user namespace using B<unshare>(2)  or joins an existing user namespace using B<setns>(2)  gains a full set of capabilities in that namespace.  On the other hand, that process has no capabilities in the parent (in the case of B<clone>(2))  or previous (in the case of B<unshare>(2)  and B<setns>(2))  user namespace, even if the new namespace is created or joined by the root user (i.e., a process with user ID 0 in the root namespace).
fr: Le processus fils créé par B<clone>(2) avec l'attribut B<CLONE_NEWUSER> s'initialise avec un nouvel ensemble de capacités dans le nouvel espace de noms utilisateur. De même, un processus qui crée un nouvel espace de noms au moyen de B<unshare>(2) ou qui rejoint un espace de noms existant via B<setns>(2) reçoit un ensemble de capacités dans cet espace de noms.

note: type: Plain text
en: A call to B<clone>(2), B<unshare>(2), or B<setns>(2)  using the B<CLONE_NEWUSER> flag sets the "securebits" flags (see B<capabilities>(7))  to their default values (all flags disabled) in the child (for B<clone>(2))  or caller (for B<unshare>(2), or B<setns>(2)).  Note that because the caller no longer has capabilities in its original user namespace after a call to B<setns>(2), it is not possible for a process to reset its "securebits" flags while retaining its user namespace membership by using a pair of B<setns>(2)  calls to move to another user namespace and then return to its original user namespace.
fr: Un appel à B<clone>(2), B<unshare>(2) ou B<setns>(2) avec l'attribut B<CLONE_NEWUSER> positionne les attributs « securebits » (consultez B<capabilities>(7)) à leurs valeurs par défaut (tous les attributs désactivés) pour le fils (dans le cas d'un appel à B<clone>(2)) ou pour le processus appelant (dans le cas d'un appel à  B<unshare>(2) ou à B<setns>(2)). Notez qu'après un appel à B<setns>(2), l'appelant a perdu ses capacités dans son espace de noms initial. Un processus ne peut donc pas réinitialiser ses attributs « securebits » lorsqu'il conserve son appartenance à un espace de noms en utilisant deux fois l'appel B<setns>(2) pour passer dans un autre espace de noms, avant de revenir dans l'espace de noms initial.

note: In the 3.8 sources, see security/commoncap.c::cap_capable(): type: Plain text
en: A process has a capability inside a user namespace if it is a member of that namespace and it has the capability in its effective capability set.  A process can gain capabilities in its effective capability set in various ways.  For example, it may execute a set-user-ID program or an executable with associated file capabilities.  In addition, a process may gain capabilities via the effect of B<clone>(2), B<unshare>(2), or B<setns>(2), as already described.
fr: Un processus dispose d'une capacité dans un espace de noms utilisateur s'il est membre de cet espace de noms et si cette capacité est activée dans son jeu de capacités. Un processus peut obtenir une nouvelle capacité dans son jeu de capacités de plusieurs façons. Il peut, par exemple, exécuter un programme set-UID ou un exécutable avec des capacités de fichier associées. Il peut également obtenir des capacités via l'action de B<clone>(2), B<unshare>(2) ou B<setns>(2) comme indiqué précédemment.

note: type: Plain text
en: If a process has a capability in a user namespace, then it has that capability in all child (and further removed descendant)  namespaces as well.
fr: Si un processus dispose d'une capacité dans un espace de noms utilisateur, alors il a cette même capacité dans tous les espaces de noms fils (et les espaces descendants supprimés).

note: type: SS
en: Interaction of user namespaces and other types of namespaces
fr: Liens entre les espaces de noms utilisateur et les autres espaces de noms

note: type: Plain text
en: If B<CLONE_NEWUSER> is specified along with other B<CLONE_NEW*> flags in a single B<clone>(2)  or B<unshare>(2)  call, the user namespace is guaranteed to be created first, giving the child (B<clone>(2))  or caller (B<unshare>(2))  privileges over the remaining namespaces created by the call.  Thus, it is possible for an unprivileged caller to specify this combination of flags.
fr: Si B<CLONE_NEWUSER> est indiqué en complément de l'attribut B<CLONE_NEW*> lors d'un appel simple à B<clone>(2) ou à B<unshare>(2), l'espace de noms utilisateur est créé en premier. Cela donne des privilèges au fils (dans le cas de B<clone>(2)) ou à l'appelant (dans le cas de B<unshare>(2)) dans l'espace de noms créé par l'appel. Il est ainsi possible à un appelant sans privilèges d'indiquer ce jeu d'attributs.

note: type: SS
en: User and group ID mappings: uid_map and gid_map
fr: Correspondance des identifiants d'utilisateur et de groupe : uid_map et gid_map

note: commit 22d917d80e842829d0ca0a561967d728eb1d6303 type: Plain text
en: When a user namespace is created, it starts out without a mapping of user IDs (group IDs)  to the parent user namespace.  The I</proc/[pid]/uid_map> and I</proc/[pid]/gid_map> files (available since Linux 3.5)  expose the mappings for user and group IDs inside the user namespace for the process I<pid>.  These files can be read to view the mappings in a user namespace and written to (once) to define the mappings.
fr: Lorsqu'un espace de noms utilisateur est créé, il s'initialise sans établir de correspondance entre ses identifiants utilisateurs (identifiants de groupes) et ceux de l'espace de noms père. Les fichiers I</proc/[pid]/uid_map> et I</proc/[pid]/gid_map> présentent (à partir de Linux 3.5) la correspondance entre identifiants d'utilisateurs et de groupes à l'intérieur de l'espace de noms pour le processus I<pid>. Ces fichiers peuvent être consultés pour prendre connaissance de la correspondance, et peuvent être modifiés (une seule fois) pour définir les correspondances.

note: type: Plain text
en: The description in the following paragraphs explains the details for I<uid_map>; I<gid_map> is exactly the same, but each instance of "user ID" is replaced by "group ID".
fr: Les paragraphes suivants décrivent I<uid_map> en détails. I<gid_map> est parfaitement analogue, chaque instance de « identifiant utilisateur » étant remplacée par « identifiant groupe ».

note: type: Plain text
en: The I<uid_map> file exposes the mapping of user IDs from the user namespace of the process I<pid> to the user namespace of the process that opened I<uid_map> (but see a qualification to this point below).  In other words, processes that are in different user namespaces will potentially see different values when reading from a particular I<uid_map> file, depending on the user ID mappings for the user namespaces of the reading processes.
fr: Le fichier I<uid_map> présente la correspondance entre les identifiants utilisateur de l'espace de noms utilisateur du processus I<pid> et ceux de l'espace de noms utilisateur du processus qui a ouvert I<uid_map> (mais consultez la réserve concernant ce point exposée ci-dessous). En d'autres termes, des processus qui se trouvent dans différents espaces de noms verront des valeurs différentes lors de la lecture d'un fichier I<uid_map> selon la correspondance des identifiants utilisateur pour l'espace de noms utilisateur du processus qui effectue la lecture.

note: type: Plain text
en: Each line in the I<uid_map> file specifies a 1-to-1 mapping of a range of contiguous user IDs between two user namespaces.  (When a user namespace is first created, this file is empty.)  The specification in each line takes the form of three numbers delimited by white space.  The first two numbers specify the starting user ID in each of the two user namespaces.  The third number specifies the length of the mapped range.  In detail, the fields are interpreted as follows:
fr: Chaque ligne du fichier I<uid_map> affiche une correspondance un-pour-un d'un intervalle d'identifiants utilisateur contigus de deux espaces de noms utilisateur. Lorsqu'un espace de noms utilisateur vient d'être créé, ce fichier est vide. Chaque ligne contient trois nombres délimités par des espaces. Les deux premiers nombres indiquent les premiers identifiants utilisateur de chacun des deux espaces de noms. Le troisième nombre indique la longueur de l'intervalle de correspondance. Plus précisément, les champs sont interprétés de la façon suivante :

note: type: Plain text
en: The start of the range of user IDs in the user namespace of the process I<pid>.
fr: Le début de l'intervalle d'identifiants utilisateur dans l'espace de noms utilisateur du processus I<pid>.

note: type: Plain text
en: The start of the range of user IDs to which the user IDs specified by field one map.  How field two is interpreted depends on whether the process that opened I<uid_map> and the process I<pid> are in the same user namespace, as follows:
fr: Le début de l'intervalle d'identifiants utilisateur auquel correspondant l'identifiant utilisateur indiqué dans le premier champ. Selon que le processus qui a ouvert le fichier I<uid_map> et le processus I<pid> sont ou non dans le même espace de noms, le deuxième champ est interprété de l'un des façons suivantes :

note: type: Plain text
en: If the two processes are in different user namespaces: field two is the start of a range of user IDs in the user namespace of the process that opened I<uid_map>.
fr: Si les deux processus sont dans différents espaces de noms : le deuxième champ est le début de l'intervalle d'identifiants utilisateur dans l'espace de noms du processus qui a ouvert I<uid_map>.

note: type: Plain text
en: If the two processes are in the same user namespace: field two is the start of the range of user IDs in the parent user namespace of the process I<pid>.  This case enables the opener of I<uid_map> (the common case here is opening I</proc/self/uid_map>)  to see the mapping of user IDs into the user namespace of the process that created this user namespace.
fr: Si les deux processus sont dans le même espace de noms : le second champ correspond au début de la séquence d'identifiants utilisateur dans l'espace de noms père du processus I<pid>. Ceci permet au processus qui a ouvert I<uid_map> (généralement, le processus ouvre I</proc/self/uid_map>) de voir les correspondances avec les identifiants utilisateur de l'espace de noms du processus qui est a créé cet espace de noms utilisateur.

note: type: Plain text
en: The length of the range of user IDs that is mapped between the two user namespaces.
fr: La longueur de l'intervalle des identifiants utilisateur qui se superposent entre les deux espaces de noms utilisateur.

note: type: Plain text
en: System calls that return user IDs (group IDs)\(emfor example, B<getuid>(2), B<getgid>(2), and the credential fields in the structure returned by B<stat>(2)\(emreturn the user ID (group ID) mapped into the caller's user namespace.
fr: Les appels système qui renvoient des identifiants utilisateur (des identifiant de groupes) \(emcomme par exemple, B<getuid>(2), B<getgid>(2), et les champ relatifs aux droits dans la structure renvoyée par B<stat>(2)\(emaffichent la valeur de l'identifiant utilisateur (de l'identifiant de groupe) correspondant dans l'espace de noms utilisateur de l'appelant.

note: type: Plain text
en: When a process accesses a file, its user and group IDs are mapped into the initial user namespace for the purpose of permission checking and assigning IDs when creating a file.  When a process retrieves file user and group IDs via B<stat>(2), the IDs are mapped in the opposite direction, to produce values relative to the process user and group ID mappings.
fr: Lorsqu'un processus accède à un fichier, ses identifiant utilisateur et groupe pris en compte pour la vérification des droits ou pour la création d'un fichier sont ceux de l'espace de noms initial. Lorsqu'un processus obtient les identifiants d'utilisateur et de groupe d'un fichier par la commande B<stat>(2), les identifiants sont évalués dans le sens inverse, afin de renvoyer les valeur d'identifiants qui dans la table de correspondance font référence à l'autre espace de noms.

note: type: Plain text
en: The initial user namespace has no parent namespace, but, for consistency, the kernel provides dummy user and group ID mapping files for this namespace.  Looking at the I<uid_map> file (I<gid_map> is the same) from a shell in the initial namespace shows:
fr: L'espace de noms utilisateur initial n'a pas de d'espace de noms père, mais pour conserver la cohérence, le noyau lui attribue un fichier de correspondance d'identifiants factice pour cet espace de noms. Si l'on consulte le fichier I<uid_map> file (ou I<gid_map> de la même façon) depuis une invite de commandes dans l'espace de noms initial, on peut voir :

note: type: SS
en: Defining user and group ID mappings: writing to uid_map and gid_map
fr: Création des correspondances d'identifiants utilisateur et groupe : écriture dans uid_map and gid_map

note: type: Plain text
en: After the creation of a new user namespace, the I<uid_map> file of I<one> of the processes in the namespace may be written to I<once> to define the mapping of user IDs in the new user namespace.  An attempt to write more than once to a I<uid_map> file in a user namespace fails with the error B<EPERM>.  Similar rules apply for I<gid_map> files.
fr: Après la création d'un nouvel espace de noms utilisateur, le fichier I<uid_map> de l'I<un> des processus de l'espace de noms peut être ouvert en écriture I<une seule fois> pour y consigner la correspondance des identifiants utilisateur dans le nouvel espace de noms. Toute tentative d'écrire plus d'une fois dans un fichier I<uid_map> se solde par un échec qui renvoie l'erreur B<EPERM>. Des règles analogues s'appliquent aux fichiers I<gid_map>.

note: type: Plain text
en: The lines written to I<uid_map> (I<gid_map>)  must conform to the following rules:
fr: Les lignes inscrites dans I<uid_map> (I<gid_map>) doivent suivre les règles suivantes :

note: type: Plain text
en: The three fields must be valid numbers, and the last field must be greater than 0.
fr: Les trois champs doivent être des nombres valides, et le dernier champ doit être strictement positif.

note: type: Plain text
en: Lines are terminated by newline characters.
fr: Les lignes doivent se terminer par un saut de ligne.

note: commit 0bd14b4fd72afd5df41e9fd59f356740f22fceba type: Plain text
en: The range of user IDs (group IDs)  specified in each line cannot overlap with the ranges in any other lines.  In the initial implementation (Linux 3.8), this requirement was satisfied by a simplistic implementation that imposed the further requirement that the values in both field 1 and field 2 of successive lines must be in ascending numerical order, which prevented some otherwise valid maps from being created.  Linux 3.9 and later fix this limitation, allowing any valid set of nonoverlapping maps.
fr: L'intervalle d'identifiants utilisateur (ou de groupe) indiqué dans chaque ligne ne peut recouvrir les intervalles des autres lignes. Dans l'implémentation initiale (Linux 3.8), cette règle était assurée par une implémentation plus sommaire qui comprenait une contrainte supplémentaire : les deux premiers champs de chaque ligne devaient apparaître en ordre croissant. Cela empêchait cependant la création de correspondances valides. Ce problème a été réglé dans Linux 3.9, et toutes les combinaisons valides de correspondances sont désormais acceptées.

note: type: Plain text
en: At least one line must be written to the file.
fr: Au moins une ligne doit être inscrite dans le fichier.

note: type: Plain text
en: Writes that violate the above rules fail with the error B<EINVAL>.
fr: Les opérations d'écritures qui ne respectent pas les règles énoncées précédemment échouent en renvoyant l'erreur B<EINVAL>.

note: type: Plain text
en: In order for a process to write to the I</proc/[pid]/uid_map> (I</proc/[pid]/gid_map>)  file, all of the following requirements must be met:
fr: Un processus ne peut écrire dans le fichier I</proc/[pid]/uid_map> (I</proc/[pid]/gid_map>) qu'à la condition de respecter les contraintes suivantes :

note: type: Plain text
en: The writing process must have the B<CAP_SETUID> (B<CAP_SETGID>)  capability in the user namespace of the process I<pid>.
fr: Le processus réalisant l'écriture doit disposer de la capacité B<CAP_SETUID> (B<CAP_SETGID>) dans l'espace de noms utilisateur du processus I<pid>.

note: type: Plain text
en: The mapped user IDs (group IDs) must in turn have a mapping in the parent user namespace.
fr: Les identifiants utilisateur (ou de groupe) de la table de correspondance doivent, en retour, figurer dans la table de correspondance de l'espace de noms utilisateur père.

note: ============================================================ type: Plain text
en: Writes that violate the above rules fail with the error B<EPERM>.
fr: Les opérations d'écriture qui ne respectent pas les règles décrites précédemment échouent en renvoyant l'erreur B<EPERM>.

note: type: SS
en: Unmapped user and group IDs
fr: Utilisateurs sans correspondance et identifiants de groupe

note: type: SS
en: Set-user-ID and set-group-ID programs
fr: Programmes set-user-ID et set-group-ID

note: ============================================================ type: Plain text
en: When a process inside a user namespace executes a set-user-ID (set-group-ID) program, the process's effective user (group) ID inside the namespace is changed to whatever value is mapped for the user (group) ID of the file.  However, if either the user I<or> the group ID of the file has no mapping inside the namespace, the set-user-ID (set-group-ID) bit is silently ignored: the new program is executed, but the process's effective user (group) ID is left unchanged.  (This mirrors the semantics of executing a set-user-ID or set-group-ID program that resides on a filesystem that was mounted with the B<MS_NOSUID> flag, as described in B<mount>(2).)
fr: Lorsqu'un processus appartenant à un espace de noms exécute le programme set-user-ID (resp. set-group-ID), l'identifiant utilisateur (resp. groupe) effectif du processus dans l'espace de noms est changé et prend la valeur correspondante dans le fichier pour cet identifiant utilisateur (resp. groupe). Cependant, si l'identifiant utilisateur I<ou> groupe n'a pas de correspondance dans l'espace de noms, la commande set-user-ID (resp. set-group-ID) reste sans effet : le nouveau programme est exécuté, mais l'identifiant utilisateur (resp. groupe) de fait reste celui de processus. Ceci reproduit la sémantique d'exécution d'un programme set-user-ID ou set-group-ID qui se trouve dans un système de fichier monté avec l'attribut B<MS_NOSUID>, comme indiqué dans B<mount>(2).

note: type: SS
en: Miscellaneous
fr: Divers

note: type: Plain text
en: When a process's user and group IDs are passed over a UNIX domain socket to a process in a different user namespace (see the description of B<SCM_CREDENTIALS> in B<unix>(7)), they are translated into the corresponding values as per the receiving process's user and group ID mappings.
fr: Lorsque les identifiants utilisateur et groupe d'un processus sont transmis via une socket de domaine UNIX à un processus d'un autre espace de noms (consultez la description de B<SCM_CREDENTIALS> dans B<unix>(7)), ils sont transformés en leur valeur correspondante suivant la correspondance des identifiants du processus réceptionnaire.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: Namespaces are a Linux-specific feature.
fr: Les espaces de noms sont propres à Linux.

note: ============================================================ type: Plain text
en: Over the years, there have been a lot of features that have been added to the Linux kernel that have been made available only to privileged users because of their potential to confuse set-user-ID-root applications.  In general, it becomes safe to allow the root user in a user namespace to use those features because it is impossible, while in a user namespace, to gain more privilege than the root user of a user namespace has.
fr: Au fil des ans, de nombreuses fonctionnalités ont été ajoutées au noyau Linux mais réservées aux utilisateurs disposant de privilèges du fait de la confusion qu'elle peut induire dans les applications set-user-ID-root. En général, il n'est pas dangereux d'autoriser un utilisateur root d'un espace de noms à utiliser ces fonctionnalités parce qu'il est impossible, dans un espace de noms, d'obtenir plus de droits que ce que peut obtenir l'utilisateur root d'un espace de noms.

note: type: SS
en: Availability
fr: Disponibilité

note: type: Plain text
en: Use of user namespaces requires a kernel that is configured with the B<CONFIG_USER_NS> option.  User namespaces require support in a range of subsystems across the kernel.  When an unsupported subsystem is configured into the kernel, it is not possible to configure user namespaces support.
fr: Le noyau doit avoir été configuré avec l'option B<CONFIG_USER_NS> pour permettre l'utilisation des espaces de noms utilisateur. Ces espaces doivent également être pris en charge par un ensemble de sous-systèmes du noyau. Si un sous-système non pris en charge est activé dans le noyau, il n'est pas possible de configurer la prise en charge des espaces de noms.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The program below is designed to allow experimenting with user namespaces, as well as other types of namespaces.  It creates namespaces as specified by command-line options and then executes a command inside those namespaces.  The comments and I<usage()> function inside the program provide a full explanation of the program.  The following shell session demonstrates its use.
fr: Le programme suivant est conçu pour permettre de s'exercer avec les espaces de noms utilisateur, comme avec d'autres espaces de noms. Il crée des espaces de noms tels que définis dans les options de la ligne de commande et exécute une commande dans ces espaces de noms. Les commentaires et la fonction I<usage()> dans le programme fournissent une explication détaillée du programme. La session shell suivante illustre son utilisation.

note: type: Plain text
en: First, we look at the run-time environment:
fr: Tout d'abord, regardons l'environnement d'exécution :

note: type: Plain text
en: $ B<uname -rs>     # Need Linux 3.8 or later
    Linux 3.8.0
    $ B<id -u>         # Running as unprivileged user
    1000
    $ B<id -g>
    1000
fr: $ B<uname -rs>     # à partir de Linux 3.8
    Linux 3.8.0
    $ B<id -u>         # exécuté comme utilisateur sans privilèges
    1000
    $ B<id -g>
    1000

note: type: Plain text
en: Now start a new shell in new user (I<-U>), mount (I<-m>), and PID (I<-p>)  namespaces, with user ID (I<-M>)  and group ID (I<-G>)  1000 mapped to 0 inside the user namespace:
fr: Démarrons maintenant un nouveau shell dans les nouveaux espaces de noms utilisateur (I<-U>), de montage (I<-m>) et de PID (I<-p>), avec l'identifiant utilisateur (I<-M>) et groupe (I<-G>) 1000 correspondant à 0 dans l'espace de noms utilisateur :

note: type: Plain text
en: The shell has PID 1, because it is the first process in the new PID namespace:
fr: Le shell a le PID 1 puisqu'il est le premier processus de l'espace de noms :

note: type: Plain text
en: Mounting a new I</proc> filesystem and listing all of the processes visible in the new PID namespace shows that the shell can't see any processes outside the PID namespace:
fr: Lorsque l'on monte un nouveau système de fichiers I</proc> et que l'on affiche tous les processus visibles dans le nouvel espaces de noms PID, on constate que le shell peut voir tous les processus qui se trouvent à l'extérieur de l'espace de noms PID :

note: type: Plain text
en: Inside the user namespace, the shell has user and group ID 0, and a full set of permitted and effective capabilities:
fr: Dans l'espace de noms utilisateur, le shell a les identifiants utilisateur et groupe 0, ainsi qu'un ensemble complet de capacités autorisées et de fait :

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en:    Create a child process that executes a shell command in new
       namespace(s); allow UID and GID mappings to be specified when
       creating a user namespace.
    */
    #define _GNU_SOURCE
    #include E<lt>sched.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/wait.hE<gt>
    #include E<lt>signal.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>string.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>errno.hE<gt>
fr: Crée un processus fils qui exécute une invite de commande dans au moins un nouvel espace de noms ; permet de préciser les correspondances d'identifiants utilisateur et groupe lors de la création de nouveaux espaces de noms utilisateur. */
    #define _GNU_SOURCE
    #include E<lt>sched.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/wait.hE<gt>
    #include E<lt>signal.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>string.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>errno.hE<gt>

note: type: Plain text
en: /* A simple error-handling function: print an error message based
       on the value in \(aqerrno\(aq and terminate the calling process */
fr: /* Une fonction de gestion des erreurs assez simple : affiche un message d'erreur dépendant de la valeur de \(aqerrno\(aq et termine le processus appelant */

note: type: Plain text
en: struct child_args {
        char **argv;        /* Command to be executed by child, with args */
        int    pipe_fd[2];  /* Pipe used to synchronize parent and child */
    };
fr: struct child_args {
        char **argv;        /* Commande à exécuter par le fils, avec arguments */
        int    pipe_fd[2];  /* tube utilisé pour synchroniser le père et le fils */
    };

note: type: Plain text
en: static void
    usage(char *pname)
    {
        fprintf(stderr, "Usage: %s [options] cmd [arg...]\en\en", pname);
        fprintf(stderr, "Create a child process that executes a shell "
                "command in a new user namespace,\en"
                "and possibly also other new namespace(s).\en\en");
        fprintf(stderr, "Options can be:\en\en");
    #define fpe(str) fprintf(stderr, "    %s", str);
        fpe("-i          New IPC namespace\en");
        fpe("-m          New mount namespace\en");
        fpe("-n          New network namespace\en");
        fpe("-p          New PID namespace\en");
        fpe("-u          New UTS namespace\en");
        fpe("-U          New user namespace\en");
        fpe("-M uid_map  Specify UID map for user namespace\en");
        fpe("-G gid_map  Specify GID map for user namespace\en");
        fpe("-z          Map user\(aqs UID and GID to 0 in user namespace\en");
        fpe("            (equivalent to: -M \(aq0 E<lt>uidE<gt> 1\(aq -G \(aq0 E<lt>gidE<gt> 1\(aq)\en");
        fpe("-v          Display verbose messages\en");
        fpe("\en");
        fpe("If -z, -M, or -G is specified, -U is required.\en");
        fpe("It is not permitted to specify both -z and either -M or -G.\en");
        fpe("\en");
        fpe("Map strings for -M and -G consist of records of the form:\en");
        fpe("\en");
        fpe("    ID-inside-ns   ID-outside-ns   len\en");
        fpe("\en");
        fpe("A map string can contain multiple records, separated"
            " by commas;\en");
        fpe("the commas are replaced by newlines before writing"
            " to map files.\en");
fr: static void
    usage(char *pname)
    {
        fprintf(stderr, "Utilisation: %s [options] cmd [arg...]\en\en", pname);
        fprintf(stderr, "Crée un processus fils qui exécute une invitel "
                "de commandes dans un nouvel espace de noms,\en"
                "et éventuellement au moins un nouvel espace"
         " de noms.\en\en");
        fprintf(stderr, "Les options sont :\en\en");
    #define fpe(str) fprintf(stderr, "    %s", str);
        fpe("-i          Nouvel espace de noms IPC\en");
        fpe("-m          Nouvel espace de noms de montage\en");
        fpe("-n          Nouvel espace de noms réseau \en");
        fpe("-p          Nouvel espace de noms PID\en");
        fpe("-u          Nouvel espace de noms UTS\en");
        fpe("-U          Nouvel espace de noms utilisateur\en");
        fpe("-M uid_map  Correspndance UID dans l'espace"
        " de noms utilisateur\en");
        fpe("-G gid_map  Correspondance GID dan l'espace"
        " de noms utilisateur\en");
        fpe("-z          Établit la correspondance des UID et GID avec"
         " avec 0 dans l'espace nom utilisateur\en");
        fpe("            (équivalent à: -M \(aq0 E<lt>uidE<gt> 1\(aq -G \(aq0 E<lt>gidE<gt> 1\(aq)\en");
        fpe("-v          Affichage volubile\en");
        fpe("\en");
        fpe("Si -z, -M, or -G est invoqué, -U doit être précisé.\en");
        fpe("Il n'est pas possible d'utiliser -z et soit -M, soit -G.\en");
        fpe("\en");
        fpe("Les chaînes de correspondance pour -M et -G se composent"
         " d'enregistrements de la forme :\en");
        fpe("\en");
        fpe("    ID-inside-ns   ID-outside-ns   len\en");
        fpe("\en");
        fpe("Une chaîne de correspondance se compose de plusieurs"
            " enregistrements séparés par des virgules;\en");
        fpe("les virgules sont remplacées par des retour à la ligne"
            " avant l'écriture des fichiers de correspondance.\en");

note: type: Plain text
en: /* Update the mapping file \(aqmap_file\(aq, with the value provided in
       \(aqmapping\(aq, a string that defines a UID or GID mapping. A UID or
       GID mapping consists of one or more newline-delimited records
       of the form:
fr: /* Mise à jour du fichier de correspondance \(aqmap_file\(aq, avec la 
     valeur fournie dans \(aqmapping\(aq, soit une chaîne qui définit une 
     une correspondance d'identifiant utilisateur ou groupe. Une correspondance
     d'identifiant d'utilisateur ou groupe se compose d'une ou plusieurs lignes 
     d'enregistrements séparés par des retours à la ligne sous la forme suivante :

note: type: Plain text
en:        ID_inside-ns    ID-outside-ns   length
fr:        ID_dans-Espace    ID-host-Espace   longueur

note: type: Plain text
en:    Requiring the user to supply a string that contains newlines is
       of course inconvenient for command-line use. Thus, we permit the
       use of commas to delimit records in this string, and replace them
       with newlines before writing the string to the file. */
fr:  La nécessité de fournir une chaîne qui contienne des retours
     à la ligne ne convient pas bien à une utilisation en ligne de commande.
     C'est pour cette raison que l'utilisation des virgules pour délimiter les
     champs de la chaîne est autorisé. Celles-ci sont remplacées par des 
     virgules avant l'écriture des chaînes dans le fichier. */

note: type: Plain text
en: static void
    update_map(char *mapping, char *map_file)
    {
        int fd, j;
        size_t map_len;     /* Length of \(aqmapping\(aq */
fr: static void
    update_map(char *mapping, char *map_file)
    {
        int fd, j;
        size_t map_len;     /* Longueur de \(aqmapping\(aq */

note: type: Plain text
en:     /* Replace commas in mapping string with newlines */
fr:     /* Remplace les virgules de la chaîne de correspondance 
     avec des retours à la ligne */

note: type: Plain text
en: static int              /* Start function for cloned child */
    childFunc(void *arg)
    {
        struct child_args *args = (struct child_args *) arg;
        char ch;
fr: static int              /* Lance la fonction pour le fils dupliqué */
    childFunc(void *arg)
    {
        struct child_args *args = (struct child_args *) arg;
        char ch;

note: type: Plain text
en:     /* Wait until the parent has updated the UID and GID mappings.
           See the comment in main(). We wait for end of file on a
           pipe that will be closed by the parent process once it has
           updated the mappings. */
fr:     /* Attend que le père ait mis à jour les correspondances d'identifiants
           d'utilisateur et de groupe. Consultez le commentaire de main(). On
           attend le signal de fin de fichier dans le tube qui sera fermé par le
           processus père lorsque les correspondances seront mises à jour. */

note: type: Plain text
en:     close(args-E<gt>pipe_fd[1]);    /* Close our descriptor for the write
                                       end of the pipe so that we see EOF
                                       when parent closes its descriptor */
        if (read(args-E<gt>pipe_fd[0], &ch, 1) != 0) {
            fprintf(stderr,
                    "Failure in child: read from pipe returned != 0\en");
            exit(EXIT_FAILURE);
        }
fr:     close(args-E<gt>pipe_fd[1]);    /* Ferme le descripteur pour le côté
                                       en écriture du tube afin de présenter EOF
                                       lorsque le père ferme le descripteur */
        if (read(args-E<gt>pipe_fd[0], &ch, 1) != 0) {
            fprintf(stderr,
                    "Échec du fils : donnée renvoyée par le tube != 0\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Execute a shell command */
fr:     /* Lance un exécuteur de commande */

note: type: Plain text
en: static char child_stack[STACK_SIZE];    /* Space for child\(aqs stack */
fr: static char child_stack[STACK_SIZE];    /* Espace pour la pile du fils */

note: type: Plain text
en:     /* Parse command-line options. The initial \(aq+\(aq character in
           the final getopt() argument prevents GNU-style permutation
           of command-line options. That\(aqs useful, since sometimes
           the \(aqcommand\(aq to be executed by this program itself
           has command-line options. We don\(aqt want getopt() to treat
           those as options to this program. */
fr:     /* Analyse les options de la commande en ligne. Le caractère
           \(aq+\(aq initial de l'argument final de getopt() empêche la
           permutation des options de la ligne de commande (comme
           le pratique GNU). Ceci peut être utile dans les cas où la
           \(aqcommande\(aq _n exécutée par le programme a
           elle-même des options. Cela évite que
     getopt() ne traite
           ces options comme étant celles du programme */

note: type: Plain text
en:     /* -M or -G without -U is nonsensical */
fr:     /* -M ou -G sans -U est incohérent */

note: type: Plain text
en:     /* We use a pipe to synchronize the parent and child, in order to
           ensure that the parent sets the UID and GID maps before the child
           calls execve(). This ensures that the child maintains its
           capabilities during the execve() in the common case where we
           want to map the child\(aqs effective user ID to 0 in the new user
           namespace. Without this synchronization, the child would lose
           its capabilities if it performed an execve() with nonzero
           user IDs (see the capabilities(7) man page for details of the
           transformation of a process\(aqs capabilities during execve()). */
fr:     /* L'utilisation d'un tube pour réaliser la synchronisation du père et
           du fils a pour but d'obliger le père a définir les correspondances
           d'identifiants utilisateur et groupe avant que le fils n'appelle        execve(). Ceci permet d'assurer que le fils conserve ses capacités 
           pendant l'exécution de execve() dans cas classique où l'on souhaite
           faire correspondre les identifiants du fils avec 0 dans le nouvel 
           espace de noms utilisateur. Sans cette synchronisation, le fils 
           perdrait ses capacités s'il effectuait execve() avec un identifiant
           utilisateur autre que 0 (consultez la page du manuel consacrée
            à capacités(7) pour plus de détails sur la modification des capacités
           d'un processus lors de l'exécution de execve()). */

note: type: Plain text
en:     /* Create the child in new namespace(s) */
fr:     /* Création du fils dans le ou les nouveaux espaces de noms */

note: type: Plain text
en:     /* Parent falls through to here */
fr:     /* Le processus père se retrouve au point suivant */

note: type: Plain text
en:     if (verbose)
            printf("%s: PID of child created by clone() is %ld\en",
                    argv[0], (long) child_pid);
fr:     if (verbose)
            printf("%s: le PID du fils créé par clone() est %ld\en",
                    argv[0], (long) child_pid);

note: type: Plain text
en:     /* Update the UID and GID maps in the child */
fr:     /* Mise à jour des correspondances de  l'UID et du PID
           pour le fils  */

note: type: Plain text
en:     /* Close the write end of the pipe, to signal to the child that we
           have updated the UID and GID maps */
fr:     /* Ferme le côté en écriture du tube afin d'indiquer au fils que
           les correspondances d'UID et de GID ont été mises à jour  */

note: type: Plain text
en:     if (waitpid(child_pid, NULL, 0) == -1)      /* Wait for child */
            errExit("waitpid");
fr:     if (waitpid(child_pid, NULL, 0) == -1)      /* Attend le fils */
            errExit("waitpid");

note: type: Plain text
en:     if (verbose)
            printf("%s: terminating\en", argv[0]);
fr:     if (verbose)
            printf("%s: fin d'exécution\en", argv[0]);

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: The kernel source file I<Documentation/namespaces/resource-control.txt>.
fr: Le fichier I<Documentation/namespaces/resource-control.txt> des sources du noyau.

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
