perkamon - en to fr translation catalogue (1334 entries)

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

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: asprintf, vasprintf - print to allocated string
fr: asprintf, vasprintf - Écriture formatée dans une chaîne allouée

note: type: Plain text
en: B<#define _GNU_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The functions B<asprintf>()  and B<vasprintf>()  are analogs of B<sprintf>(3)  and B<vsprintf>(3), except that they allocate a string large enough to hold the output including the terminating null byte (\(aq\e0\(aq), and return a pointer to it via the first argument.  This pointer should be passed to B<free>(3)  to release the allocated storage when it is no longer needed.
fr: Les fonctions B<asprintf>() et B<vasprintf>() sont similaires à B<sprintf>(3) et B<vsprintf>(3), si ce n'est qu'elles allouent une chaîne de caractères de taille suffisante pour contenir la sortie, y compris l'octet nul final (\(aq\e0\(aq) et qu'elles renvoient un pointeur vers cette chaîne via le premier paramètre. Ce pointeur devra être passé en paramètre à B<free>(3) afin de libérer la zone allouée lorsqu'elle ne sera plus nécessaire.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: When successful, these functions return the number of bytes printed, just like B<sprintf>(3).  If memory allocation wasn't possible, or some other error occurs, these functions will return -1, and the contents of I<strp> is undefined.
fr: En cas de succès, ces fonctions renvoient le nombre de caractères imprimés, tout comme B<sprintf>(3). Si l'allocation mémoire n'a pas été possible, ou qu'une autre erreur est survenue, ces fonctions renvoient -1 et la valeur de I<strp> est indéfinie.

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

note: type: Plain text
en: These functions are GNU extensions, not in C or POSIX.  They are also available under *BSD.  The FreeBSD implementation sets I<strp> to NULL on error.
fr: Ces fonctions sont des extensions GNU et sont absentes des standards C et POSIX. Elles sont également disponibles sous BSD. L'implémentation FreeBSD affecte à I<strp> la valeur NULL en cas d'erreur.

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

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<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/.

note: type: TH
en: 2013-07-04
fr: 4 juillet 2013

note: type: Plain text
en: ctermid - get controlling terminal name
fr: ctermid - Obtenir le nom du terminal de contrôle

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: From <unistd.h>: _XOPEN_SOURCE type: Plain text
en: B<ctermid>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<ctermid>()\ : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: B<ctermid>()  returns a string which is the pathname for the current controlling terminal for this process.  If I<s> is NULL, a static buffer is used, otherwise I<s> points to a buffer used to hold the terminal pathname.  The symbolic constant B<L_ctermid> is the maximum number of characters in the returned pathname.
fr: La fonction B<ctermid>() renvoie une chaîne de caractères correspondant au chemin d'accès du terminal contrôlant le processus en cours. Si I<s> vaut NULL, un tampon statique est utilisé pour renvoyer la chaîne, sinon I<s> doit pointer sur le tampon à remplir avec le nom du terminal. La constante symbolique B<L_ctermid> représente le nombre maximal de caractères dans le nom renvoyé.

note: type: Plain text
en: The pointer to the pathname.
fr: Un pointeur sur le nom du terminal.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<ctermid>()  function is thread-safe with exceptions.  It is not thread-safe if called with a NULL parameter.
fr: La fonction B<ctermid>() est sûre dans un contexte multithread avec exceptions. Elle n’est pas sûre dans un contexte multithread si appelée avec un paramètre NULL.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: The path returned may not uniquely identify the controlling terminal; it may, for example, be I</dev/tty>.
fr: Le chemin renvoyé n'identifie pas obligatoirement le terminal de contrôle de manière unique. Ce peut être, par exemple, I</dev/tty>.

note: in glibc 2.3.x, x >= 4, the glibc headers threw an error if ctermid() was given an argument; fixed in 2.4. type: Plain text
en: It is not assured that the program can open the terminal.
fr: Il n'est pas garanti que le programme puisse ouvrir le terminal.

note: type: TH
en: 2010-09-15
fr: 15 septembre 2010

note: type: Plain text
en: dprintf, vdprintf - print to a file descriptor
fr: dprintf, vdprintf - Écrire dans un descripteur de fichier

note: type: Plain text
en: B<dprintf>(), B<vdprintf>():
fr: B<dprintf>(), B<vdprintf>() :

note: type: TP
en: Since glibc 2.10:
fr: Depuis la glibc 2.10 :

note: type: TP
en: Before glibc 2.10:
fr: Avant la glibc 2.10 :

note: type: Plain text
en: The functions B<dprintf>()  and B<vdprintf>()  (as found in the glibc2 library) are exact analogs of B<fprintf>(3)  and B<vfprintf>(3), except that they output to a file descriptor I<fd> instead of to a I<stdio> stream.
fr: Les fonctions B<dprintf>() et B<vdprintf>() (telles qu'elles apparaissent dans la bibliothèque glibc2) sont les parfaits équivalents de B<fprintf>(3) et B<vfprintf>(3), si ce n'est qu'elles écrivent dans un descripteur de fichier I<fd> plutôt que dans un flux I<stdio>.

note: .SH NOTES These functions are GNU extensions, not in C or POSIX. Clearly, the names were badly chosen. Many systems (like MacOS) have incompatible functions called .BR dprintf (), usually some debugging version of .BR printf (3), perhaps with a prototype like .BI "void dprintf(int level, const char 
en: These functions are GNU extensions that are nowadays specified in POSIX.1-2008.
fr: Ces fonctions sont des extensions GNU qui sont désormais décrites dans POSIX.1-2008.

note: type: TH
en: 2009-02-23
fr: 23 février 2009

note: type: Plain text
en: fclose - close a stream
fr: fclose - Fermer un flux

note: type: Plain text
en: The B<fclose>()  function flushes the stream pointed to by I<fp> (writing any buffered output data using B<fflush>(3))  and closes the underlying file descriptor.
fr: La fonction B<fclose>() vide le flux pointé par I<fp> (en écrivant toute donnée de sortie en tampon avec B<fflush>(3)) et ferme le descripteur de fichier sous-jacent.

note: type: Plain text
en: Upon successful completion 0 is returned.  Otherwise, B<EOF> is returned and I<errno> is set to indicate the error.  In either case any further access (including another call to B<fclose>())  to the stream results in undefined behavior.
fr: Si la fonction réussit intégralement, elle renvoie 0, sinon elle renvoie B<EOF> et I<errno> contient le code d'erreur. Dans tous les cas, tout autre accès ultérieur au flux (y compris un autre appel de B<fclose>()) conduit à un comportement indéfini.

note: type: SH
en: ERRORS
fr: ERREURS

note: This error cannot occur unless you are mixing ANSI C stdio operations and low-level file operations on the same stream. If you do get this error, you must have closed the stream's low-level file descriptor using something like close(fileno(fp)). type: Plain text
en: The file descriptor underlying I<fp> is not valid.
fr: Le descripteur de fichier sous-jacent I<fp> est invalide.

note: type: Plain text
en: The B<fclose>()  function may also fail and set I<errno> for any of the errors specified for the routines B<close>(2), B<write>(2)  or B<fflush>(3).
fr: La fonction B<fclose>() peut également échouer et positionner I<errno> avec l'une des erreurs spécifiées par les foncions B<close>(2), B<write>(2) ou B<fflush>(3).

note: type: Plain text
en: Note that B<fclose>()  only flushes the user-space buffers provided by the C library.  To ensure that the data is physically stored on disk the kernel buffers must be flushed too, for example, with B<sync>(2)  or B<fsync>(2).
fr: Notez que B<fclose>() ne vide que les tampons d'espace utilisateur fournis par la bibliothèque C. Pour s'assurer que les données sont écrites physiquement sur le disque, il faut aussi vider les tampons du noyau à l'aide, par exemple, de B<sync>(2) ou B<fsync>(2).

note: type: Plain text
en: fcloseall - close all open streams
fr: fcloseall - Fermer tous les flux ouverts

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>stdio.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>stdio.hE<gt>>

note: type: Plain text
en: The B<fcloseall>()  function closes all of the calling process's open streams.  Buffered output for each stream is written before it is closed (as for B<fflush>(3)); buffered input is discarded.
fr: La fonction B<fcloseall>() ferme tous les flux ouverts des processus appelants. La sortie bufferisée de chaque flux est d'abord écrite puis fermée (comme avec B<fflush>(3))\ ; les entrées bufferisées ne sont pas traitées.

note: type: Plain text
en: The standard streams, I<stdin>, I<stdout>, and I<stderr> are also closed.
fr: Les flux standards I<stdin>, I<stdout> et I<stderr> sont aussi fermés.

note: type: Plain text
en: This function returns 0 if all files were successfully closed; on error, B<EOF> is returned.
fr: Cette fonction renvoie 0 si tous les fichiers se sont correctement fermés. Lors d'une erreur, elle renvoie B<EOF>.

note: type: Plain text
en: The B<fcloseall>()  function does not lock the streams, so it is not thread-safe.
fr: La fonction B<fcloseall>() ne verrouille pas les flux, et n’est donc pas sûre dans un contexte multithread.

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: TH
en: 2014-01-15
fr: 15 janvier 2014

note: type: Plain text
en: clearerr, feof, ferror, fileno - check and reset stream status
fr: clearerr, feof, ferror, fileno - Vérifier et réinitialiser l'état d'un flux

note: type: Plain text
en: B<fileno>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<fileno>()\ : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: The function B<clearerr>()  clears the end-of-file and error indicators for the stream pointed to by I<stream>.
fr: La fonction B<clearerr>() efface la fin de fichier et les indicateurs d'erreurs du flux pointé par I<stream>.

note: type: Plain text
en: The function B<feof>()  tests the end-of-file indicator for the stream pointed to by I<stream>, returning nonzero if it is set.  The end-of-file indicator can be cleared only by the function B<clearerr>().
fr: La fonction B<feof>() teste l'indicateur de fin de fichier du flux pointé par I<stream> et, renvoie une valeur non nulle si cet indicateur est actif. L'indicateur de fin de fichier ne peut être réinitialisé que par la fonction B<clearerr>().

note: type: Plain text
en: The function B<ferror>()  tests the error indicator for the stream pointed to by I<stream>, returning nonzero if it is set.  The error indicator can be reset only by the B<clearerr>()  function.
fr: La fonction B<ferror>() teste l'indicateur d'erreur du flux pointé par I<stream>, et renvoie une valeur non nulle si cet indicateur est actif. L'indicateur d'erreur ne peut être réinitialisé que par la fonction B<clearerr>().

note: type: Plain text
en: The function B<fileno>()  examines the argument I<stream> and returns its integer descriptor.
fr: La fonction B<fileno>() examine l'argument I<stream> et renvoie le descripteur de fichier, de type entier.

note: type: Plain text
en: For nonlocking counterparts, see B<unlocked_stdio>(3).
fr: Pour des versions de ces fonctions ignorant les verrouillages, voir B<unlocked_stdio>(3).

note: type: Plain text
en: These functions should not fail and do not set the external variable I<errno>.  (However, in case B<fileno>()  detects that its argument is not a valid stream, it must return -1 and set I<errno> to B<EBADF>.)
fr: Ces fonctions ne devraient pas échouer, et ne pas définir la variable I<errno>. (Toutefois, si B<fileno>() détecte que son argument n'est pas un flux valide, il doit renvoyer -1 et définir I<errno> avec B<EBADF>).

note: type: Plain text
en: The B<clearerr>(), B<feof>(), B<ferror>(), and B<fileno>()  functions are thread-safe.
fr: Les fonctions B<clearerr>(), B<feof>(), B<ferror>() et B<fileno>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The functions B<clearerr>(), B<feof>(), and B<ferror>()  conform to C89, C99, POSIX.1-2001, and POSIX.1-2008.
fr: Les fonctions B<clearerr>(), B<feof>(), et B<ferror>() sont conformes à C89, C99, POSIX.1-2001 et POSIX.1-2008.

note: type: Plain text
en: The function B<fileno>()  conforms to POSIX.1-2001 and POSIX.1-2008.
fr: La fonction B<fileno>() est conforme à POSIX.1-2001 et POSIX.1-2008.

note: type: TH
en: 2013-07-15
fr: 15 juillet 2013

note: type: Plain text
en: fflush - flush a stream
fr: fflush - Vider les tampons d'un flux

note: type: Plain text
en: For output streams, B<fflush>()  forces a write of all user-space buffered data for the given output or update I<stream> via the stream's underlying write function.  For input streams, B<fflush>()  discards any buffered data that has been fetched from the underlying file, but has not been consumed by the application.  The open status of the stream is unaffected.
fr: Pour les flux de sortie, B<fflush>() force l'écriture de toutes les données se trouvant dans les tampons de l'espace utilisateur, et met à jour le flux I<stream> à travers la fonction sous-jacente d'écriture. Pour les flux d'entrée, B<fflush>() ne traite pas toute donnée en tampon qui aurait été lue depuis le fichier sous-jacent mais qui n'aurait pas été consommée par l'application. Le statut d'ouverture du flux n'est pas affecté.

note: type: Plain text
en: If the I<stream> argument is NULL, B<fflush>()  flushes I<all> open output streams.
fr: Si l'argument I<stream> est NULL, B<fflush>() vide I<tous> les flux ouverts en sortie.

note: type: Plain text
en: For a nonlocking counterpart, see B<unlocked_stdio>(3).
fr: Pour une version de cette fonction ignorant les verrouillages, voir B<unlocked_stdio>(3).

note: type: Plain text
en: Upon successful completion 0 is returned.  Otherwise, B<EOF> is returned and I<errno> is set to indicate the error.
fr: Si elle réussit intégralement, cette fonction renvoie 0. Sinon, elle renvoie B<EOF>, et la variable I<errno> contient le code d'erreur.

note: type: Plain text
en: I<Stream> is not an open stream, or is not open for writing.
fr: I<stream> n'est pas ouvert, ou du moins pas en écriture.

note: type: Plain text
en: The function B<fflush>()  may also fail and set I<errno> for any of the errors specified for B<write>(2).
fr: La fonction B<fflush>() peut aussi échouer, et définir dans I<errno> n'importe quelles erreurs spécifiées par la routine B<write>(2).

note: type: Plain text
en: The B<fflush>()  function is thread-safe.
fr: La fonction B<fflush>() est sûre dans un contexte multithread.

note: Verified on: Solaris 8. type: Plain text
en: The standards do not specify the behavior for input streams.  Most other implementations behave the same as Linux.
fr: Les normes ne spécifient pas le comportement pour les flux d'entrée. La plupart des autres implémentations ont le même comportement que l'implémentation Linux.

note: type: Plain text
en: Note that B<fflush>()  only flushes the user-space buffers provided by the C library.  To ensure that the data is physically stored on disk the kernel buffers must be flushed too, for example, with B<sync>(2)  or B<fsync>(2).
fr: Remarquez que B<fflush>() ne vide que les tampons d'espace utilisateur fournis par la bibliothèque C. Pour s'assurer que les données sont écrites physiquement sur le disque, il faut aussi vider les tampons du noyau à l'aide par exemple de B<sync>(2) ou B<fsync>(2).

note: type: TH
en: 2013-12-31
fr: 31 décembre 2013

note: type: Plain text
en: fgetc, fgets, getc, getchar, ungetc - input of characters and strings
fr: fgetc, fgets, getc, getchar, ungetc - Saisie de caractères et de chaînes

note: type: Plain text
en: B<fgetc>()  reads the next character from I<stream> and returns it as an I<unsigned char> cast to an I<int>, or B<EOF> on end of file or error.
fr: B<fgetc>() lit le caractère suivant depuis le flux I<stream> et le renvoie sous forme d'un I<unsigned char>, transformé en I<int>, ou B<EOF> en cas d'erreur ou de fin de fichier.

note: type: Plain text
en: B<getc>()  is equivalent to B<fgetc>()  except that it may be implemented as a macro which evaluates I<stream> more than once.
fr: B<getc>() est équivalent à B<fgetc>() sauf qu'il peut être implémenté sous forme de macro, qui évalue l'argument I<stream> plusieurs fois.

note: type: Plain text
en: B<getchar>()  is equivalent to B<getc(>I<stdin>B<)>.
fr: B<getchar>() est équivalent à B<getc(>I<stdin>B<)>.

note: type: Plain text
en: B<fgets>()  reads in at most one less than I<size> characters from I<stream> and stores them into the buffer pointed to by I<s>.  Reading stops after an B<EOF> or a newline.  If a newline is read, it is stored into the buffer.  A terminating null byte (\(aq\e0\(aq)  is stored after the last character in the buffer.
fr: B<fgets>() lit au plus I<size - 1> caractères depuis I<stream> et les place dans le tampon pointé par I<s>. La lecture s'arrête après B<EOF> ou un retour chariot. Si un retour chariot (newline) est lu, il est placé dans le tampon. Un octet nul (« \e0 ») final est placé à la fin de la ligne.

note: type: Plain text
en: B<ungetc>()  pushes I<c> back to I<stream>, cast to I<unsigned char>, where it is available for subsequent read operations.  Pushed-back characters will be returned in reverse order; only one pushback is guaranteed.
fr: B<ungetc>() replace le caractère I<c> dans le flux I<stream>, en le transformant en I<unsigned char>, où il sera disponible pour une lecture ultérieure. Les caractères replacés seront renvoyés en ordre inverse. Le fonctionnement n'est garanti que pour le replacement d'un seul caractère.

note: type: Plain text
en: Calls to the functions described here can be mixed with each other and with calls to other input functions from the I<stdio> library for the same input stream.
fr: Les fonctions décrites ci-dessus peuvent être utilisées conjointement, ainsi qu'avec les autres fonctions de lecture de la bibliothèque I<stdio>.

note: type: Plain text
en: B<fgetc>(), B<getc>()  and B<getchar>()  return the character read as an I<unsigned char> cast to an I<int> or B<EOF> on end of file or error.
fr: B<fgetc>(), B<getc>() et B<getchar>() renvoient un caractère, lu comme un I<unsigned char>, et transformé en I<int>, ou B<EOF> à la fin du fichier, ou en cas d'erreur.

note: type: Plain text
en: B<fgets>()  returns I<s> on success, and NULL on error or when end of file occurs while no characters have been read.
fr: B<gets>() renvoie le pointeur I<s> en cas de succès et NULL en cas d'erreur, ou si la fin de fichier est atteinte avant d'avoir pu lire au moins un caractère.

note: type: Plain text
en: B<ungetc>()  returns I<c> on success, or B<EOF> on error.
fr: B<ungetc>() renvoie I<c> s'il réussit, ou B<EOF> en cas d'erreur.

note: type: Plain text
en: It is not advisable to mix calls to input functions from the I<stdio> library with low-level calls to B<read>(2)  for the file descriptor associated with the input stream; the results will be undefined and very probably not what you want.
fr: Il est fortement déconseillé de mélanger les appels aux fonctions de lecture de la bibliothèque I<stdio> avec les appels aux fonctions de lecture bas niveau B<read>(2) sur le descripteur de fichier associé au flux. Les résultats sont indéfinis, et très probablement indésirables.

note: type: TH
en: 2013-04-19
fr: 19 avril 2013

note: type: Plain text
en: fgetwc, getwc - read a wide character from a FILE stream
fr: fgetwc, getwc - Lire une chaîne de caractères larges dans un flux FILE

note: type: Plain text
en: The B<fgetwc>()  function is the wide-character equivalent of the B<fgetc>(3)  function.  It reads a wide character from I<stream> and returns it.  If the end of stream is reached, or if I<ferror(stream)> becomes true, it returns B<WEOF>.  If a wide-character conversion error occurs, it sets I<errno> to B<EILSEQ> and returns B<WEOF>.
fr: La fonction B<fgetwc>() est l'équivalent pour les caractères larges de la fonction B<fgetc>(3). Elle lit un caractère large depuis I<stream> et le renvoie. Si la fin du fichier est rencontrée, ou si I<ferror(stream)> devient vrai, elle retourne B<WEOF>. Si une erreur de conversion de caractère large se produit, I<errno> est défini à B<EILSEQ> et B<WEOF> est retourné.

note: type: Plain text
en: The B<getwc>()  function or macro functions identically to B<fgetwc>().  It may be implemented as a macro, and may evaluate its argument more than once.  There is no reason ever to use it.
fr: La fonction ou la macro B<getwc>() fonctionne de manière identique à B<fgetwc>(). Elle peut être implémentée sous forme de macro, et peut évaluer ses arguments plus d'une fois. Il n'y a aucune raison de ne pas l'utiliser.

note: type: Plain text
en: The B<fgetwc>()  function returns the next wide-character from the stream, or B<WEOF>.  In the event of an error, I<errno> is set to indicate the cause.
fr: La fonction B<fgetwc>() renvoie le caractère large suivant du flux ou B<WEOF>. En cas d'erreur, I<errno> permet d'identifier la cause de l'erreur.

note: type: Plain text
en: Apart from the usual ones, there is
fr: En plus des erreurs habituelles, il y a :

note: type: Plain text
en: The data obtained from the input stream does not form a valid character.
fr: Les données lues depuis le flux d'entrée ne forment pas des caractères corrects.

note: type: Plain text
en: The behavior of B<fgetwc>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<fgetwc>() dépend de la catégorie B<LC_CTYPE> de la localisation actuelle.

note: type: Plain text
en: In the absence of additional information passed to the B<fopen>(3)  call, it is reasonable to expect that B<fgetwc>()  will actually read a multibyte sequence from the stream and then convert it to a wide character.
fr: En l'absence d'informations supplémentaires passées à l'appel B<fopen>(3), il est normal de présumer que B<fgetwc>() va lire en réalité une séquence multioctet depuis le flux puis la convertir en une chaîne de caractères larges.

note: type: TH
en: 2013-07-23
fr: 23 juillet 2013

note: type: Plain text
en: flockfile, ftrylockfile, funlockfile - lock FILE for stdio
fr: flockfile, ftrylockfile, funlockfile - Verrouiller un flux FILE pour stdio

note: type: Plain text
en: All functions shown above:
fr: Pour toutes les fonctions ci-dessus :

note: type: Plain text
en: The stdio functions are thread-safe.  This is achieved by assigning to each I<FILE> object a lockcount and (if the lockcount is nonzero)  an owning thread.  For each library call, these functions wait until the I<FILE> object is no longer locked by a different thread, then lock it, do the requested I/O, and unlock the object again.
fr: Les fonctions stdio peuvent être utilisées dans un contexte multithread. Ceci est réalisé en affectant à chaque objet de type I<FILE> un «\ compteur de verrouillage\ » et (si le «\ compteur de verrouillage\ » est non nul) un thread propriétaire. Lors de chaque appel à la bibliothèque, ces fonctions attendent jusqu'à ce que l'objet I<FILE> ne soit plus verrouillé par un thread différent, puis elles le verrouillent, réalisent les entrées/sorties demandées, et libèrent l'objet.

note: type: Plain text
en: (Note: this locking has nothing to do with the file locking done by functions like B<flock>(2)  and B<lockf>(3).)
fr: (Remarque\ : ce verrouillage n'a rien à voir avec le verrouillage de fichier réalisé par des fonctions comme B<flock>(2) et B<lockf>(3).)

note: type: Plain text
en: All this is invisible to the C-programmer, but there may be two reasons to wish for more detailed control.  On the one hand, maybe a series of I/O actions by one thread belongs together, and should not be interrupted by the I/O of some other thread.  On the other hand, maybe the locking overhead should be avoided for greater efficiency.
fr: Tout ceci est invisible au programmeur en C, mais il existe deux raisons de souhaiter un contrôle plus fin. D'une part, un thread peut réaliser une série d'entrées/sorties interdépendantes, ces opérations ne devant pas être interrompues par les entrées/sorties d'autres threads. D'autre part, on peut désirer supprimer la surcharge induite par ce verrouillage afin d'obtenir de meilleures performances.

note: type: Plain text
en: To this end, a thread can explicitly lock the I<FILE> object, then do its series of I/O actions, then unlock.  This prevents other threads from coming in between.  If the reason for doing this was to achieve greater efficiency, one does the I/O with the nonlocking versions of the stdio functions: with B<getc_unlocked>(3)  and B<putc_unlocked>(3)  instead of B<getc>(3)  and B<putc>(3).
fr: À cette fin, un thread peut verrouiller explicitement un objet de type I<FILE>, puis réaliser sa série d'entrées/sorties, et enfin, relâcher le verrou. Cela empêche les autres threads d'intervenir sur le flux. Si la motivation du verrouillage est la recherche de meilleures performances, on peut réaliser l'entrée/sortie à l'aide des versions non bloquantes des fonctions stdio\ : avec B<getc_unlocked>(3) et B<putc_unlocked>(3) au lieu de B<getc>(3) et B<putc>(3).

note: type: Plain text
en: The B<flockfile>()  function waits for I<*filehandle> to be no longer locked by a different thread, then makes the current thread owner of I<*filehandle>, and increments the lockcount.
fr: La fonction B<flockfile>() attend jusqu'à ce que I<*filehandle> ne soit plus verrouillé par un autre thread, puis affecte I<*filehandle> au thread actuel, et incrémente le «\ compteur de verrouillage\ ».

note: type: Plain text
en: The B<funlockfile>()  function decrements the lock count.
fr: La fonction B<funlockfile>() décrémente le «\ compteur de verrouillage\ ».

note: type: Plain text
en: The B<ftrylockfile>()  function is a nonblocking version of B<flockfile>().  It does nothing in case some other thread owns I<*filehandle>, and it obtains ownership and increments the lockcount otherwise.
fr: La fonction B<ftrylockfile>() est une version non bloquante de B<flockfile>(). Elle ne fait rien lorsqu'un autre thread est propriétaire de I<*filehandle>, sinon, elle se l'approprie et incrémente le «\ compteur de verrouillage\ ».

note: type: Plain text
en: The B<ftrylockfile>()  function returns zero for success (the lock was obtained), and nonzero for failure.
fr: La fonction B<ftrylockfile>() renvoie zéro en cas de succès (le verrou a été obtenu), et une valeur non nulle en cas d'échec.

note: type: Plain text
en: None.
fr: Aucune.

note: type: Plain text
en: The B<flockfile>(), B<ftrylockfile>(), and B<funlockfile>()  functions are thread-safe.
fr: Les fonctions B<flockfile>(), B<ftrylockfile>() et B<funlockfile>() sont sûres dans un contexte multithread.

note: type: SH
en: AVAILABILITY
fr: DISPONIBILITÉ

note: type: Plain text
en: These functions are available when B<_POSIX_THREAD_SAFE_FUNCTIONS> is defined.  They are in libc since libc 5.1.1 and in glibc since glibc 2.0.
fr: Ces fonctions sont disponibles lorsque B<_POSIX_THREAD_SAFE_FUNCTIONS> est défini. Elles sont présentes dans la libc depuis la version\ 5.1.1 et dans la glibc depuis la version\ 2.0.

note: type: TH
en: 2014-04-06
fr: 6 avril 2014

note: type: Plain text
en: fmemopen, open_memstream, open_wmemstream - open memory as stream
fr: fmemopen, open_memstream, open_wmemstream  - Ouvrir de la mémoire comme un flux

note: type: Plain text
en: B<fmemopen>(), B<open_memstream>(), B<open_wmemstream>():
fr: B<fmemopen>(), B<open_memstream>(), B<open_wmemstream>() :

note: type: Plain text
en: The B<fmemopen>()  function opens a stream that permits the access specified by I<mode>.  The stream allows I/O to be performed on the string or memory buffer pointed to by I<buf>.  This buffer must be at least I<size> bytes long.
fr: La fonction B<fmemopen>() ouvre un flux qui permet l'accès spécifié par I<mode>. Le flux permet d'effectuer des entrées sorties sur la chaîne ou la mémoire du tampon pointée par I<buf>. Ce tampon doit au moins être d'une longueur de I<size> octets.

note: type: Plain text
en: The argument I<mode> is the same as for B<fopen>(3).  If I<mode> specifies an append mode, then the initial file position is set to the location of the first null byte (\(aq\e0\(aq) in the buffer; otherwise the initial file position is set to the start of the buffer.  Since glibc 2.9, the letter \(aqb\(aq may be specified as the second character in I<mode>.  This provides "binary" mode: writes don't implicitly add a terminating null byte, and B<fseek>(3)  B<SEEK_END> is relative to the end of the buffer (i.e., the value specified by the I<size> argument), rather than the current string length.
fr: L'argument I<mode> est le même que celui de la fonction B<fopen>(3). Si I<mode> indique un mode d'ajout («\ append mode\ »), alors la position initiale du fichier est définie à la position du premier octet nul (« \e0 ») du tampon\ ; sinon la position initiale est définie au début du tampon. Depuis la glibc\ 2.9, la lettre «\ b\ » peut être indiquée comme second caractère de I<mode>. Cela fournit le mode binaire\ : une écriture n'implique pas d'ajouter un octet nul final et B<fseek>(3) B<SEEK_END> est relative à la fin du tampon (c'est-à-dire la valeur indiquée par I<size>) au lieu de la taille de la chaîne actuelle.

note: type: Plain text
en: When a stream that has been opened for writing is flushed (B<fflush>(3))  or closed (B<fclose>(3)), a null byte is written at the end of the buffer if there is space.  The caller should ensure that an extra byte is available in the buffer (and that I<size> counts that byte)  to allow for this.
fr: Lorsqu'un flux ouvert en écriture est vidé (consultez B<fflush>(3)), ou fermé (consultez B<fclose>(3)), un octet nul est écrit à la fin du tampon s'il y a de la place. L'appelant devrait s'assurer qu'un octet supplémentaire est disponible dans le tampon (et que I<size> en tient compte) pour permettre ceci.

note: See http://sourceware.org/bugzilla/show_bug.cgi?id=1995 and http://sources.redhat.com/ml/libc-alpha/2006-04/msg00064.html type: Plain text
en: Attempts to write more than I<size> bytes to the buffer result in an error.  (By default, such errors will be visible only when the I<stdio> buffer is flushed.  Disabling buffering with I<setbuf(fp,\ NULL)> may be useful to detect errors at the time of an output operation.  Alternatively, the caller can explicitly set I<buf> as the stdio stream buffer, at the same time informing stdio of the buffer's size, using I<setbuffer(fp, buf, size)>.)
fr: Essayer d'écrire plus de I<size> octets dans le tampon crée une erreur. (Par défaut, de telles erreurs ne sont seulement visibles que lorsque le tampon I<stdio> est vidé. Désactiver la mise en tampon avec I<setbuf(fp,\ NULL)> peut être utile pour détecter les erreurs au moment d'une opération de sortie. Alternativement, l'appelant peut explicitement définir I<buf> comme un tampon de flux stdio, au même moment en informant stdio de la taille du tampon avec I<setbuffer(fp, buf, size)>).

note: type: Plain text
en: In a stream opened for reading, null bytes (\(aq\e0\(aq) in the buffer do not cause read operations to return an end-of-file indication.  A read from the buffer will only indicate end-of-file when the file pointer advances I<size> bytes past the start of the buffer.
fr: Avec un flux ouvert en lecture, un octet nul dans le tampon ne crée pas d'opérations de lecture et renvoie une indication de fin de fichier. Une lecture depuis le tampon indiquera seulement la fin du fichier quand le pointeur de fichier aura avancé de plus de I<size> octets par rapport au début du tampon.

note: type: Plain text
en: If I<buf> is specified as NULL, then B<fmemopen>()  dynamically allocates a buffer I<size> bytes long.  This is useful for an application that wants to write data to a temporary buffer and then read it back again.  The buffer is automatically freed when the stream is closed.  Note that the caller has no way to obtain a pointer to the temporary buffer allocated by this call (but see B<open_memstream>()  below).
fr: Si l'argument I<buf> vaut NULL, alors la fonction B<fmemopen>() alloue dynamiquement un tampon de I<size> octets. C'est utile pour les applications qui veulent écrire des données dans un tampon temporaire et les lire ensuite. Le tampon est automatiquement supprimé lorsque le flux est fermé. Notez que l'appelant ne peut pas obtenir un pointeur vers le tampon alloué temporairement avec cette fonction (c'est possible avec B<open_memstream>(), ci-dessous).

note: type: Plain text
en: The B<open_memstream>()  function opens a stream for writing to a buffer.  The buffer is dynamically allocated (as with B<malloc>(3)), and automatically grows as required.  After closing the stream, the caller should B<free>(3)  this buffer.
fr: La fonction B<open_memstream>() ouvre un flux en écriture vers un tampon. Le tampon est dynamiquement alloué (comme avec B<malloc>(3)) et grandit automatiquement à la demande. Après la fermeture du flux, l'appelant doit libérer (B<free>(3)) ce tampon.

note: type: Plain text
en: When the stream is closed (B<fclose>(3))  or flushed (B<fflush>(3)), the locations pointed to by I<ptr> and I<sizeloc> are updated to contain, respectively, a pointer to the buffer and the current size of the buffer.  These values remain valid only as long as the caller performs no further output on the stream.  If further output is performed, then the stream must again be flushed before trying to access these variables.
fr: Lorsqu'un flux est fermé (B<fclose>(3)) ou vidé (B<fflush>(3)), les adresses pointées par I<ptr> et I<sizeloc> sont mises à jour, avec respectivement, un pointeur vers le tampon et la taille du tampon actuel. Ces valeurs restent valides tant que l'appelant n'effectue pas de sortie sur le flux. Si d'autres sorties sont réalisées, alors le flux doit être ne nouveau vidé avant d'essayer d'accéder à ces variables.

note: type: Plain text
en: A null byte is maintained at the end of the buffer.  This byte is I<not> included in the size value stored at I<sizeloc>.
fr: Un octet nul est conservé à la fin du tampon. Cet octet I<n'est pas> inclus dans la valeur de la taille stockée dans I<sizeloc>.

note: type: Plain text
en: The stream's file position can be changed with B<fseek>(3)  or B<fseeko>(3).  Moving the file position past the end of the data already written fills the intervening space with zeros.
fr: La position du flux de fichier peut être changée avec B<fseek>(3) ou B<fseeko>(3). Déplacer la position après la fin des données déjà écrites remplit l'intervalle vide avec des zéros.

note: type: Plain text
en: The B<open_wmemstream>()  is similar to B<open_memstream>(), but operates on wide characters instead of bytes.
fr: La fonction B<open_wmemstream>() est similaire à B<open_memstream>(), mais elle opère sur les caractères larges et non sur des octets.

note: type: Plain text
en: Upon successful completion B<fmemopen>(), B<open_memstream>()  and B<open_wmemstream>()  return a I<FILE> pointer.  Otherwise, NULL is returned and I<errno> is set to indicate the error.
fr: Si elles réussissent intégralement, les fonctions B<fmemopen>(), B<open_memstream>() et B<open_wmemstream>() renvoient un pointeur de type I<FILE>. Sinon, elles renvoient NULL et I<errno> est définie avec le code d'erreur.

note: type: Plain text
en: B<fmemopen>()  and B<open_memstream>()  were already available in glibc 1.0.x.  B<open_wmemstream>()  is available since glibc 2.4.
fr: B<fmemopen>() est B<open_memstream>() sont déjà disponibles dans la glibc 1.0.x. B<open_wmemstream>() est disponible depuis la glibc 2.4.

note: type: Plain text
en: POSIX.1-2008.  These functions are not specified in POSIX.1-2001, and are not widely available on other systems.
fr: POSIX.1-2008. Ces fonctions ne sont pas spécifiées dans POSIX.1-2001 et ne sont que rarement disponible sur d'autres systèmes.

note: http://austingroupbugs.net/view.php?id=396 type: Plain text
en: POSIX.1-2008 specifies that \(aqb\(aq in I<mode> shall be ignored.  However, Technical Corrigendum 1 adjusts the standard to allow implementation-specific treatment for this case, thus permitting the glibc treatment of \(aqb\(aq.
fr: POSIX.1-2008 spécifie que « b » dans I<mode> sera ignoré. Cependant, Technical Corrigendum 1 ajuste la norme pour permettre un traitement spécifique à l'implémentation dans ce cas, permettant ainsi à la glibc de traiter « b ».

note: type: Plain text
en: There is no file descriptor associated with the file stream returned by these functions (i.e., B<fileno>(3)  will return an error if called on the returned stream).
fr: Il n'y a pas de descripteur de fichier associé avec le flux renvoyé par ces fonctions (par exemple, B<fileno>(3) retournera une erreur si elle est appelée avec un tel flux).

note: http://sourceware.org/bugzilla/show_bug.cgi?id=1996 type: Plain text
en: In glibc before version 2.7, seeking past the end of a stream created by B<open_memstream>()  does not enlarge the buffer; instead the B<fseek>(3)  call fails, returning -1.
fr: Avant la glibc 2.7, un positionnement après la fin d'un flux crée par B<open_memstream>() n'agrandit pas le tampon ; à la place, l'appel à B<fseek>() échoue et renvoie -1.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=11216 type: Plain text
en: If I<size> is specified as zero, B<fmemopen>()  fails with the error B<EINVAL>.  It would be more consistent if this case successfully created a stream that then returned end of file on the first attempt at reading.  Furthermore, POSIX.1-2008 does not specify a failure for this case.
fr: Si I<size> est indiqué comme nul, B<fmemopen>() échoue avec l'erreur B<EINVAL>. Il serait plus cohérent dans ce cas de créer un flux renvoyant la fin de fichier au premier essai de lecture. De plus, POSIX.1-2008 ne spécifie pas d'échec dans ce cas.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=13152 type: Plain text
en: Specifying append mode ("a" or "a+") for B<fmemopen>()  sets the initial file position to the first null byte, but (if the file offset is reset to a location other than the end of the stream)  does not force subsequent writes to append at the end of the stream.
fr: Indiquer un mode d'ajout (« a » ou « a+ ») pour B<fmemopen>() définit la position initiale du fichier au premier octet nul, mais (si le décalage du fichier est réinitialisé à un autre endroit que la fin du flux) ne force pas les écritures suivantes à ajouter à la fin du flux.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=13151 type: Plain text
en: If the I<mode> argument to B<fmemopen>()  specifies append ("a" or "a+"), and the I<size> argument does not cover a null byte in I<buf>, then, according to POSIX.1-2008, the initial file position should be set to the next byte after the end of the buffer.  However, in this case the glibc B<fmemopen>()  sets the file position to -1.
fr: Si l'argument I<mode> de B<fmemopen>() indique un ajout (« a » ou « a+ »), et que l'argument I<size> ne couvre pas d'octet nul dans I<buf>, alors, d'après POSIX.1-2008, la position initiale du fichier devrait être définie à l'octet qui suit la fin du tampon. Cependant, dans ce cas le B<fmemopen>() de la glibc définie la position du fichier à -1.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=12836 type: Plain text
en: To specify binary mode for B<fmemopen>()  the \(aqb\(aq must be the I<second> character in I<mode>.  Thus, for example, "wb+" has the desired effect, but "w+b" does not.  This is inconsistent with the treatment of I<mode> by B<fopen>(3).
fr: Pour indiquer le mode binaire de B<fmemopen>(), le « b » doit être le deuxième caractère de I<mode>. Ainsi, par exemple, « wb+ » a le comportement attendu, mais pas « w+b ». Ce n'est pas cohérent avec le traitement de I<mode> par B<fopen>(3).

note: http://sourceware.org/bugzilla/show_bug.cgi?id=6544 type: Plain text
en: The glibc 2.9 addition of "binary" mode for B<fmemopen>()  silently changed the ABI: previously, B<fmemopen>()  ignored \(aqb\(aq in I<mode>.
fr: L'ajout du mode « binaire » dans la glibc 2.9 pour B<fmemopen>() a modifié silencieusement l'ABI : auparavant, B<fmemopen>() ignorait « b » dans I<mode>.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The program below uses B<fmemopen>()  to open an input buffer, and B<open_memstream>()  to open a dynamically sized output buffer.  The program scans its input string (taken from the program's first command-line argument) reading integers, and writes the squares of these integers to the output buffer.  An example of the output produced by this program is the following:
fr: Le programme ci-dessous utilise B<fmemopen>() pour ouvrir un tampon d'entrée et B<open_memstream>() pour ouvrir un tampon de sortie de taille dynamique. Ce programme scrute la chaînes en entrée (récupérée du premier argument de la ligne de commande du programme) sous forme d'entiers, et écrit le carré de ces entiers dans le tampon de sortie. Voici un exemple de la sortie produite par ce programme\ :

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

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s E<lt>fileE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Utilisation : %s E<lt>fichierE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en: fmtmsg - print formatted error messages
fr: fmtmsg - Afficher des messages d'erreur formatés

note: type: Plain text
en: This function displays a message described by its arguments on the device(s)  specified in the I<classification> argument.  For messages written to I<stderr>, the format depends on the B<MSGVERB> environment variable.
fr: Cette fonction affiche un message décrit par ses arguments sur le(s) périphérique(s) spécifié(s) par le paramètre I<classification>. Pour les messages écrits sur I<stderr>, le format dépend de la variable d'environnement B<MSGVERB>.

note: type: Plain text
en: The I<label> argument identifies the source of the message.  The string must consist of two colon separated parts where the first part has not more than 10 and the second part not more than 14 characters.
fr: Le paramètre I<label> identifie la source du message. La chaîne doit être composée en deux parties, séparées par le caractère deux-points «\ :\ », où la première partie ne comporte pas plus de 10 caractères et la seconde, pas plus de 14.

note: type: Plain text
en: The I<text> argument describes the condition of the error.
fr: Le paramètre I<text> décrit la condition de l'erreur.

note: type: Plain text
en: The I<action> argument describes possible steps to recover from the error.  If it is printed, it is prefixed by "TO FIX: ".
fr: Le paramètre I<action> décrit les étapes possibles pour récupérer l'erreur. Si elle est affichée, elle sera préfixée par «\TO FIX:\ ».

note: type: Plain text
en: The I<tag> argument is a reference to the online documentation where more information can be found.  It should contain the I<label> value and a unique identification number.
fr: Le paramètre I<tag> est une référence à la documentation en ligne où l'on pourra trouver plus d'informations. Il devrait contenir la valeur I<label> et un numéro d'identification unique.

note: type: SS
en: Dummy arguments
fr: Paramètres factices

note: type: Plain text
en: Each of the arguments can have a dummy value.  The dummy classification value B<MM_NULLMC> (0L) does not specify any output, so nothing is printed.  The dummy severity value B<NO_SEV> (0) says that no severity is supplied.  The values B<MM_NULLLBL>, B<MM_NULLTXT>, B<MM_NULLACT>, B<MM_NULLTAG> are synonyms for I<((char\ *)\ 0)>, the empty string, and B<MM_NULLSEV> is a synonym for B<NO_SEV>.
fr: Chacun des paramètres peut avoir une valeur factice. La valeur de classification factice B<MM_NULLMC> (0L) ne spécifie aucune sortie, ainsi, rien n'est affiché. La valeur de sévérité factice B<NO_SEV> (0) signifie qu'aucune sévérité n'est fournie. Les valeurs B<MM_NULLLBL>, B<MM_NULLTXT>, B<MM_NULLACT>, B<MM_NULLTAG> sont des synonymes de I<((char\ *) 0)>, la chaîne vide, et B<MM_NULLSEV> est un synonyme de B<NO_SEV>.

note: type: SS
en: The classification argument
fr: Le paramètre classification

note: type: Plain text
en: The I<classification> argument is the sum of values describing 4 types of information.
fr: Le paramètre I<classification> est la somme de valeurs décrivant 4 types d'informations.

note: type: Plain text
en: The first value defines the output channel.
fr: La première valeur définit le canal de sortie.

note: type: Plain text
en: Output to I<stderr>.
fr: Sortie sur I<stderr>.

note: type: Plain text
en: Output to the system console.
fr: Sortie sur la console du système.

note: type: Plain text
en: Output to both.
fr: Sortie sur les deux.

note: type: Plain text
en: The second value is the source of the error:
fr: La deuxième valeur est la source de l'erreur\ :

note: type: Plain text
en: A hardware error occurred.
fr: Une erreur matérielle est survenue.

note: type: Plain text
en: A firmware error occurred.
fr: Une erreur micro-logicielle («\ firmware\ ») est survenue.

note: type: Plain text
en: A software error occurred.
fr: Une erreur logicielle est survenue.

note: type: Plain text
en: The third value encodes the detector of the problem:
fr: La troisième valeur encode le détecteur du problème\ :

note: type: Plain text
en: It is detected by an application.
fr: L'erreur a été détectée par une application.

note: type: Plain text
en: It is detected by a utility.
fr: L'erreur a été détectée par un utilitaire.

note: type: Plain text
en: It is detected by the operating system.
fr: L'erreur a été détectée par le système d'exploitation.

note: type: Plain text
en: The fourth value shows the severity of the incident:
fr: La quatrième valeur indique la gravité de l'incident\ :

note: type: Plain text
en: It is a recoverable error.
fr: L'erreur est récupérable.

note: type: Plain text
en: It is a nonrecoverable error.
fr: L'erreur n'est pas récupérable.

note: type: SS
en: The severity argument
fr: Le paramètre «\ severity\ »

note: type: Plain text
en: The I<severity> argument can take one of the following values:
fr: Le paramètre I<severity> peut prendre l'une des valeurs suivantes\ :

note: type: Plain text
en: No severity is printed.
fr: Aucune sévérité ne sera affichée.

note: type: Plain text
en: This value is printed as HALT.
fr: Cette valeur est affichée en tant que HALT.

note: type: Plain text
en: This value is printed as ERROR.
fr: Cette valeur est affichée en tant que ERROR.

note: type: Plain text
en: This value is printed as WARNING.
fr: Cette valeur est affichée en tant que WARNING.

note: type: Plain text
en: This value is printed as INFO.
fr: Cette valeur est affichée en tant que INFO.

note: type: Plain text
en: The numeric values are between 0 and 4.  Using B<addseverity>(3)  or the environment variable B<SEV_LEVEL> you can add more levels and strings to print.
fr: Les valeurs numériques sont comprises entre 0 et 4. Utiliser B<addseverity>(3) ou la variable d'environnement B<SEV_LEVEL> vous permet d'ajouter plus de niveaux et d'afficher des messages.

note: type: Plain text
en: The function can return 4 values:
fr: La fonction peut retourner 4 valeurs\ :

note: type: Plain text
en: Everything went smooth.
fr: Tout c'est bien passé.

note: type: Plain text
en: Complete failure.
fr: Échec complet.

note: type: Plain text
en: Error writing to I<stderr>.
fr: Erreur lors de l'écriture sur I<stderr>.

note: type: Plain text
en: Error writing to the console.
fr: Erreur lors de l'écriture sur la console.

note: type: SH
en: ENVIRONMENT
fr: ENVIRONNEMENT

note: type: Plain text
en: The environment variable B<MSGVERB> ("message verbosity") can be used to suppress parts of the output to I<stderr>.  (It does not influence output to the console.)  When this variable is defined, is non-NULL, and is a colon-separated list of valid keywords, then only the parts of the message corresponding to these keywords is printed.  Valid keywords are "label", "severity", "text", "action" and "tag".
fr: La variable d'environnement B<MSGVERB> («\ verbosité du message\ ») peut être utilisée pour supprimer des parties de la sortie vers I<stderr> (cela n'a pas d'influence sur la sortie vers la console). Lorsque cette variable est définie, non vide et que c'est une liste de mots clés valides séparés par le caractère deux-points, seules les parties du message correspondant à ces mots clés seront affichées. Les mots-clés valides sont «\ label\ », «\ severity\ », «\ text\ », «\ action\ » et «\ tag\ ».

note: type: Plain text
en: The environment variable B<SEV_LEVEL> can be used to introduce new severity levels.  By default, only the five severity levels described above are available.  Any other numeric value would make B<fmtmsg>()  print nothing.  If the user puts B<SEV_LEVEL> with a format like
fr: La variable d'environnement B<SEV_LEVEL> peut être utilisée afin d'introduire de nouveaux niveaux de sévérité. Par défaut, seuls les cinq niveaux de sévérité décrits précédemment sont disponibles. Toute autre valeur numérique fera que la fonction B<fmtmsg>() n'affichera rien. Si l'utilisateur positionne B<SEV_LEVEL> avec un format comme

note: type: Plain text
en: in the environment of the process before the first call to B<fmtmsg>(), where each description is of the form
fr: dans l'environnement du processus avant le premier appel à B<fmtmsg>(), où chaque description est de la forme

note: type: Plain text
en: severity-keyword,level,printstring
fr: sévérité, niveau, chaîne

note: type: Plain text
en: then B<fmtmsg>()  will also accept the indicated values for the level (in addition to the standard levels 0-4), and use the indicated printstring when such a level occurs.
fr: alors B<fmtmsg>() acceptera également les valeurs indiquées pour le niveau (en plus des niveaux standard [0, 4]), et utilisera la chaîne indiquée lorsqu'un tel niveau surviendra.

note: type: Plain text
en: The severity-keyword part is not used by B<fmtmsg>()  but it has to be present.  The level part is a string representation of a number.  The numeric value must be a number greater than 4.  This value must be used in the severity argument of B<fmtmsg>()  to select this class.  It is not possible to overwrite any of the predefined classes.  The printstring is the string printed when a message of this class is processed by B<fmtmsg>().
fr: La partie «\ sévérité\ » n'est pas utilisée par B<fmtmsg>() mais elle doit être présente. La partie «\ niveau\ » est la représentation alphabétique d'un nombre. La valeur numérique doit être un nombre strictement supérieur à 4. Cette valeur doit être utilisée dans le paramètre «\ sévérité\ » de B<fmtmsg>() pour sélectionner cette classe. Il n'est pas possible de surcharger les classes prédéfinies. La partie «\ chaîne\ » est la chaîne qui sera affichée lorsqu'un message de cette classe est traité par B<fmtmsg>().

note: type: Plain text
en: B<fmtmsg>()  is provided in glibc since version 2.1.
fr: B<fmtmsg>() est fournie par la glibc depuis la version 2.1.

note: type: Plain text
en: Before glibc 2.16, the B<fmtmsg>()  function uses a static variable that is not protected, so it is not thread-safe.
fr: Avant glibc 2.16, la fonction B<fmtmsg>() utilisait une variable statique non protégée, et n’était donc pas sûre dans un contexte multithread.

note: Modified in commit 7724defcf8873116fe4efab256596861eef21a94 type: Plain text
en: Since glibc 2.16, the B<fmtmsg>()  function uses a lock to protect the static variable, so it is thread-safe.
fr: Depuis glibc 2.16, la fonction B<fmtmsg>() utilise un verrou de protection de la variable statique, donc elle est sûre dans un contexte multithread.

note: type: Plain text
en: The functions B<fmtmsg>()  and B<addseverity>(3), and environment variables B<MSGVERB> and B<SEV_LEVEL> come from System V.  The function B<fmtmsg>()  and the environment variable B<MSGVERB> are described in POSIX.1-2001.
fr: Les fonctions B<fmtmsg>(), B<addseverity>(3), les variables d'environnement B<MSGVERB> et B<SEV_LEVEL> proviennent de System V. La fonction B<fmtmsg>() et la variable d'environnement B<MSGVERB> sont décrites dans POSIX.1-2001.

note: type: Plain text
en: System V and UnixWare man pages tell us that these functions have been replaced by "pfmt() and addsev()" or by "pfmt(), vpfmt(), lfmt(), and vlfmt()", and will be removed later.
fr: Les pages de manuel System V et UnixWare disent que ces fonctions ont été remplacées par «\ pfmt() et addsev()\ » ou par «\ pfmt(), vpfmt(), lfmt(), et vlfmt()\ », et seront supprimées par la suite.

note: type: Plain text
en: The output should be:
fr: La sortie devrait être\ :

note: type: Plain text
en: and after
fr: et après

note: type: Plain text
en: the output becomes:
fr: la sortie devient\ :

note: type: TH
en: 2012-04-22
fr: 22 avril 2012

note: type: Plain text
en: fopen, fdopen, freopen - stream open functions
fr: fopen, fdopen, freopen - Fonctions d'ouverture de flux

note: type: Plain text
en: B<fdopen>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: B<fdopen>()\ : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: The B<fopen>()  function opens the file whose name is the string pointed to by I<path> and associates a stream with it.
fr: La fonction B<fopen>() ouvre le fichier dont le nom est contenu dans la chaîne pointée par I<path> et lui associe un flux.

note: type: Plain text
en: The argument I<mode> points to a string beginning with one of the following sequences (possibly followed by additional characters, as described below):
fr: L'argument I<mode> pointe vers une chaîne commençant par l'une des séquences suivantes (éventuellement suivie par des caractères supplémentaires, conformément à la description ci-dessous).

note: type: Plain text
en: Open text file for reading.  The stream is positioned at the beginning of the file.
fr: Ouvre le fichier en lecture. Le pointeur de flux est placé au début du fichier.

note: type: Plain text
en: Open for reading and writing.  The stream is positioned at the beginning of the file.
fr: Ouvre le fichier en lecture et écriture. Le pointeur de flux est placé au début du fichier.

note: type: Plain text
en: Truncate file to zero length or create text file for writing.  The stream is positioned at the beginning of the file.
fr: Tronque le fichier à son début ou ouvre le fichier en écriture. Le pointeur de flux est placé au début du fichier.

note: type: Plain text
en: Open for reading and writing.  The file is created if it does not exist, otherwise it is truncated.  The stream is positioned at the beginning of the file.
fr: Ouvre le fichier en lecture et écriture. Le fichier est créé s'il n'existait pas. S'il existait déjà, sa longueur est ramenée à 0. Le pointeur de flux est placé au début du fichier.

note: type: Plain text
en: Open for appending (writing at end of file).  The file is created if it does not exist.  The stream is positioned at the end of the file.
fr: Ouvre le fichier en ajout (écriture à la fin du fichier). Le fichier est créé s'il n'existait pas. Le pointeur de flux est placé à la fin du fichier.

note: type: Plain text
en: Open for reading and appending (writing at end of file).  The file is created if it does not exist.  The initial file position for reading is at the beginning of the file, but output is always appended to the end of the file.
fr: Ouvre le fichier en lecture et ajout (écriture en fin de fichier). Le fichier est créé s'il n'existait pas. La position initiale du fichier pour la lecture est en début de fichier, mais les ajouts sont toujours placés à la fin du fichier.

note: type: Plain text
en: The I<mode> string can also include the letter \(aqb\(aq either as a last character or as a character between the characters in any of the two-character strings described above.  This is strictly for compatibility with C89 and has no effect; the \(aqb\(aq is ignored on all POSIX conforming systems, including Linux.  (Other systems may treat text files and binary files differently, and adding the \(aqb\(aq may be a good idea if you do I/O to a binary file and expect that your program may be ported to non-UNIX environments.)
fr: La chaîne I<mode> peut également inclure la lettre «\ b\ » comme dernier caractère, ou même entre les deux caractères d'une des séquences à 2 caractères vues ci-dessus. Ce mode sert uniquement à assurer la compatibilité avec C89 et n'a aucun effet. Le «\ b\ » est ignoré sur tous les systèmes compatibles POSIX, y compris Linux (d'autres systèmes peuvent traiter les fichiers textes et les fichiers binaires différemment, et l'ajout du «\ b\ » peut être une bonne idée si vous faites des entrées/sorties sur un fichier binaire et que votre programme risque d'être porté sur un environnement non UNIX).

note: type: Plain text
en: See NOTES below for details of glibc extensions for I<mode>.
fr: Consultez la section NOTES ci-dessous pour le détails des extensions de la glibc pour I<mode>.

note: type: Plain text
en: Any created files will have mode B<S_IRUSR> | B<S_IWUSR> | B<S_IRGRP> | B<S_IWGRP> | B<S_IROTH> | B<S_IWOTH> (0666), as modified by the process's umask value (see B<umask>(2)).
fr: Tout fichier créé aura le mode B<S_IRUSR>\ | B<S_IWUSR>\ | B<S_IRGRP>\ | B<S_IWGRP>\ | B<S_IROTH>\ | B<S_IWOTH> (0666), qui sera ensuite modifié par la valeur d'umask du processus. Consultez B<umask>(2).

note: type: Plain text
en: Reads and writes may be intermixed on read/write streams in any order.  Note that ANSI C requires that a file positioning function intervene between output and input, unless an input operation encounters end-of-file.  (If this condition is not met, then a read is allowed to return the result of writes other than the most recent.)  Therefore it is good practice (and indeed sometimes necessary under Linux) to put an B<fseek>(3)  or B<fgetpos>(3)  operation between write and read operations on such a stream.  This operation may be an apparent no-op (as in I<fseek(..., 0L, SEEK_CUR)> called for its synchronizing side effect).
fr: Les lectures et les écritures peuvent être mélangées sur les flux en lecture et écriture, dans un ordre quelconque. Notez que AINSI C nécessite qu'une fonction de positionnement dans le fichier soit appelée entre une lecture et une écriture, à moins que l'opération de lecture atteigne la fin du fichier(si cette condition n'est pas rencontrée, alors une lecture est permise pour renvoyer le résultat d'une écriture autre que la dernière). Une bonne habitude (souvent nécessaire sous Linux) consiste donc à intercaler un B<fseek>(3) ou B<fgetpos>(3) entre les lectures et les écritures sur le même flux. Ces opérations peuvent être visiblement sans effet comme I<fseek(..., 0L, SEEK_CUR)> et ne servant que pour l'effet de bord de synchronisation.

note: type: Plain text
en: Opening a file in append mode (B<a> as the first character of I<mode>)  causes all subsequent write operations to this stream to occur at end-of-file, as if preceded the call:
fr: Ouvrir un fichier en mode ajout (B<a> comme le premier caractère dans le I<mode>) feront agir toutes les opérations d'écriture à la fin du flux, comme si elles étaient précédées par l'appel :

note: type: Plain text
en: The B<fdopen>()  function associates a stream with the existing file descriptor, I<fd>.  The I<mode> of the stream (one of the values "r", "r+", "w", "w+", "a", "a+")  must be compatible with the mode of the file descriptor.  The file position indicator of the new stream is set to that belonging to I<fd>, and the error and end-of-file indicators are cleared.  Modes "w" or "w+" do not cause truncation of the file.  The file descriptor is not dup'ed, and will be closed when the stream created by B<fdopen>()  is closed.  The result of applying B<fdopen>()  to a shared memory object is undefined.
fr: La fonction B<fdopen>() associe un flux avec un descripteur de fichier I<fd> existant. Le I<mode> du flux (une des valeurs, «\ r\ », «\ "r+\ », «\ w\ », «\ w+\ », «\ a\ », ou «\ a+\ ») doit être compatible avec celui du descripteur de fichier. L'indicateur de position du nouveau flux prend la même valeur que celui de I<fd>, et les indicateurs d'erreur et de fin de fichier sont effacés. Les modes «\ w\ » et «\ w+\ » ne tronquent pas le fichier. Le descripteur n'est pas dupliqué, et sera fermé lorsque le flux créé par B<fdopen>() sera fermé. L'appel de B<fdopen>() sur un objet en mémoire partagée est indéfini.

note: type: Plain text
en: The B<freopen>()  function opens the file whose name is the string pointed to by I<path> and associates the stream pointed to by I<stream> with it.  The original stream (if it exists) is closed.  The I<mode> argument is used just as in the B<fopen>()  function.  The primary use of the B<freopen>()  function is to change the file associated with a standard text stream (I<stderr>, I<stdin>, or I<stdout>).
fr: La fonction B<freopen>() ouvre le fichier dont le nom se trouve dans la chaîne de caractères pointée par I<path> et lui associe le flux pointé par I<stream>. Le flux original, s'il existe, est fermé. L'argument I<mode> est utilisé exactement comme avec B<fopen>(). La principale utilisation de B<freopen>() est de modifier le fichier associé aux flux standard de texte (I<stderr>, I<stdin>, ou I<stdout>).

note: type: Plain text
en: Upon successful completion B<fopen>(), B<fdopen>()  and B<freopen>()  return a I<FILE> pointer.  Otherwise, NULL is returned and I<errno> is set to indicate the error.
fr: Si elles réussissent intégralement, B<fopen>(), B<fdopen>() et B<freopen>() renvoient un pointeur de type I<FILE>. Sinon, elles renvoient NULL et I<errno> contient le code d'erreur.

note: type: Plain text
en: The I<mode> provided to B<fopen>(), B<fdopen>(), or B<freopen>()  was invalid.
fr: Le I<mode> fourni à B<fopen>(), B<fdopen>(), ou B<freopen>() était invalide.

note: type: Plain text
en: The B<fopen>(), B<fdopen>()  and B<freopen>()  functions may also fail and set I<errno> for any of the errors specified for the routine B<malloc>(3).
fr: Les fonctions B<fopen>(), B<fdopen>() et B<freopen>() peuvent également échouer et définir dans I<errno> une des erreurs spécifiées par B<malloc>(3).

note: type: Plain text
en: The B<fopen>()  function may also fail and set I<errno> for any of the errors specified for the routine B<open>(2).
fr: La fonction B<fopen>() peut aussi échouer et définir dans I<errno> une des erreurs spécifiées par B<open>(2).

note: type: Plain text
en: The B<fdopen>()  function may also fail and set I<errno> for any of the errors specified for the routine B<fcntl>(2).
fr: La fonction B<fdopen>() peut aussi échouer et définir dans I<errno> une des erreurs spécifiées par B<fcntl>(2).

note: type: Plain text
en: The B<freopen>()  function may also fail and set I<errno> for any of the errors specified for the routines B<open>(2), B<fclose>(3)  and B<fflush>(3).
fr: La fonction B<freopen>() peut aussi échouer et définir dans I<errno> une des erreurs spécifiées par B<open>(2), B<fclose>(3) et B<fflush>(3).

note: type: Plain text
en: The B<fopen>()  and B<freopen>()  functions conform to C89.  The B<fdopen>()  function conforms to POSIX.1-1990.
fr: Les fonctions B<fopen>() et B<freopen>() sont conformes à C89. La fonction B<fdopen>() est conforme à POSIX.1-1990.

note: type: SS
en: Glibc notes
fr: Notes sur la glibc

note: type: Plain text
en: The GNU C library allows the following extensions for the string specified in I<mode>:
fr: La bibliothèque GNU C permet les extensions suivantes pour la chaîne spécifiée par I<mode>\ :

note: type: TP
en: B<c> (since glibc 2.3.3)
fr: B<c> (depuis la glibc\ 2.3.3)

note: type: Plain text
en: Do not make the open operation, or subsequent read and write operations, thread cancellation points.  This flag is ignored for B<fdopen>().
fr: Ne pas faire de l'opération d'ouverture, ou des opérations de lectures et écritures ultérieures, des points d'annulation de thread. Cet attribut est ignoré pour B<fdopen>().

note: type: TP
en: B<e> (since glibc 2.7)
fr: B<e> (depuis la glibc 2.7)

note: type: Plain text
en: Open the file with the B<O_CLOEXEC> flag.  See B<open>(2)  for more information.  This flag is ignored for B<fdopen>().
fr: Ouvrir le fichier avec l'attribut B<O_CLOEXEC>. Consultez B<open>(2) pour de plus amples renseignements. Cet attribut est ignoré pour B<fdopen>().

note: type: TP
en: B<m> (since glibc 2.3)
fr: B<m> (depuis la glibc\ 2.3)

note: As at glibc 2.4: type: Plain text
en: Attempt to access the file using B<mmap>(2), rather than I/O system calls (B<read>(2), B<write>(2)).  Currently, use of B<mmap>(2)  is attempted only for a file opened for reading.
fr: Essayer d'accéder au fichier avec B<mmap>(2), au lieu des appels système d'entrées/sorties (B<read>(2), B<write>(2)). Actuellement, l'utilisation de B<mmap>(2) n'est seulement tentée que pour un fichier ouvert en lecture.

note: Since glibc 2.0? FIXME C11 specifies this flag type: Plain text
en: Open the file exclusively (like the B<O_EXCL> flag of B<open>(2)).  If the file already exists, B<fopen>()  fails, and sets I<errno> to B<EEXIST>.  This flag is ignored for B<fdopen>().
fr: Ouvrir le fichier de manière exclusive (comme avec l'attribut B<O_EXCL> de B<open>(2)). Si le fichier existe déjà, B<fopen>() échoue et I<errno> est définie à B<EEXIST>. Cet attribut est ignoré par B<fdopen>().

note: type: Plain text
en: In addition to the above characters, B<fopen>()  and B<freopen>()  support the following syntax in I<mode>:
fr: En plus des caractères supplémentaires, B<fopen>() et B<freopen>() acceptent la syntaxe suivante dans I<mode> :

note: type: Plain text
en: B< ,ccs=>I<string>
fr: B< ,ccs=>I<chaîne>

note: type: Plain text
en: The given I<string> is taken as the name of a coded character set and the stream is marked as wide-oriented.  Thereafter, internal conversion functions convert I/O to and from the character set I<string>.  If the B<,ccs=>I<string> syntax is not specified, then the wide-orientation of the stream is determined by the first file operation.  If that operation is a wide-character operation, the stream is marked wide-oriented, and functions to convert to the coded character set are loaded.
fr: La I<chaîne> donnée est considérée comme le nom d'un jeu de caractères codés et le flux est marqué orienté caractères larges. Ensuite, les fonctions internes de conversion convertissent les E/S depuis et vers le jeu de caractères I<chaîne>. Si la syntaxe B< ,ccs=>I<chaîne> n'est pas indiquée, alors l'orientation caractères larges du flux est déterminée par le premier fichier de l'opération. S'il s'agit une opération de caractères larges, le flux est marqué orienté caractères larges et les fonctions pour convertir vers le jeu de caractères codés sont chargées.

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=12685 type: Plain text
en: When parsing for individual flag characters in I<mode> (i.e., the characters preceding the "ccs" specification), the glibc implementation of B<fopen>()  and B<freopen>()  limits the number of characters examined in I<mode> to 7 (or, in glibc versions before 2.14, to 6, which was not enough to include possible specifications such as "rb+cmxe").  The current implementation of B<fdopen>()  parses at most 5 characters in I<mode>.
fr: Lors de l'analyse des caractères d'attribut individuels dans I<mode> (c'est-à-dire les caractères précédant l'indication « ccs »), l'implémentation glibc de B<fopen>() et B<freopen>() limite le nombre de caractères examinés dans I<mode> à 7 (ou, dans les versions de la glibc antérieures à 2.14, à 6, ce qui n'était pas suffisant pour inclure d'éventuelles spécifications comme « rb+cmxe »). L'implémentation actuelle de B<fdopen>() analyse au plus 5 caractères de I<mode>.

note: type: TH
en: 2013-03-17
fr: 17 mars 2013

note: type: Plain text
en: fopencookie - opening a custom stream
fr: fopencookie - Ouvrir un flux particulier

note: type: Plain text
en: The B<fopencookie>()  function allows the programmer to create a custom implementation for a standard I/O stream.  This implementation can store the stream's data at a location of its own choosing; for example, B<fopencookie>()  is used to implement B<fmemopen>(3), which provides a stream interface to data that is stored in a buffer in memory.
fr: La fonction B<fopencookie>() permet au programmeur de créer des implémentations particulières de flux d'entrées-sorties. Cette implémentation peut sauvegarder les flux de données dans une location choisie. Par exemple, B<fopencookie>() est utilisée pour implémenter B<fmemopen>(3), qui fournit une interface qui sauvegarde les flux de données dans un tampon en mémoire.

note: type: Plain text
en: In order to create a custom stream the programmer must:
fr: Pour créer un flux particulier, le programmeur doit\ :

note: type: Plain text
en: Implement four "hook" functions that are used internally by the standard I/O library when performing I/O on the stream.
fr: Implémenter quatre fonctions de «\ hook\ » qui seront utilisées en interne par la bibliothèque standard d'entrées-sorties lors d'opération d'E/S.

note: type: Plain text
en: Define a "cookie" data type, a structure that provides bookkeeping information (e.g., where to store data) used by the aforementioned hook functions.  The standard I/O package knows nothing about the contents of this cookie (thus it is typed as I<void\ *> when passed to B<fopencookie>()), but automatically supplies the cookie as the first argument when calling the hook functions.
fr: Définit un type de données «\ cookie\ », une structure permettant de sauvegarder des informations (par exemple, où sauvegarder les données) utilisée par les fonctions de hook. Les fonctions E/S standards ne connaissent rien à propos du contenu de ce cookie (il est passé comme un type I<void\ *> à B<fopencookie>()) et celui-ci est automatiquement passé en premier argument des fonctions de hook.

note: type: Plain text
en: Call B<fopencookie>()  to open a new stream and associate the cookie and hook functions with that stream.
fr: Appeler B<fopencookie>() pour ouvrir un nouveau flux et associer le cookie et les fonctions de «\ hook\ » à ce flux.

note: type: Plain text
en: The B<fopencookie>()  function serves a purpose similar to B<fopen>(3): it opens a new stream and returns a pointer to a I<FILE> object that is used to operate on that stream.
fr: La fonction B<fopencookie>() effectue une tâche similaire à celle de B<fopen>(3)\ : elle ouvre un nouveau flux et renvoie un pointeur vers un objet I<FILE> utilisé pour manipuler le flux.

note: type: Plain text
en: The I<cookie> argument is a pointer to the caller's cookie structure that is to be associated with the new stream.  This pointer is supplied as the first argument when the standard I/O library invokes any of the hook functions described below.
fr: L'argument I<cookie> est un pointeur vers la structure cookie appelante qui est associée au nouveau flux. Ce pointeur est passé en premier argument lorsque les bibliothèques d'E/S standard appellent une des fonctions de hook.

note: type: Plain text
en: The I<mode> argument serves the same purpose as for B<fopen>(3).  The following modes are supported: I<r>, I<w>, I<a>, I<r+>, I<w+>, and I<a+>.  See B<fopen>(3)  for details.
fr: L'argument I<mode> a le même sens que pour B<fopen>(3). Les modes suivants sont gérés\ :  I<r>, I<w>, I<a>, I<r+>, I<w+> et I<a+>. Consultez B<fopen>(3) pour plus de détails.

note: type: Plain text
en: The I<io_funcs> argument is a structure that contains four fields pointing to the programmer-defined hook functions that are used to implement this stream.  The structure is defined as follows
fr: L'argument I<io_funcs> est une structure qui contient quatre champs pointant vers les fonctions de «\ hook\ » définies par le programmeur qui seront utilisées dans l'implémentation du flux. La structure est définie comme suit\ :

note: type: Plain text
en: The four fields are as follows:
fr: Les quatre membres sont définis comme suit\ :

note: type: Plain text
en: This function implements read operations for the stream.  When called, it receives three arguments:
fr: Cette fonction implémente les opérations de lecture du flux. Lorsqu'elle est appelée, elle reçoit trois arguments.

note: type: Plain text
en: The I<buf> and I<size> arguments are, respectively, a buffer into which input data can be placed and the size of that buffer.  As its function result, the I<read> function should return the number of bytes copied into I<buf>, 0 on end of file, or -1 on error.  The I<read> function should update the stream offset appropriately.
fr: Les argument I<buf> et I<size> sont respectivement, un tampon de données pour sauvegarder les données en provenance du flux et la taille du tampon. La fonction I<read> renvoie le nombre d'octets copiés depuis le flux ou -1 en cas d'erreur. La fonction I<read> doit mettre à jour la position dans le flux en conséquence.

note: type: Plain text
en: If I<*read> is a null pointer, then reads from the custom stream always return end of file.
fr: Si I<*read> est un pointeur NULL, alors les lectures du flux renvoient toujours fin de fichier.

note: type: Plain text
en: This function implements write operations for the stream.  When called, it receives three arguments:
fr: Cette fonction implémente les opérations d'écriture du flux. Lorsqu'elle est appelée, elle reçoit trois arguments\ :

note: type: Plain text
en: The I<buf> and I<size> arguments are, respectively, a buffer of data to be output to the stream and the size of that buffer.  As its function result, the I<write> function should return the number of bytes copied from I<buf>, or 0 on error.  (The function must not return a negative value.)  The I<write> function should update the stream offset appropriately.
fr: Les argument I<buf> et I<size> sont respectivement, un tampon de données à écrire dans le flux et la taille du tampon. La fonction I<write> renvoie le nombre d'octets copiés depuis I<buf> ou 0 en cas d'erreur (la fonction ne doit pas renvoyer de valeur négative). La fonction I<write> doit mettre à jour la position dans le flux en conséquence.

note: type: Plain text
en: If I<*write> is a null pointer, then output to the stream is discarded.
fr: Si I<*write> est un pointeur NULL, alors les écritures dans le flux ne sont pas réalisées.

note: type: Plain text
en: This function implements seek operations on the stream.  When called, it receives three arguments:
fr: Cette fonction implémente les opérations de positionnement dans le flux. Lorsqu'elle est appelée, elle prend trois arguments\ :

note: type: Plain text
en: The I<*offset> argument specifies the new file offset depending on which of the following three values is supplied in I<whence>:
fr: L'argument I<*offset> spécifie le nouveau décalage du fichier selon les trois valeurs suivantes fournies à I<whence>\ :

note: type: Plain text
en: The stream offset should be set I<*offset> bytes from the start of the stream.
fr: Le décalage du flux doit être défini à I<*offset> octets après le début du flux.

note: type: Plain text
en: I<*offset> should be added to the current stream offset.
fr: I<*offset> doit être ajouté à l'offset actuel du flux.

note: type: Plain text
en: The stream offset should be set to the size of the stream plus I<*offset>.
fr: L'offset du flux doit être défini à la taille du flux plus I<*offset>.

note: type: Plain text
en: Before returning, the I<seek> function should update I<*offset> to indicate the new stream offset.
fr: La fonction I<seek> doit mettre à jour I<*offset> pour indiquer le nouvel offset du flux avant de renvoyer.

note: type: Plain text
en: As its function result, the I<seek> function should return 0 on success, and -1 on error.
fr: La function I<seek> devrait renvoyée 0 en cas de succès et -1 en cas d'erreur.

note: type: Plain text
en: If I<*seek> is a null pointer, then it is not possible to perform seek operations on the stream.
fr: Si I<*seek> est un pointeur NULL, alors il est impossible de se positionner dans le flux.

note: type: Plain text
en: This function closes the stream.  The hook function can do things such as freeing buffers allocated for the stream.  When called, it receives one argument:
fr: Cette fonction ferme le flux. Par exemple, la fonction de hook peut désallouer des tampons alloués pour le flux. Lorsqu'elle est appelée, elle prend un argument\ :

note: type: Plain text
en: The I<cookie> argument is the cookie that the programmer supplied when calling B<fopencookie>().
fr: L'argument I<cookie> est le cookie que le programmeur fournit à B<fopencookie>().

note: type: Plain text
en: As its function result, the I<close> function should return 0 on success, and B<EOF> on error.
fr: La function I<close> devrait renvoyée 0 en cas de succès et B<EOF> en cas d'erreur.

note: type: Plain text
en: If I<*close> is NULL, then no special action is performed when the stream is closed.
fr: Si I<*close> est NULL, alors aucune action n'est réalisée lorsque le flux est fermé.

note: .SH ERRORS It's not clear if errno ever gets set... type: Plain text
en: On success B<fopencookie>()  returns a pointer to the new stream.  On error, NULL is returned.
fr: En cas de succès, B<fopencookie>() renvoie un pointeur sur le nouveau flux. En cas d'erreur, NULL est renvoyé.

note: type: Plain text
en: This function is a nonstandard GNU extension.
fr: Cette fonction est une extension GNU non standard.

note: type: Plain text
en: The program below implements a custom stream whose functionality is similar (but not identical) to that available via B<fmemopen>(3).  It implements a stream whose data is stored in a memory buffer.  The program writes its command-line arguments to the stream, and then seeks through the stream reading two out of every five characters and writing them to standard output.  The following shell session demonstrates the use of the program:
fr: Le programme ci-dessous implémente un flux particulier dont la fonctionnalité est similaire (mais non identique) à celle de B<fmemopen>(3). Il implémente un flux dont les données sont sauvegardées dans un tampon. Le programme écrit les options de sa ligne de commande dans le flux et se positionne dans le flux afin de lire 2 caractères sur 5 et les écrit sur la sortie standard. La session shell suivante explique comment utiliser ce programme.

note: type: Plain text
en: Note that a more general version of the program below could be improved to more robustly handle various error situations (e.g., opening a stream with a cookie that already has an open stream; closing a stream that has already been closed).
fr: Notez qu'une version plus générique et plus robuste du programme ci-dessous, avec une gestion des erreurs pourrait être implémenté (par exemple, l'ouverture d'un flux avec un cookie en cours d'utilisation par un autre flux\ ; la fermeture d'un flux déjà fermé).

note: type: TH
en: 2001-12-15
fr: 15 décembre 2001

note: type: Plain text
en: fpurge, __fpurge - purge a stream
fr: fpurge, __fpurge - Purger un flux

note: type: Plain text
en: /* unsupported */
    B<#include E<lt>stdio.hE<gt>>
fr: /* Non supporté */
    B<#include E<lt>stdio.hE<gt>>

note: type: Plain text
en: /* supported */
    B<#include E<lt>stdio.hE<gt>>
fr: /* Supporté */
    B<#include E<lt>stdio.hE<gt>>

note: type: Plain text
en: The function B<fpurge>()  clears the buffers of the given stream.  For output streams this discards any unwritten output.  For input streams this discards any input read from the underlying object but not yet obtained via B<getc>(3); this includes any text pushed back via B<ungetc>(3).  See also B<fflush>(3).
fr: La fonction B<fpurge>() efface les tampons d'un flux donné. Pour les flux de sortie, on se débarrasse de toute sortie n'ayant pas encore été écrite. Pour les flux d'entrée, on renonce à toute entrée lue par l'objet sous-jacent mais n'ayant pas encore été acquise par B<getc>(3). Cela inclut tout texte réinjecté dans le flux par B<ungetc>(3). Consultez aussi B<fflush>(3).

note: type: Plain text
en: The function B<__fpurge>()  does precisely the same, but without returning a value.
fr: La fonction B<__fpurge>() fait exactement la même chose mais ne renvoie pas de code de retour.

note: type: Plain text
en: Upon successful completion B<fpurge>()  returns 0.  On error, it returns -1 and sets I<errno> appropriately.
fr: En cas de succès, B<fpurge>() renvoie 0. En cas d'erreur, elle renvoie -1 et définit I<errno>.

note: type: Plain text
en: I<stream> is not an open stream.
fr: I<stream> ne correspond pas à un flux ouvert.

note: type: Plain text
en: These functions are nonstandard and not portable.  The function B<fpurge>()  was introduced in 4.4BSD and is not available under Linux.  The function B<__fpurge>()  was introduced in Solaris, and is present in glibc 2.1.95 and later.
fr: Ces fonctions ne sont ni standard ni portables. La fonction B<fpurge>() a été introduite sous BSD\ 4.4 et n'est pas disponible sous Linux. La fonction B<__fpurge>() a été introduite sous Solaris, et se trouve dans la glibc\ 2.1.95 et ses versions ultérieures.

note: type: Plain text
en: Usually it is a mistake to want to discard input buffers.
fr: Vouloir purger des tampons d'entrée constitue généralement une erreur.

note: type: Plain text
en: fputwc, putwc - write a wide character to a FILE stream
fr: fputwc, putwc - Écrire un caractère large dans un flux FILE

note: type: Plain text
en: The B<fputwc>()  function is the wide-character equivalent of the B<fputc>(3)  function.  It writes the wide character I<wc> to I<stream>.  If I<ferror(stream)> becomes true, it returns B<WEOF>.  If a wide-character conversion error occurs, it sets I<errno> to B<EILSEQ> and returns B<WEOF>.  Otherwise it returns I<wc>.
fr: La fonction B<fputwc>() est l'équivalent pour les caractères larges de la fonction B<fputc>(3). Elle écrit le caractère large I<wc> dans le flux I<stream>. Si I<ferror(stream)> devient vraie, B<WEOF> est renvoyé. Si une erreur de conversion du caractère large se produit, I<errno> est défini à B<EILSEQ> et B<WEOF> est renvoyé. Sinon I<wc> est renvoyé.

note: type: Plain text
en: The B<putwc>()  function or macro functions identically to B<fputwc>().  It may be implemented as a macro, and may evaluate its argument more than once.  There is no reason ever to use it.
fr: La fonction ou la macro B<putwc>() est identique à B<fputwc>(). Elle peut être implémentée comme une macro et donc évaluer plusieurs fois son argument. Il n'y a plus aucune raison de l'utiliser.

note: type: Plain text
en: The B<fputwc>()  function returns I<wc> if no error occurred, or B<WEOF> to indicate an error.  In the event of an error, I<errno> is set to indicate the cause.
fr: La fonction B<fputwc>() renvoie I<wc> si aucune erreur ne s'est produite, B<WEOF> sinon. En cas d'erreur, I<errno> permet d'identifier la cause de l'erreur.

note: type: Plain text
en: Conversion of I<wc> to the stream's encoding fails.
fr: La conversion de I<wc> vers l'encodage du flux a échoué.

note: type: Plain text
en: The behavior of B<fputwc>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<fputwc>() dépend de la valeur B<LC_CTYPE> de la localisation actuelle.

note: type: Plain text
en: In the absence of additional information passed to the B<fopen>(3)  call, it is reasonable to expect that B<fputwc>()  will actually write the multibyte sequence corresponding to the wide character I<wc>.
fr: En l'absence d'informations supplémentaires passées à l'appel B<fopen>(3), il est raisonnable de penser que B<fputwc>() écrira en fait la séquence multioctet correspondant au caractère large I<wc>.

note: type: TH
en: 2012-03-30
fr: 30 mars 2012

note: type: Plain text
en: fread, fwrite - binary stream input/output
fr: fread, fwrite - Entrées/sorties binaires sur un flux

note: type: Plain text
en: The function B<fread>()  reads I<nmemb> elements of data, each I<size> bytes long, from the stream pointed to by I<stream>, storing them at the location given by I<ptr>.
fr: La fonction B<fread>() lit I<nmemb> éléments de données, chacun d'eux représentant I<size> octets de long, depuis le flux pointé par I<stream>, et les stocke à l'emplacement pointé par I<ptr>.

note: type: Plain text
en: The function B<fwrite>()  writes I<nmemb> elements of data, each I<size> bytes long, to the stream pointed to by I<stream>, obtaining them from the location given by I<ptr>.
fr: La fonction B<fwrite>() écrit I<nmemb> éléments de données, chacun d'eux représentant I<size> octet de long, dans le flux pointé par I<stream>, après les avoir récupérés depuis l'emplacement pointé par I<ptr>.

note: type: Plain text
en: On success, B<fread>()  and B<fwrite>()  return the number of I<items> read or written.  This number equals the number of bytes transferred only when I<size> is 1.  If an error occurs, or the end of the file is reached, the return value is a short item count (or zero).
fr: En cas de réussite, B<fread>() et B<fwrite>() renvoient le nombre d'I<éléments> lus ou écrits. Ce nombre n'est égal au nombre d'octets transférés que si I<size> est 1. Si une erreur se produit, ou si la fin du fichier est atteinte en lecture, le nombre renvoyé est plus petit que I<nmemb> et peut même être nul.

note: type: Plain text
en: B<fread>()  does not distinguish between end-of-file and error, and callers must use B<feof>(3)  and B<ferror>(3)  to determine which occurred.
fr: B<fread>() ne fait pas la différence entre la fin de fichier et une erreur, et l'appelant devra utiliser B<feof>(3) et B<ferror>(3) pour le savoir.

note: type: TH
en: 2014-04-02
fr: 2 avril 2014

note: type: Plain text
en: fgetpos, fseek, fsetpos, ftell, rewind - reposition a stream
fr: fgetpos, fseek, fsetpos, ftell, rewind - Positionner un flux

note: type: Plain text
en: The B<fseek>()  function sets the file position indicator for the stream pointed to by I<stream>.  The new position, measured in bytes, is obtained by adding I<offset> bytes to the position specified by I<whence>.  If I<whence> is set to B<SEEK_SET>, B<SEEK_CUR>, or B<SEEK_END>, the offset is relative to the start of the file, the current position indicator, or end-of-file, respectively.  A successful call to the B<fseek>()  function clears the end-of-file indicator for the stream and undoes any effects of the B<ungetc>(3)  function on the same stream.
fr: La fonction B<fseek>() définit l'indicateur de position du flux pointé par I<stream>. La nouvelle position, mesurée en octets, est obtenue en additionnant I<offset> octets au point de départ indiqué par I<whence>. Si I<whence> vaut B<SEEK_SET>, B<SEEK_CUR>, ou B<SEEK_END>, le point de départ correspond respectivement au début du fichier, à la position actuelle, ou à la fin du fichier. Un appel réussi à B<fseek>() efface l'indicateur de fin de fichier du flux, et annule les effets de toute fonction B<ungetc>(3) sur le même flux.

note: type: Plain text
en: The B<ftell>()  function obtains the current value of the file position indicator for the stream pointed to by I<stream>.
fr: La fonction B<ftell>() obtient la valeur de l'indicateur de position du flux pointé par I<stream>.

note: type: Plain text
en: The B<rewind>()  function sets the file position indicator for the stream pointed to by I<stream> to the beginning of the file.  It is equivalent to:
fr: La fonction B<rewind>() place l'indicateur de position du flux pointé par I<stream> au début du fichier. C'est l'équivalent de\ :

note: type: Plain text
en: except that the error indicator for the stream is also cleared (see B<clearerr>(3)).
fr: sauf que l'indicateur d'erreur du flux est également effacé (consultez B<clearerr>(3)).

note: type: Plain text
en: The B<fgetpos>()  and B<fsetpos>()  functions are alternate interfaces equivalent to B<ftell>()  and B<fseek>()  (with I<whence> set to B<SEEK_SET>), setting and storing the current value of the file offset into or from the object referenced by I<pos>.  On some non-UNIX systems, an I<fpos_t> object may be a complex object and these routines may be the only way to portably reposition a text stream.
fr: Les fonctions B<fgetpos>() et B<fsetpos>() sont des alternatives à B<ftell>() et B<fseek>() (avec I<whence> à B<SEEK_SET>), en définissant et en mémorisant la valeur de l'indicateur de position du fichier dans ou depuis l'objet référencé par I<pos>. Sur certains systèmes non UNIX, l'objet I<fpos_t> peut être un objet complexe, et ces routines peuvent être les seules méthodes possibles pour repositionner un flux de texte de manière portable.

note: type: Plain text
en: The B<rewind>()  function returns no value.  Upon successful completion, B<fgetpos>(), B<fseek>(), B<fsetpos>()  return 0, and B<ftell>()  returns the current offset.  Otherwise, -1 is returned and I<errno> is set to indicate the error.
fr: La fonction B<rewind>() ne renvoie pas de valeur. Si elles réussissent totalement, B<fgetpos>(), B<fseek>(), B<fsetpos>() renvoient 0, et B<ftell>() renvoie la position actuelle. Sinon, elles renvoient -1 et la variable globale I<errno> contient le code d'erreur.

note: type: Plain text
en: The I<stream> specified is not a seekable stream.
fr: Le flux I<stream> n'est pas un flux positionnable.

note: type: Plain text
en: The I<whence> argument to B<fseek>()  was not B<SEEK_SET>, B<SEEK_END>, or B<SEEK_CUR>.  Or: the resulting file offset would be negative.
fr: L'argument I<whence> de B<fseek>() n'était ni B<SEEK_SET>, ni B<SEEK_END>, ni B<SEEK_CUR>. Autrement, le décalage du fichier aurait été négatif.

note: type: Plain text
en: The functions B<fgetpos>(), B<fseek>(), B<fsetpos>(), and B<ftell>()  may also fail and set I<errno> for any of the errors specified for the routines B<fflush>(3), B<fstat>(2), B<lseek>(2), and B<malloc>(3).
fr: Les fonctions B<fgetpos>(), B<fseek>(), B<fsetpos>(), et B<ftell>() peuvent également, en cas d'échec, définir I<errno> sur n'importe quelle erreur indiquée par les routines B<fflush>(3), B<fstat>(2), B<lseek>(2) et B<malloc>(3).

note: type: TH
en: 2014-03-20
fr: 20 mars 2014

note: type: Plain text
en: fseeko, ftello - seek to or report file position
fr: fseeko, ftello - Définir ou consulter la position d'un fichier

note: type: Plain text
en: B<fseeko>(), B<ftello>():
fr: B<fseeko>(), B<ftello>() :

note: type: Plain text
en: (defining the obsolete _LARGEFILE_SOURCE macro also works)
fr: (fonctionne également en définissant la macro _LARGEFILE_SOURCE, qui est obsolète)

note: type: Plain text
en: The B<fseeko>()  and B<ftello>()  functions are identical to B<fseek>(3)  and B<ftell>(3)  (see B<fseek>(3)), respectively, except that the I<offset> argument of B<fseeko>()  and the return value of B<ftello>()  is of type I<off_t> instead of I<long>.
fr: Les fonctions B<fseeko>() et B<ftello>() sont respectivement identiques à B<fseek>(3) et B<ftell>(3), (consultez B<fseek>(3)), excepté que l'argument I<offset> de B<fseeko>() et le code de retour de B<ftello>() sont du type I<off_t> et non I<long>.

note: type: Plain text
en: On many architectures both I<off_t> and I<long> are 32-bit types, but compilation with
fr: Sur de nombreuses architectures, I<off_t> tout comme I<long> sont des types codés sur 32\ bits, mais une compilation avec la directive

note: type: Plain text
en: will turn I<off_t> into a 64-bit type.
fr: modifiera I<off_t> en un type codé sur 64\ bits.

note: type: Plain text
en: On successful completion, B<fseeko>()  returns 0, while B<ftello>()  returns the current offset.  Otherwise, -1 is returned and I<errno> is set to indicate the error.
fr: Sans erreur, la fonction B<fseeko>() renvoie 0, alors que la fonction B<ftello>() renvoie la valeur du décalage actuel. Sinon -1 est renvoyé et I<errno> est défini pour indiquer l'erreur.

note: type: Plain text
en: See the ERRORS in B<fseek>(3).
fr: Consultez la section ERREURS de B<fseek>(3).

note: type: Plain text
en: These functions are found on System V-like systems.  They are not present in libc4, libc5, glibc 2.0 but are available since glibc 2.1.
fr: Ces fonctions se trouve dans les systèmes System V et apparentés. Elles ne sont pas présentes dans la libc4, libc5 ou la glibc\ 2.0 mais sont disponibles depuis la glibc\ 2.1.

note: type: Plain text
en: getline, getdelim - delimited string input
fr: getline, getdelim - Saisie de chaîne délimitée

note: type: Plain text
en: B<getline>(), B<getdelim>():
fr: B<getline>(), B<getdelim>() :

note: type: Plain text
en: B<getline>()  reads an entire line from I<stream>, storing the address of the buffer containing the text into I<*lineptr>.  The buffer is null-terminated and includes the newline character, if one was found.
fr: B<getline>() lit une ligne entière dans I<stream> et stocke l'adresse du tampon contenant le texte dans I<*lineptr>. Le tampon se termine par un caractère nul et inclut le caractère saut-de-ligne, si un tel séparateur a été trouvé.

note: type: Plain text
en: If I<*lineptr> is set to NULL and I<*n> is set 0 before the call, then B<getline>()  will allocate a buffer for storing the line.  This buffer should be freed by the user program even if B<getline>()  failed.
fr: Si I<*lineptr> est positionné à NULL, et si I<*n> a la valeur 0 avant l'appel, la routine B<getline>() allouera un tampon pour sauver la ligne. Ce tampon devra être libéré par le programme utilisateur.

note: type: Plain text
en: Alternatively, before calling B<getline>(), I<*lineptr> can contain a pointer to a B<malloc>(3)-allocated buffer I<*n> bytes in size.  If the buffer is not large enough to hold the line, B<getline>()  resizes it with B<realloc>(3), updating I<*lineptr> and I<*n> as necessary.
fr: Alternativement, avant d'appeler B<getline>(), I<*lineptr> peut contenir un pointeur vers un tampon de I<*n> octets alloué par B<malloc>(3). Si le tampon n'est pas suffisant pour sauver la ligne saisie, B<getline>() le redimensionnera avec B<realloc>(3), mettant à jour I<*lineptr> et I<*n> comme il se doit.

note: type: Plain text
en: In either case, on a successful call, I<*lineptr> and I<*n> will be updated to reflect the buffer address and allocated size respectively.
fr:  Quoi qu'il en soit, en cas de succès, I<*lineptr> et I<*n> seront mis à jour afin de rendre compte respectivement de l'adresse et de la taille du tampon.

note: type: Plain text
en: B<getdelim>()  works like B<getline>(), except that a line delimiter other than newline can be specified as the I<delimiter> argument.  As with B<getline>(), a delimiter character is not added if one was not present in the input before end of file was reached.
fr: B<getdelim>() fonctionne comme B<getline>(), si ce n'est qu'un séparateur différent de saut-de-ligne peut être spécifié en tant qu'argument I<delimiter>. Tout comme avec B<getline>(), aucun séparateur n'est ajouté s'il n'y en avait pas dans l'entrée avant que la fin du fichier ne soit atteinte.

note: type: Plain text
en: On success, B<getline>()  and B<getdelim>()  return the number of characters read, including the delimiter character, but not including the terminating null byte (\(aq\e0\(aq).  This value can be used to handle embedded null bytes in the line read.
fr: En cas de succès, B<getline>() et B<getdelim>() renvoient le nombre de caractères lus, séparateur inclus, mais sans compter l'octet nul final (\(aq\e0\(aq). Cette valeur peut être utilisée afin de traiter les octets nuls insérés dans la ligne lue.

note: type: Plain text
en: Both functions return -1 on failure to read a line (including end-of-file condition).  In the event of an error, I<errno> is set to indicate the cause.
fr: Les deux fonctions renvoient -1 en cas d'échec de lecture de la ligne (condition de fin de fichier incluse). En cas d'erreur, I<errno> permet d'identifier la cause de l'erreur.

note: type: Plain text
en: Bad arguments (I<n> or I<lineptr> is NULL, or I<stream> is not valid).
fr: Paramètres erronés (I<n> ou I<lineptr> valent NULL, ou bien I<stream> n'est pas valide).

note: type: Plain text
en: These functions are available since libc 4.6.27.
fr: Ces fonctions sont présentes depuis la libc 4.6.27.

note: type: Plain text
en: Both B<getline>()  and B<getdelim>()  were originally GNU extensions.  They were standardized in POSIX.1-2008.
fr: B<getline>() tout comme B<getdelim>() sont des extensions GNU. Elles ont été standardisées dans POSIX.1-2008.

note: type: Plain text
en:     while ((read = getline(&line, &len, fp)) != -1) {
            printf("Retrieved line of length %zu :\en", read);
            printf("%s", line);
        }
fr:     while ((read = getline(&line, &len, fp)) != -1) {
            printf("Réception d'une ligne de longueur %zu :\en", read);
            printf("%s", line);
        }

note: type: TH
en: 2014-01-24
fr: 24 janvier 2014

note: type: Plain text
en: gets - get a string from standard input (DEPRECATED)
fr: gets - Récupérer une chaîne sur l'entrée standard (OBSOLÈTE)

note: type: Plain text
en: I<Never use this function>.
fr: I<Ne jamais utiliser cette fonction>.

note: type: Plain text
en: B<gets>()  reads a line from I<stdin> into the buffer pointed to by I<s> until either a terminating newline or B<EOF>, which it replaces with a null byte (\(aq\e0\(aq).  No check for buffer overrun is performed (see BUGS below).
fr: B<gets>() lit une ligne depuis I<stdin> et la place dans le tampon pointé par I<s> jusqu'à atteindre un retour chariot, ou B<EOF>, qu'il remplace par un octet nul (« \e0 »). Il n'y a pas de vérification de débordement de tampon (voir la section des B<BOGUES> plus bas).

note: type: Plain text
en: B<gets>()  returns I<s> on success, and NULL on error or when end of file occurs while no characters have been read.  However, given the lack of buffer overrun checking, there can be no guarantees that the function will even return.
fr: B<gets>() renvoie le pointeur I<s> en cas de succès et NULL en cas d'erreur, ou si la fin de fichier est atteinte avant d'avoir pu lire au moins un caractère. Cependant, le débordement de tampon n'étant pas surveillé, il ne peut y avoir de certitude que la fonction renvoie quelque chose.

note: type: Plain text
en: LSB deprecates B<gets>().  POSIX.1-2008 marks B<gets>()  obsolescent.  ISO C11 removes the specification of B<gets>()  from the C language, and since version 2.16, glibc header files don't expose the function declaration if the B<_ISOC11_SOURCE> feature test macro is defined.
fr: LSB déconseille l'utilisation de B<gets>(). POSIX.1-2008 marque B<gets>() comme étant obsolète. ISO C11 retire la specification de B<gets>() du langage C et, depuis la version 2.16, les fichiers d'en-tête glibc n'exposent pas la déclaration de fonction si la macro de test de fonctionnalités B<_ISOC11_SOURCE> est définie.

note: type: Plain text
en: Never use B<gets>().  Because it is impossible to tell without knowing the data in advance how many characters B<gets>()  will read, and because B<gets>()  will continue to store characters past the end of the buffer, it is extremely dangerous to use.  It has been used to break computer security.  Use B<fgets>()  instead.
fr: N'utilisez jamais B<gets>(). Comme il est impossible de savoir à l'avance combien de caractères seront lus par B<gets>(), et comme celui-ci écrira tous les caractères lus, même s'ils débordent du tampon, cette fonction est extrêmement dangereuse à utiliser. On a déjà utilisé ce dysfonctionnement pour créer des trous de sécurité. UTILISEZ TOUJOURS B<fgets>() À LA PLACE DE B<gets>().

note: type: Plain text
en: For more information, see CWE-242 (aka "Use of Inherently Dangerous Function") at http://cwe.mitre.org/data/definitions/242.html
fr: Pour plus d'informations, consultez CWE-242 (document intitulé sous le nom « Use of Inherently Dangerous Function ») à l'adresse http://cwe.mitre.org/data/definitions/242.html

note: type: TH
en: 2010-09-26
fr: 26 septembre 2010

note: type: Plain text
en: getw, putw - input and output of words (ints)
fr: getw, putw - Lecture et écriture de mots (ints)

note: type: Plain text
en: B<getw>(), B<putw>():
fr: B<getw>(), B<putw>() :

note: type: TP
en: Since glibc 2.3.3:
fr: Depuis la glibc 2.3.3 :

note: type: TP
en: Before glibc 2.3.3:
fr: Avant la glibc 2.3.3 :

note: type: Plain text
en: B<getw>()  reads a word (that is, an I<int>) from I<stream>.  It's provided for compatibility with SVr4.  We recommend you use B<fread>(3)  instead.
fr: B<getw>() lit un mot (c'est-à-dire un entier I<int>) depuis le flux I<stream>. Cette fonction est fournie pour des raisons de compatibilité avec SVr4. Veuillez utiliser B<fread>(3) à la place.

note: type: Plain text
en: B<putw>()  writes the word I<w> (that is, an I<int>) to I<stream>.  It is provided for compatibility with SVr4, but we recommend you use B<fwrite>(3)  instead.
fr: B<putw>() écrit le mot I<w> (c'est-à-dire un entier I<int>) dans le flux I<stream>. Cette fonction est fournie pour des raisons de compatibilité avec SVr4. Veuillez utiliser B<fwrite>(3) à sa place.

note: type: Plain text
en: Normally, B<getw>()  returns the word read, and B<putw>()  returns 0.  On error, they return B<EOF>.
fr: Normalement, B<getw>() renvoie le mot lu, et B<putw>() renvoie 0. En cas d'erreur, ils renvoient B<EOF>.

note: type: Plain text
en: SVr4, SUSv2.  Not present in POSIX.1-2001.
fr: SVr4, SUSv2. Pas présent dans POSIX.1-2001.

note: type: Plain text
en: The value returned on error is also a legitimate data value.  B<ferror>(3)  can be used to distinguish between the two cases.
fr: La valeur renvoyée en cas d'erreur est aussi une valeur légitime pour une donnée. On peut utiliser B<ferror>(3) pour distinguer ces cas.

note: type: TH
en: 2014-03-19
fr: 19 mars 2014

note: type: Plain text
en: link, linkat - make a new name for a file
fr: link, linkat - Créer un nouveau nom pour un fichier

note: type: Plain text
en: B<#include E<lt>fcntl.hE<gt>           >/* Definition of AT_* constants */
    B<#include E<lt>unistd.hE<gt>>
fr: B<#include E<lt>fcntl.hE<gt> /* Définition des constantes AT_* */>
    B<#include E<lt>unistd.hE<gt>>

note: type: Plain text
en: B<linkat>():
fr: B<linkat>()\ :

note: type: Plain text
en: B<link>()  creates a new link (also known as a hard link) to an existing file.
fr: B<link>() crée un nouveau lien (aussi appelé lien matériel ou hard link) sur un fichier existant.

note: type: Plain text
en: If I<newpath> exists, it will I<not> be overwritten.
fr: Si I<newpath> existe, il ne sera I<pas> écrasé.

note: type: Plain text
en: This new name may be used exactly as the old one for any operation; both names refer to the same file (and so have the same permissions and ownership) and it is impossible to tell which name was the "original".
fr: Ce nouveau nom pourra être utilisé exactement comme l'ancien quelle que soit l'opération. Les deux noms réfèrent au même fichier (et ont donc les mêmes permissions et propriétaire) et il est impossible de déterminer quel nom était l'original.

note: type: Plain text
en: The B<linkat>()  system call operates in exactly the same way as B<link>(), except for the differences described here.
fr: L'appel système B<linkat>() fonctionne exactement comme B<link>(), les seules différences étant celles décrites ici.

note: type: Plain text
en: If the pathname given in I<oldpath> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<olddirfd> (rather than relative to the current working directory of the calling process, as is done by B<link>()  for a relative pathname).
fr: Si le chemin donné dans I<oldpath> est relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier I<olddirfd> (plutôt que par rapport au répertoire courant du processus appelant, comme dans B<link>()).

note: type: Plain text
en: If I<oldpath> is relative and I<olddirfd> is the special value B<AT_FDCWD>, then I<oldpath> is interpreted relative to the current working directory of the calling process (like B<link>()).
fr: Si I<oldpath> est relatif et I<olddirfd> a la valeur spéciale B<AT_FDCWD>, I<oldpath> est interprété relativement au répertoire courant du processus appelant, comme B<link>().

note: type: Plain text
en: If I<oldpath> is absolute, then I<olddirfd> is ignored.
fr: Si I<oldpath> est un chemin absolu, I<olddirfd> est ignoré.

note: type: Plain text
en: The interpretation of I<newpath> is as for I<oldpath>, except that a relative pathname is interpreted relative to the directory referred to by the file descriptor I<newdirfd>.
fr: L'interprétation de I<newpath> est identique à celle de I<oldpath>, excepté qu'un chemin relatif est interprété par rapport au répertoire correspondant à I<newdirfd>.

note: type: Plain text
en: The following values can be bitwise ORed in I<flags>:
fr: Les valeurs suivantes peuvent être combinées avec un OU binaire dans le paramètre I<flags> :

note: type: TP
en: B<AT_EMPTY_PATH> (since Linux 2.6.39)
fr: B<AT_EMPTY_PATH> (depuis Linux 2.6.39)

note: commit 11a7b371b64ef39fc5fb1b6f2218eef7c4d035e3 Before glibc 2.16, defining _ATFILE_SOURCE sufficed type: Plain text
en: If I<oldpath> is an empty string, create a link to the file referenced by I<olddirfd> (which may have been obtained using the B<open>(2)  B<O_PATH> flag).  In this case, I<olddirfd> must refer to a file other than a directory.  The caller must have the B<CAP_DAC_READ_SEARCH> capability in order to use this flag; this prevents arbitrary users from creating hard links using file descriptors received via a UNIX domain socket (see the discussion of B<SCM_RIGHTS> in B<unix>(7)).  This flag is Linux-specific; define B<_GNU_SOURCE> to obtain its definition.
fr: Si I<oldpath> est une chaîne vide, créer un lien vers le fichier référencé par I<olddirfd> (qui peut avoir été obtenu en utilisant B<open>(2) avec le drapeau B<O_PATH>). Dans ce cas, I<olddirfd> doit faire référence à fichier, et pas à un répertoire. L'appelant doit avoir la capacité B<CAP_DAC_READ_SEARCH> pour utiliser cet attribut. Cette sécurité empêche des utilisateurs arbitraires de créer des liens matériels en utilisant des descripteurs de fichiers reçus via socket UNIX (consultez la discussion au sujet de B<SCM_RIGHTS> dans B<unix>(7)). Cet attribut est spécifique à Linux, B<_GNU_SOURCE> doit être définie pour obtenir sa définition.

note: type: TP
en: B<AT_SYMLINK_FOLLOW> (since Linux 2.6.18)
fr: B<AT_SYMLINK_FOLLOW> (depuis Linux 2.6.18)

note: type: Plain text
en: By default, B<linkat>(), does not dereference I<oldpath> if it is a symbolic link (like B<link>()).  The flag B<AT_SYMLINK_FOLLOW> can be specified in I<flags> to cause I<oldpath> to be dereferenced if it is a symbolic link.
fr: Par défaut, B<linkat>() ne déréférence pas I<oldpath> si c'est un lien symbolique (de même que B<link>()). L'attribut B<AT_SYMLINK_FOLLOW> peut être passé dans I<flags> pour forcer le déréférencement de I<oldpath> si c'est un lien symbolique.

note: type: Plain text
en: Before kernel 2.6.18, the I<flags> argument was unused, and had to be specified as 0.
fr: Avant le noyau 2.6.18, l'argument I<flags> n'était pas utilisé, et devait être nul.

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<linkat>().
fr: Consultez B<openat>(2) pour une explication de la nécessité de B<linkat>().

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: Plain text
en: Write access to the directory containing I<newpath> is denied, or search permission is denied for one of the directories in the path prefix of I<oldpath> or I<newpath>.  (See also B<path_resolution>(7).)
fr: L'écriture dans le répertoire contenant I<newpath> n'est pas autorisée pour l'UID effectif du processus, ou l'un des répertoires de I<oldpath> ou I<newpath> ne permet pas le parcours (exécution). Consultez aussi B<path_resolution>(7).

note: type: Plain text
en: The user's quota of disk blocks on the filesystem has been exhausted.
fr: Le quota de blocs de disque de l'utilisateur sur le système de fichiers a été atteint.

note: type: Plain text
en: I<newpath> already exists.
fr: I<newpath> existe déjà.

note: type: Plain text
en: I<oldpath> or I<newpath> points outside your accessible address space.
fr: I<oldpath> ou I<newpath> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: An I/O error occurred.
fr: Une erreur d'entrée-sortie s'est produite.

note: type: Plain text
en: Too many symbolic links were encountered in resolving I<oldpath> or I<newpath>.
fr: Trop de liens symboliques ont été rencontrés en parcourant I<oldpath> ou I<newpath>.

note: type: Plain text
en: The file referred to by I<oldpath> already has the maximum number of links to it.
fr: Le fichier référencé par I<oldpath> possède déjà le nombre maximal de liens.

note: type: Plain text
en: I<oldpath> or I<newpath> was too long.
fr: I<oldpath> ou I<newpath> est trop long.

note: type: Plain text
en: A directory component in I<oldpath> or I<newpath> does not exist or is a dangling symbolic link.
fr: Un répertoire contenu dans I<oldpath> ou I<newpath> n'existe pas, ou est un lien symbolique pointant nulle part.

note: type: Plain text
en: Insufficient kernel memory was available.
fr: Pas assez de mémoire pour le noyau.

note: type: Plain text
en: The device containing the file has no room for the new directory entry.
fr: Le périphérique contenant le fichier n'a pas de place pour une nouvelle entrée de répertoire.

note: type: Plain text
en: A component used as a directory in I<oldpath> or I<newpath> is not, in fact, a directory.
fr: Un élément du chemin d'accès I<oldpath> ou I<newpath> n'est pas réellement un répertoire.

note: type: Plain text
en: I<oldpath> is a directory.
fr: I<oldpath> est un répertoire.

note: type: Plain text
en: The filesystem containing I<oldpath> and I<newpath> does not support the creation of hard links.
fr: Le système de fichiers contenant I<oldpath> et I<newpath> ne permet pas la création de liens matériels.

note: type: TP
en: B<EPERM> (since Linux 3.6)
fr: B<EPERM> (depuis Linux 3.6)

note: type: Plain text
en: The caller does not have permission to create a hard link to this file (see the description of I</proc/sys/fs/protected_hardlinks> in B<proc>(5)).
fr: L'appelant n'a pas le droit de créer un lien matériel vers ce fichier (consultez la description de I</proc/sys/fs/protected_hardlinks> dans B<proc>(5)).

note: type: Plain text
en: The file is on a read-only filesystem.
fr: Le fichier se trouve sur un système de fichiers en lecture seule.

note: type: Plain text
en: I<oldpath> and I<newpath> are not on the same mounted filesystem.  (Linux permits a filesystem to be mounted at multiple points, but B<link>()  does not work across different mount points, even if the same filesystem is mounted on both.)
fr: I<oldpath> et I<newpath> ne résident pas sur le même système de fichiers. (Linux permet de monter un système de fichiers à différents endroits, mais B<link>() ne fonctionne pas sur différents points de montage, même si le système de fichiers sous\(hyjacent est le même.

note: type: Plain text
en: The following additional errors can occur for B<linkat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<linkat>()\ :

note: type: Plain text
en: I<olddirfd> or I<newdirfd> is not a valid file descriptor.
fr: I<olddirfd> ou I<newdirfd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: An invalid flag value was specified in I<flags>.
fr: I<flags> contient un drapeau invalide.

note: type: Plain text
en: B<AT_EMPTY_PATH> was specified in I<flags>, but the caller did not have the B<CAP_DAC_READ_SEARCH> capability.
fr: B<AT_EMPTY_PATH> est indiqué dans I<flags> mais l'appelant n'a pas la capacité B<CAP_DAC_READ_SEARCH>.

note: type: Plain text
en: An attempt was made to link to the I</proc/self/fd/NN> file corresponding to a file descriptor created with
fr: Une tentative de lier vers le fichier I</proc/self/fd/NN> correspondant à un descripteur de fichier créé avec

note: type: Plain text
en: See B<open>(2).
fr: a été réalisée. Consultez B<open>(2).

note: type: Plain text
en: I<oldpath> is relative and I<olddirfd> is a file descriptor referring to a file other than a directory; or similar for I<newpath> and I<newdirfd>
fr: I<oldpath> est un chemin relatif, et I<olddirfd> est un descripteur de fichier ne référençant pas un répertoire\ ; ou bien c'est le cas pour I<newpath> et I<newdirfd>.

note: type: Plain text
en: B<AT_EMPTY_PATH> was specified in I<flags>, I<oldpath> is an empty string, and I<olddirfd> refers to a directory.
fr: B<AT_EMPTY_PATH> a été précisé dans I<flags>, I<oldpath> est une chaîne vide, et I<olddirfd> fait référence à un répertoire.

note: type: Plain text
en: B<linkat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<linkat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: SVr4 documents additional ENOLINK and EMULTIHOP error conditions; POSIX.1 does not document ELOOP. X/OPEN does not document EFAULT, ENOMEM or EIO. type: Plain text
en: B<link>(): SVr4, 4.3BSD, POSIX.1-2001 (but see NOTES), POSIX.1-2008.
fr: B<link>() : SVr4, BSD\ 4.3, POSIX.1-2001 (mais consultez la section NOTES), POSIX.1-2008.

note: type: Plain text
en: B<linkat>(): POSIX.1-2008.
fr: B<linkat>() : POSIX.1-2008.

note: type: Plain text
en: Hard links, as created by B<link>(), cannot span filesystems.  Use B<symlink>(2)  if this is required.
fr: Les liens matériels créés par B<link>(), ne peuvent pas s'étendre sur plusieurs systèmes de fichiers. Utilisez plutôt B<symlink>(2) si ceci est nécessaire.

note: more precisely: since kernel 1.3.56 For example, the default Solaris compilation environment behaves like Linux, and contributors to a March 2005 thread in the Austin mailing list reported that some other (System V) implementations did/do the same -- MTK, Apr 05 type: Plain text
en: POSIX.1-2001 says that B<link>()  should dereference I<oldpath> if it is a symbolic link.  However, since kernel 2.0, Linux does not do so: if I<oldpath> is a symbolic link, then I<newpath> is created as a (hard) link to the same symbolic link file (i.e., I<newpath> becomes a symbolic link to the same file that I<oldpath> refers to).  Some other implementations behave in the same manner as Linux.  POSIX.1-2008 changes the specification of B<link>(), making it implementation-dependent whether or not I<oldpath> is dereferenced if it is a symbolic link.  For precise control over the treatment of symbolic links when creating a link, use B<linkat>(2).
fr: Selon POSIX.1-2001, B<link>() devrait déréférencer I<oldpath> s'il s'agit d'un lien symbolique. Cependant, depuis le noyau 2.0, Linux ne se comporte pas comme cela\ : si I<oldpath> est un lien symbolique, alors I<newpath> est créé comme un lien matériel vers le même fichier de lien symbolique (c'est\(hyà\(hydire que I<newpath> devient un lien symbolique vers le fichier sur lequel pointe I<oldpath>). Certaines autres implémentations ont le même comportement que Linux. POSIX.1-2008 change la spécification de B<link>(), en rendant dépendant de l'implémentation le fait que I<oldpath> est déréférencé s'il s'agit d'un lien symbolique. Pour un contrôle précis sur le traitement des liens symboliques pour la création d'un lien, consultez B<linkat>(2).

note: type: Plain text
en: On NFS filesystems, the return code may be wrong in case the NFS server performs the link creation and dies before it can say so.  Use B<stat>(2)  to find out if the link got created.
fr: Sur les systèmes de fichiers NFS, le code de retour peut être faux si le serveur NFS a créé correctement le lien mais s'est arrêté avant de donner le code de retour. Utiliser dans ce cas B<stat>(2) pour vérifier si le lien a été effectivement créé.

note: type: TH
en: 2012-07-13
fr: 13 juillet 2012

note: type: Plain text
en: _llseek - reposition read/write file offset
fr: _llseek - Positionner la tête de lecture/écriture dans un fichier

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: The B<_llseek>()  function repositions the offset of the open file associated with the file descriptor I<fd> to I<(offset_highE<lt>E<lt>32) | offset_low> bytes relative to the beginning of the file, the current position in the file, or the end of the file, depending on whether I<whence> is B<SEEK_SET>, B<SEEK_CUR>, or B<SEEK_END>, respectively.  It returns the resulting file position in the argument I<result>.
fr: La fonction B<_llseek>() place la tête de lecture/écriture du fichier associé à I<fd> à la position I<(offset_highE<lt>E<lt>32) | offset_low> (en octets) par rapport au début du fichier, à la position actuelle, ou à la fin du fichier, suivant que la valeur I<whence> soit B<SEEK_SET>, B<SEEK_CUR> ou B<SEEK_END>, respectivement. La fonction retourne la nouvelle position dans l'argument I<result>.

note: type: Plain text
en: Upon successful completion, B<_llseek>()  returns 0.  Otherwise, a value of -1 is returned and I<errno> is set to indicate the error.
fr: En cas de réussite, B<_llseek>() renvoie 0, sinon il renvoie -1, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: I<fd> is not an open file descriptor.
fr: I<fd> n'est pas un descripteur de fichier ouvert.

note: type: Plain text
en: Problem with copying results to user space.
fr: Problème lors de la copie des résultats vers l'espace utilisateur.

note: type: Plain text
en: I<whence> is invalid.
fr: I<whence> est invalide.

note: type: Plain text
en: This function is Linux-specific, and should not be used in programs intended to be portable.
fr: Cette fonction est spécifique à Linux et ne devrait pas être employée dans des programmes destinés à être portables.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; utilisez B<syscall>(2) pour l'appeler.

note: type: TH
en: 2014-01-22
fr: 22 janvier 2014

note: type: Plain text
en: lseek - reposition read/write file offset
fr: lseek - Positionner la tête de lecture/écriture dans un fichier

note: type: Plain text
en: The B<lseek>()  function repositions the offset of the open file associated with the file descriptor I<fd> to the argument I<offset> according to the directive I<whence> as follows:
fr: La fonction B<lseek>() place la tête de lecture/écriture à la position I<offset> dans le fichier associé au descripteur I<fd> en suivant la directive I<whence> ainsi\ :

note: type: Plain text
en: The offset is set to I<offset> bytes.
fr: La tête est placée à I<offset> octets depuis le début du fichier.

note: type: Plain text
en: The offset is set to its current location plus I<offset> bytes.
fr: La tête de lecture/écriture est avancée de I<offset> octets.

note: type: Plain text
en: The offset is set to the size of the file plus I<offset> bytes.
fr: La tête est placée à la fin du fichier plus I<offset> octets.

note: type: Plain text
en: The B<lseek>()  function allows the file offset to be set beyond the end of the file (but this does not change the size of the file).  If data is later written at this point, subsequent reads of the data in the gap (a "hole") return null bytes (\(aq\e0\(aq) until data is actually written into the gap.
fr: La fonction B<lseek>() permet de placer la tête au\(hydelà de la fin actuelle du fichier (mais cela ne modifie pas la taille du fichier). Si des données sont écrites à cet emplacement, une lecture ultérieure de l'espace intermédiaire (un «\ trou\ ») retournera des octets nul («\ \e0\ ») jusqu'à ce que d'autres données y soient écrites.

note: type: SS
en: Seeking file data and holes
fr: Recherche de données et trous de fichiers

note: type: Plain text
en: Since version 3.1, Linux supports the following additional values for I<whence>:
fr: Depuis la version 3.1, Linux accepte de plus les valeurs suivantes de I<whence> :

note: type: Plain text
en: Adjust the file offset to the next location in the file greater than or equal to I<offset> containing data.  If I<offset> points to data, then the file offset is set to I<offset>.
fr: Positionner la tête sur le prochain (supérieur ou égal à I<offset>) emplacement du fichier contenant des données. Si I<offset> pointe sur des données, la tête est placée sur I<offset>.

note: type: Plain text
en: Adjust the file offset to the next hole in the file greater than or equal to I<offset>.  If I<offset> points into the middle of a hole, then the file offset is set to I<offset>.  If there is no hole past I<offset>, then the file offset is adjusted to the end of the file (i.e., there is an implicit hole at the end of any file).
fr: Positionner la tête sur le prochain (supérieur ou égal à I<offset>) trou du fichier. Si I<offset> pointe au milieu d'un trou, la tête est placée sur I<offset>. S'il n'y a pas de trou après I<offset>, la tête est positionnée à la fin du fichier (c'est-à-dire qu'il y a un trou implicite à la fin de tous les fichiers).

note: type: Plain text
en: In both of the above cases, B<lseek>()  fails if I<offset> points past the end of the file.
fr: Dans les deux cas précédents, B<lseek>() échoue si I<offset> pointe après la fin du fichier.

note: type: Plain text
en: These operations allow applications to map holes in a sparsely allocated file.  This can be useful for applications such as file backup tools, which can save space when creating backups and preserve holes, if they have a mechanism for discovering holes.
fr: Ces opérations permettent aux applications d'établir une projection des trous dans un fichier fractionné. Cela peut servir aux applications du type outils de sauvegarde, qui peuvent économiser de l'espace lors de la création de sauvegardes et conserver les trous, si elles disposent d'un mécanisme permettant de trouver les trous.

note: https://lkml.org/lkml/2011/4/22/79 http://lwn.net/Articles/440255/ http://blogs.oracle.com/bonwick/entry/seek_hole_and_seek_data type: Plain text
en: For the purposes of these operations, a hole is a sequence of zeros that (normally) has not been allocated in the underlying file storage.  However, a filesystem is not obliged to report holes, so these operations are not a guaranteed mechanism for mapping the storage space actually allocated to a file.  (Furthermore, a sequence of zeros that actually has been written to the underlying storage may not be reported as a hole.)  In the simplest implementation, a filesystem can support the operations by making B<SEEK_HOLE> always return the offset of the end of the file, and making B<SEEK_DATA> always return I<offset> (i.e., even if the location referred to by I<offset> is a hole, it can be considered to consist of data that is a sequence of zeros).
fr: Pour ces opérations, un trou est une suite de zéros qui n'a (normalement) pas été allouée au stockage sous-jacent du fichier. Cependant, un système de fichiers n'est pas forcé de signaler les trous, donc ces opérations ne permettent pas de garantir la projection de l'espace de stockage vraiment alloué à un fichier (de plus, une suite de zéros vraiment écrite sur le stockage sous-jacent pourrait ne pas être signalée comme un trou). La plus simple implémentation de ses opérations pour un système de fichier, serait avec B<SEEK_HOLE> renvoyant toujours la position de fin de fichier, et B<SEEK_DATA> renvoyant toujours I<offset> (c'est-à-dire, même si I<offset> pointe à l'emplacement d'un trou, la suite de zéros peut être considérée comme des données).

note: type: Plain text
en: The B<_GNU_SOURCE> feature test macro must be defined in order to obtain the definitions of B<SEEK_DATA> and B<SEEK_HOLE> from I<E<lt>unistd.hE<gt>>.
fr: La macro de test de fonctionnalités B<_GNU_SOURCE> doit être définie pour accéder aux définitions de B<SEEK_DATA> et B<SEEK_HOLE> depuis I<E<lt>unistd.hE<gt>>.

note: type: Plain text
en: The B<SEEK_HOLE> and B<SEEK_DATA> operations are supported for the following filesystems:
fr: Les opérations B<SEEK_HOLE> et B<SEEK_DATA> sont prises en charge avec les systèmes de fichiers suivants :

note: type: Plain text
en: Btrfs (since Linux 3.1)
fr: Btrfs (depuis Linux 3.1)

note: commit 93862d5e1ab875664c6cc95254fc365028a48bb1 type: Plain text
en: OCFS (since Linux 3.2)
fr: OCFS (depuis Linux 3.2)

note: type: Plain text
en: XFS (since Linux 3.5)
fr: XFS (depuis Linux 3.5)

note: type: Plain text
en: ext4 (since Linux 3.8)
fr: ext4 (depuis Linux 3.8)

note: type: Plain text
en: tmpfs (since Linux 3.8)
fr: tmpfs (depuis Linux 3.8)

note: type: Plain text
en: Upon successful completion, B<lseek>()  returns the resulting offset location as measured in bytes from the beginning of the file.  On error, the value I<(off_t)\ -1> is returned and I<errno> is set to indicate the error.
fr: B<lseek>(), si elle réussit, renvoie le nouvel emplacement, mesuré en octets depuis le début du fichier. En cas d'échec, la valeur I<(off_t)\ -1> est renvoyée, et I<errno> contient le code d'erreur.

note: Some systems may allow negative offsets for character devices and/or for remote filesystems. type: Plain text
en: I<whence> is not valid.  Or: the resulting file offset would be negative, or beyond the end of a seekable device.
fr: Soit I<whence> n'est pas valable, soit la position demandée serait négative, ou après la fin d'un périphérique.

note: HP-UX 11 says EINVAL for this case (but POSIX.1 says EOVERFLOW) type: Plain text
en: The resulting file offset cannot be represented in an I<off_t>.
fr: La position résultante dans le fichier ne peut être représentée dans un I<off_t>.

note: type: Plain text
en: I<fd> is associated with a pipe, socket, or FIFO.
fr: I<fd> est associé à un tube (pipe), une socket, ou une file FIFO.

note: type: Plain text
en: I<whence> is B<SEEK_DATA> or B<SEEK_HOLE>, and the current file offset is beyond the end of the file.
fr: I<whence> est B<SEEK_DATA> ou B<SEEK_HOLE>, et la position demandée est après la fin d'un périphérique.

note: SVr4 documents additional error conditions EDEADLK, ENOLCK, ENOLNK, ENOSR, ENXIO, or ERANGE. type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001.

note: FIXME . Review http://austingroupbugs.net/view.php?id=415 in the future type: Plain text
en: B<SEEK_DATA> and B<SEEK_HOLE> are nonstandard extensions also present in Solaris, FreeBSD, and DragonFly BSD; they are proposed for inclusion in the next POSIX revision (Issue 8).
fr: B<SEEK_DATA> et B<SEEK_HOLE> sont des extensions non normalisées existant aussi sous Solaris, FreeBSD et DragonFly BSD. Leur intégration est proposée pour la prochaine révision de POSIX (Issue 8).

note: type: Plain text
en: Some devices are incapable of seeking and POSIX does not specify which devices must support B<lseek>().
fr: Certains périphériques ne permettent pas de positionnement direct, POSIX ne précise quels périphériques doivent gérer B<lseek>().

note: Other systems return the number of written characters, using SEEK_SET to set the counter. (Of written characters.) type: Plain text
en: On Linux, using B<lseek>()  on a terminal device returns B<ESPIPE>.
fr: Sous Linux, l'utilisation de B<lseek>() sur un périphérique terminal (tty) renvoie B<ESPIPE>.

note: type: Plain text
en: When converting old code, substitute values for I<whence> with the following macros:
fr: Lors de la conversion d'un ancien code, substituez les valeurs de I<whence> par les macros suivantes\ :

note: type: tbl table
en: old	new
fr: ancien	nouveau

note: type: Plain text
en: Note that file descriptors created by B<dup>(2)  or B<fork>(2)  share the current file position pointer, so seeking on such files may be subject to race conditions.
fr: Notez que les descripteurs de fichier dupliqués par B<dup>(2) ou B<fork>(2) partagent le même pointeur de position. Ainsi le déplacement sur de tels fichiers peut conduire à des problèmes d'accès concurrents.

note: type: TH
en: 2013-08-19
fr: 19 août 2013

note: type: Plain text
en: lseek64 - reposition 64-bit read/write file offset
fr: lseek64 - Positionner la tête de lecture/écriture dans un fichier (version 64 bits)

note: type: Plain text
en: B<#define _LARGEFILE64_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _LARGEFILE64_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The B<lseek>(2)  family of functions reposition the offset of the open file associated with the file descriptor I<fd> to I<offset> bytes relative to the start, current position, or end of the file, when I<whence> has the value B<SEEK_SET>, B<SEEK_CUR>, or B<SEEK_END>, respectively.
fr: Les fonctions de la famille B<lseek>(2) repositionnent la tête de lecture d'un fichier ouvert associé au descripteur de fichier I<fd> à I<offset> octets relativement au début du fichier, à la position actuelle et à la fin du fichier lorsque I<whence> a respectivement la valeur B<SEEK_SET>, B<SEEK_CUR> ou B<SEEK_END>.

note: type: Plain text
en: For more details, return value, and errors, see B<lseek>(2).
fr: Pour plus de détails sur les valeurs renvoyées et les erreurs, consultez B<lseek>(2).

note: type: Plain text
en: Four interfaces are available: B<lseek>(2), B<lseek64>(), B<llseek>(2), and the raw system call B<_llseek>(2).
fr: Quatre interfaces sont disponibles\ : B<lseek>(2), B<lseek64>(), B<llseek>(2) et l'appel système brut B<_llseek>(2).

note: type: Plain text
en: Prototype:
fr: Prototype\ :

note: type: Plain text
en: B<lseek>(2)  uses the type I<off_t>.  This is a 32-bit signed type on 32-bit architectures, unless one compiles with
fr: B<lseek>(2) utilise le type I<off_t>. C'est un type signé sur 32\ bits pour les architectures 32\ bits, à moins que l'on compile avec

note: type: Plain text
en: in which case it is a 64-bit signed type.
fr: auquel cas c'est un type 64 bits signé.

note: type: Plain text
en: The library routine B<lseek64>()  uses a 64-bit type even when I<off_t> is a 32-bit type.  Its prototype (and the type I<off64_t>)  is available only when one compiles with
fr: La routine de bibliothèque B<lseek64>() utilise un type sur 64\ bits même si I<off_t> est un type 32\ bits. Son prototype (et le type I<off64_t>) n'est disponible que lorsqu'on compile avec

note: in glibc 2.0.94, not in 2.0.6 type: Plain text
en: The function B<lseek64>()  is available since glibc 2.1, and is defined to be an alias for B<llseek>().
fr: La fonction B<lseek64>() est disponible depuis la glibc\ 2.1, et elle est définie comme un alias de B<llseek>().

note: in libc 5.0.9, not in 4.7.6 type: Plain text
en: The type I<loff_t> is a 64-bit signed type.  The library routine B<llseek>()  is available in libc5 and glibc and works without special defines.  Its prototype was given in I<E<lt>unistd.hE<gt>> with libc5, but glibc does not provide a prototype.  This is bad, since a prototype is needed.  Users should add the above prototype, or something equivalent, to their own source.  When users complained about data loss caused by a miscompilation of B<e2fsck>(8), glibc 2.1.3 added the link-time warning
fr: Le type I<loff_t> est un type 64\ bits signé. La routine de bibliothèque B<llseek> est disponible dans la libc5 et dans la glibc, mais sans définition particulière. Son prototype était donné dans I<E<lt>unistd.hE<gt>> pour la libc5, mais la glibc ne propose pas de prototype. Ceci n'est pas bon puisqu'un prototype est nécessaire. Les utilisateurs devraient ajouter le prototype ci-dessus, ou quelque chose d'équivalent dans leurs sources. Lorsque des utilisateurs se plaignaient à propos de données perdues à cause d'une mauvaise compilation de B<e2fsck>(8), la glibc\ 2.1.3 a ajouté un avertissement au moment de l'édition de liens\ :

note: type: Plain text
en: the \`llseek\' function may be dangerous; use \`lseek64\' instead.
fr: la fonction «\ llseek\ » peut être dangereuse\ ; utilisez «\ lseek64\ » à la place.

note: type: Plain text
en: This makes this function unusable if one desires a warning-free compilation.
fr: Cela fait que cette fonction est inutilisable si l'on souhaite une compilation vierge de tout avertissement.

note: type: Plain text
en: All the above functions are implemented in terms of this system call.  The prototype is:
fr: Toutes les fonctions ci-dessus sont implémentées avec cet appel système. Le prototype est le suivant\ :

note: type: Plain text
en: For more details, see B<llseek>(2).
fr: Pour plus de détails, consultez B<llseek>(2).

note: type: Plain text
en: The B<lseek64>()  function is thread-safe.
fr: La fonction B<lseek64>() est sûre dans un contexte multithread.

note: type: TH
en: 2014-04-20
fr: 20 avril 2014

note: type: Plain text
en: open, openat, creat - open and possibly create a file
fr: open, openat, creat - Ouvrir ou créer éventuellement un fichier

note: type: Plain text
en: Given a I<pathname> for a file, B<open>()  returns a file descriptor, a small, nonnegative integer for use in subsequent system calls (B<read>(2), B<write>(2), B<lseek>(2), B<fcntl>(2), etc.).  The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.
fr: Étant donné le chemin I<pathname> d'un fichier, B<open>() renvoie un descripteur de fichier (petit entier positif ou nul) qui pourra ensuite être utilisé dans d'autres appels système (B<read>(2), B<write>(2), B<lseek>(2), B<fcntl>(2), etc.). Le descripteur de fichier renvoyé par un appel réussi sera le plus petit descripteur de fichier non actuellement ouvert par le processus.

note: type: Plain text
en: By default, the new file descriptor is set to remain open across an B<execve>(2)  (i.e., the B<FD_CLOEXEC> file descriptor flag described in B<fcntl>(2)  is initially disabled; the B<O_CLOEXEC> flag, described below, can be used to change this default).  The file offset is set to the beginning of the file (see B<lseek>(2)).
fr: Par défaut, le nouveau descripteur de fichier est configuré pour rester ouvert après un appel à B<execve>(2) (son attribut B<FD_CLOEXEC> décrit dans B<fcntl>(2) est initialement désactivé). L'attribut B<O_CLOEXEC> décrit ci-dessous permet de modifier ce comportement par défaut. La position dans le fichier est définie au début du fichier (consultez B<lseek>(2)).

note: type: Plain text
en: A call to B<open>()  creates a new I<open file description>, an entry in the system-wide table of open files.  This entry records the file offset and the file status flags (modifiable via the B<fcntl>(2)  B<F_SETFL> operation).  A file descriptor is a reference to one of these entries; this reference is unaffected if I<pathname> is subsequently removed or modified to refer to a different file.  The new open file description is initially not shared with any other process, but sharing may arise via B<fork>(2).
fr: Un appel à B<open>() crée une nouvelle I<description de fichier ouvert>, une entrée dans la table de fichiers ouverts du système. Cette entrée enregistre la position dans le fichier et les attributs d'état du fichier (modifiables par l'opération B<F_SETFL> de B<fcntl>(2)). Un descripteur de fichier est une référence à l'une de ces entrées\ ; cette référence n'est pas modifiée si I<pathname> est ensuite supprimé ou modifié pour correspondre à un autre fichier. La nouvelle description de fichier ouvert n'est initialement partagée avec aucun autre processus, mais ce partage peut apparaître après un B<fork>(2).

note: type: Plain text
en: The argument I<flags> must include one of the following I<access modes>: B<O_RDONLY>, B<O_WRONLY>, or B<O_RDWR>.  These request opening the file read-only, write-only, or read/write, respectively.
fr: Le paramètre I<flags> est l'un des éléments B<O_RDONLY>, B<O_WRONLY> ou B<O_RDWR> qui réclament respectivement l'ouverture du fichier en lecture seule, écriture seule, ou lecture/écriture.

note: SUSv4 divides the flags into: * Access mode * File creation * File status * Other (O_CLOEXEC, O_DIRECTORY, O_NOFOLLOW) though it's not clear what the difference between "other" and "File creation" flags is.  I raised an Aardvark to see if this can be clarified in SUSv4; 10 Oct 2008. http://thread.gm
en: In addition, zero or more file creation flags and file status flags can be bitwise-I<or>'d in I<flags>.  The I<file creation flags> are B<O_CLOEXEC>, B<O_CREAT>, B<O_DIRECTORY>, B<O_EXCL>, B<O_NOCTTY>, B<O_NOFOLLOW>, B<O_TMPFILE>, B<O_TRUNC>, and B<O_TTY_INIT>.  The I<file status flags> are all of the remaining flags listed below.  The distinction between these two groups of flags is that the file status flags can be retrieved and (in some cases)  modified; see B<fcntl>(2)  for details.
fr: De plus, zéro ou plusieurs attributs de création de fichier et attributs d'état de fichier peuvent être indiqués dans I<flags> avec un OU binaire. Les I<attributs de création de fichier> sont B<O_CLOEXEC>, B<O_CREAT>, B<O_DIRECTORY>, B<O_EXCL>, B<O_NOCTTY>, B<O_NOFOLLOW>, B<O_TMPFILE>, B<O_TRUNC> et B<O_TTY_INIT>. Les I<attributs d'état de fichier> sont tous les autres attributs indiqués ci-dessous. La distinction entre ces deux groupes est que les attributs d'état de fichier peuvent être lus et (dans certains cas) modifiés ; consultez B<fcntl>(2) pour plus de précisions.

note: type: Plain text
en: The full list of file creation flags and file status flags is as follows:
fr: La liste complète des attributs de création et d'état de fichier est la suivante.

note: For more background, see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=453946 http://nfs.sourceforge.net/ type: Plain text
en: The file is opened in append mode.  Before each B<write>(2), the file offset is positioned at the end of the file, as if with B<lseek>(2).  B<O_APPEND> may lead to corrupted files on NFS filesystems if more than one process appends data to a file at once.  This is because NFS does not support appending to a file, so the client kernel has to simulate it, which can't be done without a race condition.
fr: Le fichier est ouvert en mode «\ ajout\ ». Initialement, et avant chaque B<write>(2), la tête de lecture/écriture est placée à la fin du fichier comme avec B<lseek>(2). Il y a un risque d'endommager le fichier lorsque B<O_APPEND> est utilisé, sur un système de fichiers NFS, si plusieurs processus tentent d'ajouter des données simultanément au même fichier. Ceci est dû au fait que NFS ne supporte pas l'opération d'ajout de données dans un fichier, aussi le noyau du client est obligé de la simuler, avec un risque de concurrence des tâches.

note: type: Plain text
en: Enable signal-driven I/O: generate a signal (B<SIGIO> by default, but this can be changed via B<fcntl>(2))  when input or output becomes possible on this file descriptor.  This feature is available only for terminals, pseudoterminals, sockets, and (since Linux 2.6) pipes and FIFOs.  See B<fcntl>(2)  for further details.  See also BUGS, below.
fr: Déclencher un signal (B<SIGIO> par défaut, mais peut être changé via B<fcntl>(2)) lorsque la lecture ou l'écriture deviennent possibles sur ce descripteur. Ceci n'est possible que pour les terminaux, pseudoterminaux, sockets et (depuis Linux 2.6) tubes et FIFO. Consultez B<fcntl>(2) pour plus de détails. Consultez aussi B<BOGUES> ci-dessous.

note: type: TP
en: B<O_CLOEXEC> (since Linux 2.6.23)
fr: B<O_CLOEXEC> (depuis Linux 2.6.23)

note: NOTE! several otehr man pages refer to this text type: Plain text
en: Enable the close-on-exec flag for the new file descriptor.  Specifying this flag permits a program to avoid additional B<fcntl>(2)  B<F_SETFD> operations to set the B<FD_CLOEXEC> flag.
fr: Activer l'attribut « close-on-exec » pour le nouveau descripteur de fichier. En précisant cet attribut, on évite au programme d'avoir à utiliser les opérations B<fcntl>(2)  B<F_SETFD> pour positionner l'attribut B<FD_CLOEXEC>.

note: This flag fixes only one form of the race condition; The race can also occur with, for example, descriptors returned by accept(), pipe(), etc. type: Plain text
en: Note that the use of this flag is essential in some multithreaded programs, because using a separate B<fcntl>(2)  B<F_SETFD> operation to set the B<FD_CLOEXEC> flag does not suffice to avoid race conditions where one thread opens a file descriptor and attempts to set its close-on-exec flag using B<fcntl>(2)  at the same time as another thread does a B<fork>(2)  plus B<execve>(2).  Depending on the order of execution, the race may lead to the file desriptor returned by B<open>()  being unintentionally leaked to the program executed by the child process created by B<fork>(2).  (This kind of race is in principle possible for any system call that creates a file descriptor whose close-on-exec flag should be set, and various other Linux system calls provide an equivalent of the B<O_CLOEXEC> flag to deal with this problem.)
fr: Notez que le recours à cet attribut est indispensable pour certains programmes multithreadés. En effet, l'utilisation d'une opération B<fcntl>(2) B<F_SETFD> pour positionner l'attribut B<FD_CLOEXEC> ne suffit pas à éviter une situation d'accès concurrents si un thread ouvre un descripteur de fichier et tente d'activer l'attribut « close-on-exec » au moyen de B<fcntl>(2) au moment où un autre thread execute B<fork>(2) suivi de B<execve>(2). Selon l'ordre dans lequel ces opérations s'exécutent, cette concurrence peut aboutir à ce que le descripteur de fichier renvoyé par B<open>() soit involontairement mis à disposition du programme exécuté par le processus fils créé par B<fork>(2). (Ce type concurrence est en principe possible pour tout appel système qui crée un descripteur de fichier dont l'attribut « close-on-exec » est actif ; certains appels système de Linux offrent des équivalents de l'attribut B<O_CLOEXEC> pour régler ce problème.)

note: As at 2.6.25, bsdgroups is supported by ext2, ext3, ext4, and XFS (since 2.6.14). type: Plain text
en: If the file does not exist, it will be created.  The owner (user ID) of the file is set to the effective user ID of the process.  The group ownership (group ID) is set either to the effective group ID of the process or to the group ID of the parent directory (depending on filesystem type and mount options, and the mode of the parent directory; see the mount options I<bsdgroups> and I<sysvgroups> described in B<mount>(8)).
fr: Créer le fichier s'il n'existe pas. Le possesseur (UID) du fichier est renseigné avec l'UID effectif du processus. Le groupe propriétaire (GID) du fichier est le GID effectif du processus ou le GID du répertoire parent (cela dépend du système de fichiers, des options de montage, du mode du répertoire parent ; consultez les options de montage I<bsdgroups> et I<sysvgroups> décrites dans la page B<mount>(8)).

note: type: Plain text
en: I<mode> specifies the permissions to use in case a new file is created.  This argument must be supplied when B<O_CREAT> or B<O_TMPFILE> is specified in I<flags>; if neither B<O_CREAT> nor B<O_TMPFILE> is specified, then I<mode> is ignored.  The effective permissions are modified by the process's I<umask> in the usual way: The permissions of the created file are I<(mode\ &\ ~umask)>.  Note that this mode applies only to future accesses of the newly created file; the B<open>()  call that creates a read-only file may well return a read/write file descriptor.
fr: Le paramètre I<mode> indique les droits à utiliser si un nouveau fichier est créé. Ce paramètre doit être fourni quand B<O_CREAT> ou B<O_TMPFILE> sont indiqués dans I<flags> ; si ni B<O_CREAT> ni B<O_TMPFILE> ne sont précisés, I<mode> est ignoré. Les droits effectifs sont modifiées par le I<umask> du processus : la véritable valeur utilisée est I<(mode\ &\ ~umask)>. Remarquez que ce mode ne s'applique qu'aux accès ultérieurs au fichier nouvellement créé. L'appel B<open>() qui crée un fichier dont le mode est en lecture seule fournira quand même un descripteur de fichier en lecture et écriture.

note: type: Plain text
en: The following symbolic constants are provided for I<mode>:
fr: Les constantes symboliques suivantes sont disponibles pour I<mode>\ :

note: type: Plain text
en: 00700 user (file owner) has read, write and execute permission
fr: 00700 L'utilisateur (propriétaire du fichier) a les autorisations de lecture, écriture, exécution.

note: type: Plain text
en: 00400 user has read permission
fr: 00400 L'utilisateur a l'autorisation de lecture.

note: type: Plain text
en: 00200 user has write permission
fr: 00200 L'utilisateur a l'autorisation d'écriture.

note: type: Plain text
en: 00100 user has execute permission
fr: 00100 L'utilisateur a l'autorisation d'exécution.

note: type: Plain text
en: 00070 group has read, write and execute permission
fr: 00070 Le groupe a les autorisations de lecture, écriture, exécution.

note: type: Plain text
en: 00040 group has read permission
fr: 00040 Le groupe a l'autorisation de lecture.

note: type: Plain text
en: 00020 group has write permission
fr: 00020 Le groupe a l'autorisation d'écriture.

note: type: Plain text
en: 00010 group has execute permission
fr: 00010 Le groupe a l'autorisation d'exécution.

note: type: Plain text
en: 00007 others have read, write and execute permission
fr: 00007 Tout le monde a les autorisations de lecture, écriture, exécution.

note: type: Plain text
en: 00004 others have read permission
fr: 00004 Tout le monde a l'autorisation de lecture.

note: type: Plain text
en: 00002 others have write permission
fr: 00002 Tout le monde a l'autorisation d'écriture.

note: type: Plain text
en: 00001 others have execute permission
fr: 00001 Tout le monde a l'autorisation d'exécution.

note: type: TP
en: B<O_DIRECT> (since Linux 2.4.10)
fr: B<O_DIRECT> (depuis Linux 2.4.10)

note: type: Plain text
en: Try to minimize cache effects of the I/O to and from this file.  In general this will degrade performance, but it is useful in special situations, such as when applications do their own caching.  File I/O is done directly to/from user-space buffers.  The B<O_DIRECT> flag on its own makes an effort to transfer data synchronously, but does not give the guarantees of the B<O_SYNC> flag that data and necessary metadata are transferred.  To guarantee synchronous I/O, B<O_SYNC> must be used in addition to B<O_DIRECT>.  See NOTES below for further discussion.
fr: Essayer de minimiser les effets du cache d'entrée-sortie sur ce fichier. Cela dégradera en général les performances, mais est utile dans des situations spéciales, comme lorsque les applications ont leur propre cache. Les entrées-sorties de fichier sont faites directement de et vers les tampons d'espace utilisateur. L'ajout de l'attribut B<O_DIRECT> fait que les entrées-sorties sont synchrones ; en réalité un effort est fait pour rendre le transfert synchrone mais cela n'offre pas la garantie fournie par l'attribut B<O_SYNC> que les données et métadonnées sont transférées. Pour garantir des entrées-sorties synchrones, l'attribut B<O_SYNC> doit être utilisé en plus de l'attribut B<O_DIRECT>. Consultez la section B<NOTES> ci-dessous.

note: type: Plain text
en: A semantically similar (but deprecated) interface for block devices is described in B<raw>(8).
fr: Une interface à la sémantique similaire (mais dépréciée) pour les périphériques blocs est décrite à la page B<raw>(8).

note: But see the following and its replies: http://marc.theaimsgroup.com/?t=112748702800001&r=1&w=2 [PATCH] open: O_DIRECTORY and O_CREAT together should fail O_DIRECTORY | O_CREAT causes O_DIRECTORY to be ignored. type: Plain text
en: If I<pathname> is not a directory, cause the open to fail.  This flag was added in kernel version 2.1.126, to avoid denial-of-service problems if B<opendir>(3)  is called on a FIFO or tape device.
fr: Si I<pathname> n'est pas un répertoire, l'ouverture échoue. Cet attribut fut ajouté dans la version 2.1.126 du noyau, pour éviter des problèmes de dysfonctionnement si B<opendir>(3) est invoqué sur une FIFO ou un périphérique de bande.

note: type: Plain text
en: Write operations on the file will complete according to the requirements of synchronized I/O I<data> integrity completion.
fr: Les opérations d'écriture dans le fichier se dérouleront selon les conditions d'exécution des opérations E/S synchrones avec garantie d'intégrité des I<données>.

note: type: Plain text
en: By the time B<write>(2)  (and similar)  return, the output data has been transferred to the underlying hardware, along with any file metadata that would be required to retrieve that data (i.e., as though each B<write>(2)  was followed by a call to B<fdatasync>(2)).  I<See NOTES below>.
fr: Au moment où B<write>(2) (ou un appel similaire) renvoie une donnée, elle a été transmise au matériel sur lequel s'exécute l'appel, avec toutes les métadonnées du fichier qui pourraient être nécessaires à la récupération de cette donnée (c'est à dire comme si chaque appel à B<write>(2) était suivi d'un appel à B<fdatasync>(2)).  I<Consultez NOTES ci-dessous>.

note: type: Plain text
en: Ensure that this call creates the file: if this flag is specified in conjunction with B<O_CREAT>, and I<pathname> already exists, then B<open>()  will fail.
fr: S'assurer que cet appel crée le fichier : si cet attribut est spécifié en conjonction avec B<O_CREAT> et si le fichier I<pathname> existe déjà, B<open>() échouera.

note: POSIX.1-2001 explicitly requires this behavior. type: Plain text
en: When these two flags are specified, symbolic links are not followed: if I<pathname> is a symbolic link, then B<open>()  fails regardless of where the symbolic link points to.
fr: Lorsque ces deux attributs sont spécifiés, les liens symboliques ne sont pas suivis : si I<pathname> est un lien symbolique, B<open>() échouera quelque soit l'endroit où pointe le lien symbolique.

note: type: Plain text
en: In general, the behavior of B<O_EXCL> is undefined if it is used without B<O_CREAT>.  There is one exception: on Linux 2.6 and later, B<O_EXCL> can be used without B<O_CREAT> if I<pathname> refers to a block device.  If the block device is in use by the system (e.g., mounted), B<open>()  fails with the error B<EBUSY>.
fr: En général, le comportement de B<O_EXCL> est indéterminé s'il est utilisé sans B<O_CREAT>. Il existe une exception toutefois : à partir de Linux 2.6, B<O_EXCL> peut être utilisé sans B<O_CREAT> si I<pathname> fait référence à un périphérique bloc. Si le périphérique bloc est utilisé par le système (par exemple, s'il est monté), B<open>() échoue avec l'erreur B<EBUSY>.

note: type: Plain text
en: On NFS, B<O_EXCL> is supported only when using NFSv3 or later on kernel 2.6 or later.  In NFS environments where B<O_EXCL> support is not provided, programs that rely on it for performing locking tasks will contain a race condition.  Portable programs that want to perform atomic file locking using a lockfile, and need to avoid reliance on NFS support for B<O_EXCL>, can create a unique file on the same filesystem (e.g., incorporating hostname and PID), and use B<link>(2)  to make a link to the lockfile.  If B<link>(2)  returns 0, the lock is successful.  Otherwise, use B<stat>(2)  on the unique file to check if its link count has increased to 2, in which case the lock is also successful.
fr: Sur les systèmes de fichiers NFS, B<O_EXCL> n'est pris en charge qu'avec la version NFSv3 ou ultérieure, sur les noyaux 2.6 ou plus récents. Dans les environnements NFS où la prise en charge d'B<O_EXCL> n'est pas fournie, les programmes qui ont besoin de cette fonctionnalité pour verrouiller des tâches risquent de rencontrer une concurrence critique (race condition). Les programmes portables qui veulent effectuer un verrouillage fichier atomique en utilisant un fichier verrou et qui doivent éviter la dépendance de la prise en charge NFS pour B<O_EXCL> peuvent créer un fichier unique sur le même système de fichiers (par exemple, avec le PID et le nom de l'hôte), et utiliser B<link>(2) pour créer un lien sur un fichier de verrouillage. Si B<link>(2) renvoie 0, le verrouillage est réussi. Sinon, utiliser B<stat>(2) sur ce fichier unique pour vérifier si le nombre de liens a augmenté jusqu'à 2, auquel cas le verrouillage est également réussi.pour vérifier si le nombre de liens a augmenté jusqu'à 2. Ne pas utiliser la valeur de retour de B<link>(2).

note: type: Plain text
en: (LFS)  Allow files whose sizes cannot be represented in an I<off_t> (but can be represented in an I<off64_t>)  to be opened.  The B<_LARGEFILE64_SOURCE> macro must be defined (before including I<any> header files)  in order to obtain this definition.  Setting the B<_FILE_OFFSET_BITS> feature test macro to 64 (rather than using B<O_LARGEFILE>)  is the preferred method of accessing large files on 32-bit systems (see B<feature_test_macros>(7)).
fr: (LFS) Permet d'ouvrir des fichiers dont la taille ne peut pas être représentée dans un I<off_t> (mais peut l'être dans un I<off64_t>). La macro B<_LARGEFILE64_SOURCE> doit être définie (avant d'inclure I<tout> fichier d'en\(hytête) pour obtenir cette définition. Définir la macro B<_FILE_OFFSET_BITS> à 64 est la méthode à favoriser pour accéder à des grands fichiers sur des systèmes 32 bits, plutôt que d'utiliser B<O_LARGEFILE> (consultez B<feature_test_macros>(7)).

note: type: TP
en: B<O_NOATIME> (since Linux 2.6.8)
fr: B<O_NOATIME> (depuis Linux 2.6.8)

note: The O_NOATIME flag also affects the treatment of st_atime by mmap() and readdir(2), MTK, Dec 04. type: Plain text
en: Do not update the file last access time (I<st_atime> in the inode)  when the file is B<read>(2).  This flag is intended for use by indexing or backup programs, where its use can significantly reduce the amount of disk activity.  This flag may not be effective on all filesystems.  One example is NFS, where the server maintains the access time.
fr: Ne pas mettre à jour l'heure de dernier accès au fichier (champ I<st_atime> de l'inœud) quand le fichier est lu avec B<read>(2). Ce attribut est seulement conçu pour les programmes d'indexation et d'archivage, pour lesquels il peut réduire significativement l'activité du disque. L'attribut peut ne pas être effectif sur tous les systèmes de fichiers. Par exemple, avec NFS, l'heure d'accès est mise à jour par le serveur.

note: type: Plain text
en: If I<pathname> refers to a terminal device\(emsee B<tty>(4)\(emit will not become the process's controlling terminal even if the process does not have one.
fr: Si I<pathname> correspond à un périphérique de terminal \(em consultez B<tty>(4) \(em, il ne deviendra pas le terminal contrôlant le processus même si celui-ci n'est attaché à aucun autre terminal.

note: The headers from glibc 2.0.100 and later include a definition of this flag; \fIkernels before 2.1.126 will ignore it if used\fP. type: Plain text
en: If I<pathname> is a symbolic link, then the open fails.  This is a FreeBSD extension, which was added to Linux in version 2.1.126.  Symbolic links in earlier components of the pathname will still be followed.  See also B<O_PATH> below.
fr: Si I<pathname> est un lien symbolique, l'ouverture échoue. C’est une extension FreeBSD, qui fut ajoutée à Linux dans la version 2.1.126. Les liens symboliques se trouvant dans le chemin d'accès proprement dit seront suivis normalement. Consultez également B<O_PATH> dans la suite du document.

note: type: TP
en: B<O_NONBLOCK> or B<O_NDELAY>
fr: B<O_NONBLOCK> ou B<O_NDELAY>

note: type: Plain text
en: When possible, the file is opened in nonblocking mode.  Neither the B<open>()  nor any subsequent operations on the file descriptor which is returned will cause the calling process to wait.  For the handling of FIFOs (named pipes), see also B<fifo>(7).  For a discussion of the effect of B<O_NONBLOCK> in conjunction with mandatory file locks and with file leases, see B<fcntl>(2).
fr: Le fichier est ouvert en mode «\ non-bloquant\ ». Ni la fonction B<open>() ni aucune autre opération ultérieure sur ce fichier ne laissera le processus appelant en attente. Pour la manipulation des FIFO (tubes nommés), voir également B<fifo>(7). Pour une explication de l'effet de B<O_NONBLOCK> en conjonction avec les verrouillages impératifs et les baux de fichiers, voir B<fcntl>(2).

note: type: TP
en: B<O_PATH> (since Linux 2.6.39)
fr: B<O_PATH> (depuis Linux 2.6.39)

note: commit 1abf0c718f15a56a0a435588d1b104c7a37dc9bd commit 326be7b484843988afe57566b627fb7a70beac56 commit 65cfc6722361570bfe255698d9cd4dccaf47570d http://thread.gmane.org/gmane.linux.man/2790/focus=3496 Subject: Re: [PATCH] open(2): document O_PATH Newsgroups: gmane.linux.man, gmane.linux.kernel type: 
en: Obtain a file descriptor that can be used for two purposes: to indicate a location in the filesystem tree and to perform operations that act purely at the file descriptor level.  The file itself is not opened, and other file operations (e.g., B<read>(2), B<write>(2), B<fchmod>(2), B<fchown>(2), B<fgetxattr>(2), B<mmap>(2))  fail with the error B<EBADF>.
fr: Obtenir un descripteur de fichier qui peut être utile de deux façons : pour indiquer la localisation dans l'arborescence du système de fichiers et pour effectuer des opérations exclusivement au niveau du descripteur de fichier. Le fichier n'est pas lui-même ouvert et d'autres opérations sur le fichier (par exemple B<read>(2), B<write>(2), B<fchmod>(2), B<fchown>(2), B<fgetxattr>(2), B<mmap>(2)) échoueront en renvoyant l'erreur B<EBADF>.

note: type: Plain text
en: The following operations I<can> be performed on the resulting file descriptor:
fr: Les opérations suivantes I<peuvent> être réalisées sur le descripteur de fichier obtenu :

note: commit 332a2e1244bd08b9e3ecd378028513396a004a24 fstat(): commit 55815f70147dcfa3ead5738fd56d3574e2e3c1c2 type: Plain text
en: B<close>(2); B<fchdir>(2)  (since Linux 3.5); B<fstat>(2)  (since Linux 3.6).
fr: B<close>(2); B<fchdir>(2)  (à partir de Linux 3.5); B<fstat>(2)  (à partir de Linux 3.6).

note: type: Plain text
en: Duplicating the file descriptor (B<dup>(2), B<fcntl>(2)  B<F_DUPFD>, etc.).
fr: Dupliquer le descripteur de fichier (B<dup>(2), B<fcntl>(2),  B<F_DUPFD>, etc.).

note: type: Plain text
en: Getting and setting file descriptor flags (B<fcntl>(2)  B<F_GETFD> and B<F_SETFD>).
fr: Consulter et affecter les valeurs des attributs du descripteur de fichier (B<fcntl>(2),  B<F_GETFD> and B<F_SETFD>).

note: type: Plain text
en: Retrieving open file status flags using the B<fcntl>(2)  B<F_GETFL> operation: the returned flags will include the bit B<O_PATH>.
fr: Récupérer les attributs d'état de fichiers ouverts au moyen de l'opération B<fcntl>(2)  B<F_GETFL> : les attributs renvoyés comprendront le bit B<O_PATH>.

note: type: Plain text
en: Passing the file descriptor as the I<dirfd> argument of B<openat>(2)  and the other "*at()" system calls.
fr: Transmettre le descripteur de fichier comme l'argument  I<dirfd> de B<openat>(2) et les autres appels système « *at() ».

note: type: Plain text
en: Passing the file descriptor to another process via a UNIX domain socket (see B<SCM_RIGHTS> in B<unix>(7)).
fr: Transmettre le descripteur de fichier à un autre processus via une socket de domaine UNIX (consultez B<SCM_RIGHTS> dans B<unix>(7)).

note: type: Plain text
en: When B<O_PATH> is specified in I<flags>, flag bits other than B<O_DIRECTORY> and B<O_NOFOLLOW> are ignored.
fr: Lorsque B<O_PATH> est précisé dans I<flags>, seuls les bits B<O_DIRECTORY> et B<O_NOFOLLOW> de l'attribut sont pris en compte.

note: type: Plain text
en: If I<pathname> is a symbolic link and the B<O_NOFOLLOW> flag is also specified, then the call returns a file descriptor referring to the symbolic link.  This file descriptor can be used as the I<dirfd> argument in calls to B<fchownat>(2), B<fstatat>(2), B<linkat>(2), and B<readlinkat>(2)  with an empty pathname to have the calls operate on the symbolic link.
fr: Si I<pathname> est un lien symbolique et si l'attribut B<O_NOFOLLOW> est précisé, alors l'appel renvoie le descripteur de fichier d'un lien symbolique. Ce descripteur de fichier peut être utilisé comme l'argument I<dirfd> lors d'appels aux fonctions B<fchownat>(2), B<fstatat>(2), B<linkat>(2) et B<readlinkat>(2) avec un chemin d'accès vide pour permettre à l'appel de s'exécuter sur le lien symbolique.

note: type: Plain text
en: Write operations on the file will complete according to the requirements of synchronized I/O I<file> integrity completion (by contrast with contrast with the synchronized I/O I<data> integrity completion provided by B<O_DSYNC>.)
fr: Les opérations d'écriture dans le fichier se dérouleront selon les conditions d'exécution des opérations E/S synchrones avec garantie d'intégrité du I<fichier> (contrairement à l'exécution des opérations E/S synchrones avec garantie d'intégrité des I<données> fournie par B<O_DSYNC>.)

note: type: Plain text
en: By the time B<write>(2)  (and similar)  return, the output data and associated file metadata have been transferred to the underlying hardware (i.e., as though each B<write>(2)  was followed by a call to B<fsync>(2)).  I<See NOTES below>.
fr: Au moment où B<write>(2) (ou un appel similaire) renvoie une donnée, cette donnée et les métadonnées associées au fichier ont été transmises au matériel sur lequel s'exécute l'appel (autrement dit, comme si chaque appel à B<write>(2) était suivi d'un appel à B<fsync>(2)).  I<Consultez NOTES ci-dessous>.

note: type: TP
en: B<O_TMPFILE> (since Linux 3.11)
fr: B<O_TMPFILE> (depuis Linux 3.11)

note: commit 60545d0d4610b02e55f65d141c95b18ccf855b6e commit f4e0c30c191f87851c4a53454abb55ee276f4a7e commit bb458c644a59dbba3a1fe59b27106c5e68e1c4bd type: Plain text
en: Create an unnamed temporary file.  The I<pathname> argument specifies a directory; an unnamed inode will be created in that directory's filesystem.  Anything written to the resulting file will be lost when the last file descriptor is closed, unless the file is given a name.
fr: Créer un fichier temporaire sans nom. L’argument I<pathname> indique un répertoire ; un inœud sans nom sera créé dans le système de fichiers de ce répertoire. Tout ce qui est écrit dans le fichier résultant sera perdu quand le dernier descripteur de fichier sera fermé, à moins de donner un nom au fichier.

note: type: Plain text
en: B<O_TMPFILE> must be specified with one of B<O_RDWR> or B<O_WRONLY> and, optionally, B<O_EXCL>.  If B<O_EXCL> is not specified, then B<linkat>(2)  can be used to link the temporary file into the filesystem, making it permanent, using code like the following:
fr: B<O_TMPFILE> doit être indiqué avec soit B<O_RDWR>, soit B<O_WRONLY>, et facultativement B<O_EXCL>. Si B<O_EXCL> s’est pas indiqué, alors B<linkat>(2) peut être utilisé pour lier le fichier temporaire dans le système de fichier, le rendant permanent, en utilisant du code comme :

note: type: Plain text
en: char path[PATH_MAX];
    fd = open("/path/to/dir", O_TMPFILE | O_RDWR,
                            S_IRUSR | S_IWUSR);
fr: char chemin[PATH_MAX];
    df = open("/chemin/vers/rép.", O_TMPFILE | O_RDWR,
                            S_IRUSR | S_IWUSR);

note: type: Plain text
en: /* File I/O on 'fd'... */
fr: /* Entrée et sortie du fichier sur « df »… */

note: type: Plain text
en: snprintf(path, PATH_MAX,  "/proc/self/fd/%d", fd);
    linkat(AT_FDCWD, path, AT_FDCWD, "/path/for/file",
                            AT_SYMLINK_FOLLOW);
fr: snprintf(chemin, PATH_MAX,  "/proc/self/fd/%d", df);
    linkat(AT_FDCWD, chemin, AT_FDCWD, "/chemin/vers/fichier",
                            AT_SYMLINK_FOLLOW);

note: type: Plain text
en: In this case, the B<open>()  I<mode> argument determines the file permission mode, as with B<O_CREAT>.
fr: Dans ce cas, l’argument I<mode> d’B<open>() détermine le mode de droits du fichier, comme avec B<O_CREAT>.

note: type: Plain text
en: Specifying B<O_EXCL> in conjunction with B<O_TMPFILE> prevents a temporary file from being linked into the filesystem in the above manner.  (Note that the meaning of B<O_EXCL> in this case is different from the meaning of B<O_EXCL> otherwise.)
fr: Indiquer B<O_EXCL> en conjonction avec B<O_TMPFILE> empêche de lier un fichier temporaire dans le système de fichiers comme précédemment (remarquez que la signification de B<O_EXCL> dans ce cas est différente de la signification habituelle de B<O_EXCL>).

note: Inspired by http://lwn.net/Articles/559147/ type: Plain text
en: There are two main use cases for B<O_TMPFILE>:
fr: Les deux principaux cas d’utilisation de B<O_TMPFILE> sont présentés ci-dessous :

note: type: Plain text
en: Improved B<tmpfile>(3)  functionality: race-free creation of temporary files that (1) are automatically deleted when closed; (2) can never be reached via any pathname; (3) are not subject to symlink attacks; and (4) do not require the caller to devise unique names.
fr: Améliorer la fonctionnalité B<tmpfile>(3) : création de fichiers temporaires sans situation de compétition qui (1) sont automatiquement supprimés à la fermeture ; (2) ne peuvent jamais être atteints par leur chemin ; (3) ne sont pas exposés aux attaques de lien symbolique ; et (4) ne nécessitent pas à l’appelant d’inventer des noms uniques.

note: type: Plain text
en: Creating a file that is initially invisible, which is then populated with data and adjusted to have appropriate filesystem attributes (B<chown>(2), B<chmod>(2), B<fsetxattr>(2), etc.)  before being atomically linked into the filesystem in a fully formed state (using B<linkat>(2)  as described above).
fr: Créer un fichier initialement invisible, qui est ensuite peuplé de données et ajusté aux attributs de système de fichiers adéquats (B<chown>(2), B<chmod>(2), B<fsetxattr>(2), etc.) avant d’être automatiquement lié dans le système de fichiers dans un état complètement formé (en utilisant B<linkat>(2) comme décrit précédemment).

note: commit 99b6436bc29e4f10e4388c27a3e4810191cc4788 commit ab29743117f9f4c22ac44c13c1647fb24fb2bafe type: Plain text
en: B<O_TMPFILE> requires support by the underlying filesystem; only a subset of Linux filesystems provide that support.  In the initial implementation, support was provided in the ex2, ext3, ext4, UDF, Minix, and shmem filesystems.  XFS support was added in Linux 3.15.
fr: B<O_TMPFILE> nécessite une prise en charge par le système de fichiers sous-jacent. Seul une partie des systèmes de fichiers Linux fournit cette prise en charge. Dans l'implémentation initiale, la prise en charge était assurée pour les systèmes de fichiers ext2, ext3, ext4, UDF, Minix et shmem. XFS est également pris en charge depuis Linux 3.15.

note: type: Plain text
en: If the file already exists and is a regular file and the access mode allows writing (i.e., is B<O_RDWR> or B<O_WRONLY>)  it will be truncated to length 0.  If the file is a FIFO or terminal device file, the B<O_TRUNC> flag is ignored.  Otherwise the effect of B<O_TRUNC> is unspecified.
fr: Si le fichier existe, est un fichier ordinaire et que le mode d’accès permet l’écriture (B<O_RDWR> ou B<O_WRONLY>), il sera tronqué à une longueur nulle. Si le fichier est une FIFO ou un périphérique terminal, l'attribut B<O_TRUNC> est ignoré. Sinon, le comportement de B<O_TRUNC> n'est pas précisé. Sur de nombreuses versions de Linux, il sera ignoré\ ; sur d'autres versions il déclenchera une erreur).

note: type: Plain text
en: B<creat>()  is equivalent to B<open>()  with I<flags> equal to B<O_CREAT|O_WRONLY|O_TRUNC>.
fr: B<creat>() est équivalent à B<open>() avec l'attribut I<flags> égal à B<O_CREAT | O_WRONLY | O_TRUNC>.

note: type: Plain text
en: The B<openat>()  system call operates in exactly the same way as B<open>(), except for the differences described here.
fr: L'appel système B<openat>() fonctionne de la même façon que B<open>(), les différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<pathname> is relative, then it is interpreted relative to the directory relative to by the file descriptor I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<open>()  for a relative pathname).
fr: Si le chemin donné dans I<pathname> est relatif, il est interprété par rapport au répertoire auquel le descripteur de fichier I<dirfd> fait référence (et non par rapport au répertoire courant du processus, comme pour B<open>()).

note: type: Plain text
en: If I<pathname> is relative and I<dirfd> is the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the calling process (like B<open>()).
fr: Si I<pathname> est un chemin relatif, et si I<dirfd> a la valeur spéciale B<AT_FDCWD>, alors I<pathname> est interprété par rapport au répertoire courant du processus appelant, comme dans B<open>().

note: type: Plain text
en: If I<pathname> is absolute, then I<dirfd> is ignored.
fr: Si I<pathname> est un chemin absolu, I<dirfd> est ignoré.

note: type: Plain text
en: B<open>(), B<openat>(), and B<creat>()  return the new file descriptor, or -1 if an error occurred (in which case, I<errno> is set appropriately).
fr: B<open>(), B<openat>() et B<creat>() renvoient le nouveau descripteur de fichier s'ils réussissent, ou -1 s'ils échouent, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: B<open>(), B<openat>(), and B<creat>()  can fail with the following errors:
fr: B<open>(), B<openat>() et B<creat>() peuvent échouer avec les erreurs suivantes :

note: type: Plain text
en: The requested access to the file is not allowed, or search permission is denied for one of the directories in the path prefix of I<pathname>, or the file did not exist yet and write access to the parent directory is not allowed.  (See also B<path_resolution>(7).)
fr: L'accès demandé au fichier est interdit, ou la permission de parcours pour l'un des répertoires du chemin I<pathname> est refusée, ou le fichier n'existe pas encore et le répertoire parent ne permet pas l'écriture. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: Where B<O_CREAT> is specified, the file does not exist, and the user's quota of disk blocks or inodes on the filesystem has been exhausted.
fr: Si B<O_CREAT> est indiqué, le fichier n'existe pas et le quota de blocs de disque ou d'inœuds de l'utilisateur sur le système de fichiers a été atteint.

note: type: Plain text
en: I<pathname> already exists and B<O_CREAT> and B<O_EXCL> were used.
fr: I<pathname> existe déjà et B<O_CREAT> et B<O_EXCL> ont été indiqués.

note: type: Plain text
en: I<pathname> points outside your accessible address space.
fr: I<pathname> pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: See B<EOVERFLOW>.
fr: Consultez B<EOVERFLOW>.

note: type: Plain text
en: While blocked waiting to complete an open of a slow device (e.g., a FIFO; see B<fifo>(7)), the call was interrupted by a signal handler; see B<signal>(7).
fr: Pendant qu'il était bloqué en attente de l'ouverture d'un périphérique lent (par exemple, une FIFO ; consultez B<fifo>(7)), l'appel a été interrompu par un gestionnaire de signal ; consultez B<signal>(7).

note: type: Plain text
en: The filesystem does not support the B<O_DIRECT> flag.  See B<NOTES> for more information.
fr: Le système de fichiers ne gère pas l’attribut B<O_DIRECT>. Consultez B<NOTES> pour de plus amples renseignements.

note: In particular, __O_TMPFILE instead of O_TMPFILE type: Plain text
en: Invalid value in I<flags>.
fr: Valeur incorrecte dans I<flags>.

note: type: Plain text
en: B<O_TMPFILE> was specified in I<flags>, but neither B<O_WRONLY> nor B<O_RDWR> was specified.
fr: B<O_TMPFILE> a été indiqué dans I<flags>, mais ni B<O_WRONLY> ni B<O_RDWR> n’ont été indiqués.

note: type: Plain text
en: I<pathname> refers to a directory and the access requested involved writing (that is, B<O_WRONLY> or B<O_RDWR> is set).
fr: Une écriture a été demandée alors que I<pathname> correspond à un répertoire (en fait, B<O_WRONLY> ou B<O_RDWR> ont été demandés).

note: type: Plain text
en: I<pathname> refers to an existing directory, B<O_TMPFILE> and one of B<O_WRONLY> or B<O_RDWR> were specified in I<flags>, but this kernel version does not provide the B<O_TMPFILE> functionality.
fr: I<pathname> fait référence à un répertoire existant, B<O_TMPFILE> et soit B<O_WRONLY>, soit B<O_RDWR>, ont été indiqués dans I<flags>, mais cette version du noyau ne fournit pas la fonctionnalité B<O_TMPFILE>.

note: type: Plain text
en: Too many symbolic links were encountered in resolving I<pathname>.
fr: Trop de liens symboliques ont été rencontrés en parcourant I<pathname>.

note: type: Plain text
en: I<pathname> was a symbolic link, and I<flags> specified B<O_NOFOLLOW> but not B<O_PATH>.
fr: I<pathname> était un lien symbolique, et I<flags> indiquait B<O_NOFOLLOW> mais pas B<O_PATH>.

note: type: Plain text
en: The process already has the maximum number of files open.
fr: Le processus a déjà ouvert le nombre maximal de fichiers.

note: type: Plain text
en: I<pathname> was too long.
fr: I<pathname> est trop long.

note: type: Plain text
en: The system limit on the total number of open files has been reached.
fr: La limite du nombre total de fichiers ouverts sur le système a été atteinte.

note: type: Plain text
en: I<pathname> refers to a device special file and no corresponding device exists.  (This is a Linux kernel bug; in this situation B<ENXIO> must be returned.)
fr: I<pathname> correspond à un fichier spécial et il n'y a pas de périphérique correspondant. (Ceci est un bogue du noyau Linux\ ; dans cette situation, B<ENXIO> devrait être renvoyé.)

note: type: Plain text
en: B<O_CREAT> is not set and the named file does not exist.  Or, a directory component in I<pathname> does not exist or is a dangling symbolic link.
fr: B<O_CREAT> est absent et le fichier n'existe pas. Ou un répertoire du chemin d'accès I<pathname> n'existe pas, ou est un lien symbolique pointant nulle part.

note: type: Plain text
en: I<pathname> refers to a nonexistent directory, B<O_TMPFILE> and one of B<O_WRONLY> or B<O_RDWR> were specified in I<flags>, but this kernel version does not provide the B<O_TMPFILE> functionality.
fr: I<pathname> fait référence à un répertoire inexistant, B<O_TMPFILE> et soit B<O_WRONLY>, soit B<O_RDWR>, ont été indiqués dans I<flags>, mais cette version du noyau ne fournit pas la fonctionnalité B<O_TMPFILE>.

note: type: Plain text
en: I<pathname> was to be created but the device containing I<pathname> has no room for the new file.
fr: I<pathname> devrait être créé mais le périphérique concerné n'a plus assez de place pour un nouveau fichier.

note: type: Plain text
en: A component used as a directory in I<pathname> is not, in fact, a directory, or B<O_DIRECTORY> was specified and I<pathname> was not a directory.
fr: Un élément du chemin d'accès I<pathname> n'est pas un répertoire, ou l'attribut B<O_DIRECTORY> est utilisé et I<pathname> n'est pas un répertoire.

note: type: Plain text
en: B<O_NONBLOCK> | B<O_WRONLY> is set, the named file is a FIFO and no process has the file open for reading.  Or, the file is a device special file and no corresponding device exists.
fr: B<O_NONBLOCK> | B<O_WRONLY> est indiqué, le fichier est une FIFO et le processus n'a pas de fichier ouvert en lecture. Ou le fichier est un nœud spécial et il n'y a pas de périphérique correspondant.

note: type: Plain text
en: The filesystem containing I<pathname> does not support B<O_TMPFILE>.
fr: Le système de fichiers contenant I<pathname> ne prend pas en charge B<O_TMPFILE>.

note: See http://bugzilla.kernel.org/show_bug.cgi?id=7253 "Open of a large file on 32-bit fails with EFBIG, should be EOVERFLOW" Reported 2006-10-03 type: Plain text
en: I<pathname> refers to a regular file that is too large to be opened.  The usual scenario here is that an application compiled on a 32-bit platform without I<-D_FILE_OFFSET_BITS=64> tried to open a file whose size exceeds I<(2E<lt>E<lt>31)-1> bits; see also B<O_LARGEFILE> above.  This is the error specified by POSIX.1-2001; in kernels before 2.6.24, Linux gave the error B<EFBIG> for this case.
fr: I<pathname> fait référence à un fichier ordinaire qui est trop grand pour être ouvert. Cela arrive quand une application compilée sur une plate-forme 32 bits sans I<-D_FILE_OFFSET_BITS=64> essaie d'ouvrir un fichier dont la taille dépasse I<(2E<lt>E<lt>31)-1> bits ; consultez également B<O_LARGEFILE> ci-dessus. C'est l'erreur spécifiée par POSIX.1-2001 ; dans les noyaux antérieurs à la version 2.6.24, Linux fournissait l'erreur B<EFBIG> dans ce cas.

note: Strictly speaking, it's the filesystem UID... (MTK) type: Plain text
en: The B<O_NOATIME> flag was specified, but the effective user ID of the caller did not match the owner of the file and the caller was not privileged (B<CAP_FOWNER>).
fr: L'attribut B<O_NOATIME> est indiqué, mais l'UID effectif de l'appelant n'est pas le propriétaire du fichier, et l'appelant n'est pas privilégié (B<CAP_FOWNER>).

note: type: Plain text
en: I<pathname> refers to a file on a read-only filesystem and write access was requested.
fr: Un accès en écriture est demandé alors que I<pathname> réside sur un système de fichiers en lecture seule.

note: type: Plain text
en: I<pathname> refers to an executable image which is currently being executed and write access was requested.
fr: On a demandé une écriture alors que I<pathname> correspond à un fichier exécutable actuellement utilisé.

note: type: Plain text
en: The B<O_NONBLOCK> flag was specified, and an incompatible lease was held on the file (see B<fcntl>(2)).
fr: L'attribut B<O_NONBLOCK> est indiqué, et un bail incompatible est détenu sur le fichier (consultez B<fcntl>(2)).

note: type: Plain text
en: The following additional errors can occur for B<openat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<openat>() :

note: type: Plain text
en: I<dirfd> is not a valid file descriptor.
fr: I<dirfd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<pathname> is relative and I<dirfd> is a file descriptor referring to a file other than a directory.
fr: I<pathname> est relatif, et le descripteur de fichier I<dirfd> est associé à un fichier, pas à un répertoire.

note: type: Plain text
en: B<openat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<openat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: type: Plain text
en: B<open>(), B<creat>()  SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.
fr: B<open>(), B<creat>() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.

note: type: Plain text
en: B<openat>(): POSIX.1-2008.
fr: B<openat>() : POSIX.1-2008.

note: type: Plain text
en: The B<O_DIRECT>, B<O_NOATIME>, B<O_PATH>, and B<O_TMPFILE> flags are Linux-specific.  One must define B<_GNU_SOURCE> to obtain their definitions.
fr: Les attributs B<O_DIRECT>, B<O_NOATIME>, B<O_PATH> et B<O_TMPFILE> sont spécifiques à Linux. B<_GNU_SOURCE> doit être définie pour obtenir leurs définitions.

note: type: Plain text
en: The B<O_CLOEXEC>, B<O_DIRECTORY>, and B<O_NOFOLLOW> flags are not specified in POSIX.1-2001, but are specified in POSIX.1-2008.  Since glibc 2.12, one can obtain their definitions by defining either B<_POSIX_C_SOURCE> with a value greater than or equal to 200809L or B<_XOPEN_SOURCE> with a value greater than or equal to 700.  In glibc 2.11 and earlier, one obtains the definitions by defining B<_GNU_SOURCE>.
fr: Les attributs B<O_CLOEXEC>, B<O_DIRECTORY> et B<O_NOFOLLOW> ne sont pas spécifiés dans POSIX.1-2001, mais le sont dans POSIX.1-2008. Depuis glibc 2.12, leurs définitions peuvent être obtenues en définissant soit B<_POSIX_C_SOURCE> avec une valeur supérieure ou égale à 200809L, soit B<_XOPEN_SOURCE> avec une valeur supérieure ou égale à 700. Dans glibc 2.11 et les versions précédentes, les définitions peuvent être obtenues en définissant B<_GNU_SOURCE>.

note: type: Plain text
en: As noted in B<feature_test_macros>(7), feature test macros such as B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE>, and B<_GNU_SOURCE> must be defined before including I<any> header files.
fr: Comme indiqué dans B<feature_test_macros>(7), les macros de test de fonctionnalités comme B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE> et B<_GNU_SOURCE> doivent être définies avant d'inclure I<n’importe quel> fichier d'en-tête.

note: type: Plain text
en: Under Linux, the B<O_NONBLOCK> flag indicates that one wants to open but does not necessarily have the intention to read or write.  This is typically used to open devices in order to get a file descriptor for use with B<ioctl>(2).
fr: Sous Linux, l'attribut B<O_NONBLOCK> indique que l'on veut ouvrir mais pas nécessairement dans l'intention de lire ou d'écrire. Il est typiquement utilisé pour ouvrir des périphériques dans le but de récupérer un descripteur de fichier pour l'utiliser avec B<ioctl>(2).

note: Linux 2.0, 2.5: truncate Solaris 5.7, 5.8: truncate Irix 6.5: truncate Tru64 5.1B: truncate HP-UX 11.22: truncate FreeBSD 4.7: truncate type: Plain text
en: The (undefined) effect of B<O_RDONLY | O_TRUNC> varies among implementations.  On many systems the file is actually truncated.
fr: L'effet (indéfini) de B<O_RDONLY | O_TRUNC> varie selon l'implémentation. Sur de nombreux systèmes, le fichier est effectivement tronqué.

note: type: Plain text
en: Note that B<open>()  can open device special files, but B<creat>()  cannot create them; use B<mknod>(2)  instead.
fr: Notez que B<open>() peut ouvrir des fichiers spéciaux mais B<creat>() ne peut pas en créer, il faut utiliser B<mknod>(2) à la place.

note: type: Plain text
en: If the file is newly created, its I<st_atime>, I<st_ctime>, I<st_mtime> fields (respectively, time of last access, time of last status change, and time of last modification; see B<stat>(2))  are set to the current time, and so are the I<st_ctime> and I<st_mtime> fields of the parent directory.  Otherwise, if the file is modified because of the B<O_TRUNC> flag, its st_ctime and st_mtime fields are set to the current time.
fr: Si un fichier est créé, ses horodatages I<st_atime>, I<st_ctime>, I<st_mtime> (respectivement heure de dernier accès, de dernière modification d'état, et de dernière modification\ ; consultez B<stat>(2)) sont définis à l'heure actuelle, ainsi que les champs I<st_ctime> et I<st_mtime> du répertoire parent. Sinon, si le fichier est modifié à cause de l'attribut B<O_TRUNC>, ses champs I<st_ctime> et I<st_mtime> sont remplis avec l'heure actuelle.

note: type: SS
en: Synchronized I/O
fr: E/S synchrones

note: type: Plain text
en: The POSIX.1-2008 "synchronized I/O" option specifies different variants of synchronized I/O, and specifies the B<open>()  flags B<O_SYNC>, B<O_DSYNC>, and B<O_RSYNC> for controlling the behavior.  Regardless of whether an implementation supports this option, it must at least support the use of B<O_SYNC> for regular files.
fr: L'option POSIX-1.2008 « E/S synchrones » décrit des variantes des E/S synchrones, ainsi que plusieurs attributs de B<open>() permettant d'en contrôler le comportement : B<O_SYNC>, B<O_DSYNC> et B<O_RSYNC>. Sans chercher à savoir si une implémentation accepte cette option, elle doit au moins prendre en charge l'utilisation de B<O_SYNC> pour les fichiers normaux.

note: type: Plain text
en: Linux implements B<O_SYNC> and B<O_DSYNC>, but not B<O_RSYNC>.  (Somewhat incorrectly, glibc defines B<O_RSYNC> to have the same value as B<O_SYNC>.)
fr: Linux met en oeuvre B<O_SYNC> et B<O_DSYNC>, mais pas B<O_RSYNC>. (De façon plus ou moins correcte, glibc définit B<O_RSYNC> de façon à avoir la même valeur que B<O_SYNC>.)

note: type: Plain text
en: B<O_SYNC> provides synchronized I/O I<file> integrity completion, meaning write operations will flush data and all associated metadata to the underlying hardware.  B<O_DSYNC> provides synchronized I/O I<data> integrity completion, meaning write operations will flush data to the underlying hardware, but will only flush metadata updates that are required to allow a subsequent read operation to complete successfully.  Data integrity completion can reduce the number of disk operations that are required for applications that don't need the guarantees of file integrity completion.
fr: B<O_SYNC> fournit l'exécution d'E/S synchrones avec garantie d'intégrité des I<fichiers>, ce qui signifie que les opérations d'écriture envoient les données et les métadonnées associées au matériel. B<O_DSYNC> fournit l'exécution d'E/S synchrones avec garantie d'intégrité des I<données>, ce qui signifie que les opérations d'écriture envoient les données et les métadonnées associées au matériel, mais en envoyant seulement les mises à jour des metadonnées qui permettent d'assurer le bon déroulement d'une opération de lecture ultérieure. L'exécution avec garantie d'intégrité des données peut réduire le nombre d'accès au disque demandés par une application qui ne nécessite pas l'exécution avec garantie d'intégrité des fichiers.

note: type: Plain text
en: To understand the difference between the the two types of completion, consider two pieces of file metadata: the file last modification timestamp (I<st_mtime>)  and the file length.  All write operations will update the last file modification timestamp, but only writes that add data to the end of the file will change the file length.  The last modification timestamp is not needed to ensure that a read completes successfully, but the file length is.  Thus, B<O_DSYNC> would only guarantee to flush updates to the file length metadata (whereas B<O_SYNC> would also always flush the last modification timestamp metadata).
fr: Pour comprendre la différence entre ces deux types d'exécution, imaginez deux extraits de metadonnées d'un fichier : l'horodatage de la dernière modification (I<st_mtime>) et la longueur du fichier. Toutes les opérations d'écriture modifieront l'horodatage de la dernière modification, mais seules les écritures en fin de fichier modifieront la longueur. L'horodatage de dernière modification n'est pas nécessaire pour garantir une lecture correcte du fichier, contrairement à la longueur. Ainsi, B<O_DSYNC> transmettrait seulement la métadonnée relative à la longueur du fichier (quand B<O_SYNC> y ajouterait l'horodatage de dernière modification).

note: type: Plain text
en: Before Linux 2.6.33, Linux implemented only the B<O_SYNC> flag for B<open>().  However, when that flag was specified, most filesystems actually provided the equivalent of synchronized I/O I<data> integrity completion (i.e., B<O_SYNC> was actually implemented as the equivalent of B<O_DSYNC>).
fr: Avant Linux 2.6.33, Linux mettait seulement en oeuvre l'attribut B<O_SYNC> de B<open>(). Cependant, lorsque cet attribut était indiqué, la plupart des systèmes de fichiers fournissait des fonctionnalités équivalentes à l'exécution des E/S synchrones avec garantie de l'intégrité des I<données> (autrement dit, B<O_SYNC> était de fait mis en oeuvre comme B<O_DSYNC>).

note: type: Plain text
en: Since Linux 2.6.33, proper B<O_SYNC> support is provided.  However, to ensure backward binary compatibility, B<O_DSYNC> was defined with the same value as the historical B<O_SYNC>, and B<O_SYNC> was defined as a new (two-bit) flag value that includes the B<O_DSYNC> flag value.  This ensures that applications compiled against new headers get at least B<O_DSYNC> semantics on pre-2.6.33 kernels.
fr: A partir de Linux 2.6.33, une véritable prise de charge de B<O_SYNC> est fournie. Cependant, pour assurer la compatibilité ascendante binaire, B<O_DSYNC> a été défini avec la même valeur que le B<O_SYNC> « historique », et B<O_SYNC> a été défini comme un nouvel attribut (de deux bits) qui comprend l'attribut B<O_DSYNC>. Ceci permet d'assurer que les applications compilées avec les nouveaux en-têtes auront au moins la sémantique de B<O_DSYNC> sur les noyaux antérieurs à 2.6.33.

note: type: Plain text
en: There are many infelicities in the protocol underlying NFS, affecting amongst others B<O_SYNC> and B<O_NDELAY>.
fr: Plusieurs problèmes se posent avec le protocole NFS, concernant entre autres B<O_SYNC>, et B<O_NDELAY>.

note: type: Plain text
en: On NFS filesystems with UID mapping enabled, B<open>()  may return a file descriptor but, for example, B<read>(2)  requests are denied with B<EACCES>.  This is because the client performs B<open>()  by checking the permissions, but UID mapping is performed by the server upon read and write requests.
fr: Sur les systèmes de fichiers NFS, où la correspondance d'UID est activée, B<open>() peut renvoyer un descripteur de fichier alors qu'une requête B<read>(2) par exemple sera refusée avec le code d'erreur B<EACCES>. En effet, le client a effectué B<open>() en vérifiant les autorisations d'accès, mais la correspondance d'UID est calculée par le serveur au moment des requêtes de lecture ou d'écriture.

note: type: SS
en: File access mode
fr: mode accès au fichier

note: type: Plain text
en: Unlike the other values that can be specified in I<flags>, the I<access mode> values B<O_RDONLY>, B<O_WRONLY>, and B<O_RDWR> do not specify individual bits.  Rather, they define the low order two bits of I<flags>, and are defined respectively as 0, 1, and 2.  In other words, the combination B<O_RDONLY | O_WRONLY> is a logical error, and certainly does not have the same meaning as B<O_RDWR>.
fr: Contrairement aux autres valeurs qui peuvent être indiquées dans I<flags>, les valeurs du I<mode d'accès> B<O_RDONLY>, B<O_WRONLY> et B<O_RDWR> ne sont pas des bits individuels. Ils définissent l'ordre des deux bits de poids faible de I<flags>, et ont pour valeur respective 0, 1 et 2. En d'autres termes, l'association B<O_RDONLY | O_WRONLY> est une erreur logique et n'a certainement pas la même signification que B<O_RDWR>.

note: See for example util-linux's disk-utils/setfdprm.c For some background on access mode 3, see http://thread.gmane.org/gmane.linux.kernel/653123 "[RFC] correct flags to f_mode conversion in __dentry_open" LKML, 12 Mar 2008 type: Plain text
en: Linux reserves the special, nonstandard access mode 3 (binary 11) in I<flags> to mean: check for read and write permission on the file and return a descriptor that can't be used for reading or writing.  This nonstandard access mode is used by some Linux drivers to return a descriptor that is to be used only for device-specific B<ioctl>(2)  operations.
fr: Linux réserve le sens suivant au mode d'accès spécial et non-standard 3 (en binaire, 11) de l'attribut : vérification des droits en lecture et écriture du fichier, et renvoi d'un descripteur qui ne peut être utilisé ni en lecture, ni en écriture. Ce mode d'accès non-standard est utilisé par certains pilotes Linux afin de renvoyer un descripteur qui n'est destinée qu'à des opérations B<ioctl>(2) propres aux périphériques.

note: type: SS
en: Rationale for openat() and other directory file descriptor APIs
fr: Justification des appels openat() et des APIs des descripteurs de fichier de répertoires

note: type: Plain text
en: B<openat>()  and the other system calls and library functions that take a directory file descriptor argument (i.e., B<faccessat>(2), B<fanotify_mark>(2), B<fchmodat>(2), B<fchownat>(2), B<fstatat>(2), B<futimesat>(2), B<linkat>(2), B<mkdirat>(2), B<mknodat>(2), B<name_to_handle_at>(2), B<readlinkat>(2), B<renameat>(2), B<symlinkat>(2), B<unlinkat>(2), B<utimensat>(2)  B<mkfifoat>(3), and B<scandirat>(3))  are supported for two reasons.  Here, the explanation is in terms of the B<openat>()  call, but the rationale is analogous for the other interfaces.
fr: B<openat>() et les autres appels système similaires, ainsi que les fonctions de bibliothèques qui reçoivent pour argument un descripteur de fichier de répertoire (c'est-à-dire, B<faccessat>(2), B<fanotify_mark>(2), B<fchmodat>(2), B<fchownat>(2), B<fstatat>(2), B<futimesat>(2), B<linkat>(2), B<mkdirat>(2), B<mknodat>(2), B<name_to_handle_at>(2), B<readlinkat>(2), B<renameat>(2), B<symlinkat>(2), B<unlinkat>(2), B<utimensat>(2), B<mkfifoat>(3) et B<scandirat>(3)) sont pris en charge pour deux raisons. L'explication est ici donnée dans le contexte de l'appel B<openat>(), mais des arguments analogues sont valables pour les autres interfaces.

note: type: Plain text
en: First, B<openat>()  allows an application to avoid race conditions that could occur when using B<open>()  to open files in directories other than the current working directory.  These race conditions result from the fact that some component of the directory prefix given to B<open>()  could be changed in parallel with the call to B<open>().  Such races can be avoided by opening a file descriptor for the target directory, and then specifying that file descriptor as the I<dirfd> argument of B<openat>().
fr: Tout d'abord, B<openat>() permet à une application d'éviter les problèmes d'accès concurrents lors de l'utilisation de B<open>() pour ouvrir des fichiers dans des répertoires autres que le répertoire courant. Ces problèmes sont dus au fait que l'un des composants du chemin donné à B<open>() peut être modifié parallèlement à l'appel B<open>(). De tels problèmes peuvent être évités en ouvrant un descripteur de fichier sur le répertoire cible, puis en fournissant ce descripteur comme argument I<dirfd> de B<openat>().

note: type: Plain text
en: Second, B<openat>()  allows the implementation of a per-thread "current working directory", via file descriptor(s) maintained by the application.  (This functionality can also be obtained by tricks based on the use of I</proc/self/fd/>dirfd, but less efficiently.)
fr: Enfin, B<openat>() permet d'implémenter un «\ répertoire courant\ » par thread, grâce à des descripteurs de fichier maintenus par l'application. Cette fonctionnalité peut également être obtenue en jouant avec I</proc/self/fd/>dirfd, mais de façon moins efficace.

note: type: Plain text
en: The B<O_DIRECT> flag may impose alignment restrictions on the length and address of user-space buffers and the file offset of I/Os.  In Linux alignment restrictions vary by filesystem and kernel version and might be absent entirely.  However there is currently no filesystem-independent interface for an application to discover these restrictions for a given file or filesystem.  Some filesystems provide their own interfaces for doing so, for example the B<XFS_IOC_DIOINFO> operation in B<xfsctl>(3).
fr: L'attribut B<O_DIRECT> peut imposer, pour des raisons d'alignement, des restrictions sur la longueur et l'adresse des tampons de l'espace utilisateur et des déplacements dans les entrées-sorties de fichiers. Sous Linux, les restrictions d'alignement varient en fonction du système de fichiers et de la version du noyau, et il peut aussi ne pas y en avoir. Cependant, il n'y a pas actuellement d'interface indépendante du système de fichiers qui permette aux applications de découvrir ces restrictions pour un fichier ou système de fichiers donné. Certains systèmes de fichiers fournissent leur propre interface pour faire cela, comme par exemple l'opération B<XFS_IOC_DIOINFO> de B<xfsctl>(3).

note: type: Plain text
en: Under Linux 2.4, transfer sizes, and the alignment of the user buffer and the file offset must all be multiples of the logical block size of the filesystem.  Under Linux 2.6, alignment to 512-byte boundaries suffices.
fr: Sous Linux 2.4, la taille des transferts, l'alignement du tampon et la position dans le fichier doivent être des multiples de la taille de blocs logiques du système de fichiers. Sous Linux 2.6, un alignement sur des multiples de 512 octets est suffisant.

note: type: Plain text
en: B<O_DIRECT> I/Os should never be run concurrently with the B<fork>(2)  system call, if the memory buffer is a private mapping (i.e., any mapping created with the B<mmap>(2)  B<MAP_PRIVATE> flag; this includes memory allocated on the heap and statically allocated buffers).  Any such I/Os, whether submitted via an asynchronous I/O interface or from another thread in the process, should be completed before B<fork>(2)  is called.  Failure to do so can result in data corruption and undefined behavior in parent and child processes.  This restriction does not apply when the memory buffer for the B<O_DIRECT> I/Os was created using B<shmat>(2)  or B<mmap>(2)  with the B<MAP_SHARED> flag.  Nor does this restriction apply when the memory buffer has been advised as B<MADV_DONTFORK> with B<madvise>(2), ensuring that it will not be available to the child after B<fork>(2).
fr: Les E/S B<O_DIRECT> ne devraient jamais être exécutées en même temps que l'appel système B<fork>(2), si le tampon mémoire est une projection privée (c'est-à-dire n'importe quelle projection en mémoire créée avec l'attribut B<MAP_PRIVATE> de B<mmap>(2), y compris la mémoire allouée sur le tas et les tampons alloués de façon statique). Toutes ces E/S, qu'elles soient soumises par l'intermédiaire d'une interface d'E/S asynchrone ou depuis un autre thread du processus, devraient être achevées avant l'appel de B<fork>(2). En cas d'échec, les conséquences pourraient être une corruption de mémoire ou un comportement imprévisible dans les processus père et fils. Cette restriction ne s'applique pas quand le tampon mémoire pour les E/S B<O_DIRECT> a été créé en utilisant B<shmat>(2) ou B<mmap>(2) avec l'attribut B<MAP_SHARED>. Cette restriction ne s'applique pas non plus quand le tampon mémoire a été configuré comme B<MADV_DONTFORK> avec B<madvise>(2), en s'assurant qu'il ne sera pas disponible au fils après B<fork>(2).

note: type: Plain text
en: The B<O_DIRECT> flag was introduced in SGI IRIX, where it has alignment restrictions similar to those of Linux 2.4.  IRIX has also a B<fcntl>(2)  call to query appropriate alignments, and sizes.  FreeBSD 4.x introduced a flag of the same name, but without alignment restrictions.
fr: L'attribut B<O_DIRECT> a été introduit par SGI IRIX, qui a des restrictions d'alignement identiques à Linux 2.4. IRIX a aussi un appel B<fcntl>(2) pour obtenir les alignements et tailles appropriés. FreeBSD 4.x a introduit un attribut du même nom, mais sans les restrictions d'alignement.

note: type: Plain text
en: B<O_DIRECT> support was added under Linux in kernel version 2.4.10.  Older Linux kernels simply ignore this flag.  Some filesystems may not implement the flag and B<open>()  will fail with B<EINVAL> if it is used.
fr: La gestion de B<O_DIRECT> a été ajouté dans Linux 2.4.10. Les noyaux plus anciens ignorent simplement cet attribut. Certains système de fichiers peuvent ne pas supporter cet attribut et B<open>() échouera avec l'erreur B<EINVAL> s'il a été utilisé.

note: type: Plain text
en: Applications should avoid mixing B<O_DIRECT> and normal I/O to the same file, and especially to overlapping byte regions in the same file.  Even when the filesystem correctly handles the coherency issues in this situation, overall I/O throughput is likely to be slower than using either mode alone.  Likewise, applications should avoid mixing B<mmap>(2)  of files with direct I/O to the same files.
fr: Les applications devraient éviter de mélanger des entrées-sorties B<O_DIRECT> et normales pour le même fichier, en particulier sur des régions d'un même fichier qui se recouvrent. Même si le système de fichiers gère les problèmes de cohérence dans cette situation, le débit global d'entrées-sorties sera moindre que si un seul mode était utilisé. De la même façon, les applications devraient éviter de mélanger l'utilisation de B<mmap>(2) et d'entrées-sorties directes pour les mêmes fichiers.

note: type: Plain text
en: The behaviour of B<O_DIRECT> with NFS will differ from local filesystems.  Older kernels, or kernels configured in certain ways, may not support this combination.  The NFS protocol does not support passing the flag to the server, so B<O_DIRECT> I/O will bypass the page cache only on the client; the server may still cache the I/O.  The client asks the server to make the I/O synchronous to preserve the synchronous semantics of B<O_DIRECT>.  Some servers will perform poorly under these circumstances, especially if the I/O size is small.  Some servers may also be configured to lie to clients about the I/O having reached stable storage; this will avoid the performance penalty at some risk to data integrity in the event of server power failure.  The Linux NFS client places no alignment restrictions on B<O_DIRECT> I/O.
fr: Le comportement de B<O_DIRECT> avec NFS diffère des systèmes de fichiers locaux. Les anciens noyaux, ou les noyaux configurés d'une certaine façon, peuvent ne pas gérer cette combinaison. Le protocole NFS ne gère pas le passage de l'attribut au serveur, les entrées-sorties B<O_DIRECT> ne font donc que le cache des pages du client ; le serveur pourra toujours utiliser un cache pour les entrées-sorties. Le client demande au serveur de rendre les entrées-sorties synchrones pour préserver la sémantique synchrone de B<O_DIRECT>. Certains serveurs fonctionnent mal dans ces circonstances, tout particulièrement si les entrées-sorties sont de petite taille. Certains serveurs peuvent aussi être configurés pour mentir aux clients et indiquer que les entrées-sorties ont atteint un espace de stockage stable ; ceci évitera la perte de performance en augmentant les risques pour l'intégrité des données en cas de problème d'alimentation du serveur. Le client NFS Linux n'a pas de restriction d'alignement pour les entrées-sorties B<O_DIRECT>.

note: type: Plain text
en: In summary, B<O_DIRECT> is a potentially powerful tool that should be used with caution.  It is recommended that applications treat use of B<O_DIRECT> as a performance option which is disabled by default.
fr: En résumé, B<O_DIRECT> est un outil potentiellement puissant qui doit être utilisé avec précaution. Les applications devraient utiliser B<O_DIRECT> comme une option pour améliorer les performances, qui devrait être désactivée par défaut.

note: type: Plain text
en: "The thing that has always disturbed me about O_DIRECT is that the whole interface is just stupid, and was probably designed by a deranged monkey on some serious mind-controlling substances."\(emLinus
fr: «\ Ce qui m'a toujours dérangé avec O_DIRECT est que toute l'interface est stupide et a probablement été conçue par un singe dérangé, sous l'influence de substances psychotropes puissantes.\ » \(em Linus.

note: FIXME . Check bugzilla report on open(O_ASYNC) See http://bugzilla.kernel.org/show_bug.cgi?id=5993 type: Plain text
en: Currently, it is not possible to enable signal-driven I/O by specifying B<O_ASYNC> when calling B<open>(); use B<fcntl>(2)  to enable this flag.
fr: Actuellement, il n'est pas possible d'activer les entrées-sorties contrôlées par les signaux en indiquant B<O_ASYNC> lors de l'appel B<open>()\ ; il faut utiliser B<fcntl>(2) pour activer cet attribut.

note: type: Plain text
en: One must check for two different error codes, B<EISDIR> and B<ENOENT>, when trying to determine whether the kernel supports B<O_TMPFILE> functionality.
fr: Deux codes d’erreur différents – B<EISDIR> et B<ENOENT> — doivent être vérifiés pour essayer de déterminer si le noyau prend en charge la fonctionnalité B<O_TMPFILE>.

note: type: TH
en: 2014-03-24
fr: 24 mars 2014

note: type: Plain text
en: name_to_handle_at, open_by_handle_at - obtain handle for a pathname and open file via a handle
fr: name_to_handle_at, open_by_handle_at - récupérer le gestionnaire d'un chemin et le ouvrir le fichier au moyen d'un gestionnaire

note: type: Plain text
en: The B<name_to_handle_at>()  and B<open_by_handle_at>()  system calls split the functionality of B<openat>(2)  into two parts: B<name_to_handle_at>()  returns an opaque handle that corresponds to a specified file; B<open_by_handle_at>()  opens the file corresponding to a handle returned by a previous call to B<name_to_handle_at>()  and returns an open file descriptor.
fr: Les appels système B<name_to_handle_at>() et B<open_by_handle_at>() scindent la fonction de B<openat>(2) en deux parties : B<name_to_handle_at>() renvoie un gestionnaire opaque qui correspond à un fichier indiqué ; B<open_by_handle_at>() ouvre le fichier correspondant à un gestionnaire renvoyé par un appel antérieur à B<name_to_handle_at>() et renvoie le descripteur d'un fichier ouvert.

note: type: Plain text
en: The B<name_to_handle_at>()  system call returns a file handle and a mount ID corresponding to the file specified by the I<dirfd> and I<pathname> arguments.  The file handle is returned via the argument I<handle>, which is a pointer to a structure of the following form:
fr: L'appel système B<name_to_handle_at>() renvoie un gestionnaire de fichier et un identifiant de montage (« mount ID ») correspondant au fichier désigné par les arguments I<dirfd> et I<pathname>. Le gestionnaire de fichier est renvoyé au moyen de l'argument I<handle>. Cet argument est un pointeur vers une structure qui présente la forme suivante :

note: type: Plain text
en: struct file_handle {
        unsigned int  handle_bytes;   /* Size of f_handle [in, out] */
        int           handle_type;    /* Handle type [out] */
        unsigned char f_handle[0];    /* File identifier (sized by
                                         caller) [out] */
    };
fr: struct file_handle {
        unsigned int  handle_bytes;   /* taille de f_handle [in, out] */
        int           handle_type;    /* type du gestionnaire handle [out] */
        unsigned char f_handle[0];    /* identifiant du fichier (dont la taille est définie
                                         lors de l'appel) [out] */
    };

note: type: Plain text
en: It is the caller's responsibility to allocate the structure with a size large enough to hold the handle returned in I<f_handle>.  Before the call, the I<handle_bytes> field should be initialized to contain the allocated size for I<f_handle>.  (The constant B<MAX_HANDLE_SZ>, defined in I<E<lt>fcntl.hE<gt>>, specifies the maximum possible size for a file handle.)  Upon successful return, the I<handle_bytes> field is updated to contain the number of bytes actually written to I<f_handle>.
fr: L'appelant à l'origine de l'appel doit s'assurer que la structure est créée avec une taille suffisante pour contenir le gestionnaire renvoyé dans I<f_handle>. Avant l'appel, le champ I<handle_bytes> devrait être initialisé de sorte que l'espace alloué puisse recevoir I<f_handle>. (La constante B<MAX_HANDLE_SZ>, définie dans I<E<lt>fcntl.hE<gt>>, précise la taille maximum autorisée pour un gestionnaire de fichier.) Lorsque l'appel réussit, le champ I<handle_bytes> est mis à jour afin de contenir le nombre d'octets effectivement écrits dans I<f_handle>.

note: type: Plain text
en: The caller can discover the required size for the I<file_handle> structure by making a call in which I<handle-E<gt>handle_bytes> is zero; in this case, the call fails with the error B<EOVERFLOW> and I<handle-E<gt>handle_bytes> is set to indicate the required size; the caller can then use this information to allocate a structure of the correct size (see EXAMPLE below).
fr: L'appelant peut prendre connaissance de l'espace nécessaire à la structure I<file_handle> en effectuant un appel dans lequel I<handle-E<gt>handle_bytes> vaut zéro ; dans ce cas, l'appel échoue en renvoyant l'erreur B<EOVERFLOW> et I<handle-E<gt>handle_bytes> prend pour valeur la taille requise ; l'appelant peut alors utiliser cette information pour allouer une structure ayant la taille convenable (consultez l'exemple ci-dessous).

note: type: Plain text
en: Other than the use of the I<handle_bytes> field, the caller should treat the I<file_handle> structure as an opaque data type: the I<handle_type> and I<f_handle> fields are needed only by a subsequent call to B<open_by_handle_at>().
fr: Mise à part l'utilisation du champ I<handle_bytes>, l'appelant doit considérer la structure I<file_handle> comme une « boîte noire » : les champs I<handle_type> et I<f_handle> ne sont utiles que pour un appel ultérieur à B<open_by_handle_at>().

note: type: Plain text
en: The I<flags> argument is a bit mask constructed by ORing together zero or more of B<AT_EMPTY_PATH> and B<AT_SYMLINK_FOLLOW>, described below.
fr: L'argument I<flags> est un masque de bits construit par I<OU> binaire entre zéro ou plus de B<AT_EMPTY_PATH> et B<AT_SYMLINK_FOLLOW>, comme décrit plus bas.

note: type: Plain text
en: Together, the I<pathname> and I<dirfd> arguments identify the file for which a handle is to be obtained.  There are four distinct cases:
fr: Ensemble, les arguments I<pathname> et I<dirfd> désignent le fichier pour lequel on souhaite obtenir un gestionnaire. On distingue quatre cas :

note: type: Plain text
en: If I<pathname> is a nonempty string containing an absolute pathname, then a handle is returned for the file referred to by that pathname.  In this case, I<dirfd> is ignored.
fr: Si I<pathname> est une chaîne non vide contenant un chemin d'accès absolu, alors un gestionnaire est renvoyé pour le fichier indiqué par le chemin. Dans ce cas, I<dirfd> est ignoré.

note: type: Plain text
en: If I<pathname> is a nonempty string containing a relative pathname and I<dirfd> has the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the caller, and a handle is returned for the file to which it refers.
fr: Si I<pathname> est une chaîne non vide contenant un chemin relatif, et si I<dirfd> a la valeur spéciale B<AT_FDCWD>, alors I<pathname> est interprété par rapport au répertoire courant du processus appelant, et un gestionnaire est renvoyé pour le fichier indiqué par le chemin.

note: type: Plain text
en: If I<pathname> is a nonempty string containing a relative pathname and I<dirfd> is a file descriptor referring to a directory, then I<pathname> is interpreted relative to the directory referred to by I<dirfd>, and a handle is returned for the file to which it refers.  (See B<openat>(3)  for an explanation of why "directory file descriptors" are useful.)
fr: Si I<pathname> est une chaîne non vide contenant un chemin d'accès relatif et si I<dirfd> est le descripteur de fichier d'un répertoire, alors I<pathname> est interprété par rapport au répertoire désigné par I<dirfd>, et un gestionnaire est renvoyé pour le fichier indiqué par le chemin. (Consultez B<openat>(3) si vous souhaitez comprendre pour quelles raisons les « descripteurs de fichier de répertoires » sont utiles).

note: type: Plain text
en: If I<pathname> is an empty string and I<flags> specifies the value B<AT_EMPTY_PATH>, then I<dirfd> can be an open file descriptor referring to any type of file, or B<AT_FDCWD>, meaning the current working directory, and a handle is returned for the file to which it refers.
fr: Si I<pathname> est une chaîne vide, et si I<flags> précise la valeur de B<AT_EMPTY_PATH>, alors I<dirfd> peut être un descripteur de fichiers ouvert faisant référence à n'importe quel type de fichier ou à B<AT_FDCWD> (répertoire de travail courant), et un gestionnaire est renvoyé pour le fichier auquel il fait référence.

note: type: Plain text
en: The I<mount_id> argument returns an identifier for the filesystem mount that corresponds to I<pathname>.  This corresponds to the first field in one of the records in I</proc/self/mountinfo>.  Opening the pathname in the fifth field of that record yields a file descriptor for the mount point; that file descriptor can be used in a subsequent call to B<open_by_handle_at>().
fr: L'argument I<mount_id> renvoie un identifiant pour le point de montage du système de fichiers correspondant à I<pathname>. Cet identifiant correspond au premier champ des entrées de I</proc/self/mountinfo>. L'ouverture du chemin indiqué dans le cinquième champ délivre un descripteur de fichier pour le point de montage ; ce descripteur de fichier peut être utilisé par la suite lors d'un appel à B<open_by_handle_at>().

note: type: Plain text
en: By default, B<name_to_handle_at>()  does not dereference I<pathname> if it is a symbolic link, and thus returns a handle for the link itself.  If B<AT_SYMLINK_FOLLOW> is specified in I<flags>, I<pathname> is dereferenced if it is a symbolic link (so that the call returns a handle for the file referred to by the link).
fr: Par défaut, B<name_to_handle_at>() ne déréférence pas I<pathname> s'il s'agit d'un lien symbolique, et donc ne renvoie pas d'indicateur pour le lien symbolique. Si B<AT_SYMLINK_FOLLOW> est précisé dans I<flags>, I<pathname> est déréférencé s'il s'agit d'un lien symbolique (de sorte que l'appel renvoie un indicateur pour le fichier vers lequel pointe le lien symbolique).

note: type: Plain text
en: The B<open_by_handle_at>()  system call opens the file referred to by I<handle>, a file handle returned by a previous call to B<name_to_handle_at>().
fr: L'appel système B<open_by_handle_at>() ouvre le fichier auquel I<handle> fait référence, via un indicateur de fichier renvoyé lors d'un précédent appel à B<name_to_handle_at>().

note: type: Plain text
en: The I<mount_fd> argument is a file descriptor for any object (file, directory, etc.)  in the mounted filesystem with respect to which I<handle> should be interpreted.  The special value B<AT_FDCWD> can be specified, meaning the current working directory of the caller.
fr: L'argument I<mount_fd> est un descripteur de fichier pour n'importe quel type d'objet (fichier, répertoire, etc.) du système de fichiers monté qui permet d'interpréter l'indicateur de fichier (I<handle>). La valeur spéciale B<AT_FDCWD> peut être précisée, et indique le répertoire courant du processus appelant.

note: type: Plain text
en: The I<flags> argument is as for B<open>(2).  If I<handle> refers to a symbolic link, the caller must specify the B<O_PATH> flag, and the symbolic link is not dereferenced; the B<O_NOFOLLOW> flag, if specified, is ignored.
fr: L'argument I<flags> a la même fonction que pour B<open>(2). Si l'indicateur I<handle> fait référence à un lien symbolique, le processus appelant doit préciser l'attribut B<O_PATH> et le lien symbolique n'est pas déréférencé. L'attribut B<O_NOFOLLOW> est ignoré.

note: type: Plain text
en: The caller must have the B<CAP_DAC_READ_SEARCH> capability to invoke B<open_by_handle_at>().
fr: L'appelant doit avoir la capacité B<CAP_DAC_READ_SEARCH> pour utiliser B<open_by_handle_at>().

note: type: Plain text
en: On success, B<name_to_handle_at>()  returns 0, and B<open_by_handle_at>()  returns a nonnegative file descriptor.
fr: Lorsqu'il réussit, l'appel B<name_to_handle_at>() renvoie 0 et B<open_by_handle_at>() renvoie un descripteur de fichier positif ou nul.

note: type: Plain text
en: In the event of an error, both system calls return -1 and set I<errno> to indicate the cause of the error.
fr: En cas d'échec, les deux appels renvoient -1 et affectent à I<errno> l'identifiant de la cause de l'échec.

note: type: Plain text
en: B<name_to_handle_at>()  and B<open_by_handle_at>()  can fail for the same errors as B<openat>(2).  In addition, they can fail with the errors noted below.
fr: Les appels B<name_to_handle_at>() et B<open_by_handle_at>() peuvent échouer pour les mêmes raisons que B<openat>(2). En outre, ils peuvent également échouer pour les motifs décrits plus bas.

note: type: Plain text
en: B<name_to_handle_at>()  can fail with the following errors:
fr: B<name_to_handle_at>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<pathname>, I<mount_id>, or I<handle> points outside your accessible address space.
fr: I<pathname>, I<mount_id> ou I<handle> pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<flags> includes an invalid bit value.
fr: I<flags> comprend un bit incorrect.

note: type: Plain text
en: I<handle-E<gt>handle_bytes> is greater than B<MAX_HANDLE_SZ>.
fr: I<handle-E<gt>handle_bytes> est supérieur à B<MAX_HANDLE_SZ>.

note: type: Plain text
en: I<pathname> is an empty string, but B<AT_EMPTY_PATH> was not specified in I<flags>.
fr: I<pathname> est une chaîne vide et B<AT_EMPTY_PATH> n’était pas indiqué dans I<flags>.

note: type: Plain text
en: The file descriptor supplied in I<dirfd> does not refer to a directory, and it is not the case that both I<flags> includes B<AT_EMPTY_PATH> and I<pathname> is an empty string.
fr: Le descripteur de fichiers fourni dans I<dirfd> ne fait pas référence à un répertoire, et il ne s'agit pas du cas où I<flags> comprend B<AT_EMPTY_PATH> et I<pathname> est une chaîne vide.

note: type: Plain text
en: The filesystem does not support decoding of a pathname to a file handle.
fr: Le système de fichiers ne permet pas la transcription du chemin de fichier en indicateur de fichier.

note: type: Plain text
en: The I<handle-E<gt>handle_bytes> value passed into the call was too small.  When this error occurs, I<handle-E<gt>handle_bytes> is updated to indicate the required size for the handle.
fr: La valeur I<handle-E<gt>handle_bytes> transmise dans l'appel est trop faible. Lorsque cette erreur se produit, I<handle-E<gt>handle_bytes> est modifié afin d'indiquer la taille requise pour cet indicateur.

note: type: Plain text
en: B<open_by_handle_at>()  can fail with the following errors:
fr: B<open_by_handle_at>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<mount_fd> is not an open file descriptor.
fr: I<mount_fd> n'est pas un descripteur de fichier ouvert.

note: type: Plain text
en: I<handle> points outside your accessible address space.
fr: I<handle> pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<handle-E<gt>handle_bytes> is greater than B<MAX_HANDLE_SZ> or is equal to zero.
fr: I<handle-E<gt>handle_bytes> est supérieur à B<MAX_HANDLE_SZ> ou égal à zéro.

note: type: Plain text
en: I<handle> refers to a symbolic link, but B<O_PATH> was not specified in I<flags>.
fr: I<handle> correspond à un lien symbolique et B<O_PATH> n’était pas indiqué dans I<flags>.

note: type: Plain text
en: The caller does not have the B<CAP_DAC_READ_SEARCH> capability.
fr: L'appelant n'a pas la capacité B<CAP_DAC_READ_SEARCH>.

note: type: Plain text
en: The specified I<handle> is not valid.  This error will occur if, for example, the file has been deleted.
fr: La valeur I<handle> indiquée n'est pas correcte. Cet erreur se produit par exemple lorsque le fichier a été supprimé.

note: type: Plain text
en: These system calls first appeared in Linux 2.6.39.  Library support is provided in glibc since version 2.14.
fr: Ces appels système sont apparaus dans Linux 2.6.39. La glibc les gère depuis la version 2.14.

note: type: Plain text
en: These system calls are nonstandard Linux extensions.
fr: Ces appels système sont des extensions spécifiques à Linux.

note: type: Plain text
en: A file handle can be generated in one process using B<name_to_handle_at>()  and later used in a different process that calls B<open_by_handle_at>().
fr: Un indicateur de fichier peut être créé dans un processus au moyen de B<name_to_handle_at>() et utilisé plus tard dans un autre processus qui appelle B<open_by_handle_at>().

note: type: Plain text
en: Some filesystem don't support the translation of pathnames to file handles, for example, I</proc>, I</sys>, and various network filesystems.
fr: Certains systèmes de fichiers ne permettent pas la transcription des chemin de fichiers en indicateurs (par exemple, I</proc>, I</sys>, ainsi que divers systèmes de fichiers en réseaux).

note: type: Plain text
en: A file handle may become invalid ("stale") if a file is deleted, or for other filesystem-specific reasons.  Invalid handles are notified by an B<ESTALE> error from B<open_by_handle_at>().
fr: Un indicateur de fichier peut devenir invalide (« stale ») si un fichier est supprimé, ou pour une raison propre au système de fichiers. Les indicateurs invalides sont signalés par une erreur B<ESTALE> provenant de B<open_by_handle_at>().

note: https://lwn.net/Articles/375888/ "Open by handle" - Jonathan Corbet, 2010-02-23 type: Plain text
en: These system calls are designed for use by user-space file servers.  For example, a user-space NFS server might generate a file handle and pass it to an NFS client.  Later, when the client wants to open the file, it could pass the handle back to the server.  This sort of functionality allows a user-space file server to operate in a stateless fashion with respect to the files it serves.
fr: Ces appels systèmes sont conçus pour être utilisés par des serveurs de fichiers en espace utilisateur. Par exemple, un serveur NFS en espace utilisateur produit un indicateur de fichier et le transmet au client NFS. Plus tard, lorsque le client souhaite accéder au fichier en lecture, il peut renvoyer l'indicateur au serveur. Ce type de fonctionnalité permet à un serveur de fichier en espace utilisateur d'opérer sans état vis à vis du fichier qu'il délivre.

note: commit bcda76524cd1fa32af748536f27f674a13e56700 type: Plain text
en: If I<pathname> refers to a symbolic link and I<flags> does not specify B<AT_SYMLINK_FOLLOW>, then B<name_to_handle_at>()  returns a handle for the link (rather than the file to which it refers).  The process receiving the handle can later perform operations on the symbolic link by converting the handle to a file descriptor using B<open_by_handle_at>()  with the B<O_PATH> flag, and then passing the file descriptor as the I<dirfd> argument in system calls such as B<readlinkat>(2)  and B<fchownat>(2).
fr: Si I<pathname> fait référence à un lien symbolique et si I<flags> ne précise pas B<AT_SYMLINK_FOLLOW>, alors B<name_to_handle_at>() renvoie un indicateur pour le lien (plutôt que pour le fichier vers lequel le lien pointe). Le processus recevant l'indicateur peut effectuer plus tard une opération sur ce lien symbolique, en convertissant l'indicateur en descripteur de fichier au moyen de B<open_by_handle_at>() utilisé avec l'argument B<O_PATH>, et en passant le descripteur de fichier en argument I<dirfd> de l'appel système (comme pour B<readlinkat>(2) et B<fchownat>(2)).

note: type: SS
en: Obtaining a persistent filesystem ID
fr: Obtenir un identifiant persistant de système de fichier

note: type: Plain text
en: The mount IDs in I</proc/self/mountinfo> can be reused as filesystems are unmounted and mounted.  Therefore, the mount ID returned by B<name_to_handle_at>()  (in I<*mount_id>)  should not be treated as a persistent identifier for the corresponding mounted filesystem.  However, an application can use the information in the I<mountinfo> record that corresponds to the mount ID to derive a persistent identifier.
fr: Les identifiant de montage de I</proc/self/mountinfo> peuvent être réutilisés même lorsque les systèmes de fichiers sont démontés et remontés. Ainsi, l'identifiant de montage renvoyé par B<name_to_handle_at>() (dans I<*mount_id>) ne doit pas être considéré comme un identifiant persistant pour le système de fichiers considéré. Néanmoins, il est possible pour une application d'utiliser l'information fournie dans I<mountinfo> et correspondant à l'identifiant de montage pour en déduire un identifiant persistant.

note: e.g., http://stackoverflow.com/questions/6748429/using-libblkid-to-find-uuid-of-a-partition type: Plain text
en: For example, one can use the device name in the fifth field of the I<mountinfo> record to search for the corresponding device UUID via the symbolic links in I</dev/disks/by-uuid>.  (A more comfortable way of obtaining the UUID is to use the B<libblkid>(3)  library.)  That process can then be reversed, using the UUID to look up the device name, and then obtaining the corresponding mount point, in order to produce the I<mount_fd> argument used by B<open_by_handle_at>().
fr: Par exemple, on peut utiliser le nom de périphérique présent dans le cinquième champ de I<mountinfo> pour retrouver l'UUID du périphérique correspondant au moyen des liens symboliques de I</dev/disks/by-uuid>. (Un moyen plus simple d'obtenir cet UUID consiste à utiliser la bibliothèque B<libblkid>(3)). Cette façon de procéder peut être inversée, en utilisant l'UUID pour retrouver le nom du périphérique, et ainsi obtenir le point de montage correspondant, et enfin construire l'argument de I<mount_fd> utile à B<open_by_handle_at>().

note: type: Plain text
en: The two programs below demonstrate the use of B<name_to_handle_at>()  and B<open_by_handle_at>().  The first program (I<t_name_to_handle_at.c>)  uses B<name_to_handle_at>()  to obtain the file handle and mount ID for the file specified in its command-line argument; the handle and mount ID are written to standard output.
fr: Les deux programmes suivants illustrent l'utilisation de B<name_to_handle_at>() et de B<open_by_handle_at>(). Le premier programme (I<t_name_to_handle_at.c>) utilise B<name_to_handle_at>() pour récupérer l'indicateur de fichier et l'identifiant de montage du fichier indiqué dans les arguments en ligne de commande ; l'indicateur et l'identifiant de montage sont écrits sur la sortie standard.

note: type: Plain text
en: The second program (I<t_open_by_handle_at.c>)  reads a mount ID and file handle from standard input.  The program then employs B<open_by_handle_at>()  to open the file using that handle.  If an optional command-line argument is supplied, then the I<mount_fd> argument for B<open_by_handle_at>()  is obtained by opening the directory named in that argument.  Otherwise, I<mount_fd> is obtained by scanning I</proc/self/mountinfo> to find a record whose mount ID matches the mount ID read from standard input, and the mount directory specified in that record is opened.  (These programs do not deal with the fact that mount IDs are not persistent.)
fr: Le second programme (I<t_open_by_handle_at.c>) lit un identifiant de montage et un indicateur de fichier depuis l'entrée standard. Le programme utilise ensuite B<open_by_handle_at>() pour lire le fichier au moyen de cet indicateur. Si un argument optionnel est fourni dans la ligne de commande, alors l'argument I<mount_fd> de B<open_by_handle_at>() est obtenu en ouvrant le répertoire précisé en argument. Sinon, I<mount_fd> est obtenu en parcourant I</proc/self/mountinfo> à la recherche d'un identifiant de montage correspondant à celui fourni via l'entrée standard, et le répertoire monté qui a été trouvé est ouvert. (Ces programmes ne tiennent pas compte du fait que les identifiants de montage ne sont pas persistants.)

note: type: Plain text
en: The following shell session demonstrates the use of these two programs:
fr: La session shell suivante montre des exemples d'utilisation de ces deux programmes :

note: type: Plain text
en: $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<./t_name_to_handle_at cecilia.txt E<gt> fh>
    $ B<./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Operation not permitted
    $ B<sudo ./t_open_by_handle_at E<lt> fh>      # Need CAP_SYS_ADMIN
    Read 31 bytes
    $ B<rm cecilia.txt>
fr: $ B<echo 'Pouvez-vous réflechir à cela ?' E<gt> cecilia.txt>
    $ B<./t_name_to_handle_at cecilia.txt E<gt> fh>
    $ B<./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Operation non autorisée
    $ B<sudo ./t_open_by_handle_at E<lt> fh>      # Nécessite CAP_SYS_ADMIN
    31 octets lus
    $ B<rm cecilia.txt>

note: Christoph Hellwig: That's why the file handles contain a generation counter that gets incremented in this case. type: Plain text
en: Now we delete and (quickly) re-create the file so that it has the same content and (by chance) the same inode.  Nevertheless, B<open_by_handle_at>()  recognizes that the original file referred to by the file handle no longer exists.
fr: A ce stade, on supprime et recrée (rapidement) le fichier, de sorte qu'il ait le même contenu et (avec un peu de chance) le même inoeud. Cependant, B<open_by_handle_at>() s'aperçoit que le fichier original auquel l'indicateur fait référence n'existe plus.

note: type: Plain text
en: $ B<stat --printf="%i\en" cecilia.txt>     # Display inode number
    4072121
    $ B<rm cecilia.txt>
    $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<stat --printf="%i\en" cecilia.txt>     # Check inode number
    4072121
    $ B<sudo ./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Stale NFS file handle
fr: $ B<stat --printf="%i\en" cecilia.txt>     # affiche le numéro d'inoeud
    4072121
    $ B<rm cecilia.txt>
    $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<stat --printf="%i\en" cecilia.txt>     # Vérifie le numéro d'inoeud
    4072121
    $ B<sudo ./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Stale NFS file handle

note: type: SS
en: Program source: t_name_to_handle_at.c
fr: Source du programme : t_name_to_handle_at.c

note: type: Plain text
en:     /* Allocate file_handle structure */
fr:     /* Alloue la structure file_handle */

note: type: Plain text
en:     /* Make an initial call to name_to_handle_at() to discover
           the size required for file handle */
fr:     /* Effectue un appel initial à name_to_handle_at() afin de connaître
           la taille nécessaire à l'indicateur de fichier */

note: type: Plain text
en:     dirfd = AT_FDCWD;           /* For name_to_handle_at() calls */
        flags = 0;                  /* For name_to_handle_at() calls */
        fhp-E<gt>handle_bytes = 0;
        if (name_to_handle_at(dirfd, pathname, fhp,
                    &mount_id, flags) != -1 || errno != EOVERFLOW) {
            fprintf(stderr, "Unexpected result from name_to_handle_at()\en");
            exit(EXIT_FAILURE);
        }
fr:     dirfd = AT_FDCWD;           /* pour les appels à name_to_handle_at() */
        flags = 0;                  /* Pour les appels à  name_to_handle_at() */
        fhp-E<gt>handle_bytes = 0;
        if (name_to_handle_at(dirfd, pathname, fhp,
                    &mount_id, flags) != -1 || errno != EOVERFLOW) {
            fprintf(stderr, "Unexpected result from name_to_handle_at()\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Reallocate file_handle structure with correct size */
fr:     /* Ré-alloue la structure file_handle avec la bonne taille */

note: type: Plain text
en:     fhsize = sizeof(struct file_handle) + fhp-E<gt>handle_bytes;
        fhp = realloc(fhp, fhsize);         /* Copies fhp-E<gt>handle_bytes */
        if (fhp == NULL)
            errExit("realloc");
fr:     fhsize = sizeof(struct file_handle) + fhp-E<gt>handle_bytes;
        fhp = realloc(fhp, fhsize);         /* Copie fhp-E<gt>handle_bytes */
        if (fhp == NULL)
            errExit("realloc");

note: type: Plain text
en:     /* Get file handle from pathname supplied on command line */
fr:     /* Retrouve l'indicateur de fichier à partir
           du chemin fourni dans la ligne de commande */

note: type: Plain text
en:     /* Write mount ID, file handle size, and file handle to stdout,
           for later reuse by t_open_by_handle_at.c */
fr:     /* Écrit l'identifiant de montage, la taille de l'indicateur et
           l'indicateur vers la sortie standard
           pour être utilisé plus tard par t_open_by_handle_at.c */

note: type: SS
en: Program source: t_open_by_handle_at.c
fr: Source du programme : t_open_by_handle_at.c

note: type: Plain text
en: /* Scan /proc/self/mountinfo to find the line whose mount ID matches
       \(aqmount_id\(aq. (An easier way to do this is to install and use the
       \(aqlibmount\(aq library provided by the \(aqutil-linux\(aq project.)
       Open the corresponding mount path and return the resulting file
       descriptor. */
fr: /* Parcourt /proc/self/mountinfo pour trouver la ligne correspondant à 
       l'ID de montage \(aqmount_id\(aq. (Une méthode plus simple consiste à
       installer et à utiliser la bibliothèque (aqlibmount\(aq fournie par le
       projet \(aqutil-linux\(aq.)
       Ouvre le point de montage correspondant et renvoie le descripteur de fichier associé. */

note: type: Plain text
en:     if (!found) {
            fprintf(stderr, "Could not find mount point\en");
            exit(EXIT_FAILURE);
        }
fr:     if (!found) {
            fprintf(stderr, "Point de montage non trouvé\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Standard input contains mount ID and file handle information:
fr:     /* L'entrée standard contient l'identifiant de montage et les informations du l'indicateur :

note: type: Plain text
en:          Line 1: E<lt>mount_idE<gt>
             Line 2: E<lt>handle_bytesE<gt> E<lt>handle_typeE<gt>   E<lt>bytes of handle in hexE<gt>
        */
fr:          Ligne 1: E<lt>mount_idE<gt>
             Ligne 2: E<lt>handle_bytesE<gt> E<lt>handle_typeE<gt>   E<lt>octets du descripteur en hexadécimalE<gt>
        */

note: type: Plain text
en:     if ((fgets(line1, sizeof(line1), stdin) == NULL) ||
               (fgets(line2, sizeof(line2), stdin) == NULL)) {
            fprintf(stderr, "Missing mount_id / file handle\en");
            exit(EXIT_FAILURE);
        }
fr:     if ((fgets(line1, sizeof(line1), stdin) == NULL) ||
               (fgets(line2, sizeof(line2), stdin) == NULL)) {
            fprintf(stderr, "mount_id ou descripteur de fichier absent\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Given handle_bytes, we can now allocate file_handle structure */
fr:     /* handle_bytes étant connu, on peut maintenant allouer la structure file_handle */

note: type: Plain text
en:     /* Obtain file descriptor for mount point, either by opening
           the pathname specified on the command line, or by scanning
           /proc/self/mounts to find a mount that matches the \(aqmount_id\(aq
           that we received from stdin. */
fr:     /* Récupère le descripteur de fichier du point de montage, soit en ouvrant
           le chemin indiqué dans la ligne de commande, soit en parcourant
           /proc/self/mounts pour retrouver un montage qui corresponde à \(aqmount_id\(aq
           qui a été reçu de stdin. */

note: type: Plain text
en:     /* Open file using handle and mount point */
fr:     /* Ouvre le fichier en utilisant l'indicateur et le point de montage */

note: type: Plain text
en:     /* Try reading a few bytes from the file */
fr:     /* On essaie de lire quelques octets depuis le fichier */

note: type: Plain text
en: The I<libblkid> and I<libmount> documentation in the latest I<util-linux> release at E<.UR https://www.kernel.org/pub/linux/utils/util-linux/> E<.UE>
fr: La document relative à I<libblkid> et à I<libmount> de la dernière publication de I<util-linux> à E<.UR https://www.kernel.org/pub/linux/utils/util-linux/> E<.UE>

note: type: TH
en: 2012-04-17
fr: 17 avril 2012

note: type: Plain text
en: perror - print a system error message
fr: perror - Afficher un message d'erreur système

note: type: Plain text
en: I<sys_errlist>, I<sys_nerr>: _BSD_SOURCE
fr: I<sys_errlist>, I<sys_nerr> : _BSD_SOURCE

note: type: Plain text
en: The routine B<perror>()  produces a message on the standard error output, describing the last error encountered during a call to a system or library function.  First (if I<s> is not NULL and I<*s> is not a null byte (\(aq\e0\(aq)) the argument string I<s> is printed, followed by a colon and a blank.  Then the message and a new-line.
fr: La fonction B<perror>() affiche un message sur la sortie d'erreur standard, décrivant la dernière erreur rencontrée durant un appel système ou une fonction de bibliothèque. D'abord, (si I<s> n'est pas NULL et I<*s> n'est pas un octet nul), la chaîne de caractère I<s> est imprimée, suivie d'un deux points (« : ») ou d'un blanc, puis le message, suivi d'un saut de ligne.

note: type: Plain text
en: To be of most use, the argument string should include the name of the function that incurred the error.  The error number is taken from the external variable I<errno>, which is set when errors occur but not cleared when successful calls are made.
fr: La chaîne de caractères contient généralement le nom de la fonction où s'est produit l'erreur. Le numéro d'erreur est obtenu à partir de la variable externe I<errno>, qui contient le code d'erreur lorsqu'un problème survient, mais qui n'est pas effacé lorsqu'un appel est réussi.

note: type: Plain text
en: The global error list I<sys_errlist>[] indexed by I<errno> can be used to obtain the error message without the newline.  The largest message number provided in the table is I<sys_nerr>-1.  Be careful when directly accessing this list because new error values may not have been added to I<sys_errlist>[].  The use of I<sys_errlist>[] is nowadays deprecated.
fr: La liste globale d'erreurs I<sys_errlist>[] indexée par I<errno> peut être utilisée pour obtenir le message d'erreur sans le saut de ligne. Le plus grand numéro de message contenu dans cette table est I<sys_nerr> - 1. Soyez prudents lors des accès directs dans cette liste, car de nouvelles erreurs n'ont peut-être pas de message dans I<sys_errlist>[]. L'utilisation de I<sys_errlist>[] est maintenant obsolète.

note: type: Plain text
en: When a system call fails, it usually returns -1 and sets the variable I<errno> to a value describing what went wrong.  (These values can be found in I<E<lt>errno.hE<gt>>.)  Many library functions do likewise.  The function B<perror>()  serves to translate this error code into human-readable form.  Note that I<errno> is undefined after a successful library call: this call may well change this variable, even though it succeeds, for example because it internally used some other library function that failed.  Thus, if a failing call is not immediately followed by a call to B<perror>(), the value of I<errno> should be saved.
fr: Quand un appel système échoue, il renvoie habituellement -1, et place le code d'erreur dans I<errno> (les codes sont décrits dans I<E<lt>errno.hE<gt>>). Beaucoup de fonctions de bibliothèque se comportent également ainsi. La fonction B<perror>() permet de traduire les codes d'erreur en une forme humainement lisible. Notez que I<errno> est indéfinie après un appel de fonction de bibliothèque réussi. Cette fonction peut modifier I<errno> même si elle réussit, ne serait-ce que par des appels système internes qui peuvent échouer. Ainsi, si un appel qui échoue n'est pas immédiatement suivi par B<perror>, la valeur de I<errno> doit être sauvegardée.

note: type: Plain text
en: The function B<perror>()  and the external I<errno> (see B<errno>(3))  conform to C89, C99, 4.3BSD, POSIX.1-2001.  The externals I<sys_nerr> and I<sys_errlist> conform to BSD.
fr: La fonction B<perror>() et la variable externe I<errno> (consultez B<errno>(3)) sont conformes à C89, C99, BSD\ 4.3, POSIX.1-2001. Les variables externes I<sys_nerr> et I<sys_errlist> sont conformes à BSD.

note: and only when _BSD_SOURCE is defined. When .B _GNU_SOURCE is defined, the symbols .I _sys_nerr and .I _sys_errlist are provided. type: Plain text
en: The externals I<sys_nerr> and I<sys_errlist> are defined by glibc, but in I<E<lt>stdio.hE<gt>>.
fr: Les variables externes I<sys_nerr> et I<sys_errlist> sont définies par la glibc, mais dans I<E<lt>stdio.hE<gt>>.

note: type: TH
en: 2014-02-11
fr: 11 février 2014

note: type: Plain text
en: pipe, pipe2 - create pipe
fr: pipe, pipe2 - Créer un tube

note: type: Plain text
en: B<#define _GNU_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>fcntl.hE<gt>>              /* Obtain O_* constant definitions */
    B<#include E<lt>unistd.hE<gt>>
fr: B<#define _GNU_SOURCE>             /* Consultez feature_test_macros(7) */
    B<#include E<lt>fcntl.hE<gt>>              /* Obtenir les définition de constante O_* */
    B<#include E<lt>unistd.hE<gt>>

note: type: Plain text
en: B<pipe>()  creates a pipe, a unidirectional data channel that can be used for interprocess communication.  The array I<pipefd> is used to return two file descriptors referring to the ends of the pipe.  I<pipefd[0]> refers to the read end of the pipe.  I<pipefd[1]> refers to the write end of the pipe.  Data written to the write end of the pipe is buffered by the kernel until it is read from the read end of the pipe.  For further details, see B<pipe>(7).
fr: B<pipe>() crée un tube, un canal unidirectionnel de données qui peut être utilisé pour la communication entre processus. Le tableau I<pipefd> est utilisé pour renvoyer deux descripteurs de fichier faisant référence aux extrémités du tube. I<pipefd[0]> fait référence à l'extrémité de lecture du tube. I<pipefd[1]> fait référence à l'extrémité d'écriture du tube. Les données écrites sur l'extrémité d'écriture du tube sont mises en mémoire tampon par le noyau jusqu'à ce qu'elles soient lues sur l'extrémité de lecture du tube. Pour plus de détails, consultez B<pipe>(7).

note: type: Plain text
en: If I<flags> is 0, then B<pipe2>()  is the same as B<pipe>().  The following values can be bitwise ORed in I<flags> to obtain different behavior:
fr: Si I<flags> est nul, alors B<pipe2>() est identique à B<pipe>(). Les valeurs suivantes peuvent être incluses à l'aide d'un OU binaire dans I<flags> pour obtenir différents comportements :

note: type: Plain text
en: Set the close-on-exec (B<FD_CLOEXEC>)  flag on the two new file descriptors.  See the description of the same flag in B<open>(2)  for reasons why this may be useful.
fr: Placer l'attribut « close-on-exec » (B<FD_CLOEXEC>) sur les deux nouveaux descripteurs de fichiers. Consultez la description de cet attribut dans B<open>(2) pour savoir pourquoi ça peut être utile.

note: type: TP
en: B<O_DIRECT> (since Linux 3.4)
fr: B<O_DIRECT> (depuis Linux 3.4)

note: commit 9883035ae7edef3ec62ad215611cb8e17d6a1a5d type: Plain text
en: Create a pipe that performs I/O in "packet" mode.  Each B<write>(2)  to the pipe is dealt with as a separate packet, and B<read>(2)s from the pipe will read one packet at a time.  Note the following points:
fr: Créer un tube qui assure les E/S en mode « packet ». Chaque opération B<write>(2) vers le tube est exécutée avec un paquet distinct, and les opérations B<read>(2) depuis le tube lisent un seul paquet à la fois. Notez les précisions suivantes :

note: type: Plain text
en: Writes of greater than B<PIPE_BUF> bytes (see B<pipe>(7))  will be split into multiple packets.
fr: Les opérations d'écriture dont la taille dépasse B<PIPE_BUF> octets (voir B<pipe>(7)) seront fractionnées en plusieurs paquets.

note: type: Plain text
en: If a B<read>(2)  specifies a buffer size that is smaller than the next packet, then the requested number of bytes are read, and the excess bytes in the packet are discarded.  Specifying a buffer size of B<PIPE_BUF> will be sufficient to read the largest possible packets (see the previous point).
fr: Si une opération B<read>(2) indique une taille du tampon inférieure à celle du paquet à venir, alors seul le nombre d'octets demandé sera lu, et les octets supplémentaires du paquet seront écartés. Si l'on souhaite s'assurer que même les paquets les plus longs seront lus, il suffit de définir la taille du tampon à B<PIPE_BUF>(voir le point précédent).

note: type: Plain text
en: Zero-length packets are not supported.  (A B<read>(2)  that specifies a buffer size of zero is a no-op, and returns 0.)
fr: Les paquets de longueur nulle ne sont pas acceptés (une opération B<read>(2) qui indique une taille de tampon de longueur zéro est sans effet et renvoie 0).

note: type: Plain text
en: Older kernels that do not support this flag will indicate this via an B<EINVAL> error.
fr: Les anciens noyaux qui n'acceptent pas cet attribut renvoient une erreur B<EINVAL>.

note: type: Plain text
en: Set the B<O_NONBLOCK> file status flag on the two new open file descriptions.  Using this flag saves extra calls to B<fcntl>(2)  to achieve the same result.
fr: Placer l'attribut d'état de fichier B<O_NONBLOCK> sur les deux nouveaux descripteurs de fichiers ouverts. Utiliser cet attribut économise des appels supplémentaires à B<fcntl>(2) pour obtenir le même résultat.

note: type: Plain text
en: I<pipefd> is not valid.
fr: I<pipefd> est invalide.

note: type: Plain text
en: (B<pipe2>())  Invalid value in I<flags>.
fr: (B<pipe2>()) Valeur incorrecte dans I<flags>.

note: type: Plain text
en: Too many file descriptors are in use by the process.
fr: Trop de descripteurs de fichier sont utilisés par le processus.

note: type: Plain text
en: B<pipe2>()  was added to Linux in version 2.6.27; glibc support is available starting with version 2.9.
fr: B<pipe2>() a été ajouté à Linux dans la version 2.6.27 ; sa prise en charge par la glibc est disponible depuis la version 2.9.

note: type: Plain text
en: B<pipe>(): POSIX.1-2001.
fr: B<pipe>() : POSIX.1-2001.

note: type: Plain text
en: B<pipe2>()  is Linux-specific.
fr: B<pipe2>() est spécifique à Linux.

note: fork.2 refers to this example program. type: Plain text
en: The following program creates a pipe, and then B<fork>(2)s to create a child process; the child inherits a duplicate set of file descriptors that refer to the same pipe.  After the B<fork>(2), each process closes the descriptors that it doesn't need for the pipe (see B<pipe>(7)).  The parent then writes the string contained in the program's command-line argument to the pipe, and the child reads this string a byte at a time from the pipe and echoes it on standard output.
fr: Le programme suivant crée un tube, puis invoque B<fork>(2) pour créer un processus fils ; le fils hérite d'un jeu de descripteurs de fichier qui se rapportent au même tube. Après le B<fork>(2), chaque processus ferme les descripteurs dont il n'a pas besoin pour le tube (consultez B<pipe>(7)). Le père écrit alors la chaîne contenue dans l'argument de ligne de commande du programme dans le tube, et le fils lit cette chaîne un octet à la fois dans le tube, et l'affiche sur la sortie standard.

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s E<lt>stringE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Utilisation : %s E<lt>chaîneE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     if (cpid == 0) {    /* Child reads from pipe */
            close(pipefd[1]);          /* Close unused write end */
fr:     if (cpid == 0) {    /* Le fils lit dans le tube */
            close(pipefd[1]);          /* Fermeture du descripteur en écriture inutilisé */

note: type: Plain text
en:     } else {            /* Parent writes argv[1] to pipe */
            close(pipefd[0]);          /* Close unused read end */
            write(pipefd[1], argv[1], strlen(argv[1]));
            close(pipefd[1]);          /* Reader will see EOF */
            wait(NULL);                /* Wait for child */
            exit(EXIT_SUCCESS);
        }
    }
fr:     } else {            /* Le père écrit argv[1] dans le tube */
            close(pipefd[0]);          /* Fermeture du descripteur en lecture inutilisé*/
            write(pipefd[1], argv[1], strlen(argv[1]));
            close(pipefd[1]);          /* Le lecteur verra EOF */
            wait(NULL);                /* Attente du fils */
            exit(EXIT_SUCCESS);
        }
    }

note: type: Plain text
en: popen, pclose - pipe stream to or from a process
fr: popen, pclose - Tuyau entrant ou sortant pour un processus

note: type: Plain text
en: B<popen>(), B<pclose>():
fr: B<popen>(), B<pclose>() :

note: type: Plain text
en: The B<popen>()  function opens a process by creating a pipe, forking, and invoking the shell.  Since a pipe is by definition unidirectional, the I<type> argument may specify only reading or writing, not both; the resulting stream is correspondingly read-only or write-only.
fr: La fonction B<popen>() engendre un processus en créant un tube (pipe), exécutant un B<fork>(), et en invoquant le shell. Comme un tube est unidirectionnel par définition, l'argument I<type> doit indiquer seulement une lecture ou une écriture, et non pas les deux. Le flux correspondant sera ouvert en lecture seule ou écriture seule.

note: type: Plain text
en: The I<command> argument is a pointer to a null-terminated string containing a shell command line.  This command is passed to I</bin/sh> using the B<-c> flag; interpretation, if any, is performed by the shell.  The I<type> argument is a pointer to a null-terminated string which must contain either the letter \(aqr\(aq for reading or the letter \(aqw\(aq for writing.  Since glibc 2.9, this argument can additionally include the letter \(aqe\(aq, which causes the close-on-exec flag (B<FD_CLOEXEC>)  to be set on the underlying file descriptor; see the description of the B<O_CLOEXEC> flag in B<open>(2)  for reasons why this may be useful.
fr: L'argument I<command> est un pointeur sur une chaîne de caractères, terminée par un caractère nul, et contenant une ligne de commande shell. Cette commande est transmise à I</bin/sh> en utilisant l'option B<-c>. L'interprétation en est laissée au shell. L'argument I<type> est un pointeur sur une chaîne de caractères, terminée par un caractère nul, qui doit contenir soit la lettre «\ r\ » pour la lecture soit la lettre «\ w\ » pour l'écriture. Depuis la glibc 2.9, ce paramètre peut également contenir la lettre « e », qui a pour conséquence l'activation de l'attribut « close-on-exec » (B<FD_CLOEXEC>) pour le descripteur de fichier ; consultez la description de l'attribut B<O_CLOEXEC> dans B<open>(2) pour savoir quand c'est utile.

note: type: Plain text
en: The return value from B<popen>()  is a normal standard I/O stream in all respects save that it must be closed with B<pclose>()  rather than B<fclose>(3).  Writing to such a stream writes to the standard input of the command; the command's standard output is the same as that of the process that called B<popen>(), unless this is altered by the command itself.  Conversely, reading from a "popened" stream reads the command's standard output, and the command's standard input is the same as that of the process that called B<popen>().
fr: La valeur renvoyée par B<popen>() est un flux d'entrée-sortie normal, à la seule différence qu'il doit être fermé en appelant B<pclose>() à la place de B<fclose>(3). L'écriture dans le flux correspond à écrire sur l'entrée standard de la commande. Le flux de sortie standard de la commande est le même que celui du processus appelant B<popen>(), à moins que la commande le modifie. Symétriquement, la lecture depuis un flux ouvert par B<popen>() correspond à lire la sortie standard de la commande, et dans ce cas l'entrée standard de la commande est la même que celle du processus appelant B<popen>().

note: type: Plain text
en: Note that output B<popen>()  streams are fully buffered by default.
fr: Notez que, par défaut, les flux de sortie fournis par B<popen>() disposent d'un tampon.

note: type: Plain text
en: The B<pclose>()  function waits for the associated process to terminate and returns the exit status of the command as returned by B<wait4>(2).
fr: La fonction B<pclose>() attend que le processus correspondant se termine, et renvoie alors l'état de sortie de la commande, comme en utilisant B<wait4>(2).

note: type: Plain text
en: The B<popen>()  function returns NULL if the B<fork>(2)  or B<pipe>(2)  calls fail, or if it cannot allocate memory.
fr: La fonction B<popen>() renvoie NULL si l'appel système B<fork>(2) ou B<pipe>(2) échoue, ou s'il n'a pas assez de mémoire.

note: These conditions actually give undefined results, so I commented them out. .I stream is not associated with a "popen()ed" command, if already "pclose()d", or if type: Plain text
en: The B<pclose>()  function returns -1 if B<wait4>(2)  returns an error, or some other error is detected.  In the event of an error, these functions set I<errno> to indicate the cause of the error.
fr: La fonction B<pclose>() renvoie -1 si B<wait4>(2) échoue, ou si une autre erreur est détectée. En cas d'erreur, I<errno> permet d'identifier la cause de l'erreur.

note: type: Plain text
en: The B<popen>()  function does not set I<errno> if memory allocation fails.  If the underlying B<fork>(2)  or B<pipe>(2)  fails, I<errno> is set appropriately.  If the I<type> argument is invalid, and this condition is detected, I<errno> is set to B<EINVAL>.
fr: La fonction B<popen> ne remplit pas I<errno> si une allocation mémoire échoue. Si les appels B<fork>(2) ou B<pipe>(2) sous-jacents échouent, I<errno> est correctement rempli. Si l'argument I<type> est invalide, et si cette condition est détectée, I<errno> contient B<EINVAL>.

note: type: Plain text
en: If B<pclose>()  cannot obtain the child status, I<errno> is set to B<ECHILD>.
fr: Si B<pclose>() n'arrive pas à obtenir l'état du fils, I<errno> contient B<ECHILD>.

note: type: Plain text
en: The \(aqe\(aq value for I<type> is a Linux extension.
fr: La valeur « e » pour I<type> est une extension Linux.

note: type: Plain text
en: Since the standard input of a command opened for reading shares its seek offset with the process that called B<popen>(), if the original process has done a buffered read, the command's input position may not be as expected.  Similarly, the output from a command opened for writing may become intermingled with that of the original process.  The latter can be avoided by calling B<fflush>(3)  before B<popen>().
fr: Comme l'entrée standard d'une commande ouverte en lecture partage son pointeur de position dans le flux avec le processus appelant B<popen>(), si le processus original a effectué des lectures en tampon, la position du flux d'entrée de la commande peut être différente de celle attendue. Symétriquement, la sortie d'une commande ouverte en écriture peut s'emmêler avec celle du processus original. Le second problème peut être évité en appelant B<fflush>(3) avant B<popen>().

note: .SH HISTORY A .BR popen () and a .BR pclose () function appeared in Version 7 AT&T UNIX. type: Plain text
en: Failure to execute the shell is indistinguishable from the shell's failure to execute command, or an immediate exit of the command.  The only hint is an exit status of 127.
fr: Il n'est pas possible de distinguer un échec d'exécution du shell lui-même, d'un échec d'exécution d'une commande par le shell, ni même d'une sortie immédiate de la commande. Le seul indice est un code de retour de 127.

note: type: TH
en: 2013-12-30
fr: 30 décembre 2013

note: type: Plain text
en: printf, fprintf, sprintf, snprintf, vprintf, vfprintf, vsprintf, vsnprintf - formatted output conversion
fr: printf, fprintf, sprintf, snprintf, vprintf, vfprintf, vsprintf, vsnprintf - Formatage des sorties

note: type: Plain text
en: B<snprintf>(), B<vsnprintf>():
fr: B<snprintf>(), B<vsnprintf>() :

note: type: Plain text
en: _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: or I<cc -std=c99>
fr: ou I<cc -std=c99>

note: type: Plain text
en: The functions in the B<printf>()  family produce output according to a I<format> as described below.  The functions B<printf>()  and B<vprintf>()  write output to I<stdout>, the standard output stream; B<fprintf>()  and B<vfprintf>()  write output to the given output I<stream>; B<sprintf>(), B<snprintf>(), B<vsprintf>()  and B<vsnprintf>()  write to the character string I<str>.
fr: Les fonctions de la famille B<printf>() produisent des sorties en accord avec le I<format> décrit plus bas. Les fonctions B<printf>() et B<vprintf>() écrivent leur sortie sur I<stdout>, le flux de sortie standard. B<fprintf>() et B<vfprintf>() écrivent sur le flux I<stream> indiqué. B<sprintf>(), B<snprintf>(), B<vsprintf>() et B<vsnprintf>() écrivent leurs sorties dans la chaîne de caractères I<str>.

note: type: Plain text
en: The functions B<snprintf>()  and B<vsnprintf>()  write at most I<size> bytes (including the terminating null byte (\(aq\e0\(aq)) to I<str>.
fr: Les fonctions B<snprintf>() et B<vsnprintf>() écrivent au plus I<size> octets (octet nul (« \e0 ») final compris) dans I<str>.

note: type: Plain text
en: The functions B<vprintf>(), B<vfprintf>(), B<vsprintf>(), B<vsnprintf>()  are equivalent to the functions B<printf>(), B<fprintf>(), B<sprintf>(), B<snprintf>(), respectively, except that they are called with a I<va_list> instead of a variable number of arguments.  These functions do not call the I<va_end> macro.  Because they invoke the I<va_arg> macro, the value of I<ap> is undefined after the call.  See B<stdarg>(3).
fr: Les fonctions B<vprintf>(), B<vfprintf>(), B<vsprintf>(), B<vsnprintf>() sont équivalentes aux fonctions B<printf>(), B<fprintf>(), B<sprintf>(), B<snprintf>() respectivement, mais elles emploient un tableau I<va_list> à la place d'un nombre variable d'arguments. Ces fonctions n'appellent pas la macro I<va_end>. Du fait qu'elles appèlent la macro I<va_arg>, la valeur de I<ap> n'est pas définie après l'appel. Consultez B<stdarg>(3).

note: type: Plain text
en: These eight functions write the output under the control of a I<format> string that specifies how subsequent arguments (or arguments accessed via the variable-length argument facilities of B<stdarg>(3))  are converted for output.
fr: Ces huit fonctions créent leurs sorties sous le contrôle d'une chaîne de I<format> qui indique les conversions à apporter aux arguments suivants (ou accessibles à travers les arguments de taille variable de B<stdarg>(3)).

note: type: Plain text
en: C99 and POSIX.1-2001 specify that the results are undefined if a call to B<sprintf>(), B<snprintf>(), B<vsprintf>(), or B<vsnprintf>()  would cause copying to take place between objects that overlap (e.g., if the target string array and one of the supplied input arguments refer to the same buffer).  See NOTES.
fr: C99 et POSIX.1-2001 spécifient que les résultats ne sont pas définis si un appel à B<sprintf>(), B<snprintf>(), B<vsprintf>() ou B<vsnprintf>() causait la copie entre des objets qui se chevauchent (par exemple, si le tableau de la chaîne cible et un des paramètres d'entrée se trouvent dans le même tampon). Consultez la section NOTES.

note: type: SS
en: Return value
fr: VALEUR RENVOYÉE

note: type: Plain text
en: Upon successful return, these functions return the number of characters printed (excluding the null byte used to end output to strings).
fr: En cas de succès, ces fonctions renvoient le nombre de caractères affichés (sans compter l'octet nul final utilisé pour terminer les sorties dans les chaînes).

note: type: Plain text
en: The functions B<snprintf>()  and B<vsnprintf>()  do not write more than I<size> bytes (including the terminating null byte (\(aq\e0\(aq)).  If the output was truncated due to this limit, then the return value is the number of characters (excluding the terminating null byte)  which would have been written to the final string if enough space had been available.  Thus, a return value of I<size> or more means that the output was truncated.  (See also below under NOTES.)
fr: Les fonctions B<snprintf>() et B<vsnprintf>() n'écrivent pas plus de I<size> octets (y compris l'octet nul final). Si la sortie a été tronquée à cause de la limite, la valeur de retour est le nombre de caractères (octet nul final non compris) qui auraient été écrits dans la chaîne s'il y avait eu suffisamment de place. Ainsi, une valeur de retour I<size> ou plus signifie que la sortie a été tronquée (consultez aussi la section B<NOTES> plus bas).

note: type: Plain text
en: If an output error is encountered, a negative value is returned.
fr: Si une erreur de sortie s'est produite, une valeur négative est renvoyée.

note: type: SS
en: Format of the format string
fr: CHAÎNE DE FORMAT

note: type: Plain text
en: The format string is a character string, beginning and ending in its initial shift state, if any.  The format string is composed of zero or more directives: ordinary characters (not B<%>), which are copied unchanged to the output stream; and conversion specifications, each of which results in fetching zero or more subsequent arguments.  Each conversion specification is introduced by the character B<%>, and ends with a I<conversion specifier>.  In between there may be (in this order) zero or more I<flags>, an optional minimum I<field width>, an optional I<precision> and an optional I<length modifier>.
fr: Le format de conversion est indiqué par une chaîne de caractères, commençant et se terminant dans son état de décalage initial. La chaîne de format est composée d'indicateurs\ : les caractères ordinaires (différents de B<%>), qui sont copiés sans modification sur la sortie, et les spécifications de conversion, qui sont mises en correspondance avec les arguments suivants. Les spécifications de conversion sont introduites par le caractère B<%>, et se terminent par un I<indicateur de conversion>. Entre eux peuvent se trouver (dans l'ordre), zéro ou plusieurs I<attributs>, une valeur optionnelle de I<largeur minimal de champ>, une valeur optionnelle de I<précision>, et un éventuel I<modificateur de longueur>.

note: type: Plain text
en: The arguments must correspond properly (after type promotion) with the conversion specifier.  By default, the arguments are used in the order given, where each \(aq*\(aq and each conversion specifier asks for the next argument (and it is an error if insufficiently many arguments are given).  One can also specify explicitly which argument is taken, at each place where an argument is required, by writing "%m$" instead of \(aq%\(aq and "*m$" instead of \(aq*\(aq, where the decimal integer m denotes the position in the argument list of the desired argument, indexed starting from 1.  Thus,
fr: Les arguments doivent correspondre correctement (après les promotions de types) avec les indicateurs de conversion. Par défaut les arguments sont pris dans l'ordre indiqué, où chaque «\ *\ » et chaque indicateur de conversion réclament un nouvel argument (et où l'insuffisance en arguments est une erreur). On peut aussi préciser explicitement quel argument prendre, en écrivant, à chaque conversion, «\ %m$\ » au lieu de «\ %\ », et «\ *m$\ » au lieu de «\ *\ ». L'entier décimal m indique la position dans la liste d'arguments, l'indexation commençant à 1. Ainsi,

note: type: Plain text
en: and
fr: et

note: type: Plain text
en: are equivalent.  The second style allows repeated references to the same argument.  The C99 standard does not include the style using \(aq$\(aq, which comes from the Single UNIX Specification.  If the style using \(aq$\(aq is used, it must be used throughout for all conversions taking an argument and all width and precision arguments, but it may be mixed with "%%" formats which do not consume an argument.  There may be no gaps in the numbers of arguments specified using \(aq$\(aq; for example, if arguments 1 and 3 are specified, argument 2 must also be specified somewhere in the format string.
fr: sont équivalents. La seconde notation permet de répéter plusieurs fois le même argument. Le standard C99 n'autorise pas le style utilisant «\ $\ », qui provient des Spécifications Single UNIX. Si le style avec «\ $\ » est utilisé, il faut l'employer pour toutes conversions prenant un argument, et pour tous les arguments de largeur et de précision, mais on peut le mélanger avec des formats «\ %%\ » qui ne consomment pas d'arguments. Il ne doit pas y avoir de sauts dans les numéros des arguments spécifiés avec «\ $\ ». Par exemple, si les arguments 1 et 3 sont spécifiés, l'argument 2 doit aussi être mentionné quelque part dans la chaîne de format.

note: type: Plain text
en: For some numeric conversions a radix character ("decimal point") or thousands' grouping character is used.  The actual character used depends on the B<LC_NUMERIC> part of the locale.  The POSIX locale uses \(aq.\(aq as radix character, and does not have a grouping character.  Thus,
fr: Pour certaines conversions numériques, un caractère de séparation décimale (le point par défaut) est utilisé, ainsi qu'un caractère de regroupement par milliers. Les véritables caractères dépendent de la localisation B<LC_NUMERIC>. La localisation POSIX utilise «\ .\ » comme séparateur décimal, et n'a pas de caractère de regroupement. Ainsi,

note: type: Plain text
en: results in "1234567.89" in the POSIX locale, in "1234567,89" in the nl_NL locale, and in "1.234.567,89" in the da_DK locale.
fr: s'affichera comme « 1234567.89 » dans la localisation POSIX, « 1\ 234\ 567,89 » en localisation fr_FR, et « 1.234.567,89 » en localisation da_DK.

note: type: SS
en: The flag characters
fr: CARACTÈRE D'ATTRIBUT

note: type: Plain text
en: The character % is followed by zero or more of the following flags:
fr: Le caractère % peut être éventuellement suivi par un ou plusieurs attributs suivants\ :

note: type: Plain text
en: The value should be converted to an "alternate form".  For B<o> conversions, the first character of the output string is made zero (by prefixing a 0 if it was not zero already).  For B<x> and B<X> conversions, a nonzero result has the string "0x" (or "0X" for B<X> conversions) prepended to it.  For B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, and B<G> conversions, the result will always contain a decimal point, even if no digits follow it (normally, a decimal point appears in the results of those conversions only if a digit follows).  For B<g> and B<G> conversions, trailing zeros are not removed from the result as they would otherwise be.  For other conversions, the result is undefined.
fr: indique que la valeur doit être convertie en une autre forme. Pour la conversion B<o> le premier caractère de la chaîne de sortie vaudra zéro (en ajoutant un préfixe 0 si ce n'est pas déjà un zéro). Pour les conversions B<x> et B<X> une valeur non nulle reçoit le préfixe «\ 0x\ » (ou «\ 0X\ » pour l'indicateur B<X>). Pour les conversions B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, et B<G> le résultat contiendra toujours un point décimal même si aucun chiffre ne le suit (normalement, un point décimal n'est présent avec ces conversions que si des décimales le suivent). Pour les conversions B<g> et B<G> les zéros en tête ne sont pas éliminés, contrairement au comportement habituel. Pour les autres conversions, cet attribut n'a pas d'effet.

note: type: Plain text
en: The value should be zero padded.  For B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, and B<G> conversions, the converted value is padded on the left with zeros rather than blanks.  If the B<\&0> and B<-> flags both appear, the B<\&0> flag is ignored.  If a precision is given with a numeric conversion (B<d>, B<i>, B<o>, B<u>, B<x>, and B<X>), the B<\&0> flag is ignored.  For other conversions, the behavior is undefined.
fr: indique le remplissage avec des zéros. Pour les conversions B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, et B<G>, la valeur est complétée à gauche avec des zéros plutôt qu'avec des espaces. Si les attributs B<\&0> et B<-> apparaissent ensemble, l'attribut B<\&0> est ignoré. Si une précision est fournie avec une conversion numérique (B<d>, B<i>, B<o>, B<u>, B<x>, et B<X>), l'attribut B<\&0> est ignoré. Pour les autres conversions, le comportement est indéfini.

note: type: Plain text
en: The converted value is to be left adjusted on the field boundary.  (The default is right justification.)  Except for B<n> conversions, the converted value is padded on the right with blanks, rather than on the left with blanks or zeros.  A B<-> overrides a B<\&0> if both are given.
fr: indique que la valeur doit être justifiée sur la limite gauche du champ (par défaut elle l'est à droite). Sauf pour la conversion B<n>, les valeurs sont complétées à droite par des espaces, plutôt qu'à gauche par des zéros ou des blancs. Un attribut B<-> surcharge un attribut B<\&0> si les deux sont fournis.

note: type: Plain text
en: (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.
fr: (un espace) indique qu'un espace doit être laissé avant un nombre positif (ou une chaîne vide) produit par une conversion signée

note: type: Plain text
en: A sign (+ or -) should always be placed before a number produced by a signed conversion.  By default a sign is used only for negative numbers.  A B<+> overrides a space if both are used.
fr: Un signe (+ ou -) doit toujours être imprimé avant un nombre produit par une conversion signée. Par défaut, un signe n'est utilisé que pour des valeurs négatives. Un attribut B<+> surcharge un attribut «\ espace\ » si les deux sont fournis.

note: type: Plain text
en: The five flag characters above are defined in the C standard.  The SUSv2 specifies one further flag character.
fr: Les cinq caractères d'attributs ci-dessus sont définis dans le standard C, les spécifications SUSv2 en ajoute un\ :

note: type: Plain text
en: For decimal conversion (B<i>, B<d>, B<u>, B<f>, B<F>, B<g>, B<G>)  the output is to be grouped with thousands' grouping characters if the locale information indicates any.  Note that many versions of B<gcc>(1)  cannot parse this option and will issue a warning.  SUSv2 does not include I<%\(aqF>.
fr: Pour les conversions décimales (B<i>, B<d>, B<u>, B<f>, B<F>, B<g>, B<G>) indique que les chiffres d'un argument numérique doivent être groupés par milliers en fonction de la localisation. Remarquez que de nombreuses versions de B<gcc>(1) n'acceptent pas cet attribut et déclencheront un avertissement (warning). SUSv2 n'inclue pas I<%\(aqF>.

note: type: Plain text
en: glibc 2.2 adds one further flag character.
fr: La glibc 2.2 ajoute un caractère d'attribut supplémentaire.

note: outdigits keyword in locale file type: Plain text
en: For decimal integer conversion (B<i>, B<d>, B<u>)  the output uses the locale's alternative output digits, if any.  For example, since glibc 2.2.3 this will give Arabic-Indic digits in the Persian ("fa_IR") locale.
fr: Pour les conversions décimales (B<i>, B<d>, B<u>) la sortie emploie les chiffres alternatifs de la localisation s'il y en a. Par exemple, depuis la glibc 2.2.3, cela donnera des chiffres arabes pour la localisation perse («\ fa_IR\ »).

note: type: SS
en: The field width
fr: LARGEUR DE CHAMP

note: type: Plain text
en: An optional decimal digit string (with nonzero first digit) specifying a minimum field width.  If the converted value has fewer characters than the field width, it will be padded with spaces on the left (or right, if the left-adjustment flag has been given).  Instead of a decimal digit string one may write "*" or "*m$" (for some decimal integer I<m>) to specify that the field width is given in the next argument, or in the I<m>-th argument, respectively, which must be of type I<int>.  A negative field width is taken as a \(aq-\(aq flag followed by a positive field width.  In no case does a nonexistent or small field width cause truncation of a field; if the result of a conversion is wider than the field width, the field is expanded to contain the conversion result.
fr: Un nombre optionnel ne commençant pas par un zéro, peut indiquer une largeur minimale de champ. Si la valeur convertie occupe moins de caractères que cette largeur, elle sera complétée par des espaces à gauche (ou à droite si l'attribut d'alignement à gauche a été fourni). À la place de la chaîne représentant le nombre décimal, on peut écrire «\ *\ » ou «\ *m$\ » (m étant entier) pour indiquer que la largeur du champ est fournie dans l'argument suivant, ou dans le m-ième argument, respectivement. L'argument fournissant la largeur doit être de type I<int>. Une largeur négative est considéré comme l'attribut «\ -\ » vu plus haut suivi d'une largeur positive. En aucun cas une largeur trop petite ne provoque la troncature du champ. Si le résultat de la conversion est plus grand que la largeur indiquée, le champ est élargi pour contenir le résultat.

note: type: SS
en: The precision
fr: PRÉCISION

note: type: Plain text
en: An optional precision, in the form of a period (\(aq.\(aq)  followed by an optional decimal digit string.  Instead of a decimal digit string one may write "*" or "*m$" (for some decimal integer m) to specify that the precision is given in the next argument, or in the m-th argument, respectively, which must be of type I<int>.  If the precision is given as just \(aq.\(aq, the precision is taken to be zero.  A negative precision is taken as if the precision were omitted.  This gives the minimum number of digits to appear for B<d>, B<i>, B<o>, B<u>, B<x>, and B<X> conversions, the number of digits to appear after the radix character for B<a>, B<A>, B<e>, B<E>, B<f>, and B<F> conversions, the maximum number of significant digits for B<g> and B<G> conversions, or the maximum number of characters to be printed from a string for B<s> and B<S> conversions.
fr: Une précision éventuelle, sous la forme d'un point («\ \&.\ ») suivi par un nombre. À la place de la chaîne représentant le nombre décimal, on peut écrire «\ *\ » ou «\ *m$\ » (m étant entier) pour indiquer que la précision est fournie dans l'argument suivant, ou dans le m-ième argument, respectivement. L'argument fournissant la précision doit être de type I<int>. Si la précision ne contient que le caractère «\ .\ », elle est considérée comme nulle. Une précision négative est considérée comme omise. Cette précision indique un nombre minimal de chiffres à faire apparaître lors des conversions B<d>, B<i>, B<o>, B<u>, B<x>, et B<X>, le nombre de décimales à faire apparaître pour les conversions B<a>, B<A>, B<e>, B<E>, B<f> et B<F>, le nombre maximal de chiffres significatifs pour B<g> et B<G>, et le nombre maximal de caractères à imprimer depuis une chaîne pour les conversions B<s> et B<S>.

note: type: SS
en: The length modifier
fr: MODIFICATEUR DE LONGUEUR

note: type: Plain text
en: Here, "integer conversion" stands for B<d>, B<i>, B<o>, B<u>, B<x>, or B<X> conversion.
fr: Ici, une conversion entière correspond à B<d>, B<i>, B<o>, B<u>, B<x> ou B<X>.

note: type: Plain text
en: A following integer conversion corresponds to a I<signed char> or I<unsigned char> argument, or a following B<n> conversion corresponds to a pointer to a I<signed char> argument.
fr: La conversion entière suivante correspond à un I<signed char> ou I<unsigned char>, ou la conversion B<n> suivante correspond à un argument pointeur sur un I<signed char>.

note: type: Plain text
en: A following integer conversion corresponds to a I<short int> or I<unsigned short int> argument, or a following B<n> conversion corresponds to a pointer to a I<short int> argument.
fr: La conversion entière suivante correspond à un I<short int> ou I<unsigned short int>, ou la conversion B<n> suivante correspond à un argument pointeur sur un I<short int>.

note: type: Plain text
en: (ell) A following integer conversion corresponds to a I<long int> or I<unsigned long int> argument, or a following B<n> conversion corresponds to a pointer to a I<long int> argument, or a following B<c> conversion corresponds to a I<wint_t> argument, or a following B<s> conversion corresponds to a pointer to I<wchar_t> argument.
fr: (elle) La conversion entière suivante correspond à un I<long int> ou I<unsigned long int>, ou la conversion B<n> suivante correspond à un pointeur sur un I<long int>, ou la conversion B<c> suivante correspond à un argument I<wint_t>, ou encore la conversion B<s> suivante correspond à un pointeur sur un I<wchar_t>.

note: type: Plain text
en: (ell-ell).  A following integer conversion corresponds to a I<long long int> or I<unsigned long long int> argument, or a following B<n> conversion corresponds to a pointer to a I<long long int> argument.
fr: (elle-elle) La conversion entière suivante correspond à un I<long long int>, ou I<unsigned long long int>, ou la conversion B<n> suivante correspond à un pointeur sur un I<long long int>.

note: type: Plain text
en: A following B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, or B<G> conversion corresponds to a I<long double> argument.  (C99 allows %LF, but SUSv2 does not.)
fr: La conversion B<a>, B<A>, B<e>, B<E>, B<f>, B<F>, B<g>, ou B<G> suivante correspond à un argument I<long double> (C99 autorise %LF mais pas SUSv2).

note: type: Plain text
en: ("quad". 4.4BSD and Linux libc5 only.  Don't use.)  This is a synonym for B<ll>.
fr: («\ quad\ » BSD\ 4.4 et Linux sous libc5 seulement, ne pas utiliser) Il s'agit d'un synonyme pour B<ll>.

note: type: Plain text
en: A following integer conversion corresponds to an I<intmax_t> or I<uintmax_t> argument.
fr: La conversion entière suivante correspond à un argument I<intmax_t> ou I<uintmax_t>.

note: type: Plain text
en: A following integer conversion corresponds to a I<size_t> or I<ssize_t> argument.  (Linux libc5 has B<Z> with this meaning.  Don't use it.)
fr: La conversion entière suivante correspond à un argument I<size_t> ou I<ssize_t> (la bibliothèque libc5 de Linux proposait l'argument B<Z> pour cela, ne pas utiliser).

note: type: Plain text
en: A following integer conversion corresponds to a I<ptrdiff_t> argument.
fr: La conversion entière suivante correspond à un argument I<ptrdiff_t>.

note: type: Plain text
en: The SUSv2 knows about only the length modifiers B<h> (in B<hd>, B<hi>, B<ho>, B<hx>, B<hX>, B<hn>)  and B<l> (in B<ld>, B<li>, B<lo>, B<lx>, B<lX>, B<ln>, B<lc>, B<ls>)  and B<L> (in B<Le>, B<LE>, B<Lf>, B<Lg>, B<LG>).
fr: Les spécifications SUSv2 ne mentionnent que les modificateurs de longueur B<h> (dans B<hd>, B<hi>, B<ho>, B<hx>, B<hX>, B<hn>), B<l> (dans B<ld>, B<li>, B<lo>, B<lx>, B<lX>, B<ln>, B<lc>, B<ls>) et B<L> (dans B<Le>, B<LE>, B<Lf>, B<Lg>, B<LG>).

note: type: SS
en: The conversion specifier
fr: INDICATEUR DE CONVERSION

note: type: Plain text
en: A character that specifies the type of conversion to be applied.  The conversion specifiers and their meanings are:
fr: Un caractère indique le type de conversion à apporter. Les indicateurs de conversion, et leurs significations sont\ :

note: type: Plain text
en: The I<int> argument is converted to signed decimal notation.  The precision, if any, gives the minimum number of digits that must appear; if the converted value requires fewer digits, it is padded on the left with zeros.  The default precision is 1.  When 0 is printed with an explicit precision 0, the output is empty.
fr: L'argument I<int> est converti en un chiffre décimal signé. La précision, si elle est mentionnée, correspond au nombre minimal de chiffres qui doivent apparaître. Si la conversion fournit moins de chiffres, le résultat est rempli à gauche avec des zéros. Par défaut la précision vaut 1. Lorsque 0 est converti avec une précision valant 0, la sortie est vide.

note: type: Plain text
en: The I<unsigned int> argument is converted to unsigned octal (B<o>), unsigned decimal (B<u>), or unsigned hexadecimal (B<x> and B<X>)  notation.  The letters B<abcdef> are used for B<x> conversions; the letters B<ABCDEF> are used for B<X> conversions.  The precision, if any, gives the minimum number of digits that must appear; if the converted value requires fewer digits, it is padded on the left with zeros.  The default precision is 1.  When 0 is printed with an explicit precision 0, the output is empty.
fr: L'argument I<unsigned int> est converti en un chiffre octal non signé (B<o>), un chiffre décimal non signé (B<u>), un chiffre hexadécimal non signé (B<x> et B<X>). Les lettres B<abcdef> sont utilisées pour les conversions avec B<x>, les lettres B<ABCDEF> sont utilisées pour les conversions avec B<X>. La précision, si elle est indiquée, donne un nombre minimal de chiffres à faire apparaître. Si la valeur convertie nécessite moins de chiffres, elle est complétée à gauche avec des zéros. La précision par défaut vaut 1. Lorsque 0 est converti avec une précision valant 0, la sortie est vide.

note: type: Plain text
en: The I<double> argument is rounded and converted in the style [-]dB<\&.>dddB<e>\(+-dd where there is one digit before the decimal-point character and the number of digits after it is equal to the precision; if the precision is missing, it is taken as 6; if the precision is zero, no decimal-point character appears.  An B<E> conversion uses the letter B<E> (rather than B<e>)  to introduce the exponent.  The exponent always contains at least two digits; if the value is zero, the exponent is 00.
fr: L'argument réel, de type I<double>, est arrondi et présenté avec la notation scientifique [-]cB<\&.>cccB<e>\(+-cc dans lequel se trouve un chiffre avant le point, puis un nombre de décimales égal à la précision demandée. Si la précision n'est pas indiquée, l'affichage contiendra 6 décimales. Si la précision vaut zéro, il n'y a pas de point décimal. Une conversion B<E> utilise la lettre B<E> (plutôt que B<e>) pour introduire l'exposant. Celui-ci contient toujours au moins deux chiffres. Si la valeur affichée est nulle, son exposant est 00.

note: type: Plain text
en: The I<double> argument is rounded and converted to decimal notation in the style [-]dddB<\&.>ddd, where the number of digits after the decimal-point character is equal to the precision specification.  If the precision is missing, it is taken as 6; if the precision is explicitly zero, no decimal-point character appears.  If a decimal point appears, at least one digit appears before it.
fr: L'argument réel, de type I<double>, est arrondi, et présenté avec la notation classique [-]cccB<\&.>ccc, où le nombre de décimales est égal à la précision réclamée. Si la précision n'est pas indiquée, l'affichage se fera avec 6 décimales. Si la précision vaut zéro, aucun point n'est affiché. Lorsque le point est affiché, il y a toujours au moins un chiffre devant.

note: type: Plain text
en: (The SUSv2 does not know about B<F> and says that character string representations for infinity and NaN may be made available.  The C99 standard specifies "[-]inf" or "[-]infinity" for infinity, and a string starting with "nan" for NaN, in the case of B<f> conversion, and "[-]INF" or "[-]INFINITY" or "NAN*" in the case of B<F> conversion.)
fr: SUSv2 ne mentionne pas B<F> et dit qu'il existe une chaîne de caractères représentant l'infini ou NaN. Le standard C99 précise «\ [-]inf\ » ou «\ [-]infinity\ » pour les infinis, et une chaîne commençant par «\ nan\ » pour NaN dans le cas d'une conversion B<f>, et les chaînes «\ [-]INF\ » «\ [-]INFINITY\ » «\ NAN*\ » pour une conversion B<F>.

note: type: Plain text
en: The I<double> argument is converted in style B<f> or B<e> (or B<F> or B<E> for B<G> conversions).  The precision specifies the number of significant digits.  If the precision is missing, 6 digits are given; if the precision is zero, it is treated as 1.  Style B<e> is used if the exponent from its conversion is less than -4 or greater than or equal to the precision.  Trailing zeros are removed from the fractional part of the result; a decimal point appears only if it is followed by at least one digit.
fr: L'argument réel, de type I<double>, est converti en style B<f> ou B<e> (ou B<F> ou B<E> pour la conversion B<G>) La précision indique le nombre de décimales significatives. Si la précision est absente, une valeur par défaut de 6 est utilisée. Si la précision vaut 0, elle est considérée comme valant 1. La notation scientifique B<e> est utilisée si l'exposant est inférieur à -4 ou supérieur ou égal à la précision demandée. Les zéros en fin de partie décimale sont supprimés. Un point décimal n'est affiché que s'il est suivi d'au moins un chiffre.

note: type: Plain text
en: (C99; not in SUSv2) For B<a> conversion, the I<double> argument is converted to hexadecimal notation (using the letters abcdef)  in the style [-]B<0x>hB<\&.>hhhhB<p>\(+-; for B<A> conversion the prefix B<0X>, the letters ABCDEF, and the exponent separator B<P> is used.  There is one hexadecimal digit before the decimal point, and the number of digits after it is equal to the precision.  The default precision suffices for an exact representation of the value if an exact representation in base 2 exists and otherwise is sufficiently large to distinguish values of type I<double>.  The digit before the decimal point is unspecified for nonnormalized numbers, and nonzero but otherwise unspecified for normalized numbers.
fr: (C99 mais pas SUSv2). Pour la conversion B<a>, l'argument de type I<double> est transformé en notation hexadécimale (avec les lettres abcdef) [-]B<0x>hB<\&.>hhhhB<p>\(+- ; pour la conversion B<A>, le préfixe B<0X>, les lettres ABCDEF et le séparateur d'exposant B<P> sont utilisés. Il y a un chiffre hexadécimal avant la virgule, et le nombre de chiffres ensuite est égal à la précision. La précision par défaut suffit pour une représentation exacte de la valeur, si une représentation exacte est possible en base 2. Sinon, elle est suffisamment grande pour distinguer les valeurs de type I<double>. Le chiffre avant le point décimal n'est pas spécifié pour les nombres non normalisés, et il est non nul pour les nombres normalisés.

note: type: Plain text
en: If no B<l> modifier is present, the I<int> argument is converted to an I<unsigned char>, and the resulting character is written.  If an B<l> modifier is present, the I<wint_t> (wide character) argument is converted to a multibyte sequence by a call to the B<wcrtomb>(3)  function, with a conversion state starting in the initial state, and the resulting multibyte string is written.
fr: S'il n'y a pas de modificateur B<l>, l'argument entier, de type I<int>, est converti en un I<unsigned char>, et le caractère correspondant est affiché. Si un modificateur B<l> est présent, l'argument de type I<wint_t> (caractère large) est converti en séquence multioctet par un appel à B<wcrtomb>(3), avec un état de conversion débutant dans l'état initial. La chaîne multioctet résultante est écrite.

note: type: Plain text
en: If no B<l> modifier is present: The I<const char\ *> argument is expected to be a pointer to an array of character type (pointer to a string).  Characters from the array are written up to (but not including) a terminating null byte (\(aq\e0\(aq); if a precision is specified, no more than the number specified are written.  If a precision is given, no null byte need be present; if the precision is not specified, or is greater than the size of the array, the array must contain a terminating null byte.
fr: S'il n'y a pas de modificateur B<l>, l'argument de type I<const char\ *> est supposé être un pointeur sur un tableau de caractères (pointeur sur une chaîne). Les caractères du tableau sont écrits jusqu'à l'octet nul (« \e0 ») final, non compris. Si une précision est indiquée, seul ce nombre de caractères sont écrits. Si une précision est fournie, il n'y a pas besoin de caractère nul. Si la précision n'est pas donnée, ou si elle est supérieure à la longueur de la chaîne, le caractère nul final est nécessaire.

note: type: Plain text
en: If an B<l> modifier is present: The I<const wchar_t\ *> argument is expected to be a pointer to an array of wide characters.  Wide characters from the array are converted to multibyte characters (each by a call to the B<wcrtomb>(3)  function, with a conversion state starting in the initial state before the first wide character), up to and including a terminating null wide character.  The resulting multibyte characters are written up to (but not including) the terminating null byte.  If a precision is specified, no more bytes than the number specified are written, but no partial multibyte characters are written.  Note that the precision determines the number of I<bytes> written, not the number of I<wide characters> or I<screen positions>.  The array must contain a terminating null wide character, unless a precision is given and it is so small that the number of bytes written exceeds it before the end of the array is reached.
fr: Si un modificateur B<l> est présent, l'argument de type I<const wchar_t\ *> est supposé être un pointeur sur un tableau de caractères larges. Les caractères larges du tableau sont convertis en une séquence de caractères multioctets (chacun par un appel de B<wcrtomb>(3), avec un état de conversion dans l'état initial avant le premier caractère large), ceci jusqu'au caractère large nul final compris. Les caractères multioctets résultants sont écris jusqu'à l'octet nul final (non compris). Si une précision est fournie, il n'y a pas plus d'octets écrits que la précision indiquée, mais aucun caractère multioctet n'est écrit partiellement. Remarquez que la précision concerne le nombre d'I<octets> écrits, et non pas le nombre de I<caractères larges> ou de I<positions d'écrans>. La chaîne doit contenir un caractère large nul final, sauf si une précision est indiquée, suffisamment petite pour que le nombre d'octets écrits la remplisse avant la fin de la chaîne.

note: type: Plain text
en: (Not in C99, but in SUSv2.)  Synonym for B<lc>.  Don't use.
fr: (dans SUSv2 mais pas dans C99) Synonyme de B<lc>. Ne pas utiliser.

note: type: Plain text
en: (Not in C99, but in SUSv2.)  Synonym for B<ls>.  Don't use.
fr: (dans SUSv2 mais pas dans C99) Synonyme de B<ls>. Ne pas utiliser.

note: type: Plain text
en: The I<void\ *> pointer argument is printed in hexadecimal (as if by B<%#x> or B<%#lx>).
fr: L'argument pointeur, du type I<void\ *> est affiché en hexadécimal, comme avec B<%#x> ou B<%#lx>.

note: type: Plain text
en: The number of characters written so far is stored into the integer indicated by the I<int\ *> (or variant) pointer argument.  No argument is converted.
fr: Le nombre de caractères déjà écrits est stocké dans l'entier indiqué par l'argument pointeur de type I<int\ *>. Aucun argument n'est converti.

note: type: Plain text
en: (Glibc extension.)  Print output of I<strerror(errno)>.  No argument is required.
fr: (extension glibc) Affiche la sortie I<strerror(errno)>. Aucun argument n'est requis.

note: type: Plain text
en: A \(aq%\(aq is written.  No argument is converted.  The complete conversion specification is \(aq%%\(aq.
fr: Un caractère «\ %\ » est écrit. Il n'y a pas de conversion. L'indicateur complet est «\ %%\ ».

note: type: Plain text
en: The B<fprintf>(), B<printf>(), B<sprintf>(), B<vprintf>(), B<vfprintf>(), and B<vsprintf>()  functions conform to C89 and C99.  The B<snprintf>()  and B<vsnprintf>()  functions conform to C99.
fr: Les fonctions B<fprintf>(), B<printf>(), B<sprintf>(), B<vprintf>(), B<vfprintf>() et B<vsprintf>() sont conformes à C89 et C99. Les fonctions B<snprintf>() et B<vsnprintf>() sont conformes à C99.

note: type: Plain text
en: Concerning the return value of B<snprintf>(), SUSv2 and C99 contradict each other: when B<snprintf>()  is called with I<size>=0 then SUSv2 stipulates an unspecified return value less than 1, while C99 allows I<str> to be NULL in this case, and gives the return value (as always)  as the number of characters that would have been written in case the output string has been large enough.
fr: En ce qui concerne la valeur de retour de B<snprintf>(), SUSv2 et C99 sont en contradiction\ : lorsque B<snprintf>() est appelée avec un argument I<size>=I<0> SUSv2 précise une valeur de retour indéterminée, inférieure à 1, alors que C99 autorise I<str> à être NULL dans ce cas, et réclame en valeur de retour (comme toujours) le nombre de caractères qui auraient été écrits si la chaîne de sortie avait été assez grande.

note: type: Plain text
en: Linux libc4 knows about the five C standard flags.  It knows about the length modifiers B<h>, B<l>, B<L>, and the conversions B<c>, B<d>, B<e>, B<E>, B<f>, B<F>, B<g>, B<G>, B<i>, B<n>, B<o>, B<p>, B<s>, B<u>, B<x>, and B<X>, where B<F> is a synonym for B<f>.  Additionally, it accepts B<D>, B<O>, and B<U> as synonyms for B<ld>, B<lo>, and B<lu>.  (This is bad, and caused serious bugs later, when support for B<%D> disappeared.)  No locale-dependent radix character, no thousands' separator, no NaN or infinity, no "%m$" and "*m$".
fr: La bibliothèque libc4 de Linux connaissait les 5 attributs standards du C. Elle connaissait les modificateurs de longueur B<h>, B<l>, B<L> et les conversions B<c>, B<d>, B<e>, B<E>, B<f>, B<F>, B<g>, B<G>, B<i>, B<n>, B<o>, B<p>, B<s>, B<u>, B<x> et B<X>, où B<F> était synonyme de B<f>. De plus, elle acceptait B<D>, B<O> et B<U> comme synonymes de B<ld>, B<lo> et B<lu> (ce qui causa de sérieux bogues par la suite lorsque le support de B<%D> disparut). Il n'y avait pas de séparateur décimal dépendant de la localisation, pas de séparateur des milliers, pas de NaN ou d'infinis, et pas de « %m$ » ni « *m$ ».

note: type: Plain text
en: Linux libc5 knows about the five C standard flags and the \(aq flag, locale, "%m$" and "*m$".  It knows about the length modifiers B<h>, B<l>, B<L>, B<Z>, and B<q>, but accepts B<L> and B<q> both for I<long double> and for I<long long int> (this is a bug).  It no longer recognizes B<F>, B<D>, B<O>, and B<U>, but adds the conversion character B<m>, which outputs I<strerror(errno)>.
fr: La bibliothèque libc5 de Linux connaissait les 5 attributs standards C, l'attribut «\ \(aq\ », la localisation, « %m$ » et « *m$ ». Elle connaissait les modificateurs de longueur B<h>, B<l>, B<L>, B<Z> et B<q>, mais acceptait B<L> et B<q> pour les I<long double> et les I<long long int> (ce qui est un bogue). Elle ne reconnaissait plus B<F>, B<D>, B<O> et B<U>, mais ajoutait le caractère de conversion B<m>, qui affiche I<strerror(errno)>.

note: type: Plain text
en: glibc 2.0 adds conversion characters B<C> and B<S>.
fr: La bibliothèque glibc 2.0 ajouta les caractères de conversion B<C> et B<S>.

note: type: Plain text
en: glibc 2.1 adds length modifiers B<hh>, B<j>, B<t>, and B<z> and conversion characters B<a> and B<A>.
fr: La bibliothèque glibc 2.1 ajouta les modificateurs de longueur B<hh>, B<t> et B<z>, et les caractères de conversion B<a> et B<A>.

note: type: Plain text
en: glibc 2.2 adds the conversion character B<F> with C99 semantics, and the flag character B<I>.
fr: La bibliothèque glibc 2.2. ajouta le caractère de conversion B<F> avec la sémantique C99, et le caractère d'attribut B<I>.

note: type: Plain text
en: Some programs imprudently rely on code such as the following
fr: Certains programmes reposent imprudemment sur du code comme :

note: http://sourceware.org/bugzilla/show_bug.cgi?id=7075 type: Plain text
en: to append text to I<buf>.  However, the standards explicitly note that the results are undefined if source and destination buffers overlap when calling B<sprintf>(), B<snprintf>(), B<vsprintf>(), and B<vsnprintf>().  Depending on the version of B<gcc>(1)  used, and the compiler options employed, calls such as the above will B<not> produce the expected results.
fr: pour ajouter du texte à I<buf>. Cependant, les normes indiquent explicitement que le résultat n'est pas défini si les tampons de source et de destination se recouvrent lors d'un appel à B<sprintf>(), B<snprintf>(), B<vsprintf>() et B<vsnprintf>(). En fonction de la version de B<gcc>(1) utilisée et des options de compilation, ces appels ne produiront B<pas> le résultat attendu.

note: .SH HISTORY UNIX V7 defines the three routines .BR printf (), .BR fprintf (), .BR sprintf (), and has the flag \-, the width or precision *, the length modifier l, and the conversions doxfegcsu, and also D,O,U,X as synonyms for ld,lo,lu,lx. This is still true for 2.9.1BSD, but 2.10BSD has the flags 
en: The glibc implementation of the functions B<snprintf>()  and B<vsnprintf>()  conforms to the C99 standard, that is, behaves as described above, since glibc version 2.1.  Until glibc 2.0.6 they would return -1 when the output was truncated.
fr: L'implémentation des fonctions B<snprintf>() et B<vsnprintf>() de la glibc se conforme au standard C99, et se comporte comme décrit plus haut depuis la glibc 2.1. Jusqu'à la glibc 2.0.6, elles renvoyaient -1 si la sortie avait été tronquée.

note: type: Plain text
en: Because B<sprintf>()  and B<vsprintf>()  assume an arbitrarily long string, callers must be careful not to overflow the actual space; this is often impossible to assure.  Note that the length of the strings produced is locale-dependent and difficult to predict.  Use B<snprintf>()  and B<vsnprintf>()  instead (or B<asprintf>(3)  and B<vasprintf>(3)).
fr: Comme B<sprintf>() et B<vsprintf>() ne font pas de suppositions sur la longueur des chaînes, le programme appelant doit s'assurer de ne pas déborder l'espace d'adressage. C'est souvent difficile. Notez que la longueur des chaînes peut varier avec la localisation et être difficilement prévisible. Il faut alors utiliser B<snprintf>() ou B<vsnprintf>() à la place (ou encore B<asprintf>(3) et B<vasprintf>(3)).

note: type: Plain text
en: Linux libc4.[45] does not have a B<snprintf>(), but provides a libbsd that contains an B<snprintf>()  equivalent to B<sprintf>(), that is, one that ignores the I<size> argument.  Thus, the use of B<snprintf>()  with early libc4 leads to serious security problems.
fr: La libc4.[45] de Linux n'avait pas B<snprintf>(), mais proposait une bibliothèque libbsd qui contenait un B<snprintf>() équivalent à B<sprintf>(), c'est-à-dire qui ignorait l'argument I<size>. Ainsi, l'utilisation de B<snprintf>() avec les anciennes libc4 pouvait conduire à de sérieux problèmes de sécurité.

note: .PP Some floating-point conversions under early libc4 caused memory leaks. type: Plain text
en: Code such as B<printf(>I<foo>B<);> often indicates a bug, since I<foo> may contain a % character.  If I<foo> comes from untrusted user input, it may contain B<%n>, causing the B<printf>()  call to write to memory and creating a security hole.
fr: Un code tel que B<printf(>I<foo>B<);> indique souvent un bogue, car I<foo> peut contenir un caractère «\ %\ ». Si I<foo> vient d'une saisie non sécurisée, il peut contenir B<%n>, ce qui autorise B<printf>() à écrire dans la mémoire, et crée une faille de sécurité.

note: type: Plain text
en: To print I<Pi> to five decimal places:
fr: Pour afficher I<Pi> avec cinq décimales\ :

note: type: Plain text
en: #include E<lt>math.hE<gt>
    #include E<lt>stdio.hE<gt>
    fprintf(stdout, "pi = %.5f\en", 4 * atan(1.0));
fr: #include E<lt>math.hE<gt>
    #include E<lt>stdio.hE<gt>
    fprintf (stdout, "pi = %.5f\en", 4 * atan (1.0));

note: type: Plain text
en: To print a date and time in the form "Sunday, July 3, 10:02", where I<weekday> and I<month> are pointers to strings:
fr: Pour afficher une date et une heure sous la forme «\ Sunday, July 3, 23:15\ », ou I<jour_semaine> et I<mois> sont des pointeurs sur des chaînes\ :

note: type: Plain text
en: #include E<lt>stdio.hE<gt>
    fprintf(stdout, "%s, %s %d, %.2d:%.2d\en",
            weekday, month, day, hour, min);
fr: #include E<lt>stdio.hE<gt>
    fprintf(stdout, "%s, %s %d, %.2d:%.2d\en",
            jour_semaine, mois, jour, heure, minute);

note: type: Plain text
en: Many countries use the day-month-year order.  Hence, an internationalized version must be able to print the arguments in an order specified by the format:
fr: De nombreux pays utilisent un format de date différent, comme jour-mois-année. Une version internationale doit donc être capable d'afficher les arguments dans l'ordre indiqué par le format\ :

note: type: Plain text
en: #include E<lt>stdio.hE<gt>
    fprintf(stdout, format,
            weekday, month, day, hour, min);
fr: #include E<lt>stdio.hE<gt>
    fprintf(stdout, format,
            jour_semaine, mois, jour, heure, min);

note: type: Plain text
en: where I<format> depends on locale, and may permute the arguments.  With the value:
fr: où le I<format> dépend de la localisation et peut permuter les arguments. Avec la valeur :

note: type: Plain text
en: one might obtain "Sonntag, 3. Juli, 10:02".
fr: On peut obtenir «\ Dimanche, 3 Juillet, 23:15\ ».

note: type: Plain text
en: To allocate a sufficiently large string and print into it (code correct for both glibc 2.0 and glibc 2.1):
fr: Pour allouer une chaîne de taille suffisante et écrire dedans (code correct aussi bien pour glibc 2.0 que glibc 2.1)\ :

note: type: Plain text
en: char *
    make_message(const char *fmt, ...)
    {
        int n;
        int size = 100;     /* Guess we need no more than 100 bytes */
        char *p, *np;
        va_list ap;
fr: char *
    make_message(const char *fmt, ...)
    {
        int n;
        int size = 100; /* Supposons que nous n'avons pas besoin de plus de 100 octets */
        char *p, *np;
        va_list ap;

note: type: Plain text
en:         /* Try to print in the allocated space */
fr:         /* Essayons d'écrire dans l'espace alloué */

note: type: Plain text
en:         /* Check error code */
fr:         /* Vérifie le code d'erreur */

note: type: Plain text
en:         /* If that worked, return the string */
fr:         /* Si cela fonctionne, renvoie la chaîne */

note: type: Plain text
en:         /* Else try again with more space */
fr:         /* Sinon, essayons encore avec plus de place */

note: type: Plain text
en:         size = n + 1;       /* Precisely what is needed */
fr:         size = n + 1;       /* Exactement ce qui est nécessaire */

note: type: Plain text
en: If truncation occurs in glibc versions prior to 2.0.6, this is treated as an error instead of being handled gracefully.
fr: En cas de troncature dans les versions de glibc avant 2.0.6, c'est traité comme une erreur au lieu d'être traité de façon élégante.

note: type: TH
en: 2014-01-11
fr: 11 janvier 2014

note: type: Plain text
en: fputc, fputs, putc, putchar, puts - output of characters and strings
fr: puts, fputc, fputs, putc, putchar - Écriture de caractères et de chaînes

note: type: Plain text
en: B<fputc>()  writes the character I<c>, cast to an I<unsigned char>, to I<stream>.
fr: B<fputc>() écrit le caractère I<c>, transformé en I<unsigned char>, dans le flux I<stream>.

note: type: Plain text
en: B<fputs>()  writes the string I<s> to I<stream>, without its terminating null byte (\(aq\e0\(aq).
fr: B<fputs>() écrit la chaîne de caractères I<s> dans le flux I<stream>, sans écrire l'octet nul «\ B<\e0>\ » final.

note: type: Plain text
en: B<putc>()  is equivalent to B<fputc>()  except that it may be implemented as a macro which evaluates I<stream> more than once.
fr: B<putc>() est équivalent à B<fputc>() sauf qu'il peut être implémenté comme une macro évaluant plusieurs fois son argument I<stream>.

note: type: Plain text
en: B<putchar(>I<c>B<);> is equivalent to B<putc(>I<c>B<,>I<stdout>B<).>
fr: B<putchar>(I<c>) est équivalent à B<putc>(I<c>,I<stdout>).

note: type: Plain text
en: B<puts>()  writes the string I<s> and a trailing newline to I<stdout>.
fr: B<puts>() écrit la chaîne de caractères I<s> et un retour-chariot final sur I<stdout>.

note: type: Plain text
en: Calls to the functions described here can be mixed with each other and with calls to other output functions from the I<stdio> library for the same output stream.
fr: Les appels de ces fonctions peuvent être utilisés conjointement, ainsi qu'avec les autres fonctions d'écriture de la bibliothèque I<stdio>.

note: type: Plain text
en: B<fputc>(), B<putc>()  and B<putchar>()  return the character written as an I<unsigned char> cast to an I<int> or B<EOF> on error.
fr: B<fputc>(), B<putc>() et B<putchar>() renvoient le caractère écrit en tant qu'I<unsigned char> (converti en I<int>), ou B<EOF> en cas d'erreur.

note: type: Plain text
en: B<puts>()  and B<fputs>()  return a nonnegative number on success, or B<EOF> on error.
fr: B<puts>() et B<fputs>() renvoient un nombre non négatif si elles réussissent et B<EOF> si elles échouent.

note: type: Plain text
en: It is not advisable to mix calls to output functions from the I<stdio> library with low-level calls to B<write>(2)  for the file descriptor associated with the same output stream; the results will be undefined and very probably not what you want.
fr: Il est fortement déconseillé de mêler les fonctions d'écriture de I<stdio> avec les appels bas niveau B<write>(2) sur le descripteur du fichier associé au flux. Le comportement est imprévisible et certainement pas celui que vous attendez.

note: type: TH
en: 2013-02-12
fr: 12 février 2013

note: type: Plain text
en: read - read from a file descriptor
fr: read - Lire depuis un descripteur de fichier

note: type: Plain text
en: B<read>()  attempts to read up to I<count> bytes from file descriptor I<fd> into the buffer starting at I<buf>.
fr: B<read>() lit jusqu'à I<count> octets depuis le descripteur de fichier I<fd> dans le tampon pointé par I<buf>.

note: type: Plain text
en: On files that support seeking, the read operation commences at the current file offset, and the file offset is incremented by the number of bytes read.  If the current file offset is at or past the end of file, no bytes are read, and B<read>()  returns zero.
fr: Sur les fichiers permettant le positionnement, l'opération de lecture a lieu à la position actuelle dans le fichier et elle est déplacée du nombre d'octets lus. Si la position actuelle dans le fichier est à la fin du fichier ou après, aucun octet n'est lu et B<read>() renvoie zéro.

note: type: Plain text
en: If I<count> is zero, B<read>()  I<may> detect the errors described below.  In the absence of any errors, or if B<read>()  does not check for errors, a B<read>()  with a I<count> of 0 returns zero and has no other effects.
fr: Si I<count> vaut zéro, B<read>() I<pourrait> détecter les erreurs décrites ci-dessous. En absence d'erreur, ou si B<read>() ne vérifie pas les erreurs, un B<read>() avec un I<count> de 0 renvoie zéro et n'a pas d'autres effets.

note: type: Plain text
en: If I<count> is greater than B<SSIZE_MAX>, the result is unspecified.
fr: Si I<count> est supérieur à B<SSIZE_MAX>, le résultat est indéfini.

note: type: Plain text
en: On success, the number of bytes read is returned (zero indicates end of file), and the file position is advanced by this number.  It is not an error if this number is smaller than the number of bytes requested; this may happen for example because fewer bytes are actually available right now (maybe because we were close to end-of-file, or because we are reading from a pipe, or from a terminal), or because B<read>()  was interrupted by a signal.  On error, -1 is returned, and I<errno> is set appropriately.  In this case, it is left unspecified whether the file position (if any) changes.
fr: B<read>() renvoie -1 s'il échoue, auquel cas I<errno> contient le code d'erreur, et la position de la tête de lecture est indéfinie. Sinon, B<read> renvoie le nombre d'octets lus (0 en fin de fichier), et avance la tête de lecture de ce nombre. Le fait que le nombre renvoyé soit plus petit que le nombre demandé n'est pas une erreur. Ceci se produit à la fin du fichier, ou si on lit depuis un tube ou un terminal, ou encore si B<read>() a été interrompu par un signal.

note: type: Plain text
en: The file descriptor I<fd> refers to a file other than a socket and has been marked nonblocking (B<O_NONBLOCK>), and the read would block.
fr: Le descripteur de fichier I<fd> fait référence à un fichier autre qu'une socket et a été marqué comme non bloquant (B<O_NONBLOCK>), et la lecture devrait bloquer.

note: type: TP
en: B<EAGAIN> or B<EWOULDBLOCK>
fr: B<EAGAIN> ou B<EWOULDBLOCK>

note: Actually EAGAIN on Linux type: Plain text
en: The file descriptor I<fd> refers to a socket and has been marked nonblocking (B<O_NONBLOCK>), and the read would block.  POSIX.1-2001 allows either error to be returned for this case, and does not require these constants to have the same value, so a portable application should check for both possibilities.
fr: Le descripteur de fichier I<fd> fait référence à un fichier autre qu'une socket et a été marqué comme non bloquant (B<O_NONBLOCK>), et la lecture devrait bloquer. POSIX.1-2001 permet de renvoyer l'une ou l'autre des erreurs dans ce cas et n'exige pas que ces constantes aient la même valeur. Une application portable devrait donc tester les deux possibilités.

note: type: Plain text
en: I<fd> is not a valid file descriptor or is not open for reading.
fr: I<fd> n'est pas un descripteur de fichier valable ou n'est pas ouvert en lecture.

note: type: Plain text
en: I<buf> is outside your accessible address space.
fr: I<buf> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: The call was interrupted by a signal before any data was read; see B<signal>(7).
fr: B<read>() a été interrompu par un signal avant d'avoir eu le temps de lire quoi que ce soit ; consultez B<signal>(7).

note: type: Plain text
en: I<fd> is attached to an object which is unsuitable for reading; or the file was opened with the B<O_DIRECT> flag, and either the address specified in I<buf>, the value specified in I<count>, or the current file offset is not suitably aligned.
fr: Le descripteur I<fd> correspond à un objet sur lequel il est impossible de lire. Ou bien le fichier a été ouvert avec l'attribut B<O_DIRECT>, et l'adresse de I<buf>, la valeur de I<count> ou la position actuelle de la tête de lecture ne sont pas alignées correctement.

note: type: Plain text
en: I<fd> was created via a call to B<timerfd_create>(2)  and the wrong size buffer was given to B<read>(); see B<timerfd_create>(2)  for further information.
fr: I<fd> a été créé par un appel à B<timerfd_create>(2) et une mauvaise taille de tampon a été donnée à B<read>() ; consultez B<timerfd_create>(2) pour plus d'informations.

note: type: Plain text
en: I/O error.  This will happen for example when the process is in a background process group, tries to read from its controlling terminal, and either it is ignoring or blocking B<SIGTTIN> or its process group is orphaned.  It may also occur when there is a low-level I/O error while reading from a disk or tape.
fr: Erreur d'entrée-sortie. Ceci arrive si un processus est dans un groupe en arrière-plan et tente de lire depuis le terminal (tty). Il reçoit un signal B<SIGTTIN> mais il l'ignore ou le bloque. Ceci se produit également si une erreur d'entrée-sortie bas niveau s'est produite pendant la lecture d'un disque ou d'une bande.

note: type: Plain text
en: I<fd> refers to a directory.
fr: I<fd> est un répertoire.

note: type: Plain text
en: Other errors may occur, depending on the object connected to I<fd>.  POSIX allows a B<read>()  that is interrupted after reading some data to return -1 (with I<errno> set to B<EINTR>)  or to return the number of bytes already read.
fr: D'autres erreurs peuvent se produire, suivant le type d'objet associé à I<fd>. POSIX permet à un B<read>() interrompu par un signal de renvoyer soit le nombre d'octets lus à ce point, soit -1, et de placer I<errno> à B<EINTR>.

note: type: Plain text
en: On NFS filesystems, reading small amounts of data will update the timestamp only the first time, subsequent calls may not do so.  This is caused by client side attribute caching, because most if not all NFS clients leave st_atime (last file access time)  updates to the server and client side reads satisfied from the client's cache will not cause st_atime updates on the server as there are no server side reads.  UNIX semantics can be obtained by disabling client side attribute caching, but in most situations this will substantially increase server load and decrease performance.
fr: Sur un système de fichiers NFS, la lecture de petites quantités de données ne mettra à jour l'horodatage du fichier que lors de la première lecture. Les lectures suivantes ne modifieront pas cette heure. En effet la plupart, si ce n'est tous les clients NFS disposent d'un cache des attributs de fichiers et n'effectuent pas la mise à jour du champ «\ st_atime\ » du côté serveur. La véritable sémantique UNIX peut être obtenue en désactivant le cache des attributs du côté client, mais généralement ceci augmente sensiblement la charge du serveur, et dégrade ses performances.

note: type: TH
en: 2014-02-21
fr: 21 février 2014

note: type: Plain text
en: readlink, readlinkat - read value of a symbolic link
fr: readlink, readlinkat - Lire le contenu d'un lien symbolique

note: type: Plain text
en: B<readlink>():
fr: B<readlinkat>() :

note: type: Plain text
en: B<readlink>()  places the contents of the symbolic link I<pathname> in the buffer I<buf>, which has size I<bufsiz>.  B<readlink>()  does not append a null byte to I<buf>.  It will truncate the contents (to a length of I<bufsiz> characters), in case the buffer is too small to hold all of the contents.
fr: B<readlink>() place le contenu du lien symbolique I<pathname> dans le tampon I<buf>, dont la taille est I<bufsiz>. B<readlink>() n'ajoute pas de caractère B<NUL> dans le tampon I<buf>. Il tronquera le contenu (à la longueur I<bufsiz>) si le tampon est trop petit pour recevoir les données.

note: type: Plain text
en: The B<readlinkat>()  system call operates in exactly the same way as B<readlink>(), except for the differences described here.
fr: L'appel système B<readlinkat>() fonctionne exactement comme B<readlink>(), les seules différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<pathname> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<readlink>()  for a relative pathname).
fr: Si I<pathname> est un chemin relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier I<dirfd> (plutôt que par rapport au répertoire courant du processus appelant, comme cela est fait par B<readlink>() pour un chemin relatif).

note: type: Plain text
en: If I<pathname> is relative and I<dirfd> is the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the calling process (like B<readlink>()).
fr: Si I<pathname> est relatif et si I<dirfd> a la valeur spéciale B<AT_FDCWD>, alors I<pathname> est interprété relativement au répertoire de travail du processus appelant, comme pour B<readlink>().

note: commit 65cfc6722361570bfe255698d9cd4dccaf47570d type: Plain text
en: Since Linux 2.6.39, I<pathname> can be an empty string, in which case the call operates on the file referred to by I<dirfd> (which may have been obtained using the B<open>(2)  B<O_PATH> flag).  In this case, I<dirfd> can refer to any type of file, not just a directory.
fr: Depuis Linux 2.6.39, I<pathname> peut être une chaîne vide, auquel cas l'appel opère sur le fichier référencé par I<dirfd> (qui peut avoir été obtenu par B<open>(2) avec le drapeau B<O_PATH>). DAns ce cas, I<dirfd> peut référer à tout type de fichier, pas uniquement un répertoire.

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<readlinkat>().
fr: Consultez B<openat>(2) pour une explication de la nécessité de B<readlinkat>().

note: type: Plain text
en: On success, these calls return the number of bytes placed in I<buf>.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, ces appels renvoient le nombre d'octets placés dans I<buf>. S'il échoue, il renvoie -1 et écrit I<errno> en conséquence.

note: type: Plain text
en: Search permission is denied for a component of the path prefix.  (See also B<path_resolution>(7).)
fr: Un élément du chemin d'accès ne permet pas la recherche. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: I<buf> extends outside the process's allocated address space.
fr: I<buf> pointe en dehors de l'espace d'adressage accessible.

note: At the glibc level, bufsiz is unsigned, so this error can only occur if bufsiz==0.  However, the in the kernel syscall, bufsiz is signed, and this error can also occur if bufsiz < 0. See: http://thread.gmane.org/gmane.linux.man/380 Subject: [patch 0/3] [RFC] kernel/glibc mismatch of "readlink" sysca
en: I<bufsiz> is not positive.
fr: I<bufsiz> n'est pas positif.

note: type: Plain text
en: The named file is not a symbolic link.
fr: Le fichier n'est pas un lien symbolique.

note: type: Plain text
en: An I/O error occurred while reading from the filesystem.
fr: Une erreur d'entrée-sortie est survenue lors de la lecture sur le système de fichiers.

note: type: Plain text
en: Too many symbolic links were encountered in translating the pathname.
fr: Trop de liens symboliques ont été rencontrés en parcourant le chemin.

note: type: Plain text
en: A pathname, or a component of a pathname, was too long.
fr: I<path> ou l'un des composants de ce chemin d'accès est trop long.

note: type: Plain text
en: The named file does not exist.
fr: Le fichier indiqué n'existe pas.

note: type: Plain text
en: A component of the path prefix is not a directory.
fr: Un élément du chemin d'accès n'est pas un répertoire.

note: type: Plain text
en: The following additional errors can occur for B<readlinkat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<readlinkat>() :

note: type: Plain text
en: B<readlinkat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<readlinkat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: type: Plain text
en: B<readlink>(): 4.4BSD (B<readlink>()  first appeared in 4.2BSD), POSIX.1-2001, POSIX.1-2008.
fr: B<readlink>() : BSD\ 4.4 (B<readlink>() est apparue pour la première fois dans BSD\ 4.2), POSIX.1-2001, POSIX.1-2008.

note: type: Plain text
en: B<readlinkat>(): POSIX.1-2008.
fr: B<readlinkat>() : POSIX.1-2008.

note: type: Plain text
en: In versions of glibc up to and including glibc 2.4, the return type of B<readlink>()  was declared as I<int>.  Nowadays, the return type is declared as I<ssize_t>, as (newly) required in POSIX.1-2001.
fr: Dans les versions de glibc jusqu'à 2.4 incluse, le type de retour de B<readlink>() était déclaré comme I<int>. À présent, le type de retour est déclaré comme I<ssize_t>, ainsi que le prescrit POSIX.1-2001.

note: type: Plain text
en: Using a statically sized buffer might not provide enough room for the symbolic link contents.  The required size for the buffer can be obtained from the I<stat.st_size> value returned by a call to B<lstat>(2)  on the link.  However, the number of bytes written by B<readlink>()  and B<readlinkat>()  should be checked to make sure that the size of the symbolic link did not increase between the calls.  Dynamically allocating the buffer for B<readlink>()  and B<readlinkat>()  also addresses a common portability problem when using I<PATH_MAX> for the buffer size, as this constant is not guaranteed to be defined per POSIX if the system does not have such limit.
fr: L'utilisation d'un tampon de taille statique risque de ne pas fournir assez de place pour le contenu du lien symbolique. La taille nécessaire au tampon peut être lue dans la valeur I<stat.st_size> renvoyée par un appel à B<lstat>(2) sur le lien. Cependant, le nombre d'octets écrits par B<readlink>() et par B<readlinkat>() devrait être vérifié pour s'assurer que la taille du lien symbolique n'a pas augmenté entre les appels. L'allocation dynamique du tampon pour B<readlink>() et pour  B<readlinkat>() résout aussi un problème habituel de portabilité si I<PATH_MAX> est utilisé comme taille de tampon, car la définition de cette constante n'est pas garantie par POSIX si le système n'a pas ce genre de limite.

note: type: Plain text
en: The following program allocates the buffer needed by B<readlink>()  dynamically from the information provided by B<lstat>(), making sure there's no race condition between the calls.
fr: Le programme suivant alloue le tampon nécessaire à B<readlink>() dynamiquement à partir des données fournies par B<lstat>(), en s'assurant qu'il n'y a pas de situation de compétition entre les appels.

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s E<lt>pathnameE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Utilisation : %s E<lt>cheminE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     linkname = malloc(sb.st_size + 1);
        if (linkname == NULL) {
            fprintf(stderr, "insufficient memory\en");
            exit(EXIT_FAILURE);
        }
fr:     linkname = malloc(sb.st_size + 1);
        if (linkname == NULL) {
            fprintf(stderr, "mémoire insuffisante\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     if (r E<gt> sb.st_size) {
            fprintf(stderr, "symlink increased in size "
                            "between lstat() and readlink()\en");
            exit(EXIT_FAILURE);
        }
fr:     if (r E<gt> sb.st_size) {
            fprintf(stderr, "la taille du lien symbolique a augmenté"
                            "entre lstat() et readlink()\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     printf("\(aq%s\(aq points to \(aq%s\(aq\en", argv[1], linkname);
fr:     printf("« %s » pointe vers « %s »\en", argv[1], linkname);

note: type: TH
en: 2010-11-17
fr: 17 novembre 2010

note: type: Plain text
en: readv, writev, preadv, pwritev - read or write data into multiple buffers
fr: readv, writev, preadv, pwritev - Lire ou écrire dans plusieurs tampons

note: type: Plain text
en: B<preadv>(), B<pwritev>(): _BSD_SOURCE
fr: B<preadv>(), B<pwritev>() : _BSD_SOURCE

note: type: Plain text
en: The B<readv>()  system call reads I<iovcnt> buffers from the file associated with the file descriptor I<fd> into the buffers described by I<iov> ("scatter input").
fr: L'appel système B<readv>() lit I<iovcnt> blocs depuis le descripteur de fichier I<fd> dans les multiples tampons décrits par I<iov>.

note: type: Plain text
en: The B<writev>()  system call writes I<iovcnt> buffers of data described by I<iov> to the file associated with the file descriptor I<fd> ("gather output").
fr: L'appel système B<writev>() écrit au plus I<iovcnt> blocs décrits par I<iov> dans le fichier associé au descripteur I<fd>.

note: type: Plain text
en: The pointer I<iov> points to an array of I<iovec> structures, defined in I<E<lt>sys/uio.hE<gt>> as:
fr: Le pointeur I<iov> pointe vers un tableau de structures I<iovec> définies dans I<E<lt>sys/uio.hE<gt>>\ :

note: type: Plain text
en: struct iovec {
        void  *iov_base;    /* Starting address */
        size_t iov_len;     /* Number of bytes to transfer */
    };
fr: struct iovec {
        void  *iov_base;    /* Adresse de début */
        size_t iov_len;     /* Nombre d'octets à transférer */
    };

note: type: Plain text
en: The B<readv>()  system call works just like B<read>(2)  except that multiple buffers are filled.
fr: L'appel système B<readv>() travaille comme B<read>(2) sauf que plusieurs tampons sont remplis.

note: type: Plain text
en: The B<writev>()  system call works just like B<write>(2)  except that multiple buffers are written out.
fr: L'appel système B<writev>() travaille comme B<write>(2) sauf que plusieurs tampons sont écrits.

note: type: Plain text
en: Buffers are processed in array order.  This means that B<readv>()  completely fills I<iov>[0] before proceeding to I<iov>[1], and so on.  (If there is insufficient data, then not all buffers pointed to by I<iov> may be filled.)  Similarly, B<writev>()  writes out the entire contents of I<iov>[0] before proceeding to I<iov>[1], and so on.
fr: Les tampons sont considérés dans l'ordre du tableau. Cela signifie que B<readv>() remplit I<iov>[0] complètement avant d'en arriver à I<iov>[1], et ainsi de suite. (S'il n'y a pas assez de données, tous les tampons pointés par I<iov> ne seront pas forcément remplis.) De même, B<writev>() écrit tout le contenu de I<iov>[0] avant de considérer I<iov>[1], et ainsi de suite.

note: type: Plain text
en: The data transfers performed by B<readv>()  and B<writev>()  are atomic: the data written by B<writev>()  is written as a single block that is not intermingled with output from writes in other processes (but see B<pipe>(7)  for an exception); analogously, B<readv>()  is guaranteed to read a contiguous block of data from the file, regardless of read operations performed in other threads or processes that have file descriptors referring to the same open file description (see B<open>(2)).
fr: Les transferts de données effectués par B<readv>() et B<writev>() sont atomiques\ : les données écrites par B<writev>() sont écrites d'un bloc qui n'est pas interrompu par des écritures venant d'autres processus (mais voir B<pipe>(7) pour une exception)\ ; de façon similaire, B<readv>() a la garantie de lire un bloc contigu de données depuis le fichier, quelles que soient les opérations de lecture effectuées par d'autres threads ou processus qui ont des descripteurs de fichier correspondant à la même description de fichier ouvert (consultez B<open>(2)).

note: type: SS
en: preadv() and pwritev()
fr: preadv() et pwritev()

note: type: Plain text
en: The B<preadv>()  system call combines the functionality of B<readv>()  and B<pread>(2).  It performs the same task as B<readv>(), but adds a fourth argument, I<offset>, which specifies the file offset at which the input operation is to be performed.
fr: L'appel système B<preadv>() combine les fonctionnalités de B<readv>() et B<pread>(2). Il effectue la même tâche que B<readv>(), mais ajoute un quatrième paramètre, I<offset>, qui indique la position dans le fichier à partir de laquelle l'opération d'entrée doit être effectuée.

note: type: Plain text
en: The B<pwritev>()  system call combines the functionality of B<writev>()  and B<pwrite>(2).  It performs the same task as B<writev>(), but adds a fourth argument, I<offset>, which specifies the file offset at which the output operation is to be performed.
fr: L'appel système B<pwritev>() combine les fonctionnalités de B<writev>() et B<pwrite>(2). Il effectue la même tâche que B<writev>(), mais ajoute un quatrième paramètre, I<offset>, qui indique la position dans le fichier à partir de laquelle l'opération de sortie doit être effectuée.

note: type: Plain text
en: The file offset is not changed by these system calls.  The file referred to by I<fd> must be capable of seeking.
fr: La position dans le fichier n'est pas modifiée par ces appels système. Le fichier décrit par I<fd> doit permettre le positionnement.

note: type: Plain text
en: On success, B<readv>()  and B<preadv>()  return the number of bytes read; B<writev>()  and B<pwritev>()  return the number of bytes written.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'ils réussissent, B<readv>() et B<preadv>() renvoient le nombre d'octets lus ; B<writev> et B<pwritev>() renvoient le nombre d'octets écrits. En cas d'échec, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: The errors are as given for B<read>(2)  and B<write>(2).  Furthermore, B<preadv>()  and B<pwritev>()  can also fail for the same reasons as B<lseek>(2).  Additionally, the following error is defined:
fr: Les erreurs indiquées pour B<read>(2) et B<write>(2) sont susceptibles de se produire. D'autre part, B<preadv>() et B<pwritev>() peuvent aussi échouer pour les mêmes raisons que B<lseek>(2). De plus, il peut survenir\ :

note: type: Plain text
en: The sum of the I<iov_len> values overflows an I<ssize_t> value.  Or, the vector count I<iovcnt> is less than zero or greater than the permitted maximum.
fr: La somme des valeurs I<iov_len> déborde du type I<ssize_t>, ou le nombre I<iovcnt> de vecteur est nul ou supérieur au maximum autorisé.

note: type: Plain text
en: B<preadv>()  and B<pwritev>()  first appeared in Linux 2.6.30; library support was added in glibc 2.10.
fr: B<preadv>() et B<pwritev>() sont apparus dans Linux 2.6.30\ ; la glibc le gère depuis la version 2.10.

note: The readv/writev system calls were buggy before Linux 1.3.40. (Says release.libc.) type: Plain text
en: B<readv>(), B<writev>(): 4.4BSD (these system calls first appeared in 4.2BSD), POSIX.1-2001.  Linux libc5 used I<size_t> as the type of the I<iovcnt> argument, and I<int> as the return type.
fr: B<readv>(), B<writev>() : BSD\ 4.4 (ces appels système sont apparus dans BSD\ 4.2), POSIX.1-2001. La libc5 de Linux utilisait le type I<size_t> pour le paramètre I<iovcnt> et I<int> en retour de ces fonctions.

note: type: Plain text
en: B<preadv>(), B<pwritev>(): nonstandard, but present also on the modern BSDs.
fr: B<preadv>(), B<pwritev>() : non standard, mais sont aussi présents sur les BSD modernes.

note: type: SS
en: Linux notes
fr: Notes sur Linux

note: type: Plain text
en: POSIX.1-2001 allows an implementation to place a limit on the number of items that can be passed in I<iov>.  An implementation can advertise its limit by defining B<IOV_MAX> in I<E<lt>limits.hE<gt>> or at run time via the return value from I<sysconf(_SC_IOV_MAX)>.  On Linux, the limit advertised by these mechanisms is 1024, which is the true kernel limit.  However, the glibc wrapper functions do some extra work if they detect that the underlying kernel system call failed because this limit was exceeded.  In the case of B<readv>()  the wrapper function allocates a temporary buffer large enough for all of the items specified by I<iov>, passes that buffer in a call to B<read>(2), copies data from the buffer to the locations specified by the I<iov_base> fields of the elements of I<iov>, and then frees the buffer.  The wrapper function for B<writev>()  performs the analogous task using a temporary buffer and a call to B<write>(2).
fr: POSIX.1-2001 permet à l'implémentation de limiter le nombre d'éléments qui peuvent être passés dans I<iov>. Une implémentation peut annoncer sa limite en définissant B<IOV_MAX> dans I<E<lt>limits.hE<gt>> ou à l'exécution à travers I<sysconf(_SC_IOV_MAX)>. Sous Linux, la limite annoncée ainsi est 1024, qui est la véritable limite du noyau. Cependant, les fonctions d'enrobage de la glibc font du travail supplémentaire si elles détectent que l'appel système a échoué en raison de cette limite. Pour B<readv>(), la fonction d'enrobage alloue un tampon temporaire assez grand pour tous les éléments de I<iov>, passe ce tampon à B<read>(2), copie les données du tampon vers les emplacements indiqués par le champ I<iov_base> des éléments de I<iov>, puis libère le tampon. La fonction d'enrobage de B<writev>() fonctionne de façon similaire avec un tampon temporaire et un appel à B<write>(2).

note: type: Plain text
en: It is not advisable to mix calls to B<readv>()  or B<writev>(), which operate on file descriptors, with the functions from the stdio library; the results will be undefined and probably not what you want.
fr: Il est déconseillé de mélanger les appels à B<readv>() ou B<writev>() qui agissent sur les descripteurs avec les fonctions de la bibliothèque stdio\ ; les résultats sont indéfinis et probablement différents de ce que l'on attend.

note: type: Plain text
en: The following code sample demonstrates the use of B<writev>():
fr: Le segment de code suivant donne un exemple d'utilisation de B<writev>()\ :

note: type: TH
en: 2014-03-10
fr: 10 mars 2014

note: type: Plain text
en: remove - remove a file or directory
fr: remove - Supprimer un fichier ou un répertoire

note: type: Plain text
en: B<remove>()  deletes a name from the filesystem.  It calls B<unlink>(2)  for files, and B<rmdir>(2)  for directories.
fr: B<remove>() supprime un nom du système de fichiers, en invoquant B<unlink>(2) pour les fichiers, et B<rmdir>(2) pour les répertoires.

note: type: Plain text
en: If the removed name was the last link to a file and no processes have the file open, the file is deleted and the space it was using is made available for reuse.
fr: Si ce nom était le dernier lien sur le fichier correspondant, et si aucun processus n'a ouvert le fichier, celui-ci est supprimé, et l'espace qu'il occupait est à nouveau disponible.

note: type: Plain text
en: If the name was the last link to a file, but any processes still have the file open, the file will remain in existence until the last file descriptor referring to it is closed.
fr: Si le nom était le dernier lien sur un fichier, mais qu'un processus conserve encore le fichier ouvert, celui-ci continue d'exister jusqu'à ce que le dernier descripteur le référençant soit fermé.

note: type: Plain text
en: If the name referred to a symbolic link, the link is removed.
fr: Si le nom correspond à un lien symbolique, le lien est supprimé.

note: type: Plain text
en: If the name referred to a socket, FIFO, or device, the name is removed, but processes which have the object open may continue to use it.
fr: Si le nom correspond à une socket, une FIFO, ou un périphérique, le nom est supprimé mais les processus qui ont ouvert l'objet peuvent continuer à l'utiliser.

note: type: Plain text
en: The errors that occur are those for B<unlink>(2)  and B<rmdir>(2).
fr: Les erreurs qui peuvent se produire pour B<unlink>(2) et B<rmdir>(2).

note: type: Plain text
en: The B<remove>()  function is thread-safe.
fr: La fonction B<remove>() est sûre dans un contexte multithread.

note: type: Plain text
en: C89, C99, 4.3BSD, POSIX.1-2001.
fr: C89, C99, BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: Under libc4 and libc5, B<remove>()  was an alias for B<unlink>(2)  (and hence would not remove directories).
fr: Avec libc4 et libc5, B<remove>() était simplement un alias de B<unlink>(2), et ne supprimait donc pas les répertoires.

note: type: Plain text
en: Infelicities in the protocol underlying NFS can cause the unexpected disappearance of files which are still being used.
fr: Des problèmes dans le protocole sous-jacent à NFS peuvent provoquer la disparition inattendue de fichiers encore utilisés.

note: type: Plain text
en: rename, renameat - change the name or location of a file
fr: rename, renameat - Changer le nom ou l'emplacement d'un fichier

note: type: Plain text
en: B<#include E<lt>fcntl.hE<gt>           >/* Definition of AT_* constants */
    B<#include E<lt>stdio.hE<gt>>
fr: B<#include E<lt>fcntl.hE<gt> /* Définition des constantes AT_* */>
    B<#include E<lt>stdio.hE<gt>>

note: type: Plain text
en: B<rename>()  renames a file, moving it between directories if required.  Any other hard links to the file (as created using B<link>(2))  are unaffected.  Open file descriptors for I<oldpath> are also unaffected.
fr: B<rename>() renomme un fichier, en le déplaçant dans un autre répertoire si nécessaire. Tous les autres liens vers le fichier (créés avec B<link>(2)) sont inchangés. Les descripteurs de fichier ouverts sur I<oldpath> ne sont pas non plus affectés.

note: type: Plain text
en: If I<newpath> already exists, it will be atomically replaced (subject to a few conditions; see ERRORS below), so that there is no point at which another process attempting to access I<newpath> will find it missing.
fr: Si I<newpath> existe déjà, il sera écrasé (avec quelques restrictions, voir le paragraphe ERREURS), de manière à ce qu'à aucun moment, un autre processus tentant d'accéder à I<newpath> ne le voie absent.

note: type: Plain text
en: If I<oldpath> and I<newpath> are existing hard links referring to the same file, then B<rename>()  does nothing, and returns a success status.
fr: Si I<oldpath> et I<newpath> sont des liens existants correspondant au même fichier, B<rename>() ne fait rien et renvoie un code de succès.

note: type: Plain text
en: If I<newpath> exists but the operation fails for some reason, B<rename>()  guarantees to leave an instance of I<newpath> in place.
fr: Si I<newpath> existe mais que l'opération échoue pour une raison quelconque, B<rename>() garantit la présence d'une instance de I<newpath> en place.

note: type: Plain text
en: I<oldpath> can specify a directory.  In this case, I<newpath> must either not exist, or it must specify an empty directory.
fr: I<oldpath> peut être un répertoire. Dans ce cas, I<newpath> doit être soit absent, soit un répertoire vide.

note: type: Plain text
en: However, when overwriting there will probably be a window in which both I<oldpath> and I<newpath> refer to the file being renamed.
fr: Néanmoins, pendant un écrasement, il se trouve un court instant pendant lequel à la fois I<oldpath> et I<newpath> font référence au fichier.

note: type: Plain text
en: If I<oldpath> refers to a symbolic link, the link is renamed; if I<newpath> refers to a symbolic link, the link will be overwritten.
fr: Si I<oldpath> correspond à un lien symbolique, le lien est renommé\ ; si I<newpath> correspond à un lien symbolique, le lien est écrasé.

note: type: Plain text
en: The B<renameat>()  system call operates in exactly the same way as B<rename>(), except for the differences described here.
fr: L'appel système B<renameat>() fonctionne exactement comme B<rename>(), les seules différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<oldpath> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<olddirfd> (rather than relative to the current working directory of the calling process, as is done by B<rename>()  for a relative pathname).
fr: Si le chemin donné dans I<oldpath> est relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier I<olddirfd> (plutôt que par rapport au répertoire de travail du processus, comme c'est le cas pour B<rename>()).

note: type: Plain text
en: If I<oldpath> is relative and I<olddirfd> is the special value B<AT_FDCWD>, then I<oldpath> is interpreted relative to the current working directory of the calling process (like B<rename>()).
fr: Si I<oldpath> est un chemin relatif, et si I<olddirfd> a la valeur spéciale B<AT_FDCWD>, alors I<oldpath> est interprété par rapport au répertoire de travail du processus (comme pour B<rename>()).

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<renameat>().
fr: Consultez B<openat>(2) pour une explication de la nécessité de B<renameat>().

note: type: Plain text
en: Write permission is denied for the directory containing I<oldpath> or I<newpath>, or, search permission is denied for one of the directories in the path prefix of I<oldpath> or I<newpath>, or I<oldpath> is a directory and does not allow write permission (needed to update the I<..> entry).  (See also B<path_resolution>(7).)
fr: La permission d'écrire est refusée dans le répertoire contenant I<oldpath> ou I<newpath> ou la permission de parcours est refusée pour l'un des répertoires des chemins I<oldpath> ou I<newpath>, ou encore I<oldpath> était un répertoire et ne permet pas l'écriture (nécessaire pour mettre à jour l'entrée I<..>). (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: The rename fails because I<oldpath> or I<newpath> is a directory that is in use by some process (perhaps as current working directory, or as root directory, or because it was open for reading) or is in use by the system (for example as mount point), while the system considers this an error.  (Note that there is no requirement to return B<EBUSY> in such cases\(emthere is nothing wrong with doing the rename anyway\(embut it is allowed to return B<EBUSY> if the system cannot otherwise handle such situations.)
fr: Le renommage a échoué car I<oldpath> ou I<newpath> est un répertoire utilisé par un processus (peut-être comme répertoire de travail, ou comme répertoire racine, ou ouvert en lecture), ou il est utilisé par le système (comme point de montage par exemple). Le système a donc considéré qu'il y avait une erreur. (Notez qu'il n'est pas indispensable de renvoyer B<EBUSY> dans un tel cas \(em rien n'empêche d'effectuer le renommage malgré tout \(em mais il est permis de retourner B<EBUSY> si le système n'arrive pas à gérer une telle situation).

note: type: Plain text
en: The new pathname contained a path prefix of the old, or, more generally, an attempt was made to make a directory a subdirectory of itself.
fr: Une partie du nouveau chemin contient en préfixe l'ancien chemin, ou plus généralement, un répertoire ne peut pas être déplacé dans ses propres sous-répertoires.

note: type: Plain text
en: I<newpath> is an existing directory, but I<oldpath> is not a directory.
fr: I<newpath> est un répertoire existant mais I<oldpath> n'est pas un répertoire

note: type: Plain text
en: I<oldpath> already has the maximum number of links to it, or it was a directory and the directory containing I<newpath> has the maximum number of links.
fr: I<oldpath> a déjà un nombre maximal de liens, ou bien c'est un répertoire, et le répertoire contenant I<newpath> a le nombre maximal de liens.

note: type: Plain text
en: The link named by I<oldpath> does not exist; or, a directory component in I<newpath> does not exist; or, I<oldpath> or I<newpath> is an empty string.
fr: Le lien indiqué par I<oldpath> n'existe pas ; ou un répertoire du chemin I<newpath> n'existe pas ; ou I<oldpath> ou I<newpath> est une chaîne vide.

note: type: Plain text
en: A component used as a directory in I<oldpath> or I<newpath> is not, in fact, a directory.  Or, I<oldpath> is a directory, and I<newpath> exists but is not a directory.
fr: Un élément du chemin d'accès I<oldpath> ou I<newpath> n'est pas un répertoire, ou I<oldpath> est un répertoire et I<newpath> existe mais n'est pas un répertoire.

note: type: TP
en: B<ENOTEMPTY> or B<EEXIST>
fr: B<ENOTEMPTY> ou B<EEXIST>

note: type: Plain text
en: I<newpath> is a nonempty directory, that is, contains entries other than "." and "..".
fr: I<newpath> est un répertoire non vide (contient autre chose que «\ .\ » et «\ ..\ »).

note: type: TP
en: B<EPERM> or B<EACCES>
fr: B<EPERM> ou B<EACCES>

note: type: Plain text
en: The directory containing I<oldpath> has the sticky bit (B<S_ISVTX>)  set and the process's effective user ID is neither the user ID of the file to be deleted nor that of the directory containing it, and the process is not privileged (Linux: does not have the B<CAP_FOWNER> capability); or I<newpath> is an existing file and the directory containing it has the sticky bit set and the process's effective user ID is neither the user ID of the file to be replaced nor that of the directory containing it, and the process is not privileged (Linux: does not have the B<CAP_FOWNER> capability); or the filesystem containing I<pathname> does not support renaming of the type requested.
fr: Le répertoire contenant I<oldpath> a le Sticky-bit (B<S_ISVTX>) positionné, et l'UID effectif du processus n'est ni celui du fichier à déplacer, ni celui du répertoire le contenant, et le processus n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_FOWNER>\ ; ou I<newpath> est un fichier existant et le répertoire le contenant a son sticky bit positionné et l'UID effectif du processus n'est ni celui du fichier à déplacer, ni celui du répertoire le contenant, et le processus n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_FOWNER>\ ; ou alors le système de fichiers contenant I<pathname> ne permet pas le renommage de fichiers.

note: type: Plain text
en: I<oldpath> and I<newpath> are not on the same mounted filesystem.  (Linux permits a filesystem to be mounted at multiple points, but B<rename>()  does not work across different mount points, even if the same filesystem is mounted on both.)
fr: I<oldpath> et I<newpath> ne sont pas sur le même système de fichiers. (Linux permet de monter un système de fichiers à plusieurs endroits, mais B<rename>() ne marche pas entre différents points de montage, même si le système de fichiers monté sur les deux est le même.)

note: type: Plain text
en: The following additional errors can occur for B<renameat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<renameat>() :

note: type: Plain text
en: B<renameat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<renameat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: type: Plain text
en: B<rename>(): 4.3BSD, C89, C99, POSIX.1-2001, POSIX.1-2008.
fr: B<rename>() : 4.3BSD, C89, C99, POSIX.1-2001, POSIX.1-2008.

note: type: Plain text
en: B<renameat>(): POSIX.1-2008.
fr: B<renameat>() : POSIX.1-2008.

note: type: Plain text
en: On NFS filesystems, you can not assume that if the operation failed, the file was not renamed.  If the server does the rename operation and then crashes, the retransmitted RPC which will be processed when the server is up again causes a failure.  The application is expected to deal with this.  See B<link>(2)  for a similar problem.
fr: Sur les systèmes de fichiers NFS, ce n'est pas parce que l'opération a échoué que le fichier n'a pas été renommé. Si le serveur effectue le déplacement, et s'effondre, la RPC transmise qui sera traitée lorsque le serveur sera à nouveau en état va indiquer un échec. L'application doit supporter ce genre de problème. Consultez B<link>(2) pour un cas similaire.

note: type: TH
en: 2008-05-08
fr: 8 mai 2008

note: type: Plain text
en: rmdir - delete a directory
fr: rmdir - Supprimer un répertoire

note: type: Plain text
en: B<rmdir>()  deletes a directory, which must be empty.
fr: B<rmdir>() supprime un répertoire, lequel doit être vide.

note: type: Plain text
en: Write access to the directory containing I<pathname> was not allowed, or one of the directories in the path prefix of I<pathname> did not allow search permission.  (See also B<path_resolution>(7).
fr: Les droits d'écriture dans le répertoire contenant I<pathname> ne sont pas autorisés, ou bien un des répertoires de I<pathname> ne permet pas le parcours. (Consultez aussi B<path_resolution>(7).

note: type: Plain text
en: I<pathname> is currently in use by the system or some process that prevents its removal.  On Linux this means I<pathname> is currently used as a mount point or is the root directory of the calling process.
fr: I<pathname> est actuellement utilisé par le système ou un processus qui empêche sa suppression. Sous Linux, cela signifie que I<pathname> est actuellement un point de montage, ou bien est le répertoire racine du processus appelant.

note: type: Plain text
en: I<pathname> has I<.> as last component.
fr: I<pathname> a I<.> comme dernier composant.

note: type: Plain text
en: A directory component in I<pathname> does not exist or is a dangling symbolic link.
fr: Un des répertoires du chemin d'accès I<pathname> n'existe pas ou est un lien symbolique pointant nulle part.

note: type: Plain text
en: I<pathname>, or a component used as a directory in I<pathname>, is not, in fact, a directory.
fr: I<pathname>, ou un élément du chemin d'accès I<pathname> n'est pas un répertoire.

note: type: Plain text
en: I<pathname> contains entries other than I<.> and I<..> ; or, I<pathname> has I<..> as its final component.  POSIX.1-2001 also allows B<EEXIST> for this condition.
fr: I<pathname> contient d'autres éléments que I<.> et I<..>, ou bien I<pathname> a I<..> comme composant final. POSIX.1-2001 permet également B<EEXIST> pour cette condition.

note: type: Plain text
en: The directory containing I<pathname> has the sticky bit (B<S_ISVTX>)  set and the process's effective user ID is neither the user ID of the file to be deleted nor that of the directory containing it, and the process is not privileged (Linux: does not have the B<CAP_FOWNER> capability).
fr: Le répertoire contenant I<pathname> a son sticky bit positionné (B<S_ISVTX>), et l'UID effectif du processus n'est pas le même que celui du répertoire à supprimer, ou celui du répertoire le contenant, et le processus n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_FOWNER>).

note: type: Plain text
en: The filesystem containing I<pathname> does not support the removal of directories.
fr: Le système de fichiers contenant I<pathname> ne permet pas la suppression de répertoires.

note: type: Plain text
en: I<pathname> refers to a directory on a read-only filesystem.
fr: I<pathname> correspond à un répertoire situé sur un système de fichiers en lecture seule.

note: type: Plain text
en: Infelicities in the protocol underlying NFS can cause the unexpected disappearance of directories which are still being used.
fr: Des problèmes dans le protocole sous-jacent à NFS peuvent provoquer la disparition inattendue de répertoires encore utilisés.

note: type: Plain text
en: scanf, fscanf, sscanf, vscanf, vsscanf, vfscanf - input format conversion
fr: scanf, fscanf, sscanf, vscanf, vsscanf, vfscanf - Entrées formatées

note: type: Plain text
en: B<vscanf>(), B<vsscanf>(), B<vfscanf>():
fr: B<vscanf>(), B<vsscanf>(), B<vfscanf>() :

note: type: Plain text
en: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<scanf>()  family of functions scans input according to I<format> as described below.  This format may contain I<conversion specifications>; the results from such conversions, if any, are stored in the locations pointed to by the I<pointer> arguments that follow I<format>.  Each I<pointer> argument must be of a type that is appropriate for the value returned by the corresponding conversion specification.
fr: Les fonctions de la famille B<scanf>() analysent leurs entrées conformément au I<format> décrit plus bas. Ce format peut contenir des I<indicateurs de conversion>. Les résultats des conversions, s'il y en a, sont stockés dans des endroits pointés par des arguments I<pointeurs> qui suivent le I<format>. Chaque argument I<pointeur> doit être du type approprié pour la valeur retournée par la spécification de conversion correspondante.

note: type: Plain text
en: If the number of conversion specifications in I<format> exceeds the number of I<pointer> arguments, the results are undefined.  If the number of I<pointer> arguments exceeds the number of conversion specifications, then the excess I<pointer> arguments are evaluated, but are otherwise ignored.
fr: Si le nombre de spécifications de conversion dans I<format> excède le nombre d'arguments I<pointeur>, le résultat est indéterminé. Si le nombre d'arguments I<pointeur> excède le nombre de spécifications de conversion, les arguments I<pointeur> en excès sont évalués mais ignorés.

note: type: Plain text
en: The B<scanf>()  function reads input from the standard input stream I<stdin>, B<fscanf>()  reads input from the stream pointer I<stream>, and B<sscanf>()  reads its input from the character string pointed to by I<str>.
fr: La fonction B<scanf>() lit ses données depuis le flux d'entrée standard I<stdin>, B<fscanf>() lit ses entrées depuis le flux pointé par I<stream>, et B<sscanf>() lit ses entrées dans la chaîne de caractères pointée par I<str>.

note: type: Plain text
en: The B<vfscanf>()  function is analogous to B<vfprintf>(3)  and reads input from the stream pointer I<stream> using a variable argument list of pointers (see B<stdarg>(3).  The B<vscanf>()  function scans a variable argument list from the standard input and the B<vsscanf>()  function scans it from a string; these are analogous to the B<vprintf>(3)  and B<vsprintf>(3)  functions respectively.
fr: La fonction B<vfscanf>() est analogue à B<vfprintf>(3) et lit ses arguments depuis le flux pointé par I<stream> en utilisant une liste variable d'arguments pointeurs, consultez B<stdarg>(3). La fonction B<vscanf>() examine l'entrée standard en utilisant une liste variable d'arguments pointeurs et la fonction B<vsscanf>() examine une chaîne. Elles sont respectivement analogues aux fonctions B<vprintf>(3) et B<vsprintf>(3).

note: type: Plain text
en: The I<format> string consists of a sequence of I<directives> which describe how to process the sequence of input characters.  If processing of a directive fails, no further input is read, and B<scanf>()  returns.  A "failure" can be either of the following: I<input failure>, meaning that input characters were unavailable, or I<matching failure>, meaning that the input was inappropriate (see below).
fr: La chaîne I<format> consiste en une séquence de I<directives> qui décrit comme traiter la séquence des caractères d'entrée. Si le traitement des directives échoue, aucune autre entrée n'est lue et B<scanf>() revient. Un «\ échec\ » peut être soit un I<échec d'entrée> signifiant que les caractères d'entrée ne sont pas disponibles, soit un I<échec de correspondance> signifiant que l'entrée n'est pas appropriée (voir plus loin)

note: type: Plain text
en: A directive is one of the following:
fr: Une directive peut être\ :

note: type: Plain text
en: A sequence of white-space characters (space, tab, newline, etc.; see B<isspace>(3)).  This directive matches any amount of white space, including none, in the input.
fr: Une séquence de caractères blancs (espace, tabulation, nouvelle ligne, etc.\ ; consultez B<isspace>(3)). Cette directive correspond à un nombre quelconque de caractères blancs, y compris aucun, dans l'entrée.

note: type: Plain text
en: An ordinary character (i.e., one other than white space or \(aq%\(aq).  This character must exactly match the next character of input.
fr: Un caractère ordinaire (c'est-à-dire autre qu'un caractère blanc et que le caractère «\ %\ ». Ce caractère doit exactement correspondre au caractère suivant de l'entrée.

note: type: Plain text
en: A conversion specification, which commences with a \(aq%\(aq (percent) character.  A sequence of characters from the input is converted according to this specification, and the result is placed in the corresponding I<pointer> argument.  If the next item of input does not match the conversion specification, the conversion fails\(emthis is a I<matching failure>.
fr: Une spécification de conversion qui débute avec le caractère «\ %\ ». Une séquence de caractères de l'entrée est convertie conformément à la spécification et le résultat est placé dans l'argument I<pointeur> correspondant. Si l'élément suivant de l'entrée ne correspond pas à la spécification de conversion, la conversion échoue \(em c'est un I<échec de correspondance>.

note: type: Plain text
en: Each I<conversion specification> in I<format> begins with either the character \(aq%\(aq or the character sequence "B<%>I<n>B<$>" (see below for the distinction) followed by:
fr: Chaque I<spécification de conversion> dans I<format> commence avec soit le caractère «\ %\ », soit la séquence de caractères «\ B<%>I<n>B<$>\ » (voir plus loin pour la distinction) suivie par\ :

note: type: Plain text
en: An optional \(aq*\(aq assignment-suppression character: B<scanf>()  reads input as directed by the conversion specification, but discards the input.  No corresponding I<pointer> argument is required, and this specification is not included in the count of successful assignments returned by B<scanf>().
fr: Un caractère d'affectation-suppression optionnel «\ *\ »\ : B<scanf>() lit l'entrée comme indiqué par la spécification de conversion mais ne tient pas compte de l'entrée. Aucun argument I<pointeur> n'est nécessaire et cette spécification n'est pas comptabilisée dans le nombre d'affectations réussies renvoyé par B<scanf>().

note: type: Plain text
en: An optional \(aqm\(aq character.  This is used with string conversions (I<%s>, I<%c>, I<%[>), and relieves the caller of the need to allocate a corresponding buffer to hold the input: instead, B<scanf>()  allocates a buffer of sufficient size, and assigns the address of this buffer to the corresponding I<pointer> argument, which should be a pointer to a I<char\ *> variable (this variable does not need to be initialized before the call).  The caller should subsequently B<free>(3)  this buffer when it is no longer required.
fr: Un caractère « m » optionnel. Il est utilisé dans les conversions de chaînes (I<%s>, I<%c>, I<%[>) et soulage l'appelant du besoin d'allouer un tampon correspondant pour conserver l'entrée : à la place, B<scanf>() alloue un tampon de taille suffisante et affecte l'adresse de ce tampon à l'argument I<pointeur> correspondant qui doit être un pointeur vers une variable I<char\ *> (il n'est pas nécessaire que cette variable soit initialisée avant l'appel). L'appelant doit par la suite libérer (B<free>(3)) ce tampon lorsqu'il devient inutile.

note: type: Plain text
en: An optional decimal integer which specifies the I<maximum field width>.  Reading of characters stops either when this maximum is reached or when a nonmatching character is found, whichever happens first.  Most conversions discard initial white space characters (the exceptions are noted below), and these discarded characters don't count toward the maximum field width.  String input conversions store a terminating null byte (\(aq\e0\(aq)  to mark the end of the input; the maximum field width does not include this terminator.
fr: Un entier décimal optionnel qui indique la I<taille maximum du champ>. La lecture des caractères s'arrête soit lorsque ce maximum est atteint, soit lorsque on trouve un caractère qui ne correspond pas, celui qui arrive le premier. La plupart des conversions abandonnent les caractères blancs de tête (les exceptions sont notées plus loin), et ces caractère abandonnés n'entrent pas en compte dans la taille maximale du champ. Les conversions d'entrée de chaînes stocke un octet nul («\ \e0\ ») final pour marquer la fin de l'entrée\ ; la largeur maximale du champ n'inclut pas ce caractère de terminaison.

note: type: Plain text
en: An optional I<type modifier character>.  For example, the B<l> type modifier is used with integer conversions such as B<%d> to specify that the corresponding I<pointer> argument refers to a I<long int> rather than a pointer to an I<int>.
fr: Un I<caractère modificateur de type> optionnel. Par exemple, le modificateur de type B<l> est utilisé avec les conversions d'entrée telles que B<%d> pour spécifier que l'argument I<pointeur> correspondant fait référence à un I<long int> plutôt qu'à un pointeur sur un I<int>.

note: type: Plain text
en: A I<conversion specifier> that specifies the type of input conversion to be performed.
fr: Un I<spécificateur de conversion> qui spécifie le type de conversion d'entrée à effectuer.

note: type: Plain text
en: The conversion specifications in I<format> are of two forms, either beginning with \(aq%\(aq or beginning with "B<%>I<n>B<$>".  The two forms should not be mixed in the same I<format> string, except that a string containing "B<%>I<n>B<$>" specifications can include B<%%> and B<%*>.  If I<format> contains \(aq%\(aq specifications, then these correspond in order with successive I<pointer> arguments.  In the "B<%>I<n>B<$>" form (which is specified in POSIX.1-2001, but not C99), I<n> is a decimal integer that specifies that the converted input should be placed in the location referred to by the I<n>-th I<pointer> argument following I<format>.
fr: Les spécifications de conversion dans I<format> sont de deux formes\ : soit elles commencent par «\ %\ », soit elles commencent par «\ B<%>I<n>B<$>\ ». Les deux formes ne doivent pas être mélangées dans la même chaîne I<format>, excepté qu'une chaîne contenant les spécifications «\ B<%>I<n>B<$>\ » peut inclure B<%%> et B<%*>. Si I<format> contient des spécifications «\ %\ », celles-ci correspondent, dans l'ordre, aux arguments I<pointeur> successifs. Dans la forme «\ B<%>I<n>B<$>\ » (qui est spécifiée par POSIX.1-2001 mais pas par C99), I<n> est un entier décimal qui spécifie que l'entrée convertie devrait être placée à l'endroit référencé par le I<n>-ième argument I<pointeur> suivant I<format>.

note: type: Plain text
en: The following I<type modifier characters> can appear in a conversion specification:
fr: Les I<caractères modificateurs de type> suivant peuvent se apparaître dans une spécification de conversion\ :

note: type: Plain text
en: Indicates that the conversion will be one of B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, or B<n> and the next pointer is a pointer to a I<short int> or I<unsigned short int> (rather than I<int>).
fr: Indique que la conversion sera de type B<d>, B<i>, B<o>, B<u>, B<x>, B<X> ou B<n> et que le pointeur suivant est un pointeur sur un I<short int> ou un I<unsigned short int> (plutôt que sur un I<int>).

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<signed char> or I<unsigned char>.
fr: Comme pour B<h>, sauf que le pointeur suivant est un pointeur sur un I<signed char> ou un I<unsigned char>.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to an I<intmax_t> or a I<uintmax_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, sauf que le pointeur suivant est un pointeur sur un I<intmax_t> ou un I<uintmax_t>. Ce modificateur a été introduit dans C99.

note: This use of l was introduced in Amendment 1 to ISO C90. type: Plain text
en: Indicates either that the conversion will be one of B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, or B<n> and the next pointer is a pointer to a I<long int> or I<unsigned long int> (rather than I<int>), or that the conversion will be one of B<e>, B<f>, or B<g> and the next pointer is a pointer to I<double> (rather than I<float>).  Specifying two B<l> characters is equivalent to B<L>.  If used with B<%c> or B<%s>, the corresponding parameter is considered as a pointer to a wide character or wide-character string respectively.
fr: Indique que la conversion sera de type B<d>, B<i>, B<o>, B<u>, B<x>, B<X> ou B<n> et que le pointeur suivant est un pointeur sur un I<long int> ou un I<unsigned long int> (plutôt que sur un I<int>), ou que la conversion sera de type B<e>, B<f> ou B<g> et que le pointeur suivant est un pointeur sur un I<double> (plutôt que sur un I<float>). Indiquer deux caractères B<l> successifs est équivalent à indiquer B<L>. Si c'est utilisé avec B<%c> ou B<%s>, le paramètre correspondant est considéré, respectivement, comme un pointeur vers un caractère large ou une chaîne de caractères larges.

note: MTK, Jul 05: The following is no longer true for modern ANSI C (i.e., C99): (Note that long long is not an ANSI C type. Any program using this will not be portable to all architectures). type: Plain text
en: Indicates that the conversion will be either B<e>, B<f>, or B<g> and the next pointer is a pointer to I<long double> or the conversion will be B<d>, B<i>, B<o>, B<u>, or B<x> and the next pointer is a pointer to I<long long>.
fr: Indique que la conversion sera de type B<e>, B<f> ou B<g> et que le pointeur suivant est un pointeur sur un I<long double> ou que la conversion sera de type B<d>, B<i>, B<o>, B<u>, ou B<x> et que le pointeur suivant est un pointeur sur un I<long long>.

note: type: Plain text
en: equivalent to B<L>.  This specifier does not exist in ANSI C.
fr: est équivalent à B<L>. Ce spécificateur n'existe pas en C ANSI.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<ptrdiff_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, mais le pointeur suivant est un pointeur vers un I<ptrdiff_t>. Ce modificateur a été introduit dans C99.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<size_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, mais le pointeur suivant est un pointeur vers un I<size_t>. Ce modificateur a été introduit dans C99.

note: type: Plain text
en: The following I<conversion specifiers> are available:
fr: Les I<spécificateurs de conversion> suivant sont disponibles\ :

note: type: Plain text
en: Matches a literal \(aq%\(aq.  That is, B<%\&%> in the format string matches a single input \(aq%\(aq character.  No conversion is done (but initial white space characters are discarded), and assignment does not occur.
fr: Correspond à un caractère «\ %\ ». Ceci signifie qu'un spécificateur B<%\&%> dans la chaîne de format correspond à un seul caractère «\ %\ » dans la chaîne d'entrée. Aucune conversion (mais les caractères blancs de début sont ignorés), et aucune assignation n'a lieu.

note: type: Plain text
en: Matches an optionally signed decimal integer; the next pointer must be a pointer to I<int>.
fr: Correspond à un entier décimal éventuellement signé, le pointeur correspondant doit être un pointeur vers un I<int>.

note: type: Plain text
en: Equivalent to I<ld>; this exists only for backward compatibility.  (Note: thus only in libc4.  In libc5 and glibc the B<%D> is silently ignored, causing old programs to fail mysteriously.)
fr: Équivalent à I<ld>, utilisé uniquement pour compatibilité avec des versions précédentes (et seulement dans libc4. Dans libc5 et glibc, le B<%D> est ignoré silencieusement, ce qui conduit d'anciens programmes à échouer mystérieusement).

note: type: Plain text
en: Matches an optionally signed integer; the next pointer must be a pointer to I<int>.  The integer is read in base 16 if it begins with I<0x> or I<0X>, in base 8 if it begins with I<0>, and in base 10 otherwise.  Only characters that correspond to the base are used.
fr: Correspond à un entier éventuellement signé. Le pointeur suivant doit être du type I<int>. L'entier est en base 16 (hexadécimal) s'il commence par I<0x> ou I<0X>, en base 8 (octal) s'il commence par un I<0>, et en base 10 sinon. Seuls les caractères correspondants à la base concernée sont utilisés.

note: type: Plain text
en: Matches an unsigned octal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier octal non signé. Le pointeur correspondant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Matches an unsigned decimal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier décimal non signé. Le pointeur suivant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Matches an unsigned hexadecimal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier hexadécimal non signé. Le pointeur suivant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Equivalent to B<x>.
fr: Équivalent à B<x>

note: type: Plain text
en: Matches an optionally signed floating-point number; the next pointer must be a pointer to I<float>.
fr: Correspond à un nombre réel éventuellement signé. Le pointeur correspondant doit être un pointeur vers un I<float>.

note: type: Plain text
en: Equivalent to B<f>.
fr: Équivalent à B<f>.

note: type: Plain text
en: (C99) Equivalent to B<f>.
fr: (C99) Équivalent à B<f>.

note: type: Plain text
en: Matches a sequence of non-white-space characters; the next pointer must be a pointer to character array that is long enough to hold the input sequence and the terminating null byte (\(aq\e0\(aq), which is added automatically.  The input string stops at white space or at the maximum field width, whichever occurs first.
fr: Correspond à une séquence de caractères différents des caractères blancs. Le pointeur correspondant doit être un pointeur sur un tableau de caractères qui doit être assez large pour accueillir toute la séquence d'entrée, ainsi que l'octet nul final («\ \e0\ ») qui est ajouté automatiquement. La conversion s'arrête au premier caractère blanc, ou à la longueur maximale du champ.

note: type: Plain text
en: Matches a sequence of characters whose length is specified by the I<maximum field width> (default 1); the next pointer must be a pointer to I<char>, and there must be enough room for all the characters (no terminating null byte is added).  The usual skip of leading white space is suppressed.  To skip white space first, use an explicit space in the format.
fr: Correspond à une séquence de caractères dont la longueur est spécifiée par la I<largeur maximum de champ> (par défaut 1). Le pointeur suivant doit être un pointeur vers un I<char>, et il doit y avoir suffisamment de place dans la chaîne pour tous les caractères. Aucun octet nul final n'est ajouté. Les caractères blancs de début ne sont pas supprimés. Si on veut les éliminer, il faut utiliser une espace dans le format.

note: type: Plain text
en: Matches a nonempty sequence of characters from the specified set of accepted characters; the next pointer must be a pointer to I<char>, and there must be enough room for all the characters in the string, plus a terminating null byte.  The usual skip of leading white space is suppressed.  The string is to be made up of characters in (or not in) a particular set; the set is defined by the characters between the open bracket B<[> character and a close bracket B<]> character.  The set I<excludes> those characters if the first character after the open bracket is a circumflex (B<^>).  To include a close bracket in the set, make it the first character after the open bracket or the circumflex; any other position will end the set.  The hyphen character B<-> is also special; when placed between two other characters, it adds all intervening characters to the set.  To include a hyphen, make it the last character before the final close bracket.  For instance, B<[^]0-9-]> means the set "everything except close bracket, zero through nine, and hyphen".  The string ends with the appearance of a character not in the (or, with a circumflex, in) set or when the field width runs out.
fr: Correspond à une séquence non vide de caractères appartenant à un ensemble donné. Le pointeur correspondant doit être un pointeur vers un I<char> et il doit y avoir suffisamment de place dans le tableau de caractères pour accueillir la chaîne ainsi qu'un octet nul final. Les caractères blancs du début ne sont pas supprimés. La chaîne est constituées de caractères inclus ou exclus d'un ensemble donné. L'ensemble est composé des caractères compris entre les deux crochets B<[> et B<]>. L'ensemble I<exclut> ces caractères si le premier après le crochet ouvrant est un accent circonflexe (B<^>). Pour inclure un crochet fermant dans l'ensemble, il suffit de le placer en première position après le crochet ouvrant, ou l'accent circonflexe\ ; à tout autre emplacement il servira à terminer l'ensemble. Le caractère tiret B<-> a également une signification particulière. Quand il est placé entre deux autres caractères, il ajoute à l'ensemble les caractères intermédiaires. Pour inclure un tiret dans l'ensemble, il faut le placer en dernière position avant le crochet fermant. Par exemple, B<[^]0-9-]> correspond à l'ensemble «\ Tout sauf le crochet fermant, les chiffres de 0 à 9, et le tiret\ ». La chaîne se termine dès l'occurrence d'un caractère exclu (ou inclus s'il y à un accent circonflexe ) de l'ensemble, ou dès qu'on atteint la longueur maximale du champ.

note: type: Plain text
en: Matches a pointer value (as printed by B<%p> in B<printf>(3); the next pointer must be a pointer to a pointer to I<void>.
fr: Correspond à une valeur de pointeur (comme affichée par B<%p> dans B<printf>(3). Le pointeur suivant doit être un pointeur sur un pointeur sur I<void>.

note: type: Plain text
en: Nothing is expected; instead, the number of characters consumed thus far from the input is stored through the next pointer, which must be a pointer to I<int>.  This is I<not> a conversion, although it can be suppressed with the B<*> assignment-suppression character.  The C standard says: "Execution of a B<%n> directive does not increment the assignment count returned at the completion of execution" but the Corrigendum seems to contradict this.  Probably it is wise not to make any assumptions on the effect of B<%n> conversions on the return value.
fr: Aucune lecture n'est faite. Le nombre de caractères déjà lus est stocké dans le pointeur correspondant, qui doit être un pointeur vers un I<int>. Ce n'est I<pas> une conversion, mais le stockage peut quand même être supprimé avec le caractère d'affectation-suppression B<*>. Le standard C indique\ : «\ L'exécution d'une directive B<%n> n'incrémente pas le compteur d'assignations renvoyé à la fin de l'exécution\ ». Mais il semble qu'il y ait des contradictions sur ce point. Il est probablement sage de ne pas faire de suppositions sur l'effet de la conversion B<%n> sur la valeur renvoyée.

note: type: Plain text
en: These functions return the number of input items successfully matched and assigned, which can be fewer than provided for, or even zero in the event of an early matching failure.
fr: Ces fonctions renvoient le nombre d'éléments d'entrées correctement mis en correspondance et assignés. Ce nombre peut être plus petit que le nombre d'éléments attendus, et même être nul, s'il y a une erreur de mise en correspondance.

note: type: Plain text
en: The value B<EOF> is returned if the end of input is reached before either the first successful conversion or a matching failure occurs.  B<EOF> is also returned if a read error occurs, in which case the error indicator for the stream (see B<ferror>(3))  is set, and I<errno> is set indicate the error.
fr: La valeur B<EOF> est renvoyée si la fin de l'entrée est atteinte avant la première conversion réussie ou si un échec de correspondance survient. B<EOF> est également renvoyé si une erreur de lecture survient, auquel cas l'indicateur d'erreur pour le flux (consultez B<ferror>(3)) est positionné et I<errno> est remplie en conséquence

note: type: Plain text
en: The file descriptor underlying I<stream> is marked nonblocking, and the read operation would block.
fr: Le descripteur de fichier I<stream> sous-jacent est non bloquant et l'opération de lecture bloquerait.

note: type: Plain text
en: The file descriptor underlying I<stream> is invalid, or not open for reading.
fr: Le descripteur de fichier I<stream> sous-jacent n'est pas valide ou bien n'est pas ouvert en lecture.

note: type: Plain text
en: Input byte sequence does not form a valid character.
fr: La séquence d'octet en entrée ne constitue pas un caractère valable.

note: type: Plain text
en: The read operation was interrupted by a signal; see B<signal>(7).
fr: La lecture a été interrompue par un signal ; consultez B<signal>(7).

note: type: Plain text
en: Not enough arguments; or I<format> is NULL.
fr: Pas suffisamment de paramètres ; ou bien I<format> est NULL.

note: type: Plain text
en: Out of memory.
fr: Plus de mémoire disponible.

note: type: Plain text
en: The result of an integer conversion would exceed the size that can be stored in the corresponding integer type.
fr: Le résultat de la conversion entière est plus grand que la taille pouvant être stockée dans le type entier correspondant.

note: type: Plain text
en: The functions B<fscanf>(), B<scanf>(), and B<sscanf>()  conform to C89 and C99 and POSIX.1-2001.  These standards do not specify the B<ERANGE> error.
fr: Les fonctions B<fscanf>(), B<scanf>(), et B<sscanf>() sont conformes à C89, C99 et POSIX.1-2001. Ces normes ne spécifient pas l'erreur B<ERANGE>.

note: type: Plain text
en: The B<q> specifier is the 4.4BSD notation for I<long long>, while B<ll> or the usage of B<L> in integer conversions is the GNU notation.
fr: Le spécificateur B<q> est une notation BSD\ 4.4 pour I<long long>, alors que B<ll> ou l'utilisation de B<L> dans les conversions entières sont des notations GNU.

note: type: Plain text
en: The Linux version of these functions is based on the I<GNU> I<libio> library.  Take a look at the I<info> documentation of I<GNU> I<libc (glibc-1.08)> for a more concise description.
fr: Les versions Linux de ces fonctions sont basées sur la bibliothèque I<libio GNU>. Jetez un œil sur la documentation I<info> de la I<libc GNU (glibc-1.08)> pour une description complète.

note: type: SS
en: The 'a' assignment-allocation modifier
fr: Le modificateur d'affectation-allocation « a »

note: type: Plain text
en: Originally, the GNU C library supported dynamic allocation for string inputs (as a nonstandard extension) via the B<a> character.  (This feature is present at least as far back as glibc 2.0.)  Thus, one could write the following to have B<scanf>()  allocate a buffer for an input string, with a pointer to that buffer being returned in I<*buf>:
fr: Initialement, la bibliothèque C de GNU prenait en charge l'allocation dynamique des chaînes de caractères en entrée (comme une extension non standard) au moyen du caractère B<a> (cette fonctionnalité remonte au moins à la version 2.0 de glibc). Ainsi, il était possible, grâce au code suivant, de faire que B<scanf>() alloue un tampon pour une chaîne en entrée, et renvoie un pointeur vers ce tampon dans I<*buf>:

note: type: Plain text
en: The use of the letter B<a> for this purpose was problematic, since B<a> is also specified by the ISO C standard as a synonym for B<f> (floating-point input).  POSIX.1-2008 instead specifies the B<m> modifier for assignment allocation (as documented in DESCRIPTION, above).
fr: L'utilisation de la lettre B<a> dans ce but posait problème étant donné que B<a> est également synonyme de B<f> dans le standard ISO C (entrée de nombre à virgule flottante). POSIX.1-2008 spécifie en revanche que le modificateur B<m> doit être utilisée pour l'affectation allocation (comme indiqué dans la DESCRIPTION plus haut).

note: type: Plain text
en: Note that the B<a> modifier is not available if the program is compiled with I<gcc -std=c99> or I<gcc -D_ISOC99_SOURCE> (unless B<_GNU_SOURCE> is also specified), in which case the B<a> is interpreted as a specifier for floating-point numbers (see above).
fr: Notez que le modificateur B<a> n'est pas disponible si le programme a été compilé avec I<gcc -std=c99> ou I<gcc -D_ISOC99_SOURCE> (à moins que B<_GNU_SOURCE> n'ait également été indiqué), auquel cas B<a> est interprété comme un spécificateur de nombres en virgule flottante (voir plus haut).

note: type: Plain text
en: Support for the B<m> modifier was added to glibc starting with version 2.7, and new programs should use that modifier instead of B<a>.
fr: Le modificateur B<m> est pris en charge depuis la version 2.7 de glibc et les nouveaux programmes doivent utiliser ce modificateur plutôt que B<a>.

note: type: Plain text
en: As well as being standardized by POSIX, the B<m> modifier has the following further advantages over the use of B<a:>
fr: En plus d'être un standard de POSIX, le modificateur B<m> présente les avantages suivants par rapport au modificateur B<a:>

note: type: Plain text
en: It may also be applied to B<%c> conversion specifiers (e.g., B<%3mc>).
fr: Il peut être appliqué aux spécificateurs de conversion B<%c> (par exemple B<%3mc>).

note: type: Plain text
en: It avoids ambiguity with respect to the B<%a> floating-point conversion specifier (and is unaffected by I<gcc -std=c99> etc.).
fr: Il lève toute ambiguité avec le spécificateur de conversion en virgule flottante B<%a> (et n'est pas affecté par I<gcc -std=c99> etc.).

note: type: Plain text
en: All functions are fully C89 conformant, but provide the additional specifiers B<q> and B<a> as well as an additional behavior of the B<L> and B<l> specifiers.  The latter may be considered to be a bug, as it changes the behavior of specifiers defined in C89.
fr: Toutes ces fonctions sont totalement conformes à C89, mais lui ajoutent les spécificateurs B<q> et B<a> ainsi que des comportements supplémentaires des spécificateurs B<L> et B<l>. Ce derniers doivent être considérés comme des bogues, car ils modifient le comportement de spécificateurs définis dans C89.

note: type: Plain text
en: Some combinations of the type modifiers and conversion specifiers defined by ANSI C do not make sense (e.g., B<%Ld>).  While they may have a well-defined behavior on Linux, this need not to be so on other architectures.  Therefore it usually is better to use modifiers that are not defined by ANSI C at all, that is, use B<q> instead of B<L> in combination with B<d>, B<i>, B<o>, B<u>, B<x>, and B<X> conversions or B<ll>.
fr: Certaines combinaisons de modificateurs de type et de spécificateurs de conversion définis par le C ANSI n'ont pas de sens (par exemple B<%Ld>). Bien qu'elles aient un comportement bien défini sous Linux, ce n'est peut être pas le cas sur d'autres architectures. Il vaut donc mieux n'utiliser que des modificateurs définis en C ANSI, c'est-à-dire, utilisez B<q> à la place de B<L> avec les conversions B<d>, B<i>, B<o>, B<u>, B<x> et B<X> ou B<ll>.

note: type: Plain text
en: The usage of B<q> is not the same as on 4.4BSD, as it may be used in float conversions equivalently to B<L>.
fr: L'utilisation B<q> n'est pas la même sous BSD\ 4.4, car il peut être utilisé avec des conversions de réels de manière équivalente à B<L>. [NDT] La conversion B<%s> devrait toujours être accompagnée d'une longueur maximale de chaîne de caractères. En effet, il existe un risque de débordement de tampon, qui peut conduire à un trou de sécurité important dans un programme setuid ou setgid.

note: type: Plain text
en: To use the dynamic allocation conversion specifier, specify B<m> as a length modifier (thus B<%ms> or B<%m[>I<range>B<]>).  The caller must B<free>(3)  the returned string, as in the following example:
fr: Pour utiliser l'indicateur de conversion d'allocation dynamique, indiquez B<m> comme modificateur de longueur (par conséquent B<%ms> ou B<%m[>I<range>B<]>). L'appelant doit libérer (B<free>(3)) l'espace occupé par la chaîne renvoyée, comme dans l'exemple suivant :

note: type: Plain text
en: errno = 0;
    n = scanf("%m[a-z]", &p);
    if (n == 1) {
        printf("read: %s\en", p);
        free(p);
    } else if (errno != 0) {
        perror("scanf");
    } else {
        fprintf(stderr, "No matching characters\en");
    }
fr: errno = 0;
    n = scanf("%m[a-z]", &p);
    if (n == 1) {
        printf("read: %s\en", p);
        free(p);
    } else if (errno != 0) {
        perror("scanf");
    } else {
        fprintf(stderr, "Pas de caractères correspondants\en");
    }

note: type: Plain text
en: As shown in the above example, it is necessary to call B<free>(3)  only if the B<scanf>()  call successfully read a string.
fr: Comme montré dans cet exemple, il n'est nécessaire d'appeler B<free>(3) que si l'appel à B<scanf>() a réussi à lire une chaîne.

note: type: TH
en: 2014-02-18
fr: 18 février 2014

note: type: Plain text
en: setbuf, setbuffer, setlinebuf, setvbuf - stream buffering operations
fr: setbuf, setbuffer, setlinebuf, setvbuf - Agir sur les tampons d'un flux

note: type: Plain text
en: B<setbuffer>(), B<setlinebuf>(): _BSD_SOURCE
fr: B<setbuffer>(), B<setlinebuf>() : _BSD_SOURCE

note: type: Plain text
en: The three types of buffering available are unbuffered, block buffered, and line buffered.  When an output stream is unbuffered, information appears on the destination file or terminal as soon as written; when it is block buffered many characters are saved up and written as a block; when it is line buffered characters are saved up until a newline is output or input is read from any stream attached to a terminal device (typically I<stdin>).  The function B<fflush>(3)  may be used to force the block out early.  (See B<fclose>(3).)  Normally all files are block buffered.  When the first I/O operation occurs on a file, B<malloc>(3)  is called, and a buffer is obtained.  If a stream refers to a terminal (as I<stdout> normally does), it is line buffered.  The standard error stream I<stderr> is always unbuffered by default.
fr: Les trois types de tampons disponibles sont les suivants\ : pas de tampons, tampons de blocs, et tampons de lignes. Quand un flux de sortie n'a pas de tampon, les données apparaissent dans le fichier destination, ou sur le terminal, dès qu'elles sont écrites. Avec les tampons par blocs, une certaine quantité de données est conservée avant d'être écrite en tant que bloc. Avec les tampons de lignes, les caractères sont conservés jusqu'à ce qu'un saut de ligne soit transmis, ou que l'on réclame une lecture sur un flux attaché au terminal (typiquement I<stdin>). La fonction B<fflush>(3) peut être utilisée pour forcer l'écriture à n'importe quel moment (voir B<fclose>(3)). Normalement, tous les fichiers utilisent des tampons de blocs. Quand une première opération d'entrée-sortie se déroule sur un fichier, B<malloc>(3) est appelée, et un tampon est créé. Si le flux se rapporte à un terminal (comme I<stdout> habituellement) il s'agit d'un tampon de ligne. Le flux standard de sortie d'erreur I<stderr> n'a jamais de tampon par défaut.

note: type: Plain text
en: The B<setvbuf>()  function may be used on any open stream to change its buffer.  The I<mode> argument must be one of the following three macros:
fr: La fonction B<setvbuf>() peut être utilisée sur n'importe quel flux ouvert pour modifier son type de tampon. La paramètre I<mode> doit correspondre à l'une des constantes symboliques suivantes\ :

note: type: Plain text
en: unbuffered
fr: pas de tampon

note: type: Plain text
en: line buffered
fr: tampon de ligne

note: type: Plain text
en: fully buffered
fr: tampon complet

note: type: Plain text
en: Except for unbuffered files, the I<buf> argument should point to a buffer at least I<size> bytes long; this buffer will be used instead of the current buffer.  If the argument I<buf> is NULL, only the mode is affected; a new buffer will be allocated on the next read or write operation.  The B<setvbuf>()  function may be used only after opening a stream and before any other operations have been performed on it.
fr: À l'exception des fichiers sans tampons, l'argument I<buf> doit pointer sur un tampon contenant au moins I<size> octets. Ce nouveau tampon sera utilisé à la place de l'ancien. Si l'argument I<buf> est NULL, seul le mode est affecté. Un nouveau tampon sera alloué automatiquement lors de la prochaine opération de lecture ou d'écriture. La fonction B<setvbuf>() ne peut être utilisée qu'après l'ouverture du flux, et avant toute opération dessus.

note: type: Plain text
en: The other three calls are, in effect, simply aliases for calls to B<setvbuf>().  The B<setbuf>()  function is exactly equivalent to the call
fr: Les trois autres appels sont, en fait, simplement des alias pour l'appel de B<setvbuf>(). la fonction B<setbuf>() est exactement équivalente à

note: type: Plain text
en: The B<setbuffer>()  function is the same, except that the size of the buffer is up to the caller, rather than being determined by the default B<BUFSIZ>.  The B<setlinebuf>()  function is exactly equivalent to the call:
fr: La fonction B<setbuffer>() est identique, sauf que la taille du tampon est indiquée par l'appelant plutôt que la valeur par défaut B<BUFSIZ>. La fonction B<setlinebuf>() est exactement équivalente à\ :

note: type: Plain text
en: The function B<setvbuf>()  returns 0 on success.  It returns nonzero on failure (I<mode> is invalid or the request cannot be honored).  It may set I<errno> on failure.
fr: La fonction B<setvbuf>() renvoie zéro si elle réussit. Elle renvoie une valeur non nulle en cas d'échec (I<mode> n'est pas valable ou la requête ne peut pas être honorée). Elle peut remplir I<errno> en cas d'erreur. Les autres fonctions ne renvoient rien.

note: type: Plain text
en: The other functions do not return a value.
fr: Les autres fonctions ne renvoient pas de valeur.

note: type: Plain text
en: The B<setbuf>(), B<setbuffer>(), B<setlinebuf>(), and B<setvbuf>()  functions are thread-safe.
fr: Les fonctions B<setbuf>(), B<setbuffer>(), B<setlinebuf>() et B<setvbuf>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The B<setbuf>()  and B<setvbuf>()  functions conform to C89 and C99.
fr: Les fonctions B<setbuf>() et B<setvbuf>() sont conformes à C89 et C99.

note: type: Plain text
en: The B<setbuffer>()  and B<setlinebuf>()  functions are not portable to versions of BSD before 4.2BSD, and are available under Linux since libc 4.5.21.  On 4.2BSD and 4.3BSD systems, B<setbuf>()  always uses a suboptimal buffer size and should be avoided.
fr: Les fonctions B<setbuffer>() et B<setlinebuf>() ne sont pas portables sur les systèmes BSD antérieurs à BSD\ 4.2, et sont disponibles sous Linux depuis la libc 4.5.21. Sur les systèmes BSD\ 4.2 et BSD\ 4.3, B<setbuf>() utilise toujours une taille de tampon non optimale, et doit être évitée.

note: type: Plain text
en: You must make sure that the space that I<buf> points to still exists by the time I<stream> is closed, which also happens at program termination.  For example, the following is invalid:
fr: Il faut toujours s'assurer que le contenu de I<buf> existe encore au moment de la fermeture du flux I<stream> (qui se produit automatiquement à la fin du programme). Par exemple, ceci n'est pas valable\ :

note: type: TH
en: 2008-07-14
fr: 14 juillet 2008

note: type: Plain text
en: stdin, stdout, stderr - standard I/O streams
fr: stdin, stdout, stderr - Flux d'entrées-sorties standard

note: type: Plain text
en: Under normal circumstances every UNIX program has three streams opened for it when it starts up, one for input, one for output, and one for printing diagnostic or error messages.  These are typically attached to the user's terminal (see B<tty>(4)  but might instead refer to files or other devices, depending on what the parent process chose to set up.  (See also the "Redirection" section of B<sh>(1).)
fr: Normalement, tout programme UNIX démarre avec trois flux déjà ouverts, l'un pour l'entrée des données, un autre pour la sortie des données, et un troisième pour l'affichage des messages de diagnostic ou d'erreur. Ces trois flux sont typiquement attachés au terminal de l'utilisateur (consultez B<tty>(4)), mais peuvent également être redirigés vers des fichiers ou vers d'autres périphériques suivant les choix du processus parent (voir le paragraphe «\ Redirection\ » dans B<sh>(1)).

note: type: Plain text
en: The input stream is referred to as "standard input"; the output stream is referred to as "standard output"; and the error stream is referred to as "standard error".  These terms are abbreviated to form the symbols used to refer to these files, namely I<stdin>, I<stdout>, and I<stderr>.
fr: Le flux d'entrée est appelé «\ entrée standard\ » (standard input), le flux de sortie «\ sortie standard\ » (standard output), et le flux d'erreur est souvent appelé «\ erreur standard\ » (standard error). Ces noms sont abrégés dans les dénominations symboliques de ces fichiers\ : I<stdin>, I<stdout> et I<stderr>.

note: type: Plain text
en: Each of these symbols is a B<stdio>(3)  macro of type pointer to I<FILE>, and can be used with functions like B<fprintf>(3)  or B<fread>(3).
fr: Chacun de ces symboles est une macro de B<stdio>(3) de type pointeur sur un FILE, et peut être utilisé dans des fonctions comme B<fprintf>(3) ou B<fread>(3).

note: type: Plain text
en: Since I<FILE>s are a buffering wrapper around UNIX file descriptors, the same underlying files may also be accessed using the raw UNIX file interface, that is, the functions like B<read>(2)  and B<lseek>(2).
fr: Comme les I<FILE> sont simplement des coquilles entourant les descripteurs de fichiers en ajoutant une mémoire tampon, il est également possible d'accéder aux fichiers UNIX «\ bruts\ », avec des fonctions comme B<read>(2) et B<lseek>(2).

note: type: Plain text
en: On program startup, the integer file descriptors associated with the streams I<stdin>, I<stdout>, and I<stderr> are 0, 1, and 2, respectively.  The preprocessor symbols B<STDIN_FILENO>, B<STDOUT_FILENO>, and B<STDERR_FILENO> are defined with these values in I<E<lt>unistd.hE<gt>>.  (Applying B<freopen>(3)  to one of these streams can change the file descriptor number associated with the stream.)
fr: Au démarrage du programme, les descripteurs de fichier associés aux flux I<stdin>, I<stdout> et I<stderr> valent respectivement 0, 1 et 2. Les constantes symboliques B<STDIN_FILENO>, B<STDOUT_FILENO>, et B<STDERR_FILENO> sont définies avec ces valeurs dans I<E<lt>unistd.hE<gt>> (appliquer B<freopen>(3) sur l'un de ces flux peut modifier le numéro de descripteur de fichier associé au flux).

note: type: Plain text
en: Note that mixing use of I<FILE>s and raw file descriptors can produce unexpected results and should generally be avoided.  (For the masochistic among you: POSIX.1, section 8.2.3, describes in detail how this interaction is supposed to work.)  A general rule is that file descriptors are handled in the kernel, while stdio is just a library.  This means for example, that after an B<exec>(3), the child inherits all open file descriptors, but all old streams have become inaccessible.
fr: Notez que l'utilisation conjointe des I<FILE> et des descripteurs bruts risque de produire des résultats inattendus, et doit être généralement évitée. Pour les plus masochistes d'entre vous, POSIX.1 décrit en détail, dans son paragraphe 8.2.3, comment ces interactions sont censées fonctionner. Une règle générale est que les descripteurs de fichier sont manipulés par le noyau, alors que stdio est simplement une bibliothèque. Ceci signifie par exemple qu'après un B<exec>(3), le processus fils hérite de tous les descripteurs de fichier ouverts, mais que les flux deviennent inaccessibles.

note: type: Plain text
en: Since the symbols I<stdin>, I<stdout>, and I<stderr> are specified to be macros, assigning to them is nonportable.  The standard streams can be made to refer to different files with help of the library function B<freopen>(3), specially introduced to make it possible to reassign I<stdin>, I<stdout>, and I<stderr>.  The standard streams are closed by a call to B<exit>(3)  and by normal program termination.
fr: Les symboles I<stdin>, I<stdout> et I<stderr> étant définis comme des macros, il est interdit de leur assigner une valeur. On peut utiliser la fonction de bibliothèque B<freopen>(3), spécialement conçue pour réassigner I<stdin>, I<stdout> et I<stderr>. Les flux standard sont fermés lors d'un appel à B<exit>(3) ou lors d'une fin normale de programme.

note: type: Plain text
en: The I<stdin>, I<stdout>, and I<stderr> macros conform to C89 and this standard also stipulates that these three streams shall be open at program startup.
fr: Les macros I<stdin>, I<stdout> et I<stderr> sont conformes au standard C89, et celui-ci stipule également que ces trois flux doivent être ouverts au démarrage du programme.

note: type: Plain text
en: The stream I<stderr> is unbuffered.  The stream I<stdout> is line-buffered when it points to a terminal.  Partial lines will not appear until B<fflush>(3)  or B<exit>(3)  is called, or a newline is printed.  This can produce unexpected results, especially with debugging output.  The buffering mode of the standard streams (or any other stream)  can be changed using the B<setbuf>(3)  or B<setvbuf>(3)  call.  Note that in case I<stdin> is associated with a terminal, there may also be input buffering in the terminal driver, entirely unrelated to stdio buffering.  (Indeed, normally terminal input is line buffered in the kernel.)  This kernel input handling can be modified using calls like B<tcsetattr>(3); see also B<stty>(1), and B<termios>(3).
fr: Le flux I<stderr> n'a pas de tampon. Le flux I<stdout> a un tampon de ligne lorsqu'il est dirigé vers un terminal. Les lignes partielles n'apparaîtront pas avant que B<fflush>(3) ou B<exit>(3) ne soient invoquées, ou qu'un retour-chariot soit écrit. Ceci a parfois des effets inattendus, principalement lors du débogage des programmes. La gestion des tampons des flux standard (et des autres flux également) peut être modifiée en utilisant B<setbuf>(3) ou B<setvbuf>(3). Remarquez que dans le cas où I<stdin> est associée à un terminal, il peut également y avoir un tampon d'entrée dans le pilote de terminal, sans aucune relation avec le tampon de stdio (en effet, normalement, la saisie depuis un terminal est gérée avec un tampon de ligne dans le noyau). Cette gestion par le noyau peut être configurée en utilisant des appels système comme B<tcsetattr>(3). Consultez également B<stty>(1) et B<termios>(3).

note: type: TH
en: 2001-12-26
fr: 26 décembre 2001

note: type: Plain text
en: stdio - standard input/output library functions
fr: stdio - Bibliothèque standard de fonctions d'entrées-sorties

note: type: Plain text
en: The standard I/O library provides a simple and efficient buffered stream I/O interface.  Input and output is mapped into logical data streams and the physical I/O characteristics are concealed.  The functions and macros are listed below; more information is available from the individual man pages.
fr: Cette bibliothèque standard fournit une interface simple et efficace pour les entrées-sorties avec tampons. Les entrées et les sorties sont projetées dans des flux de données logiques, et les caractéristiques des entrées-sorties physiques sont masquées. Les fonctions et les macros sont présentées rapidement ci-dessous. Des informations supplémentaires sont disponibles dans leurs pages de manuel individuelles.

note: type: Plain text
en: A stream is associated with an external file (which may be a physical device) by I<opening> a file, which may involve creating a new file.  Creating an existing file causes its former contents to be discarded.  If a file can support positioning requests (such as a disk file, as opposed to a terminal), then a I<file position indicator> associated with the stream is positioned at the start of the file (byte zero), unless the file is opened with append mode.  If append mode is used, it is unspecified whether the position indicator will be placed at the start or the end of the file.  The position indicator is maintained by subsequent reads, writes and positioning requests.  All input occurs as if the characters were read by successive calls to the B<fgetc>(3)  function; all output takes place as if all characters were written by successive calls to the B<fputc>(3)  function.
fr: Un flux est associé avec un fichier externe (qui peut aussi être un dispositif physique) en I<ouvrant> un fichier (ceci peut impliquer la création d'un nouveau fichier). La création d'un fichier déjà existant efface son contenu précédent. Si un fichier supporte les demandes de positionnement (par exemple un fichier sur disque, contrairement à un terminal), alors I<l'indicateur de position du fichier> associé au flux est placé au début du fichier (octet zéro), à moins que le fichier soit ouvert en mode d'ajout. Si le mode d'ajout est utilisé, l'indicateur de position est placé à la fin du fichier. L'indicateur de position est mis à jour après chaque lecture, écriture, ou repositionnement. Toutes les entrées se déroulent comme si les caractères étaient lus par des appels successifs à la fonction B<fgetc>(3). Toutes les sorties ont lieu comme si les caractères étaient envoyés à des appels successifs à la fonction B<fputc>(3).

note: type: Plain text
en: A file is disassociated from a stream by I<closing> the file.  Output streams are flushed (any unwritten buffer contents are transferred to the host environment) before the stream is disassociated from the file.  The value of a pointer to a I<FILE> object is indeterminate after a file is closed (garbage).
fr: Un fichier est dissocié d'un flux en I<fermant> le fichier. Les flux de sortie sont vidés (flush) avant que le flux soit dissocié du fichier. Ceci signifie que le contenu des tampons pas encore écrits est transféré dans l'environnement de l'hôte. La valeur d'un pointeur sur un objet I<FILE> (fichier) est indéfinie après la fermeture d'un fichier.

note: type: Plain text
en: A file may be subsequently reopened, by the same or another program execution, and its contents reclaimed or modified (if it can be repositioned at the start).  If the main function returns to its original caller, or the B<exit>(3)  function is called, all open files are closed (hence all output streams are flushed) before program termination.  Other methods of program termination, such as B<abort>(3)  do not bother about closing files properly.
fr: Un fichier peut être réouvert plus tard par le même programme ou par un autre, et son contenu relu ou modifié (si l'on peut placer l'indicateur de positionnement au début). Si la fonction I<main>() se termine, ou si la fonction B<exit>(3) est invoquée, tous les fichiers sont fermés (tous les tampons de sortie sont transférés par fflush) avant la fin du programme. Les autres méthodes d'abandon du programme, telles que B<abort>(3) ne s'occupent pas de fermer proprement les fichiers.

note: type: Plain text
en: At program startup, three text streams are predefined and need not be opened explicitly: I<standard input> (for reading conventional input), I<standard output> (for writing conventional input), and I<standard error> (for writing diagnostic output).  These streams are abbreviated I<stdin>,I<stdout> and I<stderr>.  When opened, the standard error stream is not fully buffered; the standard input and output streams are fully buffered if and only if the streams do not refer to an interactive device.
fr: Au démarrage du programme, trois flux de texte sont prédéfinis et n'ont pas besoin d'être ouverts explicitement\ : I<l'entrée standard> (pour la lecture des données), I<la sortie standard> (pour l'écriture des données), et I<le flux d'erreur standard> (pour les messages de diagnostique). Ces flux sont nommés I<stdin>,I<stdout> et I<stderr>. À l'ouverture, le flux d'erreur n'a pas de tampon, l'entrée standard et la sortie standard ont des tampons complets si et seulement si ils ne se réfèrent pas à un périphérique interactif.

note: type: Plain text
en: Output streams that refer to terminal devices are always line buffered by default; pending output to such streams is written automatically whenever an input stream that refers to a terminal device is read.  In cases where a large amount of computation is done after printing part of a line on an output terminal, it is necessary to B<fflush>(3)  the standard output before going off and computing so that the output will appear.
fr: Les flux de sortie qui s'adressent à un périphérique terminal disposent toujours d'un tampon de ligne par défaut. Les caractères sont conservés dans le tampon jusqu'à un saut de ligne, ou jusqu'à ce qu'une lecture soit demandée sur un flux associé au même terminal. Il peut être nécessaire de déclencher intentionnellement l'écriture effective sur le terminal en invoquant B<fflush>(3).

note: type: Plain text
en: The I<stdio> library is a part of the library B<libc> and routines are automatically loaded as needed by the compilers B<cc>(1)  and B<pc>(1).  The SYNOPSIS sections of the following manual pages indicate which include files are to be used, what the compiler declaration for the function looks like and which external variables are of interest.
fr: La bibliothèque standard I<stdio> fait partie de la bibliothèque B<libc> et ses routines sont chargées automatiquement par les compilateurs B<cc>(1) et B<pc>(1) si besoin est. Les sections SYNOPSIS des pages de manuel mentionnées plus bas indiquent les fichiers d'en-tête nécessaires, l'allure des déclarations de fonctions, et les variables externes utiles.

note: Not on Linux: .BR fropen , Not on Linux: .BR fwopen , type: Plain text
en: The following are defined as macros; these names may not be reused without first removing their current definitions with B<#undef>: B<BUFSIZ>, B<EOF>, B<FILENAME_MAX>, B<FOPEN_MAX>, B<L_cuserid>, B<L_ctermid>, B<L_tmpnam>, B<NULL>, B<SEEK_END>, B<SEEK_SET>, B<SEEK_CUR>, B<TMP_MAX>, B<clearerr>, B<feof>, B<ferror>, B<fileno>, B<getc>, B<getchar>, B<putc>, B<putchar>, B<stderr>, B<stdin>, B<stdout>.  Function versions of the macro functions B<feof>, B<ferror>, B<clearerr>, B<fileno>, B<getc>, B<getchar>, B<putc>, and B<putchar> exist and will be used if the macros definitions are explicitly removed.
fr: Les noms ci-dessous correspondent à des macros. On ne peut pas les réutiliser sans supprimer leur définition précédente avec B<#undef>: B<BUFSIZ>, B<EOF>, B<FILENAME_MAX>, B<FOPEN_MAX>, B<L_cuserid>, B<L_ctermid>, B<L_tmpnam>, B<NULL>, B<SEEK_END>, B<SEEK_SET>, B<SEEK_CUR>, B<TMP_MAX>, B<clearerr>, B<feof>, B<ferror>, B<fileno>, B<getc>, B<getchar>, B<putc>, B<putchar>, B<stderr>, B<stdin>, B<stdout>. Il existe des définitions sous forme de fonctions des macros B<feof>, B<ferror>, B<clearerr>, B<fileno>, B<getc>, B<getchar>, B<putc>, et B<putchar> qui seront utilisées si la définition de la macro est explicitement supprimée.

note: type: SS
en: List of functions
fr: Liste des fonctions

note: type: tbl table
en: Function	Description
fr: Fonction	Description

note: type: tbl table
en: clearerr	check and reset stream status
fr: clearerr	vérifie et réinitialise l'état d'un flux.

note: type: tbl table
en: fclose	close a stream
fr: fclose	ferme un flux.

note: type: tbl table
en: fdopen	stream open functions
fr: fdopen	fonction d'ouverture d'un flux.

note: type: tbl table
en: feof	check and reset stream status
fr: feof	vérifie et réinitialise l'état d'un flux.

note: type: tbl table
en: ferror	check and reset stream status
fr: ferror	vérifie et réinitialise l'état d'un flux.

note: type: tbl table
en: fflush	flush a stream
fr: fflush	transfère les tampons d'un flux.

note: type: tbl table
en: fgetc	get next character or word from input stream
fr: fgetc	lit le caractère ou le mot suivant depuis un flux
    	d'entrée.

note: type: tbl table
en: fgetpos	reposition a stream
fr: fgetpos	repositionner un flux.

note: type: tbl table
en: fgets	get a line from a stream
fr: fgets	lit une ligne depuis un flux d'entrée.

note: type: tbl table
en: fileno	return the integer descriptor of the argument stream
fr: fileno	renvoie le descripteur (de type entier) du flux
    	fourni en paramètre.

note: type: tbl table
en: fopen	stream open functions
fr: fopen	fonction d'ouverture d'un flux.

note: type: tbl table
en: fprintf	formatted output conversion
fr: fprintf	écriture de données formatées.

note: type: tbl table
en: fpurge	flush a stream
fr: fpurge	transfère les tampons d'un flux.

note: type: tbl table
en: fputc	output a character or word to a stream
fr: fputc	écriture d'un caractère ou d'un mot dans un flux.

note: type: tbl table
en: fputs	output a line to a stream
fr: fputs	écriture d'une ligne dans un flux.

note: type: tbl table
en: fread	binary stream input/output
fr: fread	entrées-sorties binaires.

note: type: tbl table
en: freopen	stream open functions
fr: freopen	fonction d'ouverture d'un flux.

note: type: tbl table
en: fscanf	input format conversion
fr: fscanf	lecture de données formatées.

note: type: tbl table
en: fseek	reposition a stream
fr: fseek	repositionner un flux.

note: type: tbl table
en: fsetpos	reposition a stream
fr: fsetpos	repositionner un flux.

note: type: tbl table
en: ftell	reposition a stream
fr: ftell	repositionner un flux.

note: type: tbl table
en: fwrite	binary stream input/output
fr: fwrite	entrées-sorties binaires.

note: type: tbl table
en: getc	get next character or word from input stream
fr: getc	lit le caractère ou le mot suivant depuis un flux
    	d'entrée.

note: type: tbl table
en: getchar	get next character or word from input stream
fr: getchar	lit le caractère ou le mot suivant depuis un flux
    	d'entrée.

note: type: tbl table
en: gets	get a line from a stream
fr: gets	lit une ligne depuis un flux d'entrée.

note: type: tbl table
en: getw	get next character or word from input stream
fr: getw	lit le caractère ou le mot suivant depuis un flux
    	d'entrée.

note: type: tbl table
en: mktemp	make temporary filename (unique)
fr: mktemp	créer un fichier temporaire (unique).

note: type: tbl table
en: perror	system error messages
fr: perror	messages d'erreur système.

note: type: tbl table
en: printf	formatted output conversion
fr: printf	écriture de données formatées.

note: type: tbl table
en: putc	output a character or word to a stream
fr: putc	écriture d'un caractère ou d'un mot dans un flux.

note: type: tbl table
en: putchar	output a character or word to a stream
fr: putchar	écriture d'un caractère ou d'un mot dans un flux.

note: type: tbl table
en: puts	output a line to a stream
fr: puts	écriture d'une ligne dans un flux.

note: type: tbl table
en: putw	output a character or word to a stream
fr: putw	écriture d'un caractère ou d'un mot dans un flux.

note: type: tbl table
en: remove	remove directory entry
fr: remove	supprimer une entrée de répertoire.

note: type: tbl table
en: rewind	reposition a stream
fr: rewind	repositionner un flux.

note: type: tbl table
en: scanf	input format conversion
fr: scanf	lecture de données formatées.

note: type: tbl table
en: setbuf	stream buffering operations
fr: setbuf	opérations sur les tampons.

note: type: tbl table
en: setbuffer	stream buffering operations
fr: setbuffer	opérations sur les tampons.

note: type: tbl table
en: setlinebuf	stream buffering operations
fr: setlinebuf	opérations sur les tampons.

note: type: tbl table
en: setvbuf	stream buffering operations
fr: setvbuf	opérations sur les tampons.

note: type: tbl table
en: sprintf	formatted output conversion
fr: sprintf	écriture de données formatées.

note: type: tbl table
en: sscanf	input format conversion
fr: sscanf	lecture de données formatées.

note: type: tbl table
en: strerror	system error messages
fr: strerror	messages d'erreur système.

note: type: tbl table
en: sys_errlist	system error messages
fr: sys_errlist	messages d'erreur système.

note: type: tbl table
en: sys_nerr	system error messages
fr: sys_nerr	messages d'erreur système.

note: type: tbl table
en: tempnam	temporary file routines
fr: tempnam	créer un fichier temporaire.

note: type: tbl table
en: tmpfile	temporary file routines
fr: tmpfile	créer un fichier temporaire.

note: type: tbl table
en: tmpnam	temporary file routines
fr: tmpnam	créer un fichier temporaire.

note: type: tbl table
en: ungetc	un-get character from input stream
fr: ungetc	remettre un caractère dans un flux d'entrée.

note: type: tbl table
en: vfprintf	formatted output conversion
fr: vfprintf	écriture de données formatées.

note: type: tbl table
en: vfscanf	input format conversion
fr: vfscanf	lecture de données formatées.

note: type: tbl table
en: vprintf	formatted output conversion
fr: vprintf	écriture de données formatées.

note: type: tbl table
en: vscanf	input format conversion
fr: vscanf	lecture de données formatées.

note: type: tbl table
en: vsprintf	formatted output conversion
fr: vsprintf	écriture de données formatées.

note: type: tbl table
en: vsscanf	input format conversion
fr: vsscanf	lecture de données formatées.

note: type: Plain text
en: The I<stdio> library conforms to C89.
fr: La bibliothèque I<stdio> est conforme à C89.

note: type: Plain text
en: __fbufsize, __flbf, __fpending, __fpurge, __freadable, __freading, __fsetlocking, __fwritable, __fwriting, _flushlbf - interfaces to stdio FILE structure
fr: __fbufsize, __flbf, __fpending, __fpurge, __freadable, __freading, __fsetlocking, __fwritable, __fwriting, _flushlbf - Interfaces pour la structure FILE (stdio)

note: type: Plain text
en: Solaris introduced routines to allow portable access to the internals of the I<FILE> structure, and glibc also implemented these.
fr: Solaris a introduit des routines afin de permettre des accès portables aux composants internes de la structure I<FILE>. La glibc a également implémenté ces routines.

note: type: Plain text
en: The B<__fbufsize>()  function returns the size of the buffer currently used by the given stream.
fr: La fonction B<__fbufsize>() renvoie la taille du tampon actuellement utilisé par le flux considéré.

note: type: Plain text
en: The B<__fpending>()  function returns the number of bytes in the output buffer.  For wide-oriented streams the unit is wide characters.  This function is undefined on buffers in reading mode, or opened read-only.
fr: La fonction B<__fpending>() renvoie le nombre d'octets du tampon de sortie. Pour les flux orientés caractères larges, l'unité est le caractère large. Cette fonction n'est pas définie pour les tampons en mode lecture, ou bien ouverts en lecture seule.

note: type: Plain text
en: The B<__flbf>()  function returns a nonzero value if the stream is line-buffered, and zero otherwise.
fr: La fonction B<__flbf>() renvoie une valeur différente de zéro si le flux a un tampon de ligne, sinon, elle renvoie zéro.

note: type: Plain text
en: The B<__freadable>()  function returns a nonzero value if the stream allows reading, and zero otherwise.
fr: La fonction B<__freadable>() renvoie une valeur différente de zéro si le flux peut être lu, sinon, elle renvoie zéro.

note: type: Plain text
en: The B<__fwritable>()  function returns a nonzero value if the stream allows writing, and zero otherwise.
fr: La fonction B<__fwritable>() renvoie une valeur différente de zéro si l'on peut écrire dans le flux, sinon, elle renvoie zéro.

note: type: Plain text
en: The B<__freading>()  function returns a nonzero value if the stream is read-only, or if the last operation on the stream was a read operation, and zero otherwise.
fr: La fonction B<__freading>() renvoie une valeur différente de zéro si le flux est en lecture seule, ou bien si la dernière opération sur le flux était une lecture, sinon, elle renvoie zéro.

note: type: Plain text
en: The B<__fwriting>()  function returns a nonzero value if the stream is write-only (or append-only), or if the last operation on the stream was a write operation, and zero otherwise.
fr: La fonction B<__fwriting>() renvoie une valeur différente de zéro si le flux est en écriture seule, ou bien si la dernière opération sur le flux était une écriture, sinon, elle renvoie zéro.

note: type: Plain text
en: The B<__fsetlocking>()  function can be used to select the desired type of locking on the stream.  It returns the current type.  The I<type> argument can take the following three values:
fr: La fonction B<__fsetlocking>() peut être utilisée afin de sélectionner le type de verrouillage souhaité sur le flux. Elle renvoie le type actuel. Le paramètre I<type> peut prendre les trois valeurs suivantes\ :

note: type: Plain text
en: Perform implicit locking around every operation on the given stream (except for the *_unlocked ones).  This is the default.
fr: réalise un verrouillage implicite sur toutes les opérations affectant le flux considéré (à l'exception de fonctions nommées *_unlocked). Il s'agit du comportement par défaut.

note: type: Plain text
en: The caller will take care of the locking (possibly using B<flockfile>(3)  in case there is more than one thread), and the stdio routines will not do locking until the state is reset to B<FSETLOCKING_INTERNAL>.
fr: l'appelant prendra en charge le verrouillage (en utilisant potentiellement B<flockfile>(3) dans le cas où il y a plusieurs threads), et les routines d'entrées sorties standards n'effectueront plus aucun verrouillage jusqu'à ce que l'état soit rétabli à B<FSETLOCKING_INTERNAL>.

note: type: Plain text
en: Don't change the type of locking.  (Only return it.)
fr: ne change pas le type de verrouillage (le renvoie seulement).

note: type: Plain text
en: The B<_flushlbf>()  function flushes all line-buffered streams.  (Presumably so that output to a terminal is forced out, say before reading keyboard input.)
fr: La fonction B<_flushlbf>() vide tous les flux à tampon de ligne (sans doute de sorte que la sortie d'un terminal soit écrite, par exemple avant de lire une entrée sur le clavier).

note: type: Plain text
en: The B<__fpurge>()  function discards the contents of the stream's buffer.
fr: La fonction B<__fpurge>() permet de se débarrasser du contenu du tampon de flux.

note: type: Plain text
en: The B<__fbufsize>(), B<__fpending>(), B<__fpurge>()  and B<__fsetlocking>()  functions do not lock the stream, so they are not thread-safe.
fr: Les fonctions B<__fbufsize>(), B<__fpending>(), B<__fpurge>() et B<__fsetlocking>() ne verrouillent pas le flux, et ne sont donc pas sûres dans un contexte multithread.

note: type: Plain text
en: The B<__flbf>(), B<__freadable>(), B<__freading>(), B<__fwritable>(), B<__fwriting>()  and B<_flushlbf>()  functions are thread-safe.
fr: Les fonctions B<__flbf>(), B<__freadable>(), B<__freading>(), B<__fwritable>(), B<__fwriting>() and B<_flushlbf>() sont sûres dans un contexte multithread.

note: type: Plain text
en: symlink, symlinkat - make a new name for a file
fr: symlink, symlinkat - Créer un nouveau nom pour un fichier

note: type: Plain text
en: B<symlink>():
fr: B<symlink>()\ :

note: type: Plain text
en: B<symlink>()  creates a symbolic link named I<linkpath> which contains the string I<target>.
fr: B<symlink>() crée un lien symbolique avec le nom I<linkpath> indiqué, et qui pointe sur I<target>.

note: type: Plain text
en: Symbolic links are interpreted at run time as if the contents of the link had been substituted into the path being followed to find a file or directory.
fr: Les liens sont interprétés à l'exécution, comme si le contenu du lien était remplacé par le chemin d'accès pour trouver un fichier ou un répertoire.

note: type: Plain text
en: Symbolic links may contain I<..> path components, which (if used at the start of the link) refer to the parent directories of that in which the link resides.
fr: Les liens symboliques peuvent contenir I<..> pour le chemin, qui (s'il est utilisé au début du lien) se réfère aux répertoires parents du lien.

note: type: Plain text
en: A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent one; the latter case is known as a dangling link.
fr: Un lien symbolique (aussi nommé «\ soft link\ ») peut pointer vers un fichier existant ou sur un fichier non existant.

note: type: Plain text
en: The permissions of a symbolic link are irrelevant; the ownership is ignored when following the link, but is checked when removal or renaming of the link is requested and the link is in a directory with the sticky bit (B<S_ISVTX>)  set.
fr: Les permissions d'accès à un lien symbolique sont sans importance, le propriétaire est ignoré lorsque l'on suit le lien, il n'est vérifié que pour supprimer ou renommer le lien si celui-ci se trouve dans un répertoire avec le sticky bit (B<S_ISVTX>) positionné.

note: type: Plain text
en: If I<linkpath> exists, it will I<not> be overwritten.
fr: Si I<linkpath> existe, il ne sera I<pas> écrasé.

note: type: Plain text
en: The B<symlinkat>()  system call operates in exactly the same way as B<symlink>(), except for the differences described here.
fr: L'appel système B<symlinkat>() fonctionne exactement comme B<symlink>(), les seules différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<linkpath> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<newdirfd> (rather than relative to the current working directory of the calling process, as is done by B<symlink>()  for a relative pathname).
fr: Si I<linkpath> est un chemin relatif, il est interprété relativement au répertoire référencé par le descripteur I<newdirfd> (plutôt que par rapport au répertoire courant, comme c'est le cas avec B<symlink>()).

note: type: Plain text
en: If I<linkpath> is relative and I<newdirfd> is the special value B<AT_FDCWD>, then I<linkpath> is interpreted relative to the current working directory of the calling process (like B<symlink>()).
fr: Si I<linkpath> est relatif et si I<newdirfd> a la valeur spéciale B<AT_FDCWD>, alors I<linkpath> est interprété relativement au répertoire de travail du processus appelant, comme pour B<symlink>().

note: type: Plain text
en: If I<linkpath> is absolute, then I<newdirfd> is ignored.
fr: Si I<linkpath> est un chemin absolu, I<newdirfd> est ignoré.

note: type: Plain text
en: Write access to the directory containing I<linkpath> is denied, or one of the directories in the path prefix of I<linkpath> did not allow search permission.  (See also B<path_resolution>(7).)
fr: L'écriture dans le répertoire contenant I<linkpath> est interdite, ou l'un des répertoires composant I<linkpath> ne permet pas le parcours. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: The user's quota of resources on the filesystem has been exhausted.  The resources could be inodes or disk blocks, depending on the filesystem implementation.
fr: Le quota de ressources de l'utilisateur sur le système de fichiers a été atteint. Les ressources peuvent être des inœuds ou des blocs de disque, suivant l'implémentation sur le système de fichiers.

note: type: Plain text
en: I<linkpath> already exists.
fr: I<linkpath> existe déjà.

note: type: Plain text
en: I<target> or I<linkpath> points outside your accessible address space.
fr: I<target> ou I<linkpath> pointent en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: Too many symbolic links were encountered in resolving I<linkpath>.
fr: I<linkpath> contient une référence circulaire (à travers un lien symbolique).

note: type: Plain text
en: I<target> or I<linkpath> was too long.
fr: I<target> ou I<linkpath> est trop long.

note: type: Plain text
en: A directory component in I<linkpath> does not exist or is a dangling symbolic link, or I<target> is the empty string.
fr: Un répertoire dans le chemin I<linkpath> n'existe pas ou est un lien symbolique pointant nulle part. Ou encore I<target> est une chaîne vide.

note: type: Plain text
en: A component used as a directory in I<linkpath> is not, in fact, a directory.
fr: Un composant utilisé comme un répertoire dans le chemin I<linkpath> n'est en fait pas un répertoire.

note: type: Plain text
en: The filesystem containing I<linkpath> does not support the creation of symbolic links.
fr: le système de fichiers contenant I<linkpath> ne permet pas la création de liens symboliques.

note: type: Plain text
en: I<linkpath> is on a read-only filesystem.
fr: Le chemin I<linkpath> se trouve sur un système de fichiers en lecture seule.

note: type: Plain text
en: The following additional errors can occur for B<symlinkat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<symlinkat>() :

note: type: Plain text
en: I<newdirfd> is not a valid file descriptor.
fr: I<newdirfd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<linkpath> is relative and I<newdirfd> is a file descriptor referring to a file other than a directory.
fr: I<linkpath> est un chemin relatif, et le descripteur I<newdirfd> est associé à un fichier, pas à un répertoire.

note: type: Plain text
en: B<symlinkat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<symlinkat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: SVr4 documents additional error codes EDQUOT and ENOSYS. See .BR open (2) re multiple files with the same name, and NFS. type: Plain text
en: B<symlink>(): SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.
fr: B<symlink>() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.

note: type: Plain text
en: B<symlinkat>(): POSIX.1-2008.
fr: B<symlinkat>() : POSIX.1-2008.

note: type: Plain text
en: No checking of I<target> is done.
fr: Il n'y a pas de vérification de l'existence de I<target>.

note: type: Plain text
en: Deleting the name referred to by a symbolic link will actually delete the file (unless it also has other hard links).  If this behavior is not desired, use B<link>(2).
fr: Effacer le nom référencé par un lien symbolique effacera effectivement le fichier (à moins qu'il ait d'autres liens matériels). Si ce comportement est indésirable, utiliser B<link>().

note: type: Plain text
en: symlink - symbolic link handling
fr: symlink - Fonctionnement des liens symboliques

note: type: Plain text
en: Symbolic links are files that act as pointers to other files.  To understand their behavior, you must first understand how hard links work.
fr: Les liens symboliques sont des fichiers qui agissent comme des pointeurs vers d'autres fichiers. Pour comprendre leur fonctionnement, vous devez d'abord comprendre comment fonctionnent les liens physiques.

note: type: Plain text
en: A hard link to a file is indistinguishable from the original file because it is a reference to the object underlying the original filename.  (To be precise: each of the hard links to a file is a reference to the same I<i-node number>, where an i-node number is an index into the i-node table, which contains metadata about all files on a filesystem.  See B<stat>(2).)  Changes to a file are independent of the name used to reference the file.  Hard links may not refer to directories (to prevent the possibility of loops within the filesystem tree, which would confuse many programs)  and may not refer to files on different filesystems (because i-node numbers are not unique across filesystems).
fr: Un lien physique (hard link) vers un fichier est indistinguable du fichier original car c'est une référence directe vers l'objet sous-jacent pointé par le nom original. (Pour être précis, chaque lien physique sur un fichier fait référence au même I<numéro d'inœud>, ce numéro étant un indice dans une table d'inœud qui contient des métadonnées sur tout le contenu du système de fichiers. Consultez B<stat>(2)). Les changements dans un fichier sont indépendants du nom utilisé pour faire référence au fichier. Les liens physiques ne peuvent pas faire référence aux répertoires (pour éviter le risque de boucles dans le système de fichiers, ce qui planterait de nombreux programmes) et ne peuvent pas référencer des fichiers sur un autre système de fichiers (car les numéros d'inœud ne sont uniques que sur un même système de fichiers).

note: type: Plain text
en: A symbolic link is a special type of file whose contents are a string that is the pathname of another file, the file to which the link refers.  (The contents of a symbolic link can be read using B<readlink>(2).)  In other words, a symbolic link is a pointer to another name, and not to an underlying object.  For this reason, symbolic links may refer to directories and may cross filesystem boundaries.
fr: Un lien symbolique est un fichier d'un type spécial, dont le contenu est une chaîne représentant le chemin d'accès vers un autre fichier, celui vers lequel le lien pointe. (Le contenu d'un lien symbolique peut être lu en utilisant B<readlink>(2).) En d'autres termes, un lien symbolique est un pointeur vers un autre nom, pas vers le contenu sous-jacent. Pour cette raison, les liens symboliques peuvent faire référence aux répertoires et peuvent franchir les frontières des systèmes de fichiers.

note: type: Plain text
en: There is no requirement that the pathname referred to by a symbolic link should exist.  A symbolic link that refers to a pathname that does not exist is said to be a I<dangling link>.
fr: Il n'y a pas d'obligation pour que le fichier dont le nom est référencé par un lien symbolique existe. Un lien symbolique qui fait référence à un nom de fichier inexistant est dit I<dangling link> (pendouillant).

note: type: Plain text
en: Because a symbolic link and its referenced object coexist in the filesystem name space, confusion can arise in distinguishing between the link itself and the referenced object.  On historical systems, commands and system calls adopted their own link-following conventions in a somewhat ad-hoc fashion.  Rules for a more uniform approach, as they are implemented on Linux and other systems, are outlined here.  It is important that site-local applications also conform to these rules, so that the user interface can be as consistent as possible.
fr: Comme un lien symbolique et l'objet qu'il référence coexistent sur le système de fichiers, une confusion peut survenir pour distinguer le lien lui-même et l'objet référencé. Sur des systèmes historiques, les commandes et les appels système adoptaient leur propres conventions pour le suivi des liens symboliques de manière arbitraire. Des règles pour une approche plus uniforme, comme elles sont implémentées sur Linux et d'autres systèmes, sont présentées ici. Il est important que les applications locales se conforment aussi à ces règles pour que l'interface avec l'utilisateur soit la plus cohérente possible.

note: type: SS
en: Symbolic link ownership, permissions, and timestamps
fr: Propriétés, permissions, et horodatage des liens symboliques

note: type: Plain text
en: The owner and group of an existing symbolic link can be changed using B<lchown>(2).  The only time that the ownership of a symbolic link matters is when the link is being removed or renamed in a directory that has the sticky bit set (see B<stat>(2)).
fr: Le propriétaire et le groupe d'un lien symbolique existant peut être modifié en utilisant B<lchown>(2). Le seul moment où l'appartenance d'un lien symbolique est importante est lors de sa suppression ou de son renommage dans un répertoire dont le bit « Sticky » est positionné (consultez B<stat>(2)).

note: type: Plain text
en: The last access and last modification timestamps of a symbolic link can be changed using B<utimensat>(2)  or B<lutimes>(3).
fr: Les horodatages du dernier accès et de la dernière modification d'un lien symbolique peuvent être modifiés en utilisant B<utimensat>(2) ou B<lutimes>(3).

note: Linux does not currently implement an lchmod(2). The 4.4BSD system differs from historical 4BSD systems in that the system call .BR chown (2) has been changed to follow symbolic links. .BR lchown (2) system call was added later when the limitations of the new became apparent. type: Plain text
en: On Linux, the permissions of a symbolic link are not used in any operations; the permissions are always 0777 (read, write, and execute for all user categories), and can't be changed.
fr: Sur Linux, les permissions associées au lien symbolique ne sont utilisées dans aucune opération ; ces permissions sont toujours 0777 (lecture, écriture et exécution pour toutes les catégories d'utilisateurs) et ne peuvent pas être modifiées.

note: type: SS
en: Obtaining a file descriptor that refers to a symbolic link
fr: Obtient un descripteur de fichier qui fait référence à un lien symbolique.

note: type: Plain text
en: Using the combination of the B<O_PATH> and B<O_NOFOLLOW> flags to B<open>(2)  yields a file descriptor that can be passed as the I<dirfd> argument in system calls such as B<fstatat>(2), B<fchownat>(2), B<fchmodat>(2), B<linkat>(2), and B<readlinkat>(2), in order to operate on the symbolic link itself (rather than the file to which it refers).
fr: L'utilisation des attributs B<O_PATH> and B<O_NOFOLLOW> en association pour un appel B<open>(2) délivre un descripteur de fichier qui peut être transmis comme l'argument I<dirfd> à des appels systèmes tels que B<fstatat>(2), B<fchownat>(2), B<fchmodat>(2), B<linkat>(2), et B<readlinkat>(2), afin d'agir sur des liens symboliques (et non sur les fichiers vers lesquels ils pointent).

note: type: Plain text
en: By default (i.e., if the B<AT_SYMLINK_FOLLOW> flag is not specified), if B<name_to_handle_at>(2)  is applied to a symbolic link, it yields a handle for the symbolic link (rather than the file to which it refers).  One can then obtain a file descriptor for the symbolic link (rather than the file to which it refers)  by specifying the B<O_PATH> flag in a subsequent call to B<open_by_handle_at>(2).  Again, that file descriptor can be used in the aforementioned system calls to operate on the symbolic link itself.
fr: Par défaut (c'est à dire si l'attribut B<AT_SYMLINK_FOLLOW> n'est pas précisé), lorsque B<name_to_handle_at>(2) est utilisé sur un lien symbolique, il délivre un indicateur pour le lien symbolique (et non pour le fichier vers lequel il pointe). On peut alors obtenir un descripteur de fichier du lien symbolique (et non du fichier vers lequel il pointe) en précisant l'attribut B<O_PATH> lors d'un appel ultérieur à B<open_by_handle_at>(2). De nouveau, ce descripteur de fichier peut être utilisé dans des appels système cités précédemment pour agir sur le lien symbolique en lui-même.

note: type: SS
en: Handling of symbolic links by system calls and commands
fr: Traitement des liens symboliques par les appels système et les commandes

note: type: Plain text
en: Symbolic links are handled either by operating on the link itself, or by operating on the object referred to by the link.  In the latter case, an application or system call is said to I<follow> the link.  Symbolic links may refer to other symbolic links, in which case the links are dereferenced until an object that is not a symbolic link is found, a symbolic link that refers to a file which does not exist is found, or a loop is detected.  (Loop detection is done by placing an upper limit on the number of links that may be followed, and an error results if this limit is exceeded.)
fr: Les liens symboliques sont traités en agissant soit sur le lien lui-même, soit sur l'objet pointé par le lien. Dans ce dernier cas, on dit que l'application ou l'appel système I<suit> le lien. Les liens symboliques peuvent faire référence à d'autres liens symboliques, auquel cas les liens sont suivis jusqu'à ce qu'un objet qui ne soit pas un lien symbolique soit rencontré, qu'un lien symbolique pointant sur un fichier inexistant soit trouvé, ou qu'une boucle soit détectée. (La détection des boucles est faite en définissant une limite maximale sur le nombre de liens qui peuvent être suivis, et une erreur se produit si cette limite est atteinte).

note: type: Plain text
en: There are three separate areas that need to be discussed.  They are as follows:
fr: Il faut considérer trois domaines d'utilisation différents des liens symboliques. Ce sont :

note: type: Plain text
en: Symbolic links used as filename arguments for system calls.
fr: Les liens symboliques fournis en argument des appels système sous forme de noms de fichiers.

note: type: Plain text
en: Symbolic links specified as command-line arguments to utilities that are not traversing a file tree.
fr: Les liens symboliques indiqués comme arguments de la ligne de commande pour les utilitaires qui ne parcourent pas l'arborescence des fichiers.

note: type: Plain text
en: Symbolic links encountered by utilities that are traversing a file tree (either specified on the command line or encountered as part of the file hierarchy walk).
fr: Les liens symboliques rencontrés par les utilitaires qui traversent l'arborescence (soit indiqués sur la ligne de commande, soit rencontrés comme partie de la hiérarchie des fichiers).

note: type: SS
en: System calls
fr: Appels système

note: type: Plain text
en: The first area is symbolic links used as filename arguments for system calls.
fr: Le premier domaine est celui des liens symboliques utilisés en noms de fichiers comme argument pour les appels système.

note: type: Plain text
en: Except as noted below, all system calls follow symbolic links.  For example, if there were a symbolic link I<slink> which pointed to a file named I<afile>, the system call I<open("slink" ...\&)> would return a file descriptor referring to the file I<afile>.
fr: Sauf exception mentionnée ci-dessous, tous les appels système suivent les liens symboliques. Par exemple s'il existe un lien I<slink> qui pointe vers le fichier I<afile>, l'appel système I<open("slink" ...\&)> renverra un descripteur de fichier faisant référence à I<afile>.

note: type: Plain text
en: Various system calls do not follow links, and operate on the symbolic link itself.  They are: B<lchown>(2), B<lgetxattr>(2), B<llistxattr>(2), B<lremovexattr>(2), B<lsetxattr>(2), B<lstat>(2), B<readlink>(2), B<rename>(2), B<rmdir>(2), and B<unlink>(2).
fr: Certains appels système ne suivent pas les liens, et agissent sur le lien symbolique lui-même. Ce sont : B<lchown>(2), B<lgetxattr>(2), B<llistxattr>(2), B<lremovexattr>(2), B<lsetxattr>(2), B<lstat>(2), B<readlink>(2), B<rename>(2), B<rmdir>(2) et B<unlink>(2).

note: Maybe one day: .BR fchownat (2) type: Plain text
en: Certain other system calls optionally follow symbolic links.  They are: B<faccessat>(2), B<fchownat>(2), B<fstatat>(2), B<linkat>(2), B<name_to_handle_at>(2), B<open>(2), B<openat>(2), B<open_by_handle_at>(2), and B<utimensat>(2); see their manual pages for details.  Because B<remove>(3)  is an alias for B<unlink>(2), that library function also does not follow symbolic links.  When B<rmdir>(2)  is applied to a symbolic link, it fails with the error B<ENOTDIR>.
fr: Certains autres appels système suivent éventuellement les liens symboliques. Il s'agit de : B<faccessat>(2), B<fchownat>(2), B<fstatat>(2), B<linkat>(2), B<name_to_handle_at>(2), B<open>(2), B<openat>(2), B<open_by_handle_at>(2) et B<utimensat>(2) ; Reportez-vous à leur pages de manuel. Comme B<remove>(3) est un alias pour B<unlink>(2), cette fonction de bibliothèque ne suit pas non plus les liens symboliques. Quand B<rmdir>(2) est utilisé sur un lien symbolique, il échoue avec l'erreur B<ENOTDIR>.

note: type: Plain text
en: The B<link>(2)  warrants special discussion.  POSIX.1-2001 specifies that B<link>(2)  should dereference I<oldpath> if it is a symbolic link.  However, Linux does not do this.  (By default Solaris is the same, but the POSIX.1-2001 specified behavior can be obtained with suitable compiler options.)  The upcoming POSIX.1 revision changes the specification to allow either behavior in an implementation.
fr: L'appel B<link>(2) réclame une discussion particulière. POSIX.1-2001 précise que B<link>(2) doit déréférencer I<oldpath> si c'est un lien symbolique. Néanmoins, Linux ne le fait pas. (Par défaut, Solaris non plus, mais une option de compilation permet d'obtenir le comportement POSIX.1-2001). La révision à venir de POSIX.1 changera de description pour permettre les deux comportements.

note: type: SS
en: Commands not traversing a file tree
fr: Les commandes qui ne parcourent pas les arborescences

note: type: Plain text
en: The second area is symbolic links, specified as command-line filename arguments, to commands which are not traversing a file tree.
fr: Ce second domaine est celui des liens symboliques, indiqués en tant que noms de fichiers, comme argument pour des commandes ne traversant pas les arborescences.

note: type: Plain text
en: Except as noted below, commands follow symbolic links named as command-line arguments.  For example, if there were a symbolic link I<slink> which pointed to a file named I<afile>, the command I<cat slink> would display the contents of the file I<afile>.
fr: Sauf exception mentionnée ci-dessous, les commandes suivent les liens symboliques fournis en argument de ligne de commande. Par exemple, si un lien symbolique I<slink> pointe vers un fichier nommé I<afile>, la commande I<cat slink> affichera le contenu du fichier I<afile>.

note: type: Plain text
en: It is important to realize that this rule includes commands which may optionally traverse file trees; for example, the command I<chown file> is included in this rule, while the command I<chown\ -R file>, which performs a tree traversal, is not.  (The latter is described in the third area, below.)
fr: Notez bien que cette règle s'applique à des commandes qui peuvent dans d'autres situations parcourir l'arborescence, par exemple la commande I<chown file> suit cette règle, alors que I<chown\ -R file>, qui descend l'arborescence, ne la suit pas. (Cette dernière est traitée dans la troisième partie ci-dessous).

note: type: Plain text
en: If it is explicitly intended that the command operate on the symbolic link instead of following the symbolic link\(emfor example, it is desired that I<chown slink> change the ownership of the file that I<slink> is, whether it is a symbolic link or not\(emthe I<-h> option should be used.  In the above example, I<chown root slink> would change the ownership of the file referred to by I<slink>, while I<chown\ -h root slink> would change the ownership of I<slink> itself.
fr: Si on désire qu'une commande agisse sur le lien symbolique lui-même plutôt qu'en le suivant, \(em par exemple si on veut que I<chown slink> change l'appartenance du fichier I<slink>, que ce soit un lien symbolique ou non, \(em l'option I<-h> doit être utilisée. Dans cet exemple, la commande I<chown root slink> modifierait l'appartenance du fichier référencé par I<slink>, tandis que I<chown\ -h root slink> modifierait l'appartenance de I<slink> lui-même.

note: type: Plain text
en: There are some exceptions to this rule:
fr: Il y a quelques exceptions à cette règle :

note: type: Plain text
en: The B<mv>(1)  and B<rm>(1)  commands do not follow symbolic links named as arguments, but respectively attempt to rename and delete them.  (Note, if the symbolic link references a file via a relative path, moving it to another directory may very well cause it to stop working, since the path may no longer be correct.)
fr: Les commandes B<mv>(1) et B<rm>(1) ne suivent pas les liens symboliques fournis en argument, mais essayent respectivement de les renommer ou de les détruire. (Notez que si lorsqu'un lien symbolique fait référence à un fichier par un chemin relatif, il peut cesser de fonctionner si on le déplace dans un autre répertoire où le chemin relatif ne serait plus correct).

note: type: Plain text
en: The B<ls>(1)  command is also an exception to this rule.  For compatibility with historic systems (when B<ls>(1)  is not doing a tree walk\(emthat is, I<-R> option is not specified), the B<ls>(1)  command follows symbolic links named as arguments if the I<-H> or I<-L> option is specified, or if the I<-F>, I<-d>, or I<-l> options are not specified.  (The B<ls>(1)  command is the only command where the I<-H> and I<-L> options affect its behavior even though it is not doing a walk of a file tree.)
fr: La commande B<ls>(1) est aussi une exception à cette règle. Pour assurer la compatibilité avec des systèmes historiques ( quand B<ls>(1) ne descend pas une arborescence \(em c'est-à-dire si l'option I<-R> n'est pas présente), la commande B<ls>(1) suit les liens symboliques fournis en argument si les options I<-H> ou I<-L> sont indiquées, ou si les options I<-F>, I<-d> et I<-l> ne sont pas présentes. (La commande B<ls>(1) est la seule dont les options I<-H> et I<-L> modifient le comportement même lorsqu'elle ne fait pas un parcours d'arborescence).

note: The 4.4BSD system differs from historical 4BSD systems in that the .BR chown (1) and .BR chgrp (1) commands follow symbolic links specified on the command line. type: Plain text
en: The B<file>(1)  command is also an exception to this rule.  The B<file>(1)  command does not follow symbolic links named as argument by default.  The B<file>(1)  command does follow symbolic links named as argument if the I<-L> option is specified.
fr: La commande B<file>(1) est aussi une exception à cette règle. Sauf mention contraire, la commande B<file>(1) ne suit pas les liens symboliques fournis en argument. La commande B<file>(1) ne suit les liens symboliques que si l'option I<-L> est mentionnée.

note: type: SS
en: Commands traversing a file tree
fr: Les commandes parcourant une arborescence

note: type: Plain text
en: The following commands either optionally or always traverse file trees: B<chgrp>(1), B<chmod>(1), B<chown>(1), B<cp>(1), B<du>(1), B<find>(1), B<ls>(1), B<pax>(1), B<rm>(1), and B<tar>(1).
fr: Les commandes suivantes parcourent, toujours ou sur option, l'arborescence des fichiers : B<chgrp>(1), B<chmod>(1), B<chown>(1), B<cp>(1), B<du>(1), B<find>(1), B<ls>(1), B<pax>(1), B<rm>(1) et B<tar>(1).

note: type: Plain text
en: It is important to realize that the following rules apply equally to symbolic links encountered during the file tree traversal and symbolic links listed as command-line arguments.
fr: Il est important de remarquer que les règles ci-dessous s'appliquent tant aux liens symboliques rencontrés durant un parcours d'arborescence qu'aux liens fournis en argument de ligne de commande.

note: type: Plain text
en: The I<first rule> applies to symbolic links that reference files other than directories.  Operations that apply to symbolic links are performed on the links themselves, but otherwise the links are ignored.
fr: La I<première règle> s'applique aux liens qui référencent des fichiers autres que des répertoires. Les opérations entreprises sur ces liens sont appliquées sur les liens eux-mêmes, ou alors les liens sont ignorés.

note: type: Plain text
en: The command I<rm\ -r slink directory> will remove I<slink>, as well as any symbolic links encountered in the tree traversal of I<directory>, because symbolic links may be removed.  In no case will B<rm>(1)  affect the file referred to by I<slink>.
fr: La commande I<rm\ -r slink directory> effacera I<slink>, ainsi que tout lien symbolique rencontré durant le parcours de I<directory>, car les liens symboliques peuvent être effacés. En aucun cas B<rm>(1) ne touchera au fichier référencé par I<slink>.

note: type: Plain text
en: The I<second rule> applies to symbolic links that refer to directories.  Symbolic links that refer to directories are never followed by default.  This is often referred to as a "physical" walk, as opposed to a "logical" walk (where symbolic links the refer to directories are followed).
fr: La I<seconde règle> s'applique aux liens symboliques qui pointent vers des répertoires. Sauf mention contraire, ces liens ne sont jamais suivis. On parle souvent d'un parcours « physique » par opposition à un parcours « logique » (où les liens symboliques vers des répertoires seraient suivis).

note: type: Plain text
en: Certain conventions are (should be) followed as consistently as possible by commands that perform file tree walks:
fr: Certaines conventions sont (ou devraient être) respectées autant que possible par les commandes parcourant des arborescences de fichiers :

note: type: Plain text
en: A command can be made to follow any symbolic links named on the command line, regardless of the type of file they reference, by specifying the I<-H> (for "half-logical") flag.  This flag is intended to make the command-line name space look like the logical name space.  (Note, for commands that do not always do file tree traversals, the I<-H> flag will be ignored if the I<-R> flag is not also specified.)
fr: Une commande peut être forcée à suivre n'importe quel lien symbolique indiqué sur la ligne de commande, quel que soit le type de fichier vers lequel il pointe, en utilisant l'option I<-H> (« half-logical »). Cette option permet d'avoir une représentation des noms sur les lignes de commande conforme à l'espace logique des noms. (Notez que pour les commandes qui ne parcourent pas toujours l'arborescence, l'option I<-H> sera ignorée si l'option I<-R> n'est pas également présente.)

note: type: Plain text
en: For example, the command I<chown\ -HR user slink> will traverse the file hierarchy rooted in the file pointed to by I<slink>.  Note, the I<-H> is not the same as the previously discussed I<-h> flag.  The I<-H> flag causes symbolic links specified on the command line to be dereferenced for the purposes of both the action to be performed and the tree walk, and it is as if the user had specified the name of the file to which the symbolic link pointed.
fr: Par exemple, la commande I<chown\ -HR user slink> parcourra la hiérarchie débutant par le fichier pointé par I<slink>. Remarquez que l'option I<-H> n'est pas la même que l'option I<-h> traitée précédemment. L'option I<-H> permet de suivre les liens symboliques indiqués sur la ligne de commande aussi bien pour l'action à exécuter que pour le parcours de l'arborescence ; tout se passe comme si l'utilisateur avait fourni le nom du fichier référencé par le lien symbolique.

note: type: Plain text
en: A command can be made to follow any symbolic links named on the command line, as well as any symbolic links encountered during the traversal, regardless of the type of file they reference, by specifying the I<-L> (for "logical") flag.  This flag is intended to make the entire name space look like the logical name space.  (Note, for commands that do not always do file tree traversals, the I<-L> flag will be ignored if the I<-R> flag is not also specified.)
fr: Une commande peut être forcée à suivre les liens symboliques sur sa ligne de commande, ainsi que tous les liens rencontrés durant le parcours, quel que soit le type des fichiers qu'ils référencent, en utilisant l'option I<-L> (« logical »). Cette option permet de rendre l'espace réel des noms semblable à l'espace logique. (Notez que les commandes qui ne font pas systématiquement de parcours d'arborescence ignoreront l'option I<-L> si l'option I<-R> n'est pas présente).

note: type: Plain text
en: For example, the command I<chown\ -LR user slink> will change the owner of the file referred to by I<slink>.  If I<slink> refers to a directory, B<chown> will traverse the file hierarchy rooted in the directory that it references.  In addition, if any symbolic links are encountered in any file tree that B<chown> traverses, they will be treated in the same fashion as I<slink>.
fr: Par exemple, la commande I<chown\ -LR user slink> modifiera l'appartenance du fichier référencé par I<slink>. Si I<slink> pointe vers un répertoire, B<chown>(1) descendra l'arborescence à partir de ce répertoire. En outre, si des liens symboliques sont rencontrés pendant le parcours de B<chown>(1), ils seront traités de la même façon que I<slink>.

note: type: Plain text
en: A command can be made to provide the default behavior by specifying the I<-P> (for "physical") flag.  This flag is intended to make the entire name space look like the physical name space.
fr: Une commande peut être forcée à employer le comportement par défaut en utilisant l'option I<-P> (pour « physique »). Cet attribut permet de rendre l'espace des noms semblable à l'espace physique.

note: type: Plain text
en: For commands that do not by default do file tree traversals, the I<-H>, I<-L>, and I<-P> flags are ignored if the I<-R> flag is not also specified.  In addition, you may specify the I<-H>, I<-L>, and I<-P> options more than once; the last one specified determines the command's behavior.  This is intended to permit you to alias commands to behave one way or the other, and then override that behavior on the command line.
fr: Pour les commandes qui ne parcourent pas d'arborescence par défaut, les options I<-H>, I<-L> et I<-P> sont ignorées si l'option I<-R> n'est pas présente. De plus, vous pouvez indiquer I<-H>, I<-L> et I<-P> plusieurs fois ; c'est la dernière option qui déterminera le comportement de la commande. Ceci permet de créer des alias sur des commandes afin d'avoir un comportement choisi, et de surcharger ce comportement en ligne de commande.

note: type: Plain text
en: The B<ls>(1)  and B<rm>(1)  commands have exceptions to these rules:
fr: Les commandes B<ls>(1) et B<rm>(1) présentent des exceptions pour ces règles :

note: type: Plain text
en: The B<rm>(1)  command operates on the symbolic link, and not the file it references, and therefore never follows a symbolic link.  The B<rm>(1)  command does not support the I<-H>, I<-L>, or I<-P> options.
fr: La commande B<rm>(1) agit toujours sur le lien symbolique, et jamais sur le fichier qu'il référence. Ainsi le lien n'est jamais suivi. La commande B<rm>(1) ne prend pas en charge les options I<-H>, I<-L> ou I<-P>.

note: type: Plain text
en: To maintain compatibility with historic systems, the B<ls>(1)  command acts a little differently.  If you do not specify the I<-F>, I<-d> or I<-l> options, B<ls>(1)  will follow symbolic links specified on the command line.  If the I<-L> flag is specified, B<ls>(1)  follows all symbolic links, regardless of their type, whether specified on the command line or encountered in the tree walk.
fr: Afin d'assurer une compatibilité avec systèmes historiques, la commande B<ls>(1) agit quelque peu différemment. Si on ne précise pas d'option I<-F>, I<-d> ou I<-l>, alors B<ls>(1) suivra les liens indiqués sur la ligne de commande. Si l'option I<-L> est mentionnée, B<ls>(1) suivra tous les liens symboliques, quels que soient leurs types, et qu'ils soient fournis sur la ligne de commande ou rencontré en parcourant l'arborescence.

note: type: TH
en: 2014-02-27
fr: 27 février 2014

note: type: Plain text
en: tempnam - create a name for a temporary file
fr: tempnam - Créer un nom de fichier temporaire

note: type: Plain text
en: B<char *tempnam(const char *>I<dir>B<, const char *>I<pfx>B<);>
fr: B<char *tempnam(const char *>I<rep>B<, const char *>I<préfixe>B<);>

note: type: Plain text
en: B<tempnam>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<tempnam>() : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: I<Never use this function.> Use B<mkstemp>(3)  or B<tmpfile>(3)  instead.
fr: I<N'utilisez jamais cette fonction>. Utilisez B<mkstemp>(3) ou B<tmpfile>(3) à la place.

note: type: Plain text
en: The B<tempnam>()  function returns a pointer to a string that is a valid filename, and such that a file with this name did not exist when B<tempnam>()  checked.  The filename suffix of the pathname generated will start with I<pfx> in case I<pfx> is a non-NULL string of at most five bytes.  The directory prefix part of the pathname generated is required to be "appropriate" (often that at least implies writable).
fr: La fonction B<tempnam>() renvoie un pointeur sur un nom de fichier valide, en s'assurant qu'aucun fichier de ce nom n'existe au moment de son invocation. Le nom du fichier commence par le I<préfixe> si celui-ci n'est pas NULL et contient jusqu'à cinq caractères. Le chemin d'accès devant le nom du fichier sera obligatoirement «\ approprié\ » (ce qui implique au minimum qu'on puisse y écrire).

note: type: Plain text
en: Attempts to find an appropriate directory go through the following steps:
fr: L'ordre de recherche du répertoire pour placer le fichier est le suivant\ :

note: type: Plain text
en: In case the environment variable B<TMPDIR> exists and contains the name of an appropriate directory, that is used.
fr: Le répertoire indiqué par la variable d'environnement B<TMPDIR>, si elle existe et contient le nom d'un répertoire «\ approprié\ ».

note: type: Plain text
en: Otherwise, if the I<dir> argument is non-NULL and appropriate, it is used.
fr: Sinon, le répertoire indiqué par l'argument I<rep>, s'il n'est pas NULL et est «\ approprié\ ».

note: type: Plain text
en: Otherwise, I<P_tmpdir> (as defined in I<E<lt>stdio.hE<gt>>)  is used when appropriate.
fr: Sinon, le répertoire défini par I<P_tmpdir> (dans I<E<lt>stdio.hE<gt>>) s'il est «\ approprié\ ».

note: type: Plain text
en: Finally an implementation-defined directory may be used.
fr: Enfin, un répertoire dépendant de l'implémentation (I</tmp> par exemple).

note: type: Plain text
en: The string returned by B<tempnam>()  is allocated using B<malloc>(3)  and hence should be freed by B<free>(3).
fr: La chaîne renvoyée par B<tempnam>() est allouée avec B<malloc>(3) et doit donc être libérée avec B<free>(3).

note: type: Plain text
en: On success, the B<tempnam>()  function returns a pointer to a unique temporary filename.  It returns NULL if a unique name cannot be generated, with I<errno> set to indicate the cause of the error.
fr: Si l'exécution réussit, la fonction B<tempnam>() renvoie un pointeur sur un nom de fichier unique. Elle renvoie NULL si ce nom n'a pas pu être généré, et affecte à I<errno> le code de l'erreur.

note: type: Plain text
en: Allocation of storage failed.
fr: Échec de l'allocation de mémoire.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.  POSIX.1-2008 marks B<tempnam>()  as obsolete.
fr: SVr4, BSD 4.3, POSIX.1-2001. POSIX.1-2008 marque B<tempnam>() comme étant obsolète.

note: type: Plain text
en: Although B<tempnam>()  generates names that are difficult to guess, it is nevertheless possible that between the time that B<tempnam>()  returns a pathname, and the time that the program opens it, another program might create that pathname using B<open>(2), or create it as a symbolic link.  This can lead to security holes.  To avoid such possibilities, use the B<open>(2)  B<O_EXCL> flag to open the pathname.  Or better yet, use B<mkstemp>(3)  or B<tmpfile>(3).
fr: Bien que B<tempnam>() génère des noms difficiles à deviner, il est néanmoins possible qu'entre le moment où B<tempnam>() a renvoyé un nom de fichier, et le moment où le programme crée effectivement ce fichier, un autre programme ait déjà créé ce fichier avec B<open>(2) ou comme un lien symbolique. Ceci peut occasionner des failles de sécurité. Pour éviter ces problèmes, utilisez l'option B<O_EXCL> d'B<open>(2) lors de l'ouverture du fichier. Ou mieux encore, utilisez B<mkstemp>(3) ou B<tmpfile>(3).

note: type: Plain text
en: SUSv2 does not mention the use of B<TMPDIR>; glibc will use it only when the program is not set-user-ID.  On SVr4, the directory used under B<d)> is I</tmp> (and this is what glibc does).
fr: SUSv2 ne mentionne pas l'utilisation de B<TMPDIR>, la glibc ne l'emploiera que si le programme n'est pas setuid. SVr4 indique que le répertoire pour B<d)> est I</tmp> (ce qui correspond à ce que fait la glibc).

note: type: Plain text
en: Because it dynamically allocates memory used to return the pathname, B<tempnam>()  is reentrant, and thus thread safe, unlike B<tmpnam>(3).
fr: Comme la mémoire utilisée pour le nom du fichier est allouée dynamiquement, B<tempnam>() est réentrante, et donc sûre dans un contexte multithread, contrairement à B<tmpnam>(3).

note: type: Plain text
en: The B<tempnam>()  function generates a different string each time it is called, up to B<TMP_MAX> (defined in I<E<lt>stdio.hE<gt>>)  times.  If it is called more than B<TMP_MAX> times, the behavior is implementation defined.
fr: La fonction B<tempnam>() crée une chaîne différente à chaque fois qu'elle est appelée, jusqu'à B<TMP_MAX> (définie dans I<E<lt>stdio.hE<gt>>) fois. Si on l'appelle plus de B<TMP_MAX> fois, le comportement dépend de l'implémentation.

note: type: Plain text
en: B<tempnam>()  uses at most the first five bytes from I<pfx>.
fr: B<tempnam>() utilise au plus les cinq premiers octets de I<préfixe>.

note: type: Plain text
en: The glibc implementation of B<tempnam>()  will fail with the error B<EEXIST> upon failure to find a unique name.
fr: En cas d'échec pour créer un nom de fichier inexistant, l'implémentation de B<tempnam>() de la glibc renverra l'erreur B<EEXIST>.

note: type: Plain text
en: The precise meaning of "appropriate" is undefined; it is unspecified how accessibility of a directory is determined.
fr: La signification précise d'«\ approprié\ » est indéfinie, la détermination des conditions d'accessibilité à un répertoire n'est pas spécifiée.

note: type: Plain text
en: tmpfile - create a temporary file
fr: tmpfile - Créer un fichier temporaire

note: type: Plain text
en: The B<tmpfile>()  function opens a unique temporary file in binary read/write (w+b) mode.  The file will be automatically deleted when it is closed or the program terminates.
fr: La fonction B<tmpfile>() crée un nom de fichier unique, ouvert en lecture/écriture binaire (mode w+b). Le fichier sera automatiquement détruit lors de sa fermeture ou lorsque le programme se termine normalement.

note: type: Plain text
en: The B<tmpfile>()  function returns a stream descriptor, or NULL if a unique filename cannot be generated or the unique file cannot be opened.  In the latter case, I<errno> is set to indicate the error.
fr: La fonction B<tmpfile>() renvoie un pointeur de flux, ou NULL si la création du fichier temporaire est impossible, auquel cas I<errno> indique l'erreur.

note: type: Plain text
en: Search permission denied for directory in file's path prefix.
fr: Autorisation de parcours refusée dans un répertoire du chemin d'accès.

note: type: Plain text
en: Unable to generate a unique filename.
fr: Impossible de créer un nom de fichier unique.

note: type: Plain text
en: The call was interrupted by a signal.
fr: L'appel a été interrompu par un signal.

note: type: Plain text
en: Too many file descriptors in use by the process.
fr: Trop de descripteurs de fichier utilisés par le processus.

note: type: Plain text
en: Too many files open in the system.
fr: Trop de fichiers ouverts sur le système.

note: type: Plain text
en: There was no room in the directory to add the new filename.
fr: Pas assez de place dans le répertoire pour ajouter un fichier.

note: type: Plain text
en: Read-only filesystem.
fr: Système de fichiers en lecture seule.

note: type: Plain text
en: SVr4, 4.3BSD, C89, C99, SUSv2, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, C89, C99, SUSv2, POSIX.1-2001.

note: type: Plain text
en: POSIX.1-2001 specifies: an error message may be written to I<stdout> if the stream cannot be opened.
fr: POSIX.1-2001 spécifie : un message d'erreur peut être écrit sur I<stdout> si le flux ne peut pas être ouvert.

note: type: Plain text
en: The standard does not specify the directory that B<tmpfile>()  will use.  Glibc will try the path prefix I<P_tmpdir> defined in I<E<lt>stdio.hE<gt>>, and if that fails the directory I</tmp>.
fr: Le standard ne précise pas le répertoire employé par B<tmpfile>(). La glibc essaiera d'utiliser le préfixe I<P_tmpdir> défini dans I<E<lt>stdio.hE<gt>>, puis I</tmp> en cas d'échec.

note: type: Plain text
en: tmpnam, tmpnam_r - create a name for a temporary file
fr: tmpnam, tmpnam_r - Créer un nom de fichier temporaire

note: type: Plain text
en: B<Note:> Avoid use of B<tmpnam>(); use B<mkstemp>(3)  or B<tmpfile>(3)  instead.
fr: B<Note:> évitez d'utiliser B<tmpnam>(). Utilisez B<mkstemp>(3) ou B<tmpfile>(3) à la place.

note: type: Plain text
en: The B<tmpnam>()  function returns a pointer to a string that is a valid filename, and such that a file with this name did not exist at some point in time, so that naive programmers may think it a suitable name for a temporary file.  If the argument I<s> is NULL, this name is generated in an internal static buffer and may be overwritten by the next call to B<tmpnam>().  If I<s> is not NULL, the name is copied to the character array (of length at least I<L_tmpnam>)  pointed to by I<s> and the value I<s> is returned in case of success.
fr: La fonction B<tmpnam>() renvoie un pointeur sur une chaîne qui représente un nom de fichier valide, qui n'existait pas quelques instants auparavant. Ainsi, un programmeur naïf peut croire qu'il s'agit d'un nom correct pour créer un fichier temporaire. Si l'argument I<s> est NULL, ce nom est stocké dans un tampon interne qui pourra être écrasé lors du prochain appel à B<tmpnam>(). Si I<s> est non NULL, le nom y est copié (le tampon doit faire au moins I<L_tmpnam> octets) et la valeur de I<s> est renvoyée si la fonction réussit.

note: type: Plain text
en: The pathname that is created, has a directory prefix I<P_tmpdir>.  (Both I<L_tmpnam> and I<P_tmpdir> are defined in I<E<lt>stdio.hE<gt>>, just like the B<TMP_MAX> mentioned below.)
fr: Le nom de fichier qui est créé est préfixé par I<P_tmpdir>. Les constantes I<L_tmpnam> et I<P_tmpdir> sont définies dans I<E<lt>stdio.hE<gt>> comme B<TMP_MAX> mentionné plus bas.

note: type: Plain text
en: The B<tmpnam>()  function returns a pointer to a unique temporary filename, or NULL if a unique name cannot be generated.
fr: La fonction B<tmpnam>() renvoie un pointeur sur un nom de fichier temporaire unique, ou NULL si l'unicité n'a pas pu être assurée.

note: type: Plain text
en: No errors are defined.
fr: Aucune erreur n'est définie.

note: type: Plain text
en: The B<tmpnam>()  function is thread-safe with exceptions.  It is not thread-safe if called with a NULL parameter.
fr: La fonction B<tmpnam>() est sûre dans un contexte multithread avec exceptions. Elle n’est pas sûre dans un contexte multithread si appelées avec un paramètre NULL.

note: type: Plain text
en: The B<tmpnam_r>()  function is thread-safe.
fr: La fonction B<tmpnam_r>() est sûre dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, C89, C99, POSIX.1-2001.  POSIX.1-2008 marks B<tmpnam>()  as obsolete.
fr: SVr4, BSD 4.3, C89, C99, POSIX.1-2001. POSIX.1-2008 marque B<tmpnam>() comme étant obsolète.

note: type: Plain text
en: The B<tmpnam>()  function generates a different string each time it is called, up to B<TMP_MAX> times.  If it is called more than B<TMP_MAX> times, the behavior is implementation defined.
fr: La fonction B<tmpnam>() engendre une nouvelle chaîne à chaque appel, jusqu'à B<TMP_MAX> fois. Si on l'invoque plus de B<TMP_MAX> fois, le comportement dépend de l'implémentation.

note: type: Plain text
en: Although B<tmpnam>()  generates names that are difficult to guess, it is nevertheless possible that between the time that B<tmpnam>()  returns a pathname, and the time that the program opens it, another program might create that pathname using B<open>(2), or create it as a symbolic link.  This can lead to security holes.  To avoid such possibilities, use the B<open>(2)  B<O_EXCL> flag to open the pathname.  Or better yet, use B<mkstemp>(3)  or B<tmpfile>(3).
fr: Bien que B<tmpnam>() génère des noms difficiles à deviner, il est néanmoins possible qu'entre le moment où B<tmpnam>() a renvoyé un nom de fichier, et le moment où le programme crée effectivement ce fichier, un autre programme ait déjà créé ce fichier avec B<open>(2) ou comme un lien symbolique. Ceci peut occasionner des failles de sécurité. Pour éviter ces problèmes, utilisez l'option B<O_EXCL> d'B<open>(2) lors de l'ouverture du fichier. Ou mieux encore, utilisez B<mkstemp>(3) ou B<tmpfile>(3).

note: type: Plain text
en: Portable applications that use threads cannot call B<tmpnam>()  with a NULL argument if either B<_POSIX_THREADS> or B<_POSIX_THREAD_SAFE_FUNCTIONS> is defined.
fr: Les applications portables qui utilisent les threads ne peuvent pas appeler B<tmpnam>() avec un paramètre NULL si B<_POSIX_THREADS> ou B<_POSIX_THREAD_SAFE_FUNCTIONS> sont définies.

note: type: Plain text
en: A POSIX draft proposed to use a function B<tmpnam_r>()  defined by
fr: Un brouillon POSIX proposait l'utilisation d'une fonction B<tmpnam_r>() définie par

note: type: Plain text
en: apparently as a warning not to use NULL.  A few systems implement it.  To get a glibc prototype for this function from I<E<lt>stdio.hE<gt>>, define B<_SVID_SOURCE> or B<_BSD_SOURCE> (before including I<any> header file).
fr: apparemment comme une précaution pour ne pas utiliser NULL. Quelques systèmes l'implémentent. Pour obtenir le prototype de la glibc, définissez B<_SVID_SOURCE> ou B<_BSD_SOURCE> (avant d'inclure I<tout> fichier d'en\(hytête).

note: type: Plain text
en: Never use this function.  Use B<mkstemp>(3)  or B<tmpfile>(3)  instead.
fr: N'utilisez jamais cette routine. Utilisez B<mkstemp>(3) ou B<tmpfile>(3) à la place.

note: type: Plain text
en: unlink, unlinkat - delete a name and possibly the file it refers to
fr: unlink, unlinkat - Détruire un nom et éventuellement le fichier associé

note: type: Plain text
en: B<unlink>()  deletes a name from the filesystem.  If that name was the last link to a file and no processes have the file open, the file is deleted and the space it was using is made available for reuse.
fr: B<unlink>() détruit un nom dans le système de fichiers. Si ce nom était le dernier lien sur un fichier, et si aucun processus n'a ouvert ce fichier, ce dernier est effacé, et l'espace qu'il utilisait est rendu disponible.

note: type: Plain text
en: If the name was the last link to a file but any processes still have the file open, the file will remain in existence until the last file descriptor referring to it is closed.
fr: Si le nom était le dernier lien sur un fichier, mais qu'un processus conserve encore le fichier ouvert, celui-ci continue d'exister jusqu'à ce que le dernier descripteur le référençant soit fermé.

note: type: Plain text
en: If the name referred to a socket, FIFO, or device, the name for it is removed but processes which have the object open may continue to use it.
fr: Si le nom correspond à une socket, une FIFO, ou un périphérique, le nom est supprimé mais les processus qui ont ouvert l'objet peuvent continuer à l'utiliser.

note: type: Plain text
en: The B<unlinkat>()  system call operates in exactly the same way as either B<unlink>()  or B<rmdir>(2)  (depending on whether or not I<flags> includes the B<AT_REMOVEDIR> flag)  except for the differences described here.
fr: L'appel système B<unlinkat>() fonctionne exactement comme B<unlink>(2) ou B<rmdir>(2) (en fonction de la présence ou non du drapeau B<AT_REMOVEDIR> dans I<flags>), les seules différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<pathname> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<unlink>()  and B<rmdir>(2)  for a relative pathname).
fr: Si le chemin donné dans I<pathname> est relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier I<dirfd> (plutôt que par rapport au répertoire de travail, comme c'est le cas pour B<unlink>() et B<rmdir>(2)).

note: type: Plain text
en: If the pathname given in I<pathname> is relative and I<dirfd> is the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the calling process (like B<unlink>()  and B<rmdir>(2)).
fr: Si le chemin donné dans I<pathname> est relatif et si I<dirfd> a la valeur spéciale B<AT_FDCWD>, alors I<pathname> est interprété par rapport au répertoire de travail du processus appelant (comme pour B<unlink>() et B<rmdir>(2)).

note: type: Plain text
en: If the pathname given in I<pathname> is absolute, then I<dirfd> is ignored.
fr: Si le chemin donné dans I<pathname> est absolu, I<dirfd> est ignoré.

note: type: Plain text
en: I<flags> is a bit mask that can either be specified as 0, or by ORing together flag values that control the operation of B<unlinkat>().  Currently only one such flag is defined:
fr: I<flags> est un masque qui peut être 0 ou construit par un OU binaire de drapeaux qui contrôlent le fonctionnement de B<unlinkat>(). Actuellement, un seul drapeau est défini\ :

note: type: Plain text
en: By default, B<unlinkat>()  performs the equivalent of B<unlink>()  on I<pathname>.  If the B<AT_REMOVEDIR> flag is specified, then performs the equivalent of B<rmdir>(2)  on I<pathname>.
fr: Par défaut, B<unlinkat>() a un effet équivalent à celui de B<unlink>() sur I<pathname>. Si le drapeau B<AT_REMOVEDIR> est indiqué, B<unlinkat>() fonctionne comme B<rmdir>(2) sur I<pathname>.

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<unlinkat>().
fr: Consultez B<openat>(2) pour une explication de la nécessité de B<unlinkat>().

note: type: Plain text
en: Write access to the directory containing I<pathname> is not allowed for the process's effective UID, or one of the directories in I<pathname> did not allow search permission.  (See also B<path_resolution>(7).)
fr: L'accès en écriture au répertoire contenant I<pathname> n'est pas autorisé pour l'UID effectif du processus, ou bien l'un des répertoires de I<pathname> n'autorise pas le parcours. (Consultez aussi B<path_resolution>(7).)

note: type: Plain text
en: The file I<pathname> cannot be unlinked because it is being used by the system or another process; for example, it is a mount point or the NFS client software created it to represent an active but otherwise nameless inode ("NFS silly renamed").
fr: Le fichier I<pathname> ne peut pas être détruit avec unlink car il est utilisé par le système ou par un autre processus\ ; par exemple, il s'agit d'un point de montage, ou le logiciel client NFS l'a créé pour représenter un inœud actif, mais sinon sans nom («\ I<NFS silly renamed>\ »).

note: type: Plain text
en: I<pathname> refers to a directory.  (This is the non-POSIX value returned by Linux since 2.1.132.)
fr: I<pathname> est un répertoire. (Il s'agit d'une erreur non-POSIX renvoyée par Linux depuis le 2.1.132).

note: type: Plain text
en: Too many symbolic links were encountered in translating I<pathname>.
fr: Trop de liens symboliques dans le chemin d'accès I<pathname>.

note: type: Plain text
en: A component in I<pathname> does not exist or is a dangling symbolic link, or I<pathname> is empty.
fr: Un répertoire dans le chemin d'accès I<pathname> n'existe pas ou est un lien symbolique pointant nulle part, ou I<pathname> est vide

note: type: Plain text
en: A component used as a directory in I<pathname> is not, in fact, a directory.
fr: Un élément du chemin d'accès I<pathname> n'est pas un répertoire.

note: type: Plain text
en: The system does not allow unlinking of directories, or unlinking of directories requires privileges that the calling process doesn't have.  (This is the POSIX prescribed error return; as noted above, Linux returns B<EISDIR> for this case.)
fr: Le système ne permet pas la destruction des répertoires avec unlink, ou cette destruction nécessite des privilèges que le processus appelant n'a pas. (Il s'agit d'une erreur conseillée par POSIX. Comme précisé plus haut, Linux renvoie B<EISDIR> dans ce cas.)

note: type: TP
en: B<EPERM> (Linux only)
fr: B<EPERM> (spécifique Linux)

note: type: Plain text
en: The filesystem does not allow unlinking of files.
fr: Le système de fichiers ne permet pas la destruction avec unlink.

note: type: Plain text
en: The directory containing I<pathname> has the sticky bit (B<S_ISVTX>)  set and the process's effective UID is neither the UID of the file to be deleted nor that of the directory containing it, and the process is not privileged (Linux: does not have the B<CAP_FOWNER> capability).
fr: Le répertoire contenant I<pathname> a son sticky bit (B<S_ISVTX>) à 1, et l'UID effectif du processus n'est ni celui du fichier ni celui du répertoire et le processus n'est pas privilégié (sous Linux\ : n'a pas la capacité B<CAP_FOWNER>.

note: type: Plain text
en: I<pathname> refers to a file on a read-only filesystem.
fr: I<pathname> est placé sur un système de fichiers en lecture seule.

note: type: Plain text
en: The same errors that occur for B<unlink>()  and B<rmdir>(2)  can also occur for B<unlinkat>().  The following additional errors can occur for B<unlinkat>():
fr: Les erreurs supplémentaires suivantes peuvent également se produire pour B<unlinkat>() :

note: type: Plain text
en: I<pathname> refers to a directory, and B<AT_REMOVEDIR> was not specified in I<flags>.
fr: I<pathname> est un répertoire et B<AT_REMOVEDIR> n’était pas indiqué dans I<flags>.

note: type: Plain text
en: B<unlinkat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<unlinkat>() a été ajouté au noyau Linux dans sa version 2.6.16 ; la glibc le gère depuis la version 2.4.

note: SVr4 documents additional error conditions EINTR, EMULTIHOP, ETXTBSY, ENOLINK. type: Plain text
en: B<unlink>(): SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.
fr: B<unlink>() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.

note: type: Plain text
en: B<unlinkat>(): POSIX.1-2008.
fr: B<unlinkat>() : POSIX.1-2008.

note: type: TH
en: 2008-08-29
fr: 29 août 2008

note: type: Plain text
en: getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - nonlocking stdio functions
fr: getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - Fonctions stdio non bloquantes

note: type: Plain text
en: B<getc_unlocked>(), B<getchar_unlocked>(), B<putc_unlocked>(), B<putchar_unlocked>():
fr: B<getc_unlocked>(), B<getchar_unlocked>(), B<putc_unlocked>(), B<putchar_unlocked>()\ :

note: type: Plain text
en: B<clearerr_unlocked>(), B<feof_unlocked>(), B<ferror_unlocked>(), B<fileno_unlocked>(), B<fflush_unlocked>(), B<fgetc_unlocked>(), B<fputc_unlocked>(), B<fread_unlocked>(), B<fwrite_unlocked>():
fr: B<clearerr_unlocked>(), B<feof_unlocked>(), B<ferror_unlocked>(), B<fileno_unlocked>(), B<fflush_unlocked>(), B<fgetc_unlocked>(), B<fputc_unlocked>(), B<fread_unlocked>(), B<fwrite_unlocked>() :

note: type: Plain text
en: B<fgets_unlocked>(), B<fputs_unlocked>(), B<getwc_unlocked>(), B<getwchar_unlocked>(), B<fgetwc_unlocked>(), B<fputwc_unlocked>(), B<putwchar_unlocked>(), B<fgetws_unlocked>(), B<fputws_unlocked>():
fr: B<fgets_unlocked>(), B<fputs_unlocked>(), B<getwc_unlocked>(), B<getwchar_unlocked>(), B<fgetwc_unlocked>(), B<fputwc_unlocked>(), B<putwchar_unlocked>(), B<fgetws_unlocked>(), B<fputws_unlocked>() :

note: type: Plain text
en: Each of these functions has the same behavior as its counterpart without the "_unlocked" suffix, except that they do not use locking (they do not set locks themselves, and do not test for the presence of locks set by others) and hence are thread-unsafe.  See B<flockfile>(3).
fr: Toutes ces fonctions se comportent de la même façon que leurs homonymes sans le suffixe «\ _unlocked\ », si ce n'est qu'elles n'utilisent pas de verrouillage (elles ne positionnent pas les verrous elles-mêmes, et ne testent pas la présence éventuelle de verrous positionnés par les autres) et ne sont donc pas adaptées à un contexte multithread. Consultez B<flockfile>(3).

note: type: Plain text
en: The four functions B<getc_unlocked>(), B<getchar_unlocked>(), B<putc_unlocked>(), B<putchar_unlocked>()  are in POSIX.1-2001.
fr: Les quatre fonctions B<getc_unlocked>(), B<getchar_unlocked>(), B<putc_unlocked>(), B<putchar_unlocked>() apparaissent dans POSIX.1-2001.

note: E.g., in HP-UX 10.0. In HP-UX 10.30 they are called obsolescent, and moved to a compatibility library. Available in HP-UX 10.0: clearerr_unlocked, fclose_unlocked, feof_unlocked, ferror_unlocked, fflush_unlocked, fgets_unlocked, fgetwc_unlocked, fgetws_unlocked, fileno_unlocked, fputs_unlocked, fput
en: The nonstandard B<*_unlocked>()  variants occur on a few UNIX systems, and are available in recent glibc.  They should probably not be used.
fr: Les variantes B<*_unlocked>() non standard sont présentes sur quelques systèmes UNIX et sont disponibles dans les versions récentes de la glibc. Elles ne devraient sans doute pas être utilisées.

note: type: Plain text
en: wprintf, fwprintf, swprintf, vwprintf, vfwprintf, vswprintf - formatted wide-character output conversion
fr: wprintf, fwprintf, swprintf, vwprintf, vfwprintf, vswprintf - Formater des chaînes de caractères larges

note: type: Plain text
en: or I<cc\ -std=c99>
fr: ou I<cc\ -std=c99>

note: type: Plain text
en: The B<wprintf>()  family of functions is the wide-character equivalent of the B<printf>(3)  family of functions.  It performs formatted output of wide characters.
fr: La famille de fonctions B<wprintf>() est l'équivalent pour les caractères larges de la famille de fonctions B<printf>(3). Elle réalise une mise en forme des caractères larges.

note: type: Plain text
en: The B<wprintf>()  and B<vwprintf>()  functions perform wide-character output to I<stdout>.  I<stdout> must not be byte oriented; see B<fwide>(3)  for more information.
fr: Les fonctions B<wprintf>() et B<vwprintf>() réalisent le traitement et la sortie de chaînes de caractères larges sur I<stdout>. I<stdout> ne doit pas être orienté caractères (consultez B<fwide>(3) pour plus d'informations).

note: type: Plain text
en: The B<fwprintf>()  and B<vfwprintf>()  functions perform wide-character output to I<stream>.  I<stream> must not be byte oriented; see B<fwide>(3)  for more information.
fr: Les fonctions B<fwprintf>() et B<vfwprintf>() réalisent la mise en forme de chaînes de caractères larges en vue d'une écriture dans le fichier I<stream>. I<stream> ne doit pas être orienté caractères (consultez B<fwide>(3) pour plus d'informations).

note: type: Plain text
en: The B<swprintf>()  and B<vswprintf>()  functions perform wide-character output to an array of wide characters.  The programmer must ensure that there is room for at least I<maxlen> wide characters at I<wcs>.
fr: Les fonctions B<swprintf>() et B<vswprintf>() réalisent la mise en forme d'une chaîne de caractères larges avant de l'écrire dans un tableau de caractères larges. Le programmeur doit s'assurer qu'il y ait assez de place pour au moins I<maxlen> caractères larges dans I<wcs>.

note: type: Plain text
en: These functions are like the B<printf>(3), B<vprintf>(3), B<fprintf>(3), B<vfprintf>(3), B<sprintf>(3), B<vsprintf>(3)  functions except for the following differences:
fr: Ces fonctions se comportent de la même manière que les fonctions B<printf>(3), B<vprintf>(3), B<fprintf>(3), B<vfprintf>(3), B<sprintf>(3) et B<vsprintf>(3), hormis les différences suivantes\ :

note: type: Plain text
en: The I<format> string is a wide-character string.
fr: La chaîne I<format> est composée de caractères larges.

note: type: Plain text
en: The output consists of wide characters, not bytes.
fr: La sortie est faite de caractères larges, pas d'octets.

note: type: Plain text
en: B<swprintf>()  and B<vswprintf>()  take a I<maxlen> argument, B<sprintf>(3)  and B<vsprintf>(3)  do not.  (B<snprintf>(3)  and B<vsnprintf>(3)  take a I<maxlen> argument, but these functions do not return -1 upon buffer overflow on Linux.)
fr: B<swprintf>() et B<vswprintf>() prennent un argument I<maxlen>, contrairement à B<sprintf>(3) et B<vsprintf>(3) (B<snprintf>(3) et B<vsnprintf>(3) prennent un argument I<maxlen>, mais ces fonctions ne renvoient pas -1 en cas de débordement mémoire sous Linux).

note: type: Plain text
en: The treatment of the conversion characters B<c> and B<s> is different:
fr: Le traitement des caractères de conversion B<c> et B<s> est différent\ :

note: type: Plain text
en: If no B<l> modifier is present, the I<int> argument is converted to a wide character by a call to the B<btowc>(3)  function, and the resulting wide character is written.  If an B<l> modifier is present, the I<wint_t> (wide character) argument is written.
fr: Si aucun modificateur B<l> n'est présent, l'argument I<int> est converti en un caractère large par un appel à la fonction B<btowc>(3) et le caractère large en résultant est écrit. Si un modificateur B<l> est présent, l'argument I<wint_t> (caractère large) est écrit.

note: type: Plain text
en: If no B<l> modifier is present: The I<const\ char\ *> argument is expected to be a pointer to an array of character type (pointer to a string) containing a multibyte character sequence beginning in the initial shift state.  Characters from the array are converted to wide characters (each by a call to the B<mbrtowc>(3)  function with a conversion state starting in the initial state before the first byte).  The resulting wide characters are written up to (but not including) the terminating null wide character (L\(aq\e0\(aq).  If a precision is specified, no more wide characters than the number specified are written.  Note that the precision determines the number of I<wide characters> written, not the number of I<bytes> or I<screen positions>.  The array must contain a terminating null byte (\(aq\e0\(aq), unless a precision is given and it is so small that the number of converted wide characters reaches it before the end of the array is reached.  If an B<l> modifier is present: The I<const\ wchar_t\ *> argument is expected to be a pointer to an array of wide characters.  Wide characters from the array are written up to (but not including) a terminating null wide character.  If a precision is specified, no more than the number specified are written.  The array must contain a terminating null wide character, unless a precision is given and it is smaller than or equal to the number of wide characters in the array.
fr: Si aucun modificateur B<l> n'est présent, l'argument I<const\ char\ *> est interprété comme un pointeur sur un tableau de caractères (une chaîne) contenant une séquence de caractères larges commençant à l'état initial. Les caractères du tableau sont convertis en caractères larges (un par un par l'appel de la fonction B<mbrtowc>(3) avec un état de conversion réinitialisé avant le premier octet). La chaîne de caractères larges en résultant est écrite jusqu'au dernier caractère (non compris), le caractère nul final (L\(aq\e0\(aq)). Si la taille est donnée, le nombre de caractères larges écrits ne la dépassera pas. Notez bien que la taille détermine le nombre de I<caractères larges> écrits et non le nombre d'I<octets> ou de I<positions d'écran>. Le tableau doit contenir un octet nul final (L\(aq\e0\(aq), à moins que la taille donnée soit si petite que le nombre de caractères larges est atteint avant la fin du tableau. Si un modificateur B<l> est présent\ : l'argument I<const\ wchar_t\ *> est interprété comme un pointeur sur un tableau de caractères larges. Les caractères larges du tableau sont écrits jusqu'au dernier (non compris le caractère nul final). Si la taille est indiquée, le nombre de caractères écrits ne la dépassera pas. Le tableau doit contenir un caractère nul final à moins que la taille donnée soit inférieure ou égale au nombre de caractères larges du tableau.

note: type: Plain text
en: The functions return the number of wide characters written, excluding the terminating null wide character in case of the functions B<swprintf>()  and B<vswprintf>().  They return -1 when an error occurs.
fr: Ces fonctions renvoient le nombre de caractères larges écrits, non compris le caractère nul final dans le cas des fonctions B<swprintf>() et B<vswprintf>(). Elles renvoient -1 en cas d'erreur.

note: type: Plain text
en: The behavior of B<wprintf>()  et al. depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<wprintf>() et compagnie dépend de la catégorie B<LC_CTYPE> de la locale utilisée.

note: type: Plain text
en: If the I<format> string contains non-ASCII wide characters, the program will work correctly only if the B<LC_CTYPE> category of the current locale at run time is the same as the B<LC_CTYPE> category of the current locale at compile time.  This is because the I<wchar_t> representation is platform- and locale-dependent.  (The glibc represents wide characters using their Unicode (ISO-10646) code point, but other platforms don't do this.  Also, the use of C99 universal character names of the form \eunnnn does not solve this problem.)  Therefore, in internationalized programs, the I<format> string should consist of ASCII wide characters only, or should be constructed at run time in an internationalized way (e.g., using B<gettext>(3)  or B<iconv>(3), followed by B<mbstowcs>(3)).
fr: Si la chaîne I<format> contient des caractères larges non ASCII, le programme ne fonctionnera correctement que si la catégorie B<LC_CTYPE> de la localisation lors de l'exécution est la même que lors de la compilation. En effet, la représentation de I<wchar_t> dépend de l'architecture et de la localisation. La glibc représente les caractères larges à l'aide de leurs codes Unicode (ISO-10646), mais les autres architectures ne font pas de même. De plus, l'utilisation des noms de caractères universels de C99 (de la forme \eunnnn) ne résout pas ce problème. Aussi, la chaîne I<format> ne devrait être constituée que de caractères larges dans les programmes internationalisés, ou alors elle doit être construite à l'exécution de manière internationalisée (en utilisant par exemple B<gettext>(3) ou B<iconv>(3), suivi de B<mbstowcs>(3)).

note: type: TH
en: 2013-01-27
fr: 27 janvier 2013

note: type: Plain text
en: write - write to a file descriptor
fr: write - Écrire dans un descripteur de fichier

note: type: Plain text
en: B<write>()  writes up to I<count> bytes from the buffer pointed I<buf> to the file referred to by the file descriptor I<fd>.
fr: B<write>() lit au maximum I<count> octets dans la zone mémoire pointée par I<buf>, et les écrit dans le fichier référencé par le descripteur I<fd>.

note: type: Plain text
en: The number of bytes written may be less than I<count> if, for example, there is insufficient space on the underlying physical medium, or the B<RLIMIT_FSIZE> resource limit is encountered (see B<setrlimit>(2)), or the call was interrupted by a signal handler after having written less than I<count> bytes.  (See also B<pipe>(7).)
fr: Le nombre d'octets écrits peut être inférieur à I<count> par exemple si la place disponible sur le périphérique est insuffisante, ou la limite de ressource B<RLIMIT_FSIZE> est atteinte (consultez B<setrlimit>(2)), ou l'appel est interrompu par un gestionnaire de signal après avoir écrit moins de I<count> octets. (Consultez aussi B<pipe>(7).)

note: type: Plain text
en: For a seekable file (i.e., one to which B<lseek>(2)  may be applied, for example, a regular file)  writing takes place at the current file offset, and the file offset is incremented by the number of bytes actually written.  If the file was B<open>(2)ed with B<O_APPEND>, the file offset is first set to the end of the file before writing.  The adjustment of the file offset and the write operation are performed as an atomic step.
fr: Pour un fichier sur lequel B<lseek>(2) est possible (par exemple un fichier ordinaire), l'écriture a lieu à la position actuelle dans le fichier, et elle est déplacée du nombre d'octets effectivement écrits. Si le fichier était ouvert avec B<O_APPEND>, la position avant l'écriture est à la fin du fichier. La modification de la position et l'écriture sont effectuées de façon atomique.

note: type: Plain text
en: POSIX requires that a B<read>(2)  which can be proved to occur after a B<write>()  has returned returns the new data.  Note that not all filesystems are POSIX conforming.
fr: POSIX réclame qu'une lecture avec B<read>(2) effectuée après le retour d'une écriture avec B<write>(), renvoie les nouvelles données. Notez que tous les systèmes de fichiers ne sont pas compatibles avec POSIX.

note: type: Plain text
en: On success, the number of bytes written is returned (zero indicates nothing was written).  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<write>() renvoie le nombre d'octets écrits (0 signifiant aucune écriture), ou -1 s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: If I<count> is zero and I<fd> refers to a regular file, then B<write>()  may return a failure status if one of the errors below is detected.  If no errors are detected, 0 will be returned without causing any other effect.  If I<count> is zero and I<fd> refers to a file other than a regular file, the results are not specified.
fr: Si I<count> vaut 0 et si I<fd> correspond à un fichier ordinaire, B<write>() peut renvoyer un code d'erreur si l'une des erreurs ci-dessous est détectée. Si aucune erreur n'est détectée, 0 sera renvoyé sans autre effet de bord. Si I<count> est nul et I<fd> est un fichier spécial, les résultats sont indéfinis.

note: type: Plain text
en: The file descriptor I<fd> refers to a file other than a socket and has been marked nonblocking (B<O_NONBLOCK>), and the write would block.
fr: Le descripteur de fichier I<fd> fait référence à un fichier autre qu'une socket et a été marqué comme non bloquant (B<O_NONBLOCK>), et l'écriture devrait bloquer.

note: Actually EAGAIN on Linux type: Plain text
en: The file descriptor I<fd> refers to a socket and has been marked nonblocking (B<O_NONBLOCK>), and the write would block.  POSIX.1-2001 allows either error to be returned for this case, and does not require these constants to have the same value, so a portable application should check for both possibilities.
fr: Le descripteur de fichier I<fd> fait référence à un fichier autre qu'une socket et a été marqué comme non bloquant (B<O_NONBLOCK>), et l'écriture devrait bloquer. POSIX.1-2001 permet de renvoyer l'une ou l'autre des erreurs dans ce cas et n'exige pas que ces constantes aient la même valeur. Une application portable devrait donc tester les deux possibilités.

note: type: Plain text
en: I<fd> is not a valid file descriptor or is not open for writing.
fr: I<fd> n'est pas un descripteur de fichier valable, ou n'est pas ouvert en écriture.

note: type: Plain text
en: I<fd> refers to a datagram socket for which a peer address has not been set using B<connect>(2).
fr: I<fd> fait référence à une socket de datagramme pour laquelle l'adresse du correspondant n'a pas été initialisée avec B<connect>(2).

note: type: Plain text
en: The user's quota of disk blocks on the filesystem containing the file referred to by I<fd> has been exhausted.
fr: Le quota de blocs de disque de l'utilisateur sur le système de fichiers contenant le fichier correspondant à I<fd> a été atteint.

note: type: Plain text
en: An attempt was made to write a file that exceeds the implementation-defined maximum file size or the process's file size limit, or to write at a position past the maximum allowed offset.
fr: Tentative d'écrire un fichier dont la taille dépasse un maximum dépendant de l'implémentation ou du processus, ou d'écrire à une position qui dépasse le maximum autorisé.

note: type: Plain text
en: The call was interrupted by a signal before any data was written; see B<signal>(7).
fr: L'appel système a été interrompu par un signal avant d'avoir pu écrire quoi que ce soit ; consultez B<signal>(7).

note: type: Plain text
en: I<fd> is attached to an object which is unsuitable for writing; or the file was opened with the B<O_DIRECT> flag, and either the address specified in I<buf>, the value specified in I<count>, or the current file offset is not suitably aligned.
fr: I<fd> correspond à un objet sur lequel il est impossible d'écrire. Ou bien le fichier a été ouvert avec l'attribut B<O_DIRECT>, et soit l'adresse de I<buf>, soit la valeur de I<count>, soit la position actuelle dans le fichier ne sont pas alignées correctement.

note: type: Plain text
en: A low-level I/O error occurred while modifying the inode.
fr: Une erreur d'entrée-sortie bas niveau s'est produite durant la modification de l'inœud.

note: type: Plain text
en: The device containing the file referred to by I<fd> has no room for the data.
fr: Le périphérique correspondant à I<fd> n'a plus de place disponible.

note: type: Plain text
en: I<fd> is connected to a pipe or socket whose reading end is closed.  When this happens the writing process will also receive a B<SIGPIPE> signal.  (Thus, the write return value is seen only if the program catches, blocks or ignores this signal.)
fr: I<fd> est connecté à un tube (pipe) ou une socket dont l'autre extrémité est fermée. Quand ceci se produit, le processus écrivain reçoit un signal B<SIGPIPE>. (Ainsi la valeur de retour de write n'est vue que si le programme intercepte, bloque ou ignore ce signal.

note: type: Plain text
en: Other errors may occur, depending on the object connected to I<fd>.
fr: D'autres erreurs peuvent se produire suivant le type d'objet associé à I<fd>.

note: type: Plain text
en: Under SVr4 a write may be interrupted and return B<EINTR> at any point, not just before any data is written.
fr: Sous SVr4, un appel B<write>() peut être interrompu, et renvoyer B<EINTR> à n'importe quel moment, pas seulement avant l'écriture des données.

note: type: Plain text
en: A successful return from B<write>()  does not make any guarantee that data has been committed to disk.  In fact, on some buggy implementations, it does not even guarantee that space has successfully been reserved for the data.  The only way to be sure is to call B<fsync>(2)  after you are done writing all your data.
fr: Une réussite de B<write>() n'offre aucune garantie que les données se trouvent sur le disque. En fait, sur certaines implémentations erronées, elle ne garantit même pas que l'espace suffisant a été réservé pour les données. La seule manière d'être sûr de la réussite est d'invoquer B<fsync>(2) après avoir écrit les données.

note: type: Plain text
en: If a B<write>()  is interrupted by a signal handler before any bytes are written, then the call fails with the error B<EINTR>; if it is interrupted after at least one byte has been written, the call succeeds, and returns the number of bytes written.
fr: Si un B<write>() est interrompu par un gestionnaire de signaux avant d'avoir écrit quoi que ce soit, l'appel échoue avec B<EINTR>\ ; s'il est interrompu après avoir écrit au moins un octet, l'appel réussit et renvoie le nombre d'octets écrits.
