perkamon - en to fr translation catalogue (821 entries)

note: type: TH
en: 2013-10-07
fr: 7 octobre 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: adjtime - correct the time to synchronize the system clock
fr: adjtime - Ajuster le temps pour synchroniser l'horloge système

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: type: Plain text
en: B<adjtime>(): _BSD_SOURCE
fr: B<adjtime>()\ : _BSD_SOURCE

note: type: Plain text
en: The B<adjtime>()  function gradually adjusts the system clock (as returned by B<gettimeofday>(2)).  The amount of time by which the clock is to be adjusted is specified in the structure pointed to by I<delta>.  This structure has the following form:
fr: La fonction B<adjtime>() ajuste graduellement l'horloge système (comme renvoyée par B<gettimeofday>(2)). La quantité de temps avec laquelle l'horloge système doit être ajustée est spécifiée par la structure pointée par I<delta>. Cette structure a la forme suivante\ :

note: type: Plain text
en: struct timeval {
        time_t      tv_sec;     /* seconds */
        suseconds_t tv_usec;    /* microseconds */
    };
fr: struct timeval {
        time_t      tv_sec;     /* secondes */
        suseconds_t tv_usec;    /* microsecondes */
    };

note: type: Plain text
en: If the adjustment in I<delta> is positive, then the system clock is speeded up by some small percentage (i.e., by adding a small amount of time to the clock value in each second) until the adjustment has been completed.  If the adjustment in I<delta> is negative, then the clock is slowed down in a similar fashion.
fr: Si l'ajustement dans I<delta> est positif, alors l'horloge système est accélérée d'un faible pourcentage (par exemple, en ajoutant une petite quantité de temps à chaque seconde de l'horloge) jusqu'à ce que l'ajustement soit réalisé. Si l'ajustement dans I<delta> est négatif, l'horloge est ralentie selon le même procédé.

note: type: Plain text
en: If a clock adjustment from an earlier B<adjtime>()  call is already in progress at the time of a later B<adjtime>()  call, and I<delta> is not NULL for the later call, then the earlier adjustment is stopped, but any already completed part of that adjustment is not undone.
fr: Si un ajustement d'horloge d'un précédent appel à B<adjtime>() est déjà en cours au moment du dernier appel à B<adjtime>() et si I<delta> n'est pas NULL lors de ce dernier appel, alors le précédent ajustement est arrêté, mais aucune partie déjà complète de cet ajustement n'est défait.

note: type: Plain text
en: If I<olddelta> is not NULL, then the buffer that it points to is used to return the amount of time remaining from any previous adjustment that has not yet been completed.
fr: Si I<olddelta> n'est pas NULL, alors le tampon pointé est utilisé pour renvoyer la quantité de temps restant depuis l'ajustement précédent qui n'a pas été complété.

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

note: type: Plain text
en: On success, B<adjtime>()  returns 0.  On failure, -1 is returned, and I<errno> is set to indicate the error.
fr: En cas de réussite, B<adjtime>() renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> est définie.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The adjustment in I<delta> is outside the permitted range.
fr: L'ajustement I<delta> est hors de l'intervalle autorisé.

note: type: Plain text
en: The caller does not have sufficient privilege to adjust the time.  Under Linux the B<CAP_SYS_TIME> capability is required.
fr: L'appelant n'a pas les privilèges suffisants pour ajuster le temps. Sous Linux, la capacité B<CAP_SYS_TIME> est nécessaire.

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<adjtime>()  function is thread-safe.
fr: La fonction B<adjtime>() est sûre dans un contexte multithread.

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

note: type: Plain text
en: 4.3BSD, System V.
fr: BSD\ 4.3, System V.

note: type: Plain text
en: The adjustment that B<adjtime>()  makes to the clock is carried out in such a manner that the clock is always monotonically increasing.  Using B<adjtime>()  to adjust the time prevents the problems that can be caused for certain applications (e.g., B<make>(1))  by abrupt positive or negative jumps in the system time.
fr: L'ajustement réalisé par B<adjtime>() sur l'horloge est exécuté afin que l'horloge soit toujours incrémentée de façon monotone. Utiliser B<adjtime>() pour ajuster le temps prévient les problèmes qui peuvent se poser avec certaines applications (par exemple, B<make>(1)) lors de sauts temporels abrupts positifs ou négatifs de l'horloge système.

note: type: Plain text
en: B<adjtime>()  is intended to be used to make small adjustments to the system time.  Most systems impose a limit on the adjustment that can be specified in I<delta>.  In the glibc implementation, I<delta> must be less than or equal to (INT_MAX / 1000000 - 2)  and greater than or equal to (INT_MIN / 1000000 + 2)  (respectively 2145 and -2145 seconds on i386).
fr: B<adjtime>() est prévue pour faire de petit ajustement de l'horloge système. La plupart des systèmes impose une limite à l'ajustement qui peut être spécifié dans I<delta>. Dans l'implémentation de la glibc, I<delta> doit être inférieur ou égal à (INT_MAX / 1000000 - 2) et supérieur ou égal (INT_MIN / 1000000 + 2) (respectivement, 2145 et -2145 secondes sur i386).

note: type: SH
en: BUGS
fr: BOGUES

note: http://sourceware.org/bugzilla/show_bug?id=2449 http://bugzilla.kernel.org/show_bug.cgi?id=6761 Thanks to the new adjtimex() ADJ_OFFSET_SS_READ flag type: Plain text
en: A longstanding bug meant that if I<delta> was specified as NULL, no valid information about the outstanding clock adjustment was returned in I<olddelta>.  (In this circumstance, B<adjtime>()  should return the outstanding clock adjustment, without changing it.)  This bug is fixed on systems with glibc 2.8 or later and Linux kernel 2.6.26 or later.
fr: Un bogue de longue date faisait que si I<delta> valait NULL, aucune information valide sur l'ajustement en cours de l'horloge n'était renvoyé dans I<olddelta>. (Dans cette circonstance, B<adjtime>() devrait renvoyer l'ajustement en cours de l'horloge, sans la modifier.) Ce bogue a été corrigé sur les systèmes disposant de la glibc 2.8 ou suivantes et le noyau Linux 2.6.26 ou suivants.

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-08-07
fr: 7 août 2013

note: type: Plain text
en: adjtimex - tune kernel clock
fr: adjtimex - Régler l'horloge du noyau (kernel clock)

note: type: Plain text
en: Linux uses David L. Mills' clock adjustment algorithm (see RFC\ 1305).  The system call B<adjtimex>()  reads and optionally sets adjustment parameters for this algorithm.  It takes a pointer to a I<timex> structure, updates kernel parameters from field values, and returns the same structure with current kernel values.  This structure is declared as follows:
fr: Linux utilise l'algorithme d'ajustement d'horloge de David L. Mills (RFC 1305). L'appel système B<adjtimex>() lit, et écrit éventuellement les paramètres d'ajustement pour cet algorithme. Il utilise un pointeur sur une structure I<timex> pour mettre à jour les paramètres du noyau avec les valeurs de ses champs, et renvoyer la même structure avec les valeurs actuelles du noyau. La structure est déclarée comme suit\ :

note: FIXME -- what is the scaling unit?  2^16 ? type: Plain text
en: struct timex {
        int modes;           /* mode selector */
        long offset;         /* time offset (usec) */
        long freq;           /* frequency offset (scaled ppm) */
        long maxerror;       /* maximum error (usec) */
        long esterror;       /* estimated error (usec) */
        int status;          /* clock command/status */
        long constant;       /* pll time constant */
        long precision;      /* clock precision (usec) (read-only) */
        long tolerance;      /* clock frequency tolerance (ppm)
                                (read-only) */
        struct timeval time; /* current time (read-only) */
        long tick;           /* usecs between clock ticks */
    };
fr: struct timex {
        int modes;           /* choix du mode */
        long offset;         /* décalage temporel (usec) */
        long freq;           /* différence de fréquence (scaled ppm) */
        long maxerror;       /* erreur maximale (usec) */
        long esterror;       /* erreur estimée (usec) */
        int status;          /* commande/état de l'horloge */
        long constant;       /* constante de temps pll */
        long precision;      /* précision de l'horloge (usec)
                                (lecture seule) */
        long tolerance;      /* tolérance sur la fréquence de
                                l'horloge (ppm) (lecture seule)
        struct timeval time; /* heure actuelle (lecture seule) */
        long tick;           /* microsecondes entre les tops
                                de l'horloge */
    };

note: type: Plain text
en: The I<modes> field determines which parameters, if any, to set.  It may contain a bitwise-I<or> combination of zero or more of the following bits:
fr: Le champ I<modes> détermine les paramètres éventuels à écrire. Il contient un OU binaire «\ |\ » entre les valeurs suivantes\ :

note: type: Plain text
en: #define ADJ_OFFSET            0x0001 /* time offset */
    #define ADJ_FREQUENCY         0x0002 /* frequency offset */
    #define ADJ_MAXERROR          0x0004 /* maximum time error */
    #define ADJ_ESTERROR          0x0008 /* estimated time error */
    #define ADJ_STATUS            0x0010 /* clock status */
    #define ADJ_TIMECONST         0x0020 /* pll time constant */
    #define ADJ_TICK              0x4000 /* tick value */
    #define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime() */
fr: #define ADJ_OFFSET            0x0001 /* décalage d'heure */
    #define ADJ_FREQUENCY         0x0002 /* décalage de fréquence */
    #define ADJ_MAXERROR          0x0004 /* erreur temporelle maximale */
    #define ADJ_ESTERROR          0x0008 /* erreur temporelle estimée */
    #define ADJ_STATUS            0x0010 /* état de l'horloge */
    #define ADJ_TIMECONST         0x0020 /* constante de temps pll */
    #define ADJ_TICK              0x4000 /* valeur du top */
    #define ADJ_OFFSET_SINGLESHOT 0x8001 /* ancien adjtime() */

note: type: Plain text
en: Ordinary users are restricted to a zero value for I<mode>.  Only the superuser may set any parameters.
fr: Les utilisateurs normaux sont limités à une valeur de I<mode> nulle, seul le superutilisateur peut écrire les paramètres.

note: type: Plain text
en: On success, B<adjtimex>()  returns the clock state:
fr: S'il réussit, B<adjtimex>() renvoie l'état de l'horloge\ :

note: type: Plain text
en: #define TIME_OK   0 /* clock synchronized */
    #define TIME_INS  1 /* insert leap second */
    #define TIME_DEL  2 /* delete leap second */
    #define TIME_OOP  3 /* leap second in progress */
    #define TIME_WAIT 4 /* leap second has occurred */
    #define TIME_BAD  5 /* clock not synchronized */
fr: #define TIME_OK   0 /* horloge synchronisée */
    #define TIME_INS  1 /* ajout d'une seconde */
    #define TIME_DEL  2 /* suppression d'une seconde */
    #define TIME_OOP  3 /* seconde d'ajustement en cours */
    #define TIME_WAIT 4 /* seconde d'ajustement terminée */
    #define TIME_BAD  5 /* horloge non synchronisée */

note: type: Plain text
en: On failure, B<adjtimex>()  returns -1 and sets I<errno>.
fr: En cas d'échec B<adjtimex>() renvoie -1 et remplit I<errno>.

note: type: Plain text
en: I<buf> does not point to writable memory.
fr: I<buf> pointe en dehors de l'espace d'adressage accessible en écriture.

note: type: Plain text
en: An attempt is made to set I<buf.offset> to a value outside the range -131071 to +131071, or to set I<buf.status> to a value other than those listed above, or to set I<buf.tick> to a value outside the range 900000/B<HZ> to 1100000/B<HZ>, where B<HZ> is the system timer interrupt frequency.
fr: Une tentative est faite de remplir I<buf.offset> en dehors de l'intervalle -131071 à +131071, ou de mettre I<buf.status> a une valeur autre que celles listées ci\(hydessus, ou I<buf.tick> en dehors de l'intervalle 900000/B<HZ> à 1100000/B<HZ>, où B<HZ> est la fréquence d'interruption de l'horloge système.

note: type: Plain text
en: I<buf.mode> is nonzero and the caller does not have sufficient privilege.  Under Linux the B<CAP_SYS_TIME> capability is required.
fr: I<buf.mode> est non nul, et l'appelant n'a pas suffisamment de privilèges. Sous Linux, la capacité B<CAP_SYS_TIME> est nécessaire.

note: type: Plain text
en: B<adjtimex>()  is Linux-specific and should not be used in programs intended to be portable.  See B<adjtime>(3)  for a more portable, but less flexible, method of adjusting the system clock.
fr: B<adjtimex>() est spécifique à Linux, et ne doit pas être employé dans des programmes destinés à être portés sur d'autres systèmes. Consultez B<adjtime>(3) pour une méthode plus portable, mais moins flexible, de configurer l'horloge système.

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

note: type: Plain text
en: clock - determine processor time
fr: clock - Déterminer la durée d'utilisation du processeur

note: type: Plain text
en: The B<clock>()  function returns an approximation of processor time used by the program.
fr: La fonction B<clock>() renvoie une durée approximative d'utilisation du processeur par le programme.

note: type: Plain text
en: The value returned is the CPU time used so far as a I<clock_t>; to get the number of seconds used, divide by B<CLOCKS_PER_SEC>.  If the processor time used is not available or its value cannot be represented, the function returns the value I<(clock_t)\ -1>.
fr: La valeur renvoyée est le temps CPU écoulé, en unités d'horloge I<clock_t>, pour obtenir une durée en secondes, divisez-la par B<CLOCKS_PER_SEC>. Si l'heure processeur n'est pas disponible, ou si sa valeur ne peut pas être représentée correctement, la valeur renvoyée est I<(clock_t)\ -1>.

note: type: Plain text
en: C89, C99, POSIX.1-2001.  POSIX requires that B<CLOCKS_PER_SEC> equals 1000000 independent of the actual resolution.
fr: C89, C99, POSIX.1-2001. POSIX demande que B<CLOCKS_PER_SEC> soit égal à 1\ 000\ 000 indépendamment de la résolution réelle.

note: type: Plain text
en: The C standard allows for arbitrary values at the start of the program; subtract the value returned from a call to B<clock>()  at the start of the program to get maximum portability.
fr: Le standard C autorise une valeur quelconque d'horloge au début du programme\ ; il faut donc utiliser la différence entre la valeur actuelle et celle de B<clock>() au lancement du programme pour obtenir une portabilité maximale.

note: type: Plain text
en: Note that the time can wrap around.  On a 32-bit system where B<CLOCKS_PER_SEC> equals 1000000 this function will return the same value approximately every 72 minutes.
fr: Notez que la valeur peut revenir à zéro. Sur un système 32\ bits, lorsque B<CLOCKS_PER_SEC> vaut 1\ 000\ 000, cette fonction redonnera les mêmes valeurs toutes les 72 minutes environ.

note: I have seen this behavior on Irix 6.3, and the OSF/1, HP/UX, and Solaris manual pages say that clock() also does this on those systems. POSIX.1-2001 doesn't explicitly allow this, nor is there an explicit prohibition. -- MTK type: Plain text
en: On several other implementations, the value returned by B<clock>()  also includes the times of any children whose status has been collected via B<wait>(2)  (or another wait-type call).  Linux does not include the times of waited-for children in the value returned by B<clock>().  The B<times>(2)  function, which explicitly returns (separate) information about the caller and its children, may be preferable.
fr: Sur plusieurs autres implémentations, la valeur renvoyée par B<clock>() inclut aussi le temps écoulé par l'exécution des processus fils dont les statistiques ont été collectées par B<wait>(2) (ou une fonction équivalente). Linux n'inclut pas le temps des enfants attendus dans la valeur renvoyée par B<clock>(). La fonction B<times>(2), qui renvoie de manière explicite et distinctes les informations sur l'appelant et ses enfants, peut être préférable.

note: type: Plain text
en: In glibc 2.17 and earlier, B<clock>()  was implemented on top of B<times>(2).  For improved precision, since glibc 2.18, it is implemented on top of B<clock_gettime>(2)  (using the B<CLOCK_PROCESS_CPUTIME_ID> clock).
fr: Dans la glibc version 2.17 et antérieures, B<clock>() était construite en utilisant B<times>(2). Afin d'améliorer la précision, cette fonction est construite depuis la version 2.18 en utilisant B<clock_gettime>(2) (qui utilise l'horloge B<CLOCK_PROCESS_CPUTIME_ID>).

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

note: type: Plain text
en: clock_getcpuclockid - obtain ID of a process CPU-time clock
fr: clock_getcpuclockid - Obtenir l'identifiant de l'horloge CPU d'un processus

note: type: Plain text
en: Link with I<-lrt> (only for glibc versions before 2.17).
fr: Lier avec I<-lrt> (seulement pour les versions de glibc antérieures à 2.17).

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

note: type: Plain text
en: The B<clock_getcpuclockid>()  function obtains the ID of the CPU-time clock of the process whose ID is I<pid>, and returns it in the location pointed to by I<clock_id>.  If I<pid> is zero, then the clock ID of the CPU-time clock of the calling process is returned.
fr: La fonction B<clock_getcpuclockid>() obtient l'identifiant de l'horloge CPU du processus dont l'identifiant est I<pid> et le renvoie dans l'emplacement pointé par I<clock_id>. Si I<pid> est nul, alors l'identifiant de l'horloge CPU du processus appelant est renvoyé.

note: type: Plain text
en: On success, B<clock_getcpuclockid>()  returns 0; on error, it returns one of the positive error numbers listed in ERRORS.
fr: En cas de réussite, B<clock_getcpuclockid>() renvoie 0. En cas d'erreur, elle renvoie un numéro d'erreur positif listé dans ERRORS.

note: type: Plain text
en: The kernel does not support obtaining the per-process CPU-time clock of another process, and I<pid> does not specify the calling process.
fr: Le noyau ne permet pas d'obtenir l'horloge CPU d'un autre processus et I<pid> ne correspond pas au processus appelant.

note: type: Plain text
en: The caller does not have permission to access the CPU-time clock of the process specified by I<pid>.  (Specified as an optional error in POSIX.1-2001; does not occur on Linux unless the kernel does not support obtaining the per-process CPU-time clock of another process.)
fr: L'appelant n'a pas les permissions pour accéder à l'horloge CPU du processus indiqué par I<pid>. (Spécifiée comme une erreur optionnelle dans POSIX.1-2001 ; elle ne se produit pas sous Linux à moins que le noyau ne permette pas d'obtenir l'horloge CPU d'un autre processus)

note: type: Plain text
en: There is no process with the ID I<pid>.
fr: Il n'y a pas de processus ayant pour identifiant I<pid>

note: type: Plain text
en: The B<clock_getcpuclockid>()  function is available in glibc since version 2.2.
fr: La fonction B<clock_getcpuclockid>() est disponible dans la glibc depuis la version 2.2.

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

note: type: Plain text
en: Calling B<clock_gettime>(2)  with the clock ID obtained by a call to B<clock_getcpuclockid>()  with a I<pid> of 0, is the same as using the clock ID B<CLOCK_PROCESS_CPUTIME_ID>.
fr: Un appel à B<clock_gettime>(2) avec l'identifiant d'horloge obtenu par un appel à B<clock_getcpuclockid>() avec un I<pid> de 0 revient à utiliser l'identifiant d'horloge B<CLOCK_PROCESS_CPUTIME_ID>.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The example program below obtains the CPU-time clock ID of the process whose ID is given on the command line, and then uses B<clock_gettime>(2)  to obtain the time on that clock.  An example run is the following:
fr: Le programme d'exemple ci-dessous obtient l'identifiant de l'horloge CPU du processus dont l'identifiant est fourni sur la ligne de commande, puis utilise B<clock_gettime>(2) pour obtenir l'heure de cette horloge. Un exemple d'exécution suit :

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

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

note: type: Plain text
en: clock_getres, clock_gettime, clock_settime - clock and time functions
fr: clock_getres, clock_gettime, clock_settime - Fonctions d'horloge et de temps

note: type: Plain text
en: B<clock_getres>(), B<clock_gettime>(), B<clock_settime>():
fr: B<clock_getres>(), B<clock_gettime>(), B<clock_settime>() :

note: type: Plain text
en: The function B<clock_getres>()  finds the resolution (precision) of the specified clock I<clk_id>, and, if I<res> is non-NULL, stores it in the I<struct timespec> pointed to by I<res>.  The resolution of clocks depends on the implementation and cannot be configured by a particular process.  If the time value pointed to by the argument I<tp> of B<clock_settime>()  is not a multiple of I<res>, then it is truncated to a multiple of I<res>.
fr: La fonction B<clock_getres>() cherche la résolution (précision) de l'horloge I<clk_id> spécifiée et si I<res> est non NULL, elle l'enregistre dans la structure I<timespec> pointée par I<res>. La résolution des horloges dépend de l'implémentation et ne peut pas être configurée par un processus particulier. Si la valeur du temps pointé par l'argument I<tp> de B<clock_settime>() n'est pas un multiple de I<res>, cette valeur est tronquée à un multiple de I<res>.

note: type: Plain text
en: The functions B<clock_gettime>()  and B<clock_settime>()  retrieve and set the time of the specified clock I<clk_id>.
fr: Les fonctions B<clock_gettime>() et B<clock_settime>() récupèrent et configurent le temps de l'horloge I<clk_id> spécifiée.

note: type: Plain text
en: The I<res> and I<tp> arguments are I<timespec> structures, as specified in I<E<lt>time.hE<gt>>:
fr: Les arguments I<res> et I<tp> sont des structures I<timespec> définies dans I<E<lt>time.hE<gt>>\ :

note: type: Plain text
en: struct timespec {
        time_t   tv_sec;        /* seconds */
        long     tv_nsec;       /* nanoseconds */
    };
fr: struct timespec {
        time_t   tv_sec;        /* secondes */
        long     tv_nsec;       /* nanosecondes */
    };

note: type: Plain text
en: The I<clk_id> argument is the identifier of the particular clock on which to act.  A clock may be system-wide and hence visible for all processes, or per-process if it measures time only within a single process.
fr: L'argument I<clk_id> est l'identifiant d'une horloge particulière sur laquelle agir. Une horloge peut être globale au système, et par conséquent visible de tous les processus, ou propre à un processus, si elle mesure le temps uniquement pour celui-ci.

note: type: Plain text
en: All implementations support the system-wide real-time clock, which is identified by B<CLOCK_REALTIME>.  Its time represents seconds and nanoseconds since the Epoch.  When its time is changed, timers for a relative interval are unaffected, but timers for an absolute point in time are affected.
fr: Toutes les implémentations supportent l'horloge temps réel globale, laquelle est identifiée par B<CLOCK_REALTIME>. Son temps représente le nombre de secondes et nanosecondes écoulées depuis l'époque UNIX (1er\ janvier 1970 à\ 00:00:00 UTC). Lorsque son temps est modifié, les horloges mesurant un intervalle de temps ne sont pas affectées alors que celles indiquant une date (heure) absolue le sont.

note: type: Plain text
en: More clocks may be implemented.  The interpretation of the corresponding time values and the effect on timers is unspecified.
fr: Plusieurs horloges peuvent être implémentées. L'interprétation des valeurs de temps correspondantes et l'effet sur les temporisateurs ne sont pas spécifiés.

note: type: Plain text
en: Sufficiently recent versions of glibc and the Linux kernel support the following clocks:
fr: Les versions suffisamment récentes de la glibc et du noyau Linux gèrent les horloges suivantes\ :

note: type: Plain text
en: System-wide clock that measures real (i.e., wall-clock) time.  Setting this clock requires appropriate privileges.  This clock is affected by discontinuous jumps in the system time (e.g., if the system administrator manually changes the clock), and by the incremental adjustments performed by B<adjtime>(3)  and NTP.
fr: Horloge système qui mesure le temps réel (c'est-à-dire comme une pendule). Modifier cette horloge nécessite des privilèges adéquats. Cette horloge est concernée par les sauts discontinus de l'heure système (c'est-à-dire si l'administrateur modifie l'heure lui-même), et par les ajustements incrémentaux effectués par B<adjtime>(3) et NTP.

note: type: TP
en: B<CLOCK_REALTIME_COARSE> (since Linux 2.6.32; Linux-specific)
fr: B<CLOCK_REALTIME_COARSE> (depuis Linux 2.6.32 ; spécifique à Linux)

note: Added in commit da15cfdae03351c689736f8d142618592e3cebc3 type: Plain text
en: A faster but less precise version of B<CLOCK_REALTIME>.  Use when you need very fast, but not fine-grained timestamps.
fr: Horloge plus rapide mais moins précise que B<CLOCK_REALTIME>. À utiliser pour obtenir rapidement des données d'horodatage avec une résolution grossière.

note: type: Plain text
en: Clock that cannot be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by B<adjtime>(3)  and NTP.
fr: Horloge non configurable qui représente un temps monotone depuis une date de début arbitraire. Cette horloge n'est pas concernée par les sauts discontinus de l'heure système (c'est-à-dire si l'administrateur modifie l'heure lui-même), mais est affectée par les ajustements incrémentaux effectués par B<adjtime>(3) et NTP.

note: type: TP
en: B<CLOCK_MONOTONIC_COARSE> (since Linux 2.6.32; Linux-specific)
fr: B<CLOCK_MONOTONIC_COARSE> (depuis Linux 2.6.32 ; spécifique à Linux)

note: Added in commit da15cfdae03351c689736f8d142618592e3cebc3 type: Plain text
en: A faster but less precise version of B<CLOCK_MONOTONIC>.  Use when you need very fast, but not fine-grained timestamps.
fr: Horloge plus rapide mais moins précise que B<CLOCK_MONOTONIC>. À utiliser pour obtenir rapidement des données d'horodatage avec une résolution grossière.

note: type: TP
en: B<CLOCK_MONOTONIC_RAW> (since Linux 2.6.28; Linux-specific)
fr: B<CLOCK_MONOTONIC_RAW> (depuis Linux 2.6.28 ; spécifique à Linux)

note: Added in commit 2d42244ae71d6c7b0884b5664cf2eda30fb2ae68, John Stultz type: Plain text
en: Similar to B<CLOCK_MONOTONIC>, but provides access to a raw hardware-based time that is not subject to NTP adjustments or the incremental adjustments performed by B<adjtime>(3).
fr: Similaire à B<CLOCK_MONOTONIC>, mais fournit un accès direct à un temps matériel qui n'est pas sujet ni aux ajustements NTP ni aux ajustements incrémentaux effectués par B<adjtime>(3).

note: type: TP
en: B<CLOCK_BOOTTIME> (since Linux 2.6.39; Linux-specific)
fr: B<CLOCK_BOOTTIME> (depuis Linux 2.6.39 ; spécifique à Linux)

note: commit 7fdd7f89006dd5a4c702fa0ce0c272345fa44ae0 commit 70a08cca1227dc31c784ec930099a4417a06e7d0 type: Plain text
en: Identical to B<CLOCK_MONOTONIC>, except it also includes any time that the system is suspended.  This allows applications to get a suspend-aware monotonic clock without having to deal with the complications of B<CLOCK_REALTIME>, which may have discontinuities if the time is changed using B<settimeofday>(2).
fr: Horloge identique à B<CLOCK_MONOTONIC>, mais qui prend également en compte le temps écoulé pendant la veille du système. Cela offre aux applications une horloge monotone tenant compte des veilles, sans avoir à s'occuper des problèmes de discontinuités de B<CLOCK_REALTIME> si l'horloge est mise à jour avec B<settimeofday>(2).

note: type: TP
en: B<CLOCK_PROCESS_CPUTIME_ID> (since Linux 2.6.12)
fr: B<CLOCK_PROCESS_CPUTIME_ID> (depuis Linux 2.6.12)

note: type: Plain text
en: Per-process CPU-time clock (measures CPU time consumed by all threads in the process).
fr: Horloge CPU par processus (mesurant le temps processeur consommé par tous les threads du processus).

note: type: TP
en: B<CLOCK_THREAD_CPUTIME_ID> (since Linux 2.6.12)
fr: B<CLOCK_THREAD_CPUTIME_ID> (depuis Linux 2.6.12)

note: type: Plain text
en: Thread-specific CPU-time clock.
fr: Horloge CPU spécifique aux threads.

note: type: Plain text
en: B<clock_gettime>(), B<clock_settime>()  and B<clock_getres>()  return 0 for success, or -1 for failure (in which case I<errno> is set appropriately).
fr: B<clock_gettime>(), B<clock_settime>() et B<clock_getres>() renvoient 0 si elles réussissent ou -1 si elles échouent, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: I<tp> points outside the accessible address space.
fr: I<tp> pointe en dehors de l'espace d'adressage accessible.

note: Linux also gives this error on attempts to set CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID, when probably the proper error should be EPERM. type: Plain text
en: The I<clk_id> specified is not supported on this system.
fr: L'horloge I<clk_id> spécifiée n'est pas supportée sur ce système.

note: type: Plain text
en: B<clock_settime>()  does not have permission to set the clock indicated.
fr: B<clock_settime>() n'a pas l'autorisation de configurer l'horloge spécifiée.

note: type: Plain text
en: These system calls first appeared in Linux 2.6.
fr: Ces appels système sont apparus dans Linux 2.6.

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

note: type: Plain text
en: On POSIX systems on which these functions are available, the symbol B<_POSIX_TIMERS> is defined in I<E<lt>unistd.hE<gt>> to a value greater than 0.  The symbols B<_POSIX_MONOTONIC_CLOCK>, B<_POSIX_CPUTIME>, B<_POSIX_THREAD_CPUTIME> indicate that B<CLOCK_MONOTONIC>, B<CLOCK_PROCESS_CPUTIME_ID>, B<CLOCK_THREAD_CPUTIME_ID> are available.  (See also B<sysconf>(3).)
fr: Sur les systèmes conformes à la spécification POSIX sur lesquels ces fonctions sont disponibles, la constante symbolique B<_POSIX_TIMERS> est définie dans I<E<lt>unistd.hE<gt>> comme étant une valeur supérieure à 0. Les constantes symboliques B<_POSIX_MONOTONIC_CLOCK>, B<_POSIX_CPUTIME>, B<_POSIX_THREAD_CPUTIME> indiquent que B<CLOCK_MONOTONIC>, B<CLOCK_PROCESS_CPUTIME_ID>, B<CLOCK_THREAD_CPUTIME_ID> sont disponibles. (Consultez aussi B<sysconf>(3).)

note: type: SS
en: Historical note for SMP systems
fr: Note historique pour les systèmes multiprocesseur (SMP)

note: type: Plain text
en: Before Linux added kernel support for B<CLOCK_PROCESS_CPUTIME_ID> and B<CLOCK_THREAD_CPUTIME_ID>, glibc implemented these clocks on many platforms using timer registers from the CPUs (TSC on i386, AR.ITC on Itanium).  These registers may differ between CPUs and as a consequence these clocks may return B<bogus results> if a process is migrated to another CPU.
fr: Avant la prise en charge par le noyau Linux de B<CLOCK_PROCESS_CPUTIME_ID> et B<CLOCK_THREAD_CPUTIME_ID>, la glibc a mis en œuvre ces horloges sur bien des plate-formes en utilisant les temporisateurs des CPU (TSC sur i386, AR.ITC sur Itanium). Les registres peuvent être différents entre CPU avec pour conséquence des B<résultats bidons> pour ces horloges si un processus a été transféré sur une autre CPU.

note: type: Plain text
en: If the CPUs in an SMP system have different clock sources, then there is no way to maintain a correlation between the timer registers since each CPU will run at a slightly different frequency.  If that is the case, then I<clock_getcpuclockid(0)> will return B<ENOENT> to signify this condition.  The two clocks will then be useful only if it can be ensured that a process stays on a certain CPU.
fr: Si les CPU d'un système multiprocesseur ont différentes sources d'horloges, il n'y a aucun moyen de maintenir une corrélation entre les registres temporisateur puisque chaque CPU tournera à une fréquence légèrement différente. Si c'est le cas, I<clock_getcpuclockid(0)> renverra B<ENOENT> pour signifier cette condition. Les deux horloges seront donc utiles si on peut être certain que le processus reste sur un CPU en particulier.

note: type: Plain text
en: The processors in an SMP system do not start all at exactly the same time and therefore the timer registers are typically running at an offset.  Some architectures include code that attempts to limit these offsets on bootup.  However, the code cannot guarantee to accurately tune the offsets.  Glibc contains no provisions to deal with these offsets (unlike the Linux Kernel).  Typically these offsets are small and therefore the effects may be negligible in most cases.
fr: Les processeurs d'un système multiprocesseur ne démarrent pas exactement au même moment, ainsi les registres temporisateurs sont lancés avec un décalage. Certaines architectures incluent un code pour tenter de limiter ce décalage au démarrage. Toutefois, ce code ne garantit pas l'accord précis des décalages. La glibc ne contient rien pour gérer ces décalages (à la différence du noyau Linux). Typiquement, ces décalages sont petits et ainsi, leurs effets peuvent être négligeable dans la plupart des cas.

note: type: Plain text
en: Since glibc 2.4, the wrapper functions for the system calls described in this page avoid the abovementioned problems by employing the kernel implementation of B<CLOCK_PROCESS_CPUTIME_ID> and B<CLOCK_THREAD_CPUTIME_ID>, on systems that provide such an implementation (i.e., Linux 2.6.12 and later).
fr: Depuis la glibc 2.4, les fonctions qui encapsulent les appels systèmes décrits dans cette page permettent d'éviter les problèmes mentionnés ci-dessus en utilisant les horloges B<CLOCK_PROCESS_CPUTIME_ID> et B<CLOCK_THREAD_CPUTIME_ID> du noyau, lorsque celles-ci sont disponibles (c'est-à-dire les versions de Linux 2.6.12 et ultérieures).

note: See http://bugzilla.kernel.org/show_bug.cgi?id=11972 type: Plain text
en: According to POSIX.1-2001, a process with "appropriate privileges" may set the B<CLOCK_PROCESS_CPUTIME_ID> and B<CLOCK_THREAD_CPUTIME_ID> clocks using B<clock_settime>().  On Linux, these clocks are not settable (i.e., no process has "appropriate privileges").
fr: Selon POSIX.1-2001, un processus avec des «\ privilèges adéquats\ » peut changer les horloges B<CLOCK_PROCESS_CPUTIME_ID> et B<CLOCK_THREAD_CPUTIME_ID> avec B<clock_settime>(). Sous Linux, ces horloges ne peuvent pas être modifiées (c'est-à-dire qu'aucun processus n'a de «\ privilèges adéquats\ »).

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

note: type: Plain text
en: clock_nanosleep - high-resolution sleep with specifiable clock
fr: clock_nanosleep - Sommeil haute résolution avec horloge spécifique

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

note: type: Plain text
en: Like B<nanosleep>(2), B<clock_nanosleep>()  allows the calling thread to sleep for an interval specified with nanosecond precision.  It differs in allowing the caller to select the clock against which the sleep interval is to be measured, and in allowing the sleep interval to be specified as either an absolute or a relative value.
fr: Comme B<nanosleep>(2), B<clock_nanosleep>() permet au thread appelant de sommeiller pendant une durée indiquée avec une précision de la nanoseconde. Il diffère de B<nanosleep>(2) dans le fait qu'il permet à l'appelant de choisir l'horloge avec laquelle la durée du sommeil sera mesurée et d'indiquer une valeur absolue ou relative pour la durée du sommeil.

note: type: Plain text
en: The time values passed to and returned by this call are specified using I<timespec> structures, defined as follows:
fr: Les valeurs de temps passées à ou retournées par cet appel sont spécifiés dans des structures I<timespec> définies comme suit :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;        /* seconds */
        long   tv_nsec;       /* nanoseconds [0 .. 999999999] */
    };
fr: struct timespec {
        time_t tv_sec;        /* secondes */
        long   tv_nsec;       /* nanosecondes [0 .. 999999999] */
    };

note: type: Plain text
en: The I<clock_id> argument specifies the clock against which the sleep interval is to be measured.  This argument can have one of the following values:
fr: L'argument I<clock_id> précise l'horloge avec laquelle sera mesurée la durée du sommeil. Cet argument doit être l'une des valeurs suivantes :

note: type: Plain text
en: A settable system-wide real-time clock.
fr: Une horloge temps réel configurable à l'échelle du système.

note: On Linux this clock measures time since boot. type: Plain text
en: A nonsettable, monotonically increasing clock that measures time since some unspecified point in the past that does not change after system startup.
fr: Une horloge monotonique, non configurable, mesurant le temps depuis un instant du passé non spécifié qui ne change pas après le démarrage du système.

note: There is some trickery between glibc and the kernel to deal with the CLOCK_PROCESS_CPUTIME_ID case. type: Plain text
en: A settable per-process clock that measures CPU time consumed by all threads in the process.
fr: Une horloge configurable par processus mesurant le temps processeur consommé par tous les threads du processus.

note: type: Plain text
en: See B<clock_getres>(2)  for further details on these clocks.
fr: Consultez B<clock_getres>(2) pour plus d'informations sur ces horloges.

note: type: Plain text
en: If I<flags> is 0, then the value specified in I<request> is interpreted as an interval relative to the current value of the clock specified by I<clock_id>.
fr: Si I<flags> vaut 0, la valeur indiquée dans I<request> est interprétée comme une durée relative à la valeur actuelle de l'horloge indiquée dans I<clock_id>.

note: type: Plain text
en: If I<flags> is B<TIMER_ABSTIME>, then I<request> is interpreted as an absolute time as measured by the clock, I<clock_id>.  If I<request> is less than or equal to the current value of the clock, then B<clock_nanosleep>()  returns immediately without suspending the calling thread.
fr: Si I<flags> vaut B<TIMER_ABSTIME>, I<request> est interprété comme un temps absolu tel qu'il est mesuré par l'horloge I<clock_id>. Si I<request> est inférieur ou égal à la valeur actuelle de l'horloge, B<clock_nanosleep>() revient immédiatement sans suspendre le thread appelant.

note: type: Plain text
en: B<clock_nanosleep>()  suspends the execution of the calling thread until either at least the time specified by I<request> has elapsed, or a signal is delivered that causes a signal handler to be called or that terminates the process.
fr: B<clock_nanosleep>() suspend l'exécution du thread appelant jusqu'à ce que soit le temps indiqué dans I<request> se soit écoulé, soit un signal a été délivré provoquant l'appel d'un gestionnaire de signal ou la fin du processus.

note: type: Plain text
en: If the call is interrupted by a signal handler, B<clock_nanosleep>()  fails with the error B<EINTR>.  In addition, if I<remain> is not NULL, and I<flags> was not B<TIMER_ABSTIME>, it returns the remaining unslept time in I<remain>.  This value can then be used to call B<clock_nanosleep>()  again and complete a (relative) sleep.
fr: Si l'appel a été interrompu par un gestionnaire de signal, B<clock_nanosleep>() échoue et renseigne I<errno> avec B<EINTR>. De plus, si I<remain> n'est pas NULL et si I<flags> n'est pas B<TIMER_ABSTIME>, il renvoie dans I<remain> le temps de sommeil non consommé. Cette valeur peut être ensuite utilisée pour rappeler B<clock_nanosleep>() et achever un sommeil (relatif).

note: type: Plain text
en: On successfully sleeping for the requested interval, B<clock_nanosleep>()  returns 0.  If the call is interrupted by a signal handler or encounters an error, then it returns one of the positive error number listed in ERRORS.
fr: Après un sommeil complet de la durée souhaitée, B<clock_nanosleep>() renvoie 0. Si l'appel système est interrompu par un gestionnaire de signal ou rencontre une erreur, il renvoie un des codes d'erreur positifs listés dans ERREURS.

note: type: Plain text
en: I<request> or I<remain> specified an invalid address.
fr: I<request> ou I<remain> n'indique pas une adresse valide.

note: type: Plain text
en: The sleep was interrupted by a signal handler.
fr: Le sommeil a été interrompu par un gestionnaire de signal.

note: type: Plain text
en: The value in the I<tv_nsec> field was not in the range 0 to 999999999 or I<tv_sec> was negative.
fr: La valeur du champ I<tv_nsec> n'est pas dans l'intervalle 0 à 999\ 999\ 999 ou I<tv_sec> est négatif.

note: type: Plain text
en: I<clock_id> was invalid.  (B<CLOCK_THREAD_CPUTIME_ID> is not a permitted value for I<clock_id>.)
fr: I<clock_id> n'est pas valide. (B<CLOCK_THREAD_CPUTIME_ID> n'est pas une valeur permise pour I<clock_id>.)

note: type: Plain text
en: The B<clock_nanosleep>()  system call first appeared in Linux 2.6.  Support is available in glibc since version 2.1.
fr: L'appel système B<clock_nanosleep>() a été introduit dans le noyau Linux dans sa version\ 2.6. La prise en charge dans la glibc est disponible depuis la version\ 2.1.

note: type: Plain text
en: If the interval specified in I<request> is not an exact multiple of the granularity underlying clock (see B<time>(7)), then the interval will be rounded up to the next multiple.  Furthermore, after the sleep completes, there may still be a delay before the CPU becomes free to once again execute the calling thread.
fr: Si la durée indiquée dans I<request> n'est pas un multiple exact de la granularité de l'horloge sous-jacente (consultez B<time>(7)), la durée sera alors arrondie au multiple supérieur. De plus, lorsque le sommeil sera achevé, il y a toujours un délai avant lequel le processeur redevienne libre pour exécuter le thread appelant.

note: type: Plain text
en: Using an absolute timer is useful for preventing timer drift problems of the type described in B<nanosleep>(2).  (Such problems are exacerbated in programs that try to restart a relative sleep that is repeatedly interrupted by signals.)  To perform a relative sleep that avoids these problems, call B<clock_gettime>(2)  for the desired clock, add the desired interval to the returned time value, and then call B<clock_nanosleep>()  with the B<TIMER_ABSTIME> flag.
fr: L'utilisation d'une temporisation absolue est utile pour prévenir les problèmes de dérive de temps du type de ceux décrits dans B<nanosleep>(2). (De tels problèmes sont exacerbés dans les programmes qui essaient de relancer un sommeil relatif interrompu de manière répétitive par des signaux.) Pour réaliser un sommeil qui s'affranchisse de ces problèmes, appelez B<clock_gettime>(2) pour l'horloge souhaitée, ajoutez la durée voulue à la valeur de temps renvoyée, appelez ensuite B<clock_nanosleep>() avec l'attribut B<TIMER_ABSTIME>.

note: type: Plain text
en: B<clock_nanosleep>()  is never restarted after being interrupted by a signal handler, regardless of the use of the B<sigaction>(2)  B<SA_RESTART> flag.
fr: B<clock_nanosleep>() n'est jamais relancé après avoir été interrompu par un gestionnaire de signal, que l'on ait ou non utilisé l'attribut B<SA_RESTART> de B<sigaction>(2).

note: type: Plain text
en: The I<remain> argument is unused, and unnecessary, when I<flags> is B<TIMER_ABSTIME>.  (An absolute sleep can be restarted using the same I<request> argument.)
fr: L'argument I<remain> n'est pas utilisé et n'est pas nécessaire lorsque I<flags> vaut B<TIMER_ABSTIME>. (Un sommeil absolu peut être relancé en utilisant le même argument I<request>.)

note: type: Plain text
en: POSIX.1 specifies that B<clock_nanosleep>()  has no effect on signals dispositions or the signal mask.
fr: POSIX.1 précise que B<clock_nanosleep>() n'a aucun effet sur les dispositions de signaux ou sur le masque de signaux.

note: type: Plain text
en: POSIX.1 specifies that after changing the value of the B<CLOCK_REALTIME> clock via B<clock_settime>(2), the new clock value shall be used to determine the time at which a thread blocked on an absolute B<clock_nanosleep>()  will wake up; if the new clock value falls past the end of the sleep interval, then the B<clock_nanosleep>()  call will return immediately.
fr: POSIX.1 précise qu'après avoir modifié la valeur de l'horloge B<CLOCK_REALTIME> avec B<clock_settime>(2), la nouvelle valeur de l'horloge doit être utilisée pour déterminer l'heure à laquelle un thread bloqué avec un appel B<clock_nanosleep>() absolu se réveillera ; si la nouvelle horloge fait que la durée du sommeil est dépassée, l'appel système B<clock_nanosleep>() revient immédiatement.

note: type: Plain text
en: POSIX.1 specifies that changing the value of the B<CLOCK_REALTIME> clock via B<clock_settime>(2)  shall have no effect on a thread that is blocked on a relative B<clock_nanosleep>().
fr: POSIX.1 précise que modifier la valeur de l'horloge B<CLOCK_REALTIME> avec B<clock_settime>(2) n'a pas d'effet sur un thread bloqué par un appel B<clock_nanosleep>() absolu.

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

note: type: Plain text
en: asctime, ctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - transform date and time to broken-down time or ASCII
fr: asctime, ctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - Convertir des dates et des temps au format année/mois/jours ou au format ASCII

note: type: Plain text
en: B<asctime_r>(), B<ctime_r>(), B<gmtime_r>(), B<localtime_r>():
fr: B<asctime_r>(), B<ctime_r>(), B<gmtime_r>(), B<localtime_r>()\ :

note: type: Plain text
en: The B<ctime>(), B<gmtime>()  and B<localtime>()  functions all take an argument of data type I<time_t>, which represents calendar time.  When interpreted as an absolute time value, it represents the number of seconds elapsed since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: Les fonctions B<ctime>(), B<gmtime>() et B<localtime>() prennent toutes un paramètre de type I<time_t>, qui représente un temps en seconde. Si l'on interprète ce paramètre comme une valeur absolue, il s'agit du nombre de secondes écoulées depuis l'époque, 1er janvier 1970 à 00:00:00 (UTC).

note: type: Plain text
en: The B<asctime>()  and B<mktime>()  functions both take an argument representing broken-down time, which is a representation separated into year, month, day, and so on.
fr: Les fonctions B<asctime>() et B<mktime>() utilisent toutes deux un paramètre représentant le temps dans un format humain, c'est-à-dire année, mois, jour, etc.

note: type: Plain text
en: Broken-down time is stored in the structure I<tm>, which is defined in I<E<lt>time.hE<gt>> as follows:
fr: La représentation humaine («\ broken-down time\ ») est stockée dans une structure I<tm>, définie dans I<E<lt>time.hE<gt>> comme suit\ :

note: type: Plain text
en: struct tm {
        int tm_sec;    /* Seconds (0-60) */
        int tm_min;    /* Minutes (0-59) */
        int tm_hour;   /* Hours (0-23) */
        int tm_mday;   /* Day of the month (1-31) */
        int tm_mon;    /* Month (0-11) */
        int tm_year;   /* Year - 1900 */
        int tm_wday;   /* Day of the week (0-6, Sunday = 0) */
        int tm_yday;   /* Day in the year (0-365, 1 Jan = 0) */
        int tm_isdst;  /* Daylight saving time */
    };
fr: struct tm
    {
        int tm_sec;    /* secondes [0,60]                          */
        int tm_min;    /* minutes [0,59]                           */
        int tm_hour;   /* heures [0,23]                            */
        int tm_mday;   /* jour du mois [1,31]                      */
        int tm_mon;    /* mois [0,11]                              */
        int tm_year;   /* année - 1900                             */
        int tm_wday;   /* jour de la semaine [0,6] où Dimanche = 0 */
        int tm_yday;   /* jour de l'année [0,365] où 1er Jan = 0   */
        int tm_isdst;  /* décalage été/hiver                       */
    };

note: type: Plain text
en: The members of the I<tm> structure are:
fr: Les membres de la structure I<tm> sont\ :

note: type: Plain text
en: The number of seconds after the minute, normally in the range 0 to 59, but can be up to 60 to allow for leap seconds.
fr: Le nombre de secondes écoulées depuis le dernier changement de minute. Normalement dans l'intervalle 0 à 59, ce membre peut aller jusqu'à 60 durant les secondes de rattrapage.

note: type: Plain text
en: The number of minutes after the hour, in the range 0 to 59.
fr: Le nombre de minutes écoulées depuis le dernier changement d'heure, dans l'intervalle 0 à 59.

note: type: Plain text
en: The number of hours past midnight, in the range 0 to 23.
fr: Le nombre d'heures écoulées depuis minuit, dans l'intervalle 0 à 23.

note: type: Plain text
en: The day of the month, in the range 1 to 31.
fr: Le quantième du mois, dans l'intervalle 1 à 31.

note: type: Plain text
en: The number of months since January, in the range 0 to 11.
fr: Le nombre de mois écoulés depuis le début de l'année, dans l'intervalle 0 à 11.

note: type: Plain text
en: The number of years since 1900.
fr: Le nombre d'années écoulées depuis 1900.

note: type: Plain text
en: The number of days since Sunday, in the range 0 to 6.
fr: Le nombre de jours écoulés depuis dimanche, dans l'intervalle 0 à 6.

note: type: Plain text
en: The number of days since January 1, in the range 0 to 365.
fr: Le nombre de jours écoulés depuis le 1er janvier, dans l'intervalle 0 à 365.

note: type: Plain text
en: A flag that indicates whether daylight saving time is in effect at the time described.  The value is positive if daylight saving time is in effect, zero if it is not, and negative if the information is not available.
fr: Un drapeau indiquant si le décalage heure d'hiver, heure d'été est en cours au moment de l'appel. La valeur retournée est positive si le décalage est actif, nulle s'il ne l'est pas, et négative si l'information n'est pas disponible.

note: type: Plain text
en: The call B<ctime(>I<t>B<)> is equivalent to B<asctime(localtime(>I<t>B<))>.  It converts the calendar time I<t> into a null-terminated string of the form
fr: L'appel B<ctime(>I<t>B<)> est équivalent à B<asctime(localtime(>I<t>B<))>. Il convertit la date I<t> en une chaîne de caractères, terminée par un caractère nul, de la forme

note: type: Plain text
en: The abbreviations for the days of the week are "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", and "Sat".  The abbreviations for the months are "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", and "Dec".  The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions.  The function also sets the external variables I<tzname>, I<timezone>, and I<daylight> (see B<tzset>(3))  with information about the current timezone.  The reentrant version B<ctime_r>()  does the same, but stores the string in a user-supplied buffer which should have room for at least 26 bytes.  It need not set I<tzname>, I<timezone>, and I<daylight>.
fr: Les abréviations des jours de la semaine sont «\ Sun\ », «\ Mon\ », «\ Tue\ », «\ Wed\ », «\ Thu\ », «\ Fri\ », et «\ Sat\ ». Les abréviations des mois sont «\ Jan\ », «\ Feb\ », «\ Mar\ », «\ Apr\ », «\ May\ », «\ Jun\ », «\ Jul\ », «\ Aug\ », «\ Sep\ », «\ Oct\ », «\ Nov\ », et «\ Dec\ ». La valeur renvoyée pointe sur une chaîne statiquement allouée qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction définit aussi les variables externes I<tzname>, I<timezone> et I<daylight> (consultez B<tzset>(3)) avec les informations du fuseau horaire. La version réentrante B<ctime_r>() effectue le même travail mais stocke la chaîne dans un tampon d'une longueur minimale de 26 caractères fournie par l'utilisateur. Elle n'a pas besoin de définir I<tzname>, I<timezone> et I<daylight>.

note: type: Plain text
en: The B<gmtime>()  function converts the calendar time I<timep> to broken-down time representation, expressed in Coordinated Universal Time (UTC).  It may return NULL when the year does not fit into an integer.  The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions.  The B<gmtime_r>()  function does the same, but stores the data in a user-supplied struct.
fr: La fonction B<gmtime>() convertit la date au format calendrier (temps écoulé depuis un référentiel) I<timep> en une représentation humaine exprimée en temps universel (UTC). Elle peut renvoyer NULL quand l'année ne tient pas dans un entier. La valeur renvoyée pointe vers une structure allouée statiquement qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction réentrante B<gmtime_r>() effectue le même travail mais stocke le résultat dans une structure fournie par l'utilisateur.

note: type: Plain text
en: The B<localtime>()  function converts the calendar time I<timep> to broken-down time representation, expressed relative to the user's specified timezone.  The function acts as if it called B<tzset>(3)  and sets the external variables I<tzname> with information about the current timezone, I<timezone> with the difference between Coordinated Universal Time (UTC) and local standard time in seconds, and I<daylight> to a nonzero value if daylight savings time rules apply during some part of the year.  The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions.  The B<localtime_r>()  function does the same, but stores the data in a user-supplied struct.  It need not set I<tzname>, I<timezone>, and I<daylight>.
fr: La fonction B<localtime>() convertit la date au format calendrier I<timep> en une représentation humaine exprimée en fonction du fuseau horaire de l'utilisateur. Cette fonction se comporte comme si elle appelait B<tzset>(3) et définit les variables externes I<tzname> avec les informations concernant le fuseau horaire, I<timezone> avec la différence (en secondes) entre le temps universel (UTC) et le temps local, et I<daylight> avec une valeur non nulle si le décalage horaire saisonnier s'applique durant l'année. La valeur renvoyée pointe vers une structure allouée statiquement qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction réentrante B<localtime_r>() effectue le même travail mais stocke le résultat dans une structure fournie par l'utilisateur. Elle n'a pas besoin de définir I<tzname>, I<timezone>, et I<daylight>.

note: type: Plain text
en: The B<asctime>()  function converts the broken-down time value I<tm> into a null-terminated string with the same format as B<ctime>().  The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions.  The B<asctime_r>()  function does the same, but stores the string in a user-supplied buffer which should have room for at least 26 bytes.
fr: La fonction B<asctime>() convertit une date au format humain I<tm> en une chaîne de caractères, terminée par un caractère nul, dans le même format que B<ctime>(). La valeur renvoyée pointe sur une chaîne statique qui sera écrasée à chaque appel d'une fonction de date et de temps. La version réentrante B<asctime_r>() effectue le même travail mais stocke la chaîne dans un tampon d'une longueur minimale de 26 caractères fournie par l'utilisateur.

note: type: Plain text
en: The B<mktime>()  function converts a broken-down time structure, expressed as local time, to calendar time representation.  The function ignores the values supplied by the caller in the I<tm_wday> and I<tm_yday> fields.  The value specified in the I<tm_isdst> field informs B<mktime>()  whether or not daylight saving time (DST)  is in effect for the time supplied in the I<tm> structure: a positive value means DST is in effect; zero means that DST is not in effect; and a negative value means that B<mktime>()  should (use timezone information and system databases to)  attempt to determine whether DST is in effect at the specified time.
fr: La fonction B<mktime>() convertit une structure de temps au format humain exprimé sous forme d'un temps local en une représentation au format calendrier. La fonction ignore les valeurs I<tm_wday> et I<tm_yday> fournit par l'appelant. La valeur fournie dans le champ I<tm_isdst> informe B<mktime>() si le décalage horaire d'été (DST) a un effet ou non sur le temps fourni dans la structure I<tm>\ : une valeur positive signifie que le décalage horaire d'été a un effet\ ; une valeur nulle signifie que le décalage horaire d'été n'a aucun effet\ ; une valeur négative signifie que B<mktime>() doit déterminer si le décalage horaire d'été a un effet dans le temps spécifié (en utilisant les informations de fuseaux horaires par exemple).

note: type: Plain text
en: The B<mktime>()  function modifies the fields of the I<tm> structure as follows: I<tm_wday> and I<tm_yday> are set to values determined from the contents of the other fields; if structure members are outside their valid interval, they will be normalized (so that, for example, 40 October is changed into 9 November); I<tm_isdst> is set (regardless of its initial value)  to a positive value or to 0, respectively, to indicate whether DST is or is not in effect at the specified time.  Calling B<mktime>()  also sets the external variable I<tzname> with information about the current timezone.
fr: La fonction B<mktime>() modifie des champs de la structure I<tm>\ : les valeurs de I<tm_wday> et I<tm_yday> sont déterminées à l'aide des autres champs\ ; si la valeur d'un membre de la structure n'est pas dans un intervalle valide, elle sera normalisée (par exemple, le 40 octobre sera converti en 9 novembre)\ ; I<tm_isdst> est défini (selon sa valeur initiale) à une valeur positive s'il faut prendre en compte le décalage horaire d'été, 0 sinon. Un appel à B<mktime>() définit aussi la variable externe I<tzname> avec le fuseau horaire courant.

note: type: Plain text
en: If the specified broken-down time cannot be represented as calendar time (seconds since the Epoch), B<mktime>()  returns I<(time_t)\ -1> and does not alter the members of the broken-down time structure.
fr: Si la représentation d'un temps au format humain ne peut pas être converti au format calendrier (nombre de secondes depuis l'époque, 1er janvier 1970 à 00:00:00 (UTC)), B<mktime>() renvoie la valeur I<(time_t)\ -1> et ne modifie pas les membres de la structure du temps au format humain.

note: type: Plain text
en: Each of these functions returns the value described, or NULL (-1 in case of B<mktime>())  in case an error was detected.
fr: Chacune de ces fonctions renvoie la valeur décrite ci-dessus, ou NULL (-1 dans le cas de B<mktime>()) si une erreur est détectée.

note: type: Plain text
en: POSIX.1-2001.  C89 and C99 specify B<asctime>(), B<ctime>(), B<gmtime>(), B<localtime>(), and B<mktime>().  POSIX.1-2008 marks B<asctime>(), B<asctime_r>(), B<ctime>(), and B<ctime_r>()  as obsolete, recommending the use of B<strftime>(3)  instead.
fr: POSIX.1-2001. C89 et C99 définissent B<asctime>(), B<ctime>(), B<gmtime>(), B<localtime>() et B<mktime>(). POSIX.1-2008 marque B<asctime>(), B<asctime_r>(), B<ctime>() et B<ctime_r>() comme étant obsolètes et recommande à la place l'utilisation de B<strftime>(3).

note: type: Plain text
en: The four functions B<asctime>(), B<ctime>(), B<gmtime>()  and B<localtime>()  return a pointer to static data and hence are not thread-safe.  Thread-safe versions B<asctime_r>(), B<ctime_r>(), B<gmtime_r>()  and B<localtime_r>()  are specified by SUSv2, and available since libc 5.2.5.
fr: Les quatre fonctions B<asctime>(), B<ctime>(), B<gmtime>() et B<localtime>() renvoient un pointeur vers des données statiques et ne sont donc pas sûres dans un contexte multithread. Les versions multithread sûres, B<asctime_r>(), B<ctime_r>(), B<gmtime_r>() et B<localtime_r>() sont spécifiées dans SUSv2, et disponibles depuis la libc\ 5.2.5.

note: type: Plain text
en: POSIX.1-2001 says: "The B<asctime>(), B<ctime>(), B<gmtime>(), and B<localtime>()  functions shall return values in one of two static objects: a broken-down time structure and an array of type I<char>.  Execution of any of the functions may overwrite the information returned in either of these objects by any of the other functions." This can occur in the glibc implementation.
fr: POSIX.1-2001 indique : « Les fonctions B<asctime>(), B<ctime>(), B<gmtime>() et B<localtime>() retourneront les valeurs dans l'un des deux objets statiques : une structure de temps détraquée et un tableau de type I<char>. L'exécution de n'importe laquelle de ces fonctions peut écraser l'information renvoyée dans l'un ou l'autre de ces objets par n'importe quelle autre fonction. » cela peut arriver dans l'implémentation de la glibc.

note: type: Plain text
en: In many implementations, including glibc, a 0 in I<tm_mday> is interpreted as meaning the last day of the preceding month.
fr: Dans beaucoup d'implémentations, dont la glibc, un 0 dans I<tm_mday> est interprété comme le dernier jour du mois précédant.

note: type: Plain text
en: The glibc version of I<struct tm> has additional fields
fr: La structure I<tm> de la glibc possède des champs supplémentaires

note: type: Plain text
en: long tm_gmtoff;           /* Seconds east of UTC */
    const char *tm_zone;      /* Timezone abbreviation */
fr: long  tm_gmtoff;      /* Secondes à l'est du temps universel */
    const char *tm_zone;  /* Abréviation du nom du fuseau horaire */

note: type: Plain text
en: defined when B<_BSD_SOURCE> was set before including I<E<lt>time.hE<gt>>.  This is a BSD extension, present in 4.3BSD-Reno.
fr: définis lorsque B<_BSD_SOURCE> est définie avant l'inclusion de I<E<lt>time.hE<gt>>. Ceci est une extension BSD, présente dans BSD\ 4.3-Reno.

note: See http://thread.gmane.org/gmane.comp.time.tz/2034/ type: Plain text
en: According to POSIX.1-2004, B<localtime>()  is required to behave as though B<tzset>(3)  was called, while B<localtime_r>()  does not have this requirement.  For portable code B<tzset>(3)  should be called before B<localtime_r>().
fr: Selon POSIX.1-2004, B<localtime>() doit se comporter comme si B<tzset>() avait été appelée, alors que B<localtime_r>() n'a pas cette exigence. Pour un code portable, B<tzset>() devrait être appelé avant B<localtime_r>().

note: type: TH
en: 2013-10-28
fr: 28 octobre 2013

note: type: Plain text
en: difftime - calculate time difference
fr: difftime - Calculer des intervalles de temps

note: type: Plain text
en: The B<difftime>()  function returns the number of seconds elapsed between time I<time1> and time I<time0>, represented as a I<double>.  Each of the times is specified in calendar time, which means its value is a measurement (in seconds) relative to the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: La fonction B<difftime>() renvoie le nombre de secondes écoulées entre les instants I<time1> et I<time0> au format I<double>. Les deux paramètres de temps sont de type calendrier, ce qui représente le temps écoulé depuis l'époque, 1er janvier 1970 à 00:00:00 (UTC).

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

note: type: Plain text
en: SVr4, 4.3BSD, C89, C99.
fr: SVr4, BSD\ 4.3, C89, C99.

note: type: Plain text
en: On a POSIX system, I<time_t> is an arithmetic type, and one could just define
fr: Sur un système POSIX, I<time_t> est un type arithmétique, et on peut définir directement

note: type: Plain text
en: when the possible overflow in the subtraction is not a concern.
fr: si les risques de débordement ne sont pas gênants.

note: type: TH
en: 2013-09-25
fr: 25 septembre 2013

note: type: Plain text
en: dysize - get number of days for a given year
fr: dysize - Obtenir le nombre de jours d'une année donnée

note: type: Plain text
en: B<dysize>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<dysize>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: The function returns 365 for a normal year and 366 for a leap year.  The calculation for leap year is based on:
fr: La fonction renvoie 365 pour une année normale et 366 pour une année bissextile. L'identification d'une année bissextile repose sur le calcul suivant\ :

note: type: Plain text
en: The formula is defined in the macro I<__isleap(year)> also found in I<E<lt>time.hE<gt>>.
fr: La formule est définie dans la macro I<__isleap(year)> que l'on trouve également dans I<E<lt>time.hE<gt>>.

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

note: type: Plain text
en: This function occurs in SunOS 4.x.
fr: Cette fonction apparaît dans SunOS 4.x.

note: The SCO version of this function had a year-2000 problem. type: Plain text
en: This is a compatibility function only.  Don't use it in new programs.
fr: Il s'agit seulement d'une fonction à vocation de compatibilité. Ne l'utilisez pas dans de nouveaux programmes.

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

note: type: Plain text
en: ftime - return date and time
fr: ftime - Obtenir la date et l'heure

note: type: Plain text
en: This function returns the current time as seconds and milliseconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  The time is returned in I<tp>, which is declared as follows:
fr: Cette fonction renvoie la date et l'heure actuelle, en secondes  et millisecondes, depuis l'époque, 1er janvier 1970 à 00:00:00 (UTC). Le temps est renvoyé dans une structure I<tp>, déclarée ainsi :

note: type: Plain text
en: Here I<time> is the number of seconds since the Epoch, and I<millitm> is the number of milliseconds since I<time> seconds since the Epoch.  The I<timezone> field is the local timezone measured in minutes of time west of Greenwich (with a negative value indicating minutes east of Greenwich).  The I<dstflag> field is a flag that, if nonzero, indicates that Daylight Saving time applies locally during the appropriate part of the year.
fr: Ici, I<time> est le temps écoulé en secondes depuis l'époque, 1er janvier 1970 à 00:00:00 (UTC) et I<millitm> est le nombre de millisecondes depuis I<time>. Le champ I<timezone> est le fuseau horaire local mesuré en minutes de temps à l'ouest de Greenwich (avec une valeur négative indiquant les minutes à l'est de Greenwich). I<dstflag> est un drapeau indiquant, s'il est non nul que le décalage horaire d'été s'applique pendant la partie appropriée de l'année.

note: type: Plain text
en: POSIX.1-2001 says that the contents of the I<timezone> and I<dstflag> fields are unspecified; avoid relying on them.
fr: POSIX.1-2001 indique que le contenu des champs I<timezone> et I<dstflag> est indéfini, vous ne devez donc pas compter sur eux.

note: type: Plain text
en: This function always returns 0.  (POSIX.1-2001 specifies, and some systems document, a -1 error return.)
fr: Cette fonction renvoie toujours 0 (POSIX.1-2001 indique, et certains systèmes documentent une valeur de retour en cas d'erreur de -1).

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

note: type: Plain text
en: 4.2BSD, POSIX.1-2001.  POSIX.1-2008 removes the specification of B<ftime>().
fr: BSD 4.2, POSIX.1-2001. POSIX.1-2008 supprime la spécification de B<ftime>().

note: type: Plain text
en: This function is obsolete.  Don't use it.  If the time in seconds suffices, B<time>(2)  can be used; B<gettimeofday>(2)  gives microseconds; B<clock_gettime>(2)  gives nanoseconds but is not as widely available.
fr: Cette fonction est obsolète. Ne l'utilisez pas. Si la précision en seconde vous suffit, utilisez B<time>(2). Sinon B<gettimeofday>(2) fournit des microsecondes, et B<clock_gettime>(2) des nanosecondes, mais elle n'est pas disponible sur tous les systèmes.

note: .SH HISTORY The .BR ftime () function appeared in 4.2BSD. type: Plain text
en: Under libc4 and libc5 the I<millitm> field is meaningful.  But early glibc2 is buggy and returns 0 there; glibc 2.1.1 is correct again.
fr: Sous libc4 et libc5, le champ I<millitm> est sans signification. Les premières versions de la glibc2 étaient boguées, et renvoyaient toujours 0 dans ce champ. La glibc\ 2.1.1 est correcte.

note: type: TH
en: 2013-10-29
fr: 29 octobre 2013

note: type: Plain text
en: futimes, lutimes - change file timestamps
fr: futimes, lutimes - Modifier les horodatages d'un fichier

note: type: Plain text
en: B<futimes>(), B<lutimes>(): _BSD_SOURCE
fr: B<futimes>(), B<lutimes>() : _BSD_SOURCE

note: type: Plain text
en: B<futimes>()  changes the access and modification times of a file in the same way as B<utimes>(2), with the difference that the file whose timestamps are to be changed is specified via a file descriptor, I<fd>, rather than via a pathname.
fr: La fonction B<futimes>() change les temps d'accès et de modification d'un fichier de la même façon que B<utimes>(2), excepté que le fichier dont les données temporelles doivent être modifiées, est spécifié via un descripteur de fichier, I<fd> au lieu d'un chemin.

note: type: Plain text
en: B<lutimes>()  changes the access and modification times of a file in the same way as B<utimes>(2), with the difference that if I<filename> refers to a symbolic link, then the link is not dereferenced: instead, the timestamps of the symbolic link are changed.
fr: La fonction B<lutimes>() change les temps d'accès et de modification d'un fichier de la même façon que B<utimes>(2), excepté que si I<filename> fait référence à un lien symbolique, le lien n'est pas déréférencé : à la place, les horodatages du lien symbolique sont modifiés.

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: Errors are as for B<utimes>(2), with the following additions for B<futimes>():
fr: Les erreurs sont les mêmes que pour B<utimes>(2), avec en plus pour B<futimes>()\ :

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

note: type: Plain text
en: The I</proc> filesystem could not be accessed.
fr: Impossible d'accéder au système de fichiers I</proc>.

note: type: Plain text
en: The following additional error may occur for B<lutimes>():
fr: Les erreurs suivantes peuvent également se produire lors de l'appel à B<lutimes>() :

note: type: Plain text
en: The kernel does not support this call; Linux 2.6.22 or later is required.
fr: Le noyau ne prend pas en charge cet appel ; un noyau Linux de version 2.6.22 ou supérieure est requis.

note: type: Plain text
en: B<futimes>()  is available since glibc 2.3.  B<lutimes>()  is available since glibc 2.6, and is implemented using the B<utimensat>(2)  system call, which is supported since kernel 2.6.22.
fr: B<futimes>() est disponible depuis la glibc 2.3. B<lutimes>() est disponible depuis la glibc 2.6 et est implémentée en utilisant l'appel système B<utimensat>(2) qui est pris en charge depuis le noyau 2.6.22.

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

note: type: Plain text
en: These functions are not specified in any standard.  Other than Linux, they are available only on the BSDs.
fr: Ces fonctions ne sont spécifiées par aucune norme. En dehors Linux, elles ne sont disponibles que sous les BSD.

note: type: TH
en: 2012-05-10
fr: 10 mai 2012

note: type: Plain text
en: futimesat - change timestamps of a file relative to a directory file descriptor
fr: futimesat - Modifier les horodatages d'un fichier relativement à un descripteur de fichier de répertoire

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

note: type: Plain text
en: This system call is obsolete.  Use B<utimensat>(2)  instead.
fr: Cet appel système est obsolète. Utilisez B<utimensat>(2) à la place.

note: type: Plain text
en: The B<futimesat>()  system call operates in exactly the same way as B<utimes>(2), except for the differences described in this manual page.
fr: L'appel système B<futimesat>() fonctionne exactement comme B<utimes>(2), les seules différences étant celles décrites sur cette page.

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<utimes>(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 courant du processus, comme pour B<utimes>(2) pour les chemins relatifs).

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<utimes>(2)).
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<utimes>(2).

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: On success, B<futimesat>()  returns a 0.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: En cas de réussite, B<futimesat>() renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> est définie.

note: type: Plain text
en: The same errors that occur for B<utimes>(2)  can also occur for B<futimesat>().  The following additional errors can occur for B<futimesat>():
fr: Les mêmes erreurs qui apparaissent pour B<utimes>(2) peuvent apparaître pour B<futimesat>(). Les erreurs supplémentaires suivantes peuvent également se produire pour B<futimesat>()\ :

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<futimesat>()  was added to Linux in kernel 2.6.16; library support was added to glibc in version 2.4.
fr: B<futimesat>() 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: This system call is nonstandard.  It was implemented from a specification that was proposed for POSIX.1, but that specification was replaced by the one for B<utimensat>(2).
fr: Cet appel système n'est pas standard. Il a été implémenté à partir d'une spécification qui avait été proposée pour POSIX.1, mais cette spécification a été remplacée par celle pour B<utimensat>(2).

note: type: Plain text
en: A similar system call exists on Solaris.
fr: Un appel système similaire existe sur Solaris.

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

note: The Solaris futimesat() also has this strangeness. type: Plain text
en: If I<pathname> is NULL, then the glibc B<futimesat>()  wrapper function updates the times for the file referred to by I<dirfd>.
fr: Si I<pathname> est NULL, la fonction enveloppe B<futimesat>() de la glibc met à jour les horodatages du fichier référencé par I<dirfd>.

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

note: type: Plain text
en: getdate, getdate_r - convert a date-plus-time string to broken-down time
fr: getdate, getdate_r - Conversion d'un temps sous forme de chaîne de caractères au format humain

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

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

note: type: Plain text
en: The function B<getdate>()  converts a string representation of a date and time, contained in the buffer pointed to by I<string>, into a broken-down time.  The broken-down time is stored in a I<tm> structure, and a pointer to this structure is returned as the function result.  This I<tm> structure is allocated in static storage, and consequently it will be overwritten by further calls to B<getdate>().
fr: La fonction B<getdate>() convertit une date et un temps sous forme de chaîne de caractères, contenue dans le tampon I<string>, au format humain. Le temps au format humain est sauvegardé dans une structure I<tm> et un pointeur vers cette structure est renvoyé. Cette structure est allouée statiquement, elle sera donc écrasée lors d'un prochain appel.

note: type: Plain text
en: In contrast to B<strptime>(3), (which has a I<format> argument), B<getdate>()  uses the formats found in the file whose full pathname is given in the environment variable B<DATEMSK>.  The first line in the file that matches the given input string is used for the conversion.
fr: Contrairement à B<strptime>(3), (qui a un argument I<format>), B<getdate>() utilise les formats présents dans le fichier dont le chemin d'accès complet est donné par la variable d'environnement B<DATEMSK>. La première ligne du fichier qui peut être mise en correspondance avec la chaîne passée en paramètre est utilisée pour la conversion.

note: type: Plain text
en: The matching is done case insensitively.  Superfluous whitespace, either in the pattern or in the string to be converted, is ignored.
fr: La correspondance n'est pas sensible à la casse. Les espaces superflus, qu'ils soient dans le motif ou dans la chaîne à convertir, sont ignorés.

note: type: Plain text
en: The conversion specifications that a pattern can contain are those given for B<strptime>(3).  One more conversion specification is specified in POSIX.1-2001:
fr: Les paramètres de conversion qu'un motif peut contenir sont les mêmes que pour B<strptime>(3). Un indicateur de conversion supplémentaire est spécifié dans POSIX.1-2001\ :

note: type: Plain text
en: Timezone name.  This is not implemented in glibc.
fr: Nom du fuseaux horaire (non implémenté dans le glibc).

note: type: Plain text
en: When B<%Z> is given, the structure containing the broken-down time is initialized with values corresponding to the current time in the given timezone.  Otherwise, the structure is initialized to the broken-down time corresponding to the current local time (as by a call to B<localtime>(3)).
fr: Lorsque B<%Z> est spécifié, la structure contenant le temps au format humain est initialisée avec le temps actuel du fuseaux horaire. Sinon, elle est initialisée sous forme humaine à l'heure locale (comme lors d'un appel à B<localtime>(3)).

note: type: Plain text
en: When only the day of the week is given, the day is taken to be the first such day on or after today.
fr: Lorsque seul le jour de la semaine est donné, le jour pris en compte sera le premier jour correspondant à partir d'aujourd'hui inclus.

note: type: Plain text
en: When only the month is given (and no year), the month is taken to be the first such month equal to or after the current month.  If no day is given, it is the first day of the month.
fr: Lorsque seul le mois est spécifié (et pas l'année), le mois pris en compte est le premier mois correspondant à partir du mois courant inclus. Si aucun jour n'est indiqué, le premier jour du mois est pris par défaut.

note: type: Plain text
en: When no hour, minute and second are given, the current hour, minute and second are taken.
fr: Lorsque les heures, minutes et secondes ne sont pas indiquées, l'heure courante (heures, minutes et secondes) est prise par défaut.

note: type: Plain text
en: If no date is given, but we know the hour, then that hour is taken to be the first such hour equal to or after the current hour.
fr: Si aucune date n'est indiquée, mais que l'on connaît l'heure, l'heure prise en compte sera la première occurrence de cette heure, à partir de l'heure courante incluse.

note: type: Plain text
en: B<getdate_r>()  is a GNU extension that provides a reentrant version of B<getdate>().  Rather than using a global variable to report errors and a static buffer to return the broken down time, it returns errors via the function result value, and returns the resulting broken-down time in the caller-allocated buffer pointed to by the argument I<res>.
fr: B<getdate_r> est une extension GNU qui fournit une version réentrante de B<getdate>. Au lieu d'utiliser une variable globale pour rapporter les erreurs et un tampon statique pour renvoyer le temps au format humain, elle renvoie les erreurs avec la valeur de retour de la fonction et le temps au format humain dans le tampon alloué par l'appelant pointé par I<res>.

note: type: Plain text
en: When successful, B<getdate>()  returns a pointer to a I<struct tm>.  Otherwise, it returns NULL and sets the global variable I<getdate_err> to one of the error numbers shown below.  Changes to I<errno> are unspecified.
fr: En cas de succès, B<getdate>() renvoie un pointeur vers une structure I<struct tm>. Sinon elle renvoie NULL et positionne la variable globale I<getdate_err> avec l'un des codes d'erreur ci-dessous. La modification éventuelle de I<errno> est indéfinie.

note: type: Plain text
en: On success B<getdate_r>()  returns 0; on error it returns one of the error numbers shown below.
fr: En cas de succès, B<getdate_r>() renvoie 0. En cas d'erreur, elle renvoie l'un des codes d'erreur ci-dessous.

note: type: Plain text
en: The following errors are returned via I<getdate_err> (for B<getdate>())  or as the function result (for B<getdate_r>()):
fr: Les erreurs suivantes sont renvoyées par I<getdate_err> (pour B<getdate>()) ou par le code de retour de la fonction (pour B<getdate_r>()).

note: type: Plain text
en: The B<DATEMSK> environment variable is not defined, or its value is an empty string.
fr: La variable d'environnement B<DATEMSK> est non définie ou sa valeur est une chaîne vide.

note: type: Plain text
en: The template file specified by B<DATEMSK> cannot be opened for reading.
fr: Le fichier de modèle spécifié par B<DATEMSK> ne peut être ouvert en lecture.

note: stat() type: Plain text
en: Failed to get file status information.
fr: Impossible de lire l'état du fichier.

note: type: Plain text
en: The template file is not a regular file.
fr: Le fichier de modèle n'est pas un fichier régulier.

note: type: Plain text
en: An error was encountered while reading the template file.
fr: Une erreur est survenue au cours de la lecture du fichier de modèle.

note: Error 6 doesn't seem to occur in glibc type: Plain text
en: Memory allocation failed (not enough memory available).
fr: Échec d'allocation mémoire (pas assez de mémoire disponible).

note: type: Plain text
en: There is no line in the file that matches the input.
fr: Il n'y a pas de ligne dans le fichier qui puisse être mise en correspondance avec l'entrée.

note: type: Plain text
en: Invalid input specification.
fr: Paramètres d'entrée invalides.

note: type: SH
en: ENVIRONMENT
fr: ENVIRONNEMENT

note: type: Plain text
en: File containing format patterns.
fr: Fichier contenant les motifs de formatage.

note: type: Plain text
en: Variables used by B<strptime>(3).
fr: Variables utilisées par B<strptime>(3).

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

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

note: type: Plain text
en: The POSIX.1-2001 specification for B<strptime>(3)  contains conversion specifications using the B<%E> or B<%O> modifier, while such specifications are not given for B<getdate>().  In glibc, B<getdate>()  is implemented using B<strptime>(3), so that precisely the same conversions are supported by both.
fr: La spécification POSIX.1-2001 pour B<strptime>(3) contient des spécifications de conversion utilisant les modificateurs B<%E> ou B<%O> alors que de tels modificateurs ne sont pas indiqués pour B<getdate>(). Dans la glibc, B<getdate>() est implémentée avec B<strptime>(3), si bien que les deux fonctions supportent exactement les mêmes conversions.

note: type: Plain text
en: The program below calls B<getdate>()  for each of its command-line arguments, and for each call displays the values in the fields of the returned I<tm> structure.  The following shell session demonstrates the operation of the program:
fr: Le programme ci-dessous appelle B<getdate>() pour chaque argument de la ligne de commande et affiche la valeur des champs de la structure I<tm> renvoyée. La session shell suivante montre des exemples d'utilisation de ce programme :

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

note: type: Plain text
en: gettimeofday, settimeofday - get / set time
fr: gettimeofday, settimeofday - Lire/écrire l'heure actuelle

note: type: Plain text
en: B<settimeofday>(): _BSD_SOURCE
fr: B<settimeofday>() : _BSD_SOURCE

note: type: Plain text
en: The functions B<gettimeofday>()  and B<settimeofday>()  can get and set the time as well as a timezone.  The I<tv> argument is a I<struct timeval> (as specified in I<E<lt>sys/time.hE<gt>>):
fr: Les fonctions B<gettimeofday>() et B<settimeofday>() servent à lire ou programmer l'heure ainsi que le fuseau horaire (timezone). L'argument I<tv> est une structure I<timeval> décrite dans I<E<lt>sys/time.hE<gt>>\ :

note: type: Plain text
en: and gives the number of seconds and microseconds since the Epoch (see B<time>(2)).  The I<tz> argument is a I<struct timezone>:
fr: et donne le nombre de secondes et microsecondes écoulées depuis l'époque (consultez B<time>(2)). L'argument I<tz> est une structure I<timezone> composée ainsi\ :

note: type: Plain text
en: struct timezone {
        int tz_minuteswest;     /* minutes west of Greenwich */
        int tz_dsttime;         /* type of DST correction */
    };
fr: struct timezone {
        int tz_minuteswest; /* minutes à l'ouest de Greenwich  */
        int tz_dsttime;     /* type de changement horaire      */
    };

note: FIXME The compilation warning looks to be going away in 2.17 see glibc commit 4b7634a5e03b0da6f8875de9d3f74c1cf6f2a6e8 The following is covered under EPERM below: .PP Only the superuser may use .BR settimeofday (). type: Plain text
en: If either I<tv> or I<tz> is NULL, the corresponding structure is not set or returned.  (However, compilation warnings will result if I<tv> is NULL.)
fr: Si I<tv> ou I<tz> est nulle, la structure correspondante n'est ni remplie ni renvoyée. (Cependant, des avertissements à la compilation seront émis si I<tv> est NULL.

note: type: Plain text
en: The use of the I<timezone> structure is obsolete; the I<tz> argument should normally be specified as NULL.  (See NOTES below.)
fr: L'utilisation de la structure I<timezone> est obsolète ; le paramètre I<tz> doit normalement être NULL. Consultez la section NOTES ci-dessous.

note: type: Plain text
en: Under Linux there are some peculiar "warp clock" semantics associated with the B<settimeofday>()  system call if on the very first call (after booting)  that has a non-NULL I<tz> argument, the I<tv> argument is NULL and the I<tz_minuteswest> field is nonzero.  (The I<tz_dsttime> field should be zero for this case.)  In such a case it is assumed that the CMOS clock is on local time, and that it has to be incremented by this amount to get UTC system time.  No doubt it is a bad idea to use this feature.
fr: Sous Linux, il existe une sémantique particulière associée à l'appel système B<settimeofday>() si, durant la première invocation (après le boot), il a un argument I<tz> non NULL, un argument I<tv> NULL et un champ I<tz_minuteswest> différent de zéro (dans ce cas, le champ I<tz_dsttime> doit être nul). Dans ce cas, on suppose que l'horloge CMOS de la machine est configurée sur le temps local, et que l'on doit l'augmenter de cette valeur pour obtenir le temps UTC. Bien entendu, il faut éviter autant que possible d'utiliser cette particularité.

note: type: Plain text
en: B<gettimeofday>()  and B<settimeofday>()  return 0 for success, or -1 for failure (in which case I<errno> is set appropriately).
fr: B<gettimeofday> et B<settimeofday> renvoient 0 s'ils réussissent, ou -1 s'ils échouent, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: One of I<tv> or I<tz> pointed outside the accessible address space.
fr: I<tv> ou I<tz> pointent en dehors de l'espace d'adressage autorisé.

note: type: Plain text
en: Timezone (or something else) is invalid.
fr: Le fuseau horaire (ou autre chose) est invalide.

note: type: Plain text
en: The calling process has insufficient privilege to call B<settimeofday>(); under Linux the B<CAP_SYS_TIME> capability is required.
fr: Le processus appelant n'a pas les privilèges suffisant pour appeler B<settimeofday>()\ ; sous Linux, la capacité B<CAP_SYS_TIME> est nécessaire.

note: type: Plain text
en: SVr4, 4.3BSD.  POSIX.1-2001 describes B<gettimeofday>()  but not B<settimeofday>().  POSIX.1-2008 marks B<gettimeofday>()  as obsolete, recommending the use of B<clock_gettime>(2)  instead.
fr: SVr4, BSD 4.3. POSIX.1-2001 décrit B<gettimeofday>() mais pas B<settimeofday>(). POSIX.1-2008 marque B<gettimeofday>() comme étant obsolète, en recommandant d'utiliser B<clock_gettime>(2) à la place.

note: type: Plain text
en: The time returned by B<gettimeofday>()  I<is> affected by discontinuous jumps in the system time (e.g., if the system administrator manually changes the system time).  If you need a monotonically increasing clock, see B<clock_gettime>(2).
fr: L'heure renvoyée par B<gettimeofday>() I<est> concernée par les sauts discontinus de l'heure système (c'est-à-dire si l'administrateur modifie l'heure système lui-même). Si vous devez incrémenter l'horloge de façon monotone, consultez B<clock_gettime>(2).

note: type: Plain text
en: Macros for operating on I<timeval> structures are described in B<timeradd>(3).
fr: Les macros opérant sur les structures I<timeval> sont décrites dans B<timeradd>(3).

note: type: Plain text
en: Traditionally, the fields of I<struct timeval> were of type I<long>.
fr: Traditionnellement, les champs de la structure I<timeval> étaient de type I<long>.

note: it has not been and will not be supported by libc or glibc. Each and every occurrence of this field in the kernel source (other than the declaration) is a bug. type: Plain text
en: The I<tz_dsttime> field has never been used under Linux.  Thus, the following is purely of historic interest.
fr: Le champ I<tz_dsttime> n'a jamais été utilisé sous Linux, c'est pourquoi le paragraphe ci-dessous n'est présent qu'à but historique.

note: type: Plain text
en: On old systems, the field I<tz_dsttime> contains a symbolic constant (values are given below)  that indicates in which part of the year Daylight Saving Time is in force.  (Note: this value is constant throughout the year: it does not indicate that DST is in force, it just selects an algorithm.)  The daylight saving time algorithms defined are as follows:
fr: Sur d'anciens systèmes, le champ I<tz_dsttime> contient une constante symbolique (dont les valeurs sont fournies ci\(hydessous) qui indique quelle partie du changement horaire annuel est en cours. (Remarque\ : cette valeur est constante tout au long de l'année, elle n'indique pas réellement la valeur horaire en cours, elle sélectionne un algorithme). Les changements horaires (Daylight Saving Time - DST) sont définis comme suit\ :

note: type: Plain text
en: B<DST_NONE>     /* not on DST */
fr: B<DST_NONE>     /* Aucun */

note: type: Plain text
en: B<DST_USA>      /* USA style DST */
fr: B<DST_USA>      /* USA */

note: type: Plain text
en: B<DST_AUST>     /* Australian style DST */
fr: B<DST_AUST>     /* Australie */

note: type: Plain text
en: B<DST_WET>      /* Western European DST */
fr: B<DST_WET>      /* Europe occidentale */

note: type: Plain text
en: B<DST_MET>      /* Middle European DST */
fr: B<DST_MET>      /* Europe centrale */

note: type: Plain text
en: B<DST_EET>      /* Eastern European DST */
fr: B<DST_EET>      /* Europe Orientale */

note: type: Plain text
en: B<DST_GB>       /* Great Britain and Eire */
fr: B<DST_GB>       /* Grande\(hyBretagne et Irlande */

note: type: Plain text
en: B<DST_RUM>      /* Romania */
fr: B<DST_RUM>      /* Roumanie */

note: type: Plain text
en: B<DST_TUR>      /* Turkey */
fr: B<DST_TUR>      /* Turquie */

note: type: Plain text
en: B<DST_AUSTALT>  /* Australian style with shift in 1986 */
fr: B<DST_AUSTALT>  /* Australie avec décalage en 1986 */

note: type: Plain text
en: Of course it turned out that the period in which Daylight Saving Time is in force cannot be given by a simple algorithm, one per country; indeed, this period is determined by unpredictable political decisions.  So this method of representing timezones has been abandoned.
fr: Il est évident que le décalage horaire en cours ne peut pas être uniquement fourni par un algorithme par pays. Ce décalage dépend de décisions politiques imprévisibles. Ainsi, cette méthode des fuseaux horaires a été abandonnée.

note: type: Plain text
en: nanosleep - high-resolution sleep
fr: nanosleep - Sommeil en haute résolution

note: type: Plain text
en: B<nanosleep>(): _POSIX_C_SOURCE\ E<gt>=\ 199309L
fr: B<nanosleep>() : _POSIX_C_SOURCE\ E<gt>=\ 199309L

note: type: Plain text
en: B<nanosleep>()  suspends the execution of the calling thread until either at least the time specified in I<*req> has elapsed, or the delivery of a signal that triggers the invocation of a handler in the calling thread or that terminates the process.
fr: B<nanosleep>() suspend l'exécution du thread appelant jusqu'à ce que le temps indiqué dans I<*req> ait expiré, ou que la réception d'un signal ait déclenché l'invocation d'un gestionnaire dans le thread appelant ou ait terminé le processus.

note: type: Plain text
en: If the call is interrupted by a signal handler, B<nanosleep>()  returns -1, sets I<errno> to B<EINTR>, and writes the remaining time into the structure pointed to by I<rem> unless I<rem> is NULL.  The value of I<*rem> can then be used to call B<nanosleep>()  again and complete the specified pause (but see NOTES).
fr: Si l'appel est interrompu par un gestionnaire de signal B<nanosleep>() renvoie -1, renseigne I<errno> avec la valeur B<EINTR>, et inscrit le temps restant dans la structure pointée par I<rem> à moins que I<rem> soit NULL. La valeur de I<*rem> peut être utilisée pour rappeler à nouveau B<nanosleep>() afin de terminer la pause (mais voir la section NOTES plus loin).

note: type: Plain text
en: The structure I<timespec> is used to specify intervals of time with nanosecond precision.  It is defined as follows:
fr: La structure I<timespec> est utilisée pour indiquer l'intervalle de temps en nanosecondes. Elle est définie comme ceci :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;        /* seconds */
        long   tv_nsec;       /* nanoseconds */
    };
fr: struct timespec {
        time_t tv_sec;        /* secondes     */
        long   tv_nsec;       /* nanosecondes */
    };

note: type: Plain text
en: The value of the nanoseconds field must be in the range 0 to 999999999.
fr: La valeur du champ nanosecondes doit être dans l'intervalle 0 à 999\ 999\ 999.

note: type: Plain text
en: Compared to B<sleep>(3)  and B<usleep>(3), B<nanosleep>()  has the following advantages: it provides a higher resolution for specifying the sleep interval; POSIX.1 explicitly specifies that it does not interact with signals; and it makes the task of resuming a sleep that has been interrupted by a signal handler easier.
fr: Par rapport à B<sleep>(3) et B<usleep>(3), B<nanosleep>() a les avantages suivants : il fournit une meilleure résolution pour indiquer la durée du sommeil ; POSIX.1 indique explicitement qu'il n'interagit avec aucun signal ; il permet enfin de continuer facilement un sommeil interrompu par un signal.

note: type: Plain text
en: On successfully sleeping for the requested interval, B<nanosleep>()  returns 0.  If the call is interrupted by a signal handler or encounters an error, then it returns -1, with I<errno> set to indicate the error.
fr: L'appel B<nanosleep>() renvoie 0 s'il réussit à suspendre l'exécution pour la durée demandée. Si l'appel est interrompu par un gestionnaire de signal ou rencontre une erreur, il renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: Problem with copying information from user space.
fr: Problème lors de la copie d'information à partir de l'espace utilisateur.

note: type: Plain text
en: The pause has been interrupted by a signal that was delivered to the thread.  The remaining sleep time has been written into I<*rem> so that the thread can easily call B<nanosleep>()  again and continue with the pause.
fr: La pause a été interrompue par un signal non bloqué délivré au thread. Le temps restant de sommeil a été inscrit dans I<*rem> pour que le thread puisse terminer facilement son sommeil en rappelant B<nanosleep>().

note: type: Plain text
en: If the interval specified in I<req> is not an exact multiple of the granularity underlying clock (see B<time>(7)), then the interval will be rounded up to the next multiple.  Furthermore, after the sleep completes, there may still be a delay before the CPU becomes free to once again execute the calling thread.
fr: Si l'intervalle indiqué dans I<req> n'est pas un multiple exact de la granularité de l'horloge sous-jacente (consultez B<time>(7)), l'intervalle est arrondi au multiple supérieur. De plus, après que le sommeil est achevé, il y a toujours un délai avant que le processeur ne redevienne complètement disponible pour le thread appelant.

note: type: Plain text
en: The fact that B<nanosleep>()  sleeps for a relative interval can be problematic if the call is repeatedly restarted after being interrupted by signals, since the time between the interruptions and restarts of the call will lead to drift in the time when the sleep finally completes.  This problem can be avoided by using B<clock_nanosleep>(2)  with an absolute time value.
fr: Le fait que B<nanosleep>() endorme pour une durée relative peut être problématique si l'appel est relancé de manière répétée après avoir été interrompu par des signaux, puisque le temps entre les interruptions et les redémarrages de l'appel connaîtra une dérive lorsque le sommeil sera finalement achevé. Ce problème peut être évité en utilisant B<clock_nanosleep>(2) avec une valeur de temps absolu.

note: See also http://thread.gmane.org/gmane.linux.kernel/696854/ Subject: nanosleep() uses CLOCK_MONOTONIC, should be CLOCK_REALTIME? Date: 2008-06-22 07:35:41 GMT type: Plain text
en: POSIX.1 specifies that B<nanosleep>()  should measure time against the B<CLOCK_REALTIME> clock.  However, Linux measures the time using the B<CLOCK_MONOTONIC> clock.  This probably does not matter, since the POSIX.1 specification for B<clock_settime>(2)  says that discontinuous changes in B<CLOCK_REALTIME> should not affect B<nanosleep>():
fr: POSIX.1 indique que B<nanosleep>() doit mesurer le temps avec l'horloge B<CLOCK_REALTIME>. Pourtant, Linux mesure le temps avec l'horloge B<CLOCK_MONOTONIC>. Cela n'a probablement pas d'importance car la spécification POSIX.1 de B<clock_settime>(2) indique que les modifications discontinues dans B<CLOCK_REALTIME> n'affectent pas B<nanosleep>() :

note: type: Plain text
en: Setting the value of the B<CLOCK_REALTIME> clock via B<clock_settime>(2)  shall have no effect on threads that are blocked waiting for a relative time service based upon this clock, including the B<nanosleep>()  function; ...  Consequently, these time services shall expire when the requested relative interval elapses, independently of the new or old value of the clock.
fr: Configurer la valeur de l'horloge B<CLOCK_REALTIME> avec B<clock_settime>(2) ne doit pas avoir d'effet sur les threads bloqués attendant un service de temps relatif basé sur cette horloge. Cela inclut la fonction B<nanosleep>()\ ; ...En conséquence, ces services de temps doivent expirer lorsque la durée relative demandée est atteinte, indépendamment de l'ancienne ou la nouvelle valeur de l'horloge.

note: type: SS
en: Old behavior
fr: Ancien comportement

note: type: Plain text
en: In order to support applications requiring much more precise pauses (e.g., in order to control some time-critical hardware), B<nanosleep>()  would handle pauses of up to 2\ ms by busy waiting with microsecond precision when called from a thread scheduled under a real-time policy like B<SCHED_FIFO> or B<SCHED_RR>.  This special extension was removed in kernel 2.5.39, hence is still present in current 2.4 kernels, but not in 2.6 kernels.
fr: Certaines applications nécessitant des pauses plus précises (par exemple pour le contrôle de périphériques matériels avec un délai critique), B<nanosleep>() peut aussi offrir des pauses avec une précision plus élevée. Si le thread est mis sous le contrôle d'une politique d'ordonnancement temps réel comme B<SCHED_FIFO> ou B<SCHED_RR>, les pauses jusqu'à 2\ ms seront effectuées avec des boucles actives d'une précision de l'ordre de la microseconde. Cette extension spéciale a été supprimée dans le noyau 2.5.39, et est donc toujours présente dans les noyaux 2.4, mais pas dans les noyaux 2.6.

note: type: Plain text
en: In Linux 2.4, if B<nanosleep>()  is stopped by a signal (e.g., B<SIGTSTP>), then the call fails with the error B<EINTR> after the thread is resumed by a B<SIGCONT> signal.  If the system call is subsequently restarted, then the time that the thread spent in the stopped state is I<not> counted against the sleep interval.
fr: Dans Linux 2.4, si B<nanosleep>() est arrêté par un signal (par exemple, B<SIGTSTP>), l'appel échoue avec l'erreur B<EINTR> après que le thread a repris avec un signal B<SIGCONT>. Si l'appel système est, par la suite, relancé, le temps passé par le thread dans l'état arrêté I<n'est pas> comptabilisé dans l'intervalle de sommeil.

note: type: TH
en: 2010-02-25
fr: 25 février 2010

note: type: Plain text
en: rtc - real-time clock
fr: rtc - Horloge temps réel

note: type: Plain text
en: This is the interface to drivers for real-time clocks (RTCs).
fr: Il s'agit d'une interface aux pilotes pour les horloges temps réel (RTC).

note: type: Plain text
en: Most computers have one or more hardware clocks which record the current "wall clock" time.  These are called "Real Time Clocks" (RTCs).  One of these usually has battery backup power so that it tracks the time even while the computer is turned off.  RTCs often provide alarms and other interrupts.
fr: La plupart des ordinateurs disposent d'une ou plusieurs horloges matérielles intégrées, enregistrant l'heure locale. Elles sont appelées «\ horloges temps réel\ » (RTC). L'une d'entre elles est généralement alimentée par une pile afin de rester à l'heure une fois l'ordinateur éteint. Les RTC permettent souvent d'utiliser des alarmes et d'autres interruptions.

note: type: Plain text
en: All i386 PCs, and ACPI-based systems, have an RTC that is compatible with the Motorola MC146818 chip on the original PC/AT.  Today such an RTC is usually integrated into the mainboard's chipset (south bridge), and uses a replaceable coin-sized backup battery.
fr: Tous les PC i386 et les systèmes basés sur ACPI ont une RTC compatible avec la puce Motorola\ MC146818 du PC/AT d'origine. Aujourd'hui l'horloge est généralement intégrée au jeu de composants de la carte mère («\ south bridge\ ») et utilise une pile de secours remplaçable de la taille d'une pièce de monnaie.

note: type: Plain text
en: Non-PC systems, such as embedded systems built around system-on-chip processors, use other implementations.  They usually won't offer the same functionality as the RTC from a PC/AT.
fr: Les systèmes autres que les PC, comme les systèmes embarqués construits autour de processeurs embarquant tout le système, utilisent d'autres mises en œuvre. Généralement, ils n'offrent pas les mêmes fonctionnalités qu'une RTC de PC/AT.

note: type: SS
en: RTC vs system clock
fr: RTC vs horloge système

note: type: Plain text
en: RTCs should not be confused with the system clock, which is a software clock maintained by the kernel and used to implement B<gettimeofday>(2)  and B<time>(2), as well as setting timestamps on files, and so on.  The system clock reports seconds and microseconds since a start point, defined to be the POSIX Epoch: 1970-01-01 00:00:00 +0000 (UTC).  (One common implementation counts timer interrupts, once per "jiffy", at a frequency of 100, 250, or 1000 Hz.)  That is, it is supposed to report wall clock time, which RTCs also do.
fr: Les RTC ne doivent pas être confondues avec l'horloge système, qui est une horloge logicielle gérée par le noyau et utilisée dans B<gettimeofday>(2) et B<time>(2), ainsi que pour le marquage temporel des fichiers, etc. L'horloge système indique le nombre de secondes et microsecondes écoulées depuis un instant de départ, défini comme depuis l'époque POSIX\ : 1er\ janvier 1970 à 00:00:00 (UTC). (Une mise en œuvre usuelle compte le nombre d'interruptions, une par pulsation à une fréquence de 100, 250 ou 1000\ Hz.) C'est-à-dire qu'elle est supposée renvoyer l'heure locale, comme le font les RTC.

note: type: Plain text
en: A key difference between an RTC and the system clock is that RTCs run even when the system is in a low power state (including "off"), and the system clock can't.  Until it is initialized, the system clock can only report time since system boot ... not since the POSIX Epoch.  So at boot time, and after resuming from a system low power state, the system clock will often be set to the current wall clock time using an RTC.  Systems without an RTC need to set the system clock using another clock, maybe across the network or by entering that data manually.
fr: Une différence clé entre une RTC et l'horloge système est qu'une RTC fonctionne même lorsque le système est dans un état de veille d'alimentation (incluant «\ éteint\ ») et que l'horloge système ne peut fonctionner. Jusqu'à son initialisation, l'horloge système ne peut indiquer que le temps écoulé depuis le démarrage du système mais pas celui depuis l'époque POSIX. Ainsi, au démarrage et après la sortie de veille, l'horloge système sera souvent réglée à l'heure locale actuelle en utilisant une RTC. Les systèmes sans RTC ont besoin de régler leur horloge système par un autre moyen, peut-être à travers le réseau ou en entrant les valeurs à la main.

note: type: SS
en: RTC functionality
fr: Fonctionnalités d'une RTC

note: type: Plain text
en: RTCs can be read and written with B<hwclock>(8), or directly with the ioctl requests listed below.
fr: Les RTC peuvent être lues et réglées avec B<hwclock>(8), ou directement en utilisant les ioctl listés ci-dessous.

note: type: Plain text
en: Besides tracking the date and time, many RTCs can also generate interrupts
fr: En plus du compte de la date et de l'heure, de nombreuses RTC peuvent aussi générer des interruptions\ :

note: type: Plain text
en: on every clock update (i.e., once per second);
fr: à chaque mise à jour de l'horloge (c.-à-d.. une fois par seconde)\ ;

note: type: Plain text
en: at periodic intervals with a frequency that can be set to any power-of-2 multiple in the range 2 Hz to 8192 Hz;
fr: à des intervalles réguliers, de fréquence réglable à une puissance de 2 entre 2\ Hz et 8192\ Hz\ ;

note: type: Plain text
en: on reaching a previously specified alarm time.
fr: lorsque la date d'une alarme réglée auparavant est atteinte.

note: type: Plain text
en: Each of those interrupt sources can be enabled or disabled separately.  On many systems, the alarm interrupt can be configured as a system wakeup event, which can resume the system from a low power state such as Suspend-to-RAM (STR, called S3 in ACPI systems), Hibernation (called S4 in ACPI systems), or even "off" (called S5 in ACPI systems).  On some systems, the battery backed RTC can't issue interrupts, but another one can.
fr: Chacune de ces sources d'interruptions peut être activée ou désactivée séparément. Sur de nombreux systèmes, l'interruption venant de l'alarme peut être configurée comme un événement déclenchant le réveil du système, et ainsi sortir le système d'un état de veille d'alimentation comme la veille en RAM (STR, appelée S3 dans les systèmes ACPI), l'hibernation (appelée S4 dans les systèmes ACPI) ou même l'extinction (appelée S5 dans les systèmes ACPI). Sur certains systèmes, la pile de secours de la RTC ne peut générer d'interruptions, alors qu'une autre le peut.

note: type: Plain text
en: The I</dev/rtc> (or I</dev/rtc0>, I</dev/rtc1>, etc.)  device can be opened only once (until it is closed) and it is read-only.  On B<read>(2)  and B<select>(2)  the calling process is blocked until the next interrupt from that RTC is received.  Following the interrupt, the process can read a long integer, of which the least significant byte contains a bit mask encoding the types of interrupt that occurred, while the remaining 3 bytes contain the number of interrupts since the last B<read>(2).
fr: Le périphérique I</dev/rtc> (ou I</dev/rtc0>, I</dev/rtc1>, etc.) est en lecture seule et un seul accès simultané est possible. Un processus appelant B<read>(2) ou B<select>(2) est bloqué jusqu'à la réception de l'interruption RTC suivante. Suite à l'interruption, le processus peut lire un entier long, dont l'octet de poids faible contient le type d'interruption qui vient de se produire et les 3\ octets restants contiennent le nombre d'interruptions depuis le dernier appel à B<read>(2).

note: type: SS
en: ioctl(2) interface
fr: Interface ioctl(2)

note: type: Plain text
en: The following B<ioctl>(2)  requests are defined on file descriptors connected to RTC devices:
fr: Les appels B<ioctl>(2) suivants sont définis sur les descripteurs des fichiers associés aux périphériques RTC\ :

note: type: Plain text
en: Returns this RTC's time in the following structure:
fr: Renvoie l'heure de cette RTC dans la structure suivante\ :

note: type: Plain text
en: struct rtc_time {
        int tm_sec;
        int tm_min;
        int tm_hour;
        int tm_mday;
        int tm_mon;
        int tm_year;
        int tm_wday;     /* unused */
        int tm_yday;     /* unused */
        int tm_isdst;    /* unused */
    };
fr: struct rtc_time {
        int tm_sec;
        int tm_min;
        int tm_hour;
        int tm_mday;
        int tm_mon;
        int tm_year;
        int tm_wday;     /* non utilisé */
        int tm_yday;     /* non utilisé */
        int tm_isdst;    /* non utilisé */
    };

note: type: Plain text
en: The fields in this structure have the same meaning and ranges as for the I<tm> structure described in B<gmtime>(3).  A pointer to this structure should be passed as the third B<ioctl>(2)  argument.
fr: Les membres de cette structure ont les mêmes sens et les mêmes portées que la ceux de la structure I<tm> décrite dans B<gmtime>(3). Un pointeur vers cette structure est attendu en troisième paramètre pour B<ioctl>(2).

note: type: Plain text
en: Sets this RTC's time to the time specified by the I<rtc_time> structure pointed to by the third B<ioctl>(2)  argument.  To set the RTC's time the process must be privileged (i.e., have the B<CAP_SYS_TIME> capability).
fr: Règle cette horloge RTC à l'heure spécifiée par la structure I<rtc_time> vers laquelle pointe le troisième paramètre passé à B<ioctl>(2). Pour pouvoir modifier l'heure RTC, le processus doit être privilégié (i.e. disposer du droit B<CAP_SYS_TIME>).

note: type: Plain text
en: Read and set the alarm time, for RTCs that support alarms.  The alarm interrupt must be separately enabled or disabled using the B<RTC_AIE_ON>, B<RTC_AIE_OFF> requests.  The third B<ioctl>(2)  argument is a pointer to an I<rtc_time> structure.  Only the I<tm_sec>, I<tm_min>, and I<tm_hour> fields of this structure are used.
fr: Lit et règle l'heure d'alarme, pour les horloges RTC qui gèrent les alarmes. L'interruption venant de l'alarme doit être activée ou désactivée séparément en utilisant respectivement les requêtes B<RTC_AIE_ON> ou B<RTC_AIE_OFF>. Le troisième paramètre d'B<ioctl>(2) est un pointeur vers une structure I<rtc_time>. Seuls les champs I<tm_sec>, I<tm_min>, et I<tm_hour> de cette structure sont utilisés.

note: type: Plain text
en: Read and set the frequency for periodic interrupts, for RTCs that support periodic interrupts.  The periodic interrupt must be separately enabled or disabled using the B<RTC_PIE_ON>, B<RTC_PIE_OFF> requests.  The third B<ioctl>(2)  argument is an I<unsigned long\ *> or an I<unsigned long>, respectively.  The value is the frequency in interrupts per second.  The set of allowable frequencies is the multiples of two in the range 2 to 8192.  Only a privileged process (i.e., one having the B<CAP_SYS_RESOURCE> capability) can set frequencies above the value specified in I</proc/sys/dev/rtc/max-user-freq>.  (This file contains the value 64 by default.)
fr: Lit et règle la fréquence des interruptions, pour les horloges RTC gérant les interruptions périodiques. L'interruption périodique doit être activée ou désactivée séparément en utilisant respectivement les requêtes B<RTC_PIE_ON> ou B<RTC_PIE_OFF>. Le troisième paramètre d'B<ioctl>(2) est un I<unsigned long\ *> ou un I<unsigned long> respectivement. La valeur représente la fréquence en interruptions par seconde. Le jeu des fréquences permises est l'ensemble des multiples de deux entre 2 et 8192. Seul un processus privilégié (i.e. disposant du droit B<CAP_SYS_RESOURCE>) peut régler une fréquence supérieure à celle spécifiée dans I</proc/sys/dev/rtc/max-user-freq>, par défaut 64.

note: type: Plain text
en: Enable or disable the alarm interrupt, for RTCs that support alarms.  The third B<ioctl>(2)  argument is ignored.
fr: Active ou désactive l'interruption venant de l'alarme, pour les RTC qui gèrent les alarmes. Le troisième paramètre d'B<ioctl>(2) est ignoré.

note: type: Plain text
en: Enable or disable the interrupt on every clock update, for RTCs that support this once-per-second interrupt.  The third B<ioctl>(2)  argument is ignored.
fr: Active ou désactive l'interruption à chaque mise à jour, pour les horloges gérant cette interruption envoyée chaque seconde. Le troisième paramètre d'B<ioctl>(2) est ignoré.

note: type: Plain text
en: Enable or disable the periodic interrupt, for RTCs that support these periodic interrupts.  The third B<ioctl>(2)  argument is ignored.  Only a privileged process (i.e., one having the B<CAP_SYS_RESOURCE> capability) can enable the periodic interrupt if the frequency is currently set above the value specified in I</proc/sys/dev/rtc/max-user-freq>.
fr: Active ou désactive l'interruption périodique, pour les RTC gérant ces interruptions périodiques. Le troisième paramètre d'B<ioctl>(2) est ignoré. Seul un processus privilégié (i.e. disposant du droit B<CAP_SYS_RESOURCE>) peut régler une fréquence supérieure à celle spécifiée dans I</proc/sys/dev/rtc/max-user-freq>.

note: type: Plain text
en: Many RTCs encode the year in an 8-bit register which is either interpreted as an 8-bit binary number or as a BCD number.  In both cases, the number is interpreted relative to this RTC's Epoch.  The RTC's Epoch is initialized to 1900 on most systems but on Alpha and MIPS it might also be initialized to 1952, 1980, or 2000, depending on the value of an RTC register for the year.  With some RTCs, these operations can be used to read or to set the RTC's Epoch, respectively.  The third B<ioctl>(2)  argument is a I<unsigned long\ *> or a I<unsigned long>, respectively, and the value returned (or assigned) is the Epoch.  To set the RTC's Epoch the process must be privileged (i.e., have the B<CAP_SYS_TIME> capability).
fr: De nombreuses RTC codent l'année dans un registre de 8\ bits, interprété soit comme un nombre binaire de 8\ bits, soit comme un nombre BCD. Dans les deux cas, le nombre est interprété relativement à l'époque de cette RTC. L'époque de la RTC est initialisé à 1900 sur la plupart des systèmes, sauf sur Alpha et Mips où il peut être initialisé à 1952, 1980 ou 2000, suivant la valeur du registre RTC destiné à l'année. Avec certaines RTC, ces opérations peuvent être utilisées respectivement pour lire ou régler l'époque de la RTC. Le troisième paramètre B<ioctl>(2) est respectivement un I<unsigned long\ *> ou un I<unsigned long>, et la valeur de retour (ou assignée) est l'époque. Pour régler l'époque RTC, le processus doit être privilégié (i.e. disposer du droit B<CAP_SYS_TIME>).

note: type: Plain text
en: Some RTCs support a more powerful alarm interface, using these ioctls to read or write the RTC's alarm time (respectively) with this structure:
fr: Certaines RTC disposent d'une interface pour les alarmes plus puissante, utilisant ces ioctl pour lire ou écrire l'heure de l'alarme de la RTC avec cette structure\ :

note: type: Plain text
en: The I<enabled> flag is used to enable or disable the alarm interrupt, or to read its current status; when using these calls, B<RTC_AIE_ON> and B<RTC_AIE_OFF> are not used.  The I<pending> flag is used by B<RTC_WKALM_RD> to report a pending interrupt (so it's mostly useless on Linux, except when talking to the RTC managed by EFI firmware).  The I<time> field is as used with B<RTC_ALM_READ> and B<RTC_ALM_SET> except that the I<tm_mday>, I<tm_mon>, and I<tm_year> fields are also valid.  A pointer to this structure should be passed as the third B<ioctl>(2)  argument.
fr: L'attribut I<enabled> est utilisé pour activer ou désactiver l'interruption venant de l'alarme, ou pour lire son état actuel\ ; lorsque ces appels sont utilisés, B<RTC_AIE_ON> et B<RTC_AIE_OFF> ne sont pas utilisés. L'attribut I<pending> est utilisé par B<RTC_WKALM_RD> pour signaler une interruption en attente (c'est en général inutile sous Linux, excepté lors du dialogue avec la RTC gérée par un microcode EFI). Le champ I<time> est autant utilisé par B<RTC_ALM_READ> et B<RTC_ALM_SET>, excepté que les champs I<tm_mday>, I<tm_mon> et I<tm_year> sont également valides. Un pointeur vers cette structure doit être passé en troisième paramètre B<ioctl>(2).

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: I</dev/rtc>, I</dev/rtc0>, I</dev/rtc1>, etc: RTC special character device files.
fr: I</dev/rtc>, I</dev/rtc0>, I</dev/rtc1>\ : fichiers spéciaux de périphérique caractère des différentes RTC.

note: type: Plain text
en: I</proc/driver/rtc>: status of the (first) RTC.
fr: I</proc/driver/rtc>\ : état de la (première) RTC.

note: type: Plain text
en: When the kernel's system time is synchronized with an external reference using B<adjtimex>(2)  it will update a designated RTC periodically every 11 minutes.  To do so, the kernel has to briefly turn off periodic interrupts; this might affect programs using that RTC.
fr: Lorsque l'horloge du noyau est synchronisée avec une référence externe en utilisant B<adjtimex>(2), le noyau met à jour une RTC désignée toutes les 11\ minutes. Pour y parvenir, le noyau doit arrêter brièvement les interruptions périodiques, ce qui peut affecter les programmes utilisant cette RTC.

note: type: Plain text
en: An RTC's Epoch has nothing to do with the POSIX Epoch which is used only for the system clock.
fr: L'époque d'une RTC n'a rien à voir avec l'époque POSIX, utilisé uniquement pour l'horloge système.

note: type: Plain text
en: If the year according to the RTC's Epoch and the year register is less than 1970 it is assumed to be 100 years later, that is, between 2000 and 2069.
fr: Si l'année relative à l'époque de la RTC et au registre de l'année est inférieure à 1970, on considère que l'année est de 100\ ans supérieure, c.-à-d. entre 2000 et 2069.

note: type: Plain text
en: Some RTCs support "wildcard" values in alarm fields, to support scenarios like periodic alarms at fifteen minutes after every hour, or on the first day of each month.  Such usage is nonportable; portable user-space code only expects a single alarm interrupt, and will either disable or reinitialize the alarm after receiving it.
fr: Certaines RTC gèrent les caractères génériques («\ wildcard \ ») dans les champs des alarmes, destinés aux scénarios comme les alarmes périodiques toutes les quinze minutes après chaque heure, ou au premier jour de chaque mois. Une telle utilisation n'est pas portable\ ; un code en espace utilisateur portable n'attend qu'une seule interruption d'alarme, puis désactivera ou réinitialisera cette alarme après l'avoir reçue.

note: type: Plain text
en: Some RTCs support periodic interrupts with periods that are multiples of a second rather than fractions of a second; multiple alarms; programmable output clock signals; nonvolatile memory; and other hardware capabilities that are not currently exposed by this API.
fr: Certaines RTC gèrent des interruptions de périodes multiples d'une seconde plutôt qu'en fractions de secondes, des alarmes multiples, la programmation de signaux de sortie d'horloge, la mémoire non volatile, et d'autres possibilités matérielles qui ne sont pas accessibles par cette API.

note: type: Plain text
en: I<Documentation/rtc.txt> in the Linux kernel source tree
fr: I<Documentation/rtc.txt> dans les sources du noyau Linux

note: type: Plain text
en: stime - set time
fr: stime - Configurer l'horloge du système

note: type: Plain text
en: B<stime>(): _SVID_SOURCE
fr: B<stime>() : _SVID_SOURCE

note: type: Plain text
en: B<stime>()  sets the system's idea of the time and date.  The time, pointed to by I<t>, is measured in seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  B<stime>()  may be executed only by the superuser.
fr: B<stime>() configure l'horloge interne du système. La valeur temporelle pointée par I<t>, est mesurée en secondes écoulées depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 (UTC). B<stime>() ne peut être exécuté que par le superutilisateur.

note: type: Plain text
en: Error in getting information from user space.
fr: Erreur lors de la récupération d'information à partir de l'espace utilisateur.

note: type: Plain text
en: The calling process has insufficient privilege.  Under Linux the B<CAP_SYS_TIME> privilege is required.
fr: Le processus appelant n'a pas les privilèges suffisants. Sous Linux, la capacité B<CAP_SYS_TIME> est nécessaire.

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

note: type: Plain text
en: strftime - format date and time
fr: strftime - Formater la date et l'heure

note: FIXME POSIX says: Local timezone information is used as though strftime() called tzset().  But this doesn't appear to be the case type: Plain text
en: The B<strftime>()  function formats the broken-down time I<tm> according to the format specification I<format> and places the result in the character array I<s> of size I<max>.
fr: La fonction B<strftime>() formate les divers champs de la structure I<tm> en fonction de la chaîne de spécification I<format>, puis place le résultat dans la chaîne I<s> de taille I<max>.

note: type: Plain text
en: The format specification is a null-terminated string and may contain special character sequences called I<conversion specifications>, each of which is introduced by a \(aq%\(aq character and terminated by some other character known as a I<conversion specifier character>.  All other character sequences are I<ordinary character sequences>.
fr: La spécification de format est une chaîne terminée par un caractère nul, qui peut contenir des séquences de caractères spéciales appelées I<spécifications de conversion>, chacune commence par un character «\ %\ », et se termine par un autre caractère, appelé I<caractère spécificateur de conversion>. Toutes les autres séquences de caractères sont des I<séquences de caractères ordinaires>.

note: type: Plain text
en: The characters of ordinary character sequences (including the null byte)  are copied verbatim from I<format> to I<s>.  However, the characters of conversion specifications are replaced as follows:
fr: Les caractères des séquences de caractères ordinaires (y compris le caractère nul) sont copiés tels quels depuis I<format> dans I<s>. Cependant, les caractères spécificateurs de conversion sont remplacés comme suit\ :

note: type: Plain text
en: The abbreviated name of the day of the week according to the current locale.
fr: Le nom abrégé du jour de la semaine, en fonction de la localisation en cours.

note: type: Plain text
en: The full name of the day of the week according to the current locale.
fr: Le nom complet du jour de la semaine, en fonction de la localisation en cours.

note: type: Plain text
en: The abbreviated month name according to the current locale.
fr: Le nom abrégé du mois, en fonction de la localisation en cours.

note: type: Plain text
en: The full month name according to the current locale.
fr: Le nom complet du mois, en fonction de la localisation en cours.

note: type: Plain text
en: The preferred date and time representation for the current locale.
fr: La représentation classique de la date et de l'heure, suivant la localisation en cours.

note: type: Plain text
en: The century number (year/100) as a 2-digit integer. (SU)
fr: Le siècle (année/100) sous forme de nombre de deux chiffres. (SU)

note: type: Plain text
en: The day of the month as a decimal number (range 01 to 31).
fr: Le quantième du mois sous forme de nombre décimal (entre 01 et 31).

note: type: Plain text
en: Equivalent to B<%m/%d/%y>.  (Yecch\(emfor Americans only.  Americans should note that in other countries B<%d/%m/%y> is rather common.  This means that in international context this format is ambiguous and should not be used.) (SU)
fr: Équivalent à B<%m/%d/%y>. Seulement pour les américains. Ces derniers doivent noter que les autres pays préfèrent le format B<%d/%m/%y>. Dans un contexte international, ce format est ambigu et doit être évité. (SU)

note: type: Plain text
en: Like B<%d>, the day of the month as a decimal number, but a leading zero is replaced by a space. (SU)
fr: Comme B<%d>, le quantième du mois sous forme décimal, mais l'éventuel zéro en tête est remplacé par un espace. (SU)

note: type: Plain text
en: Modifier: use alternative format, see below. (SU)
fr: Modificateur\ : utiliser un format de rechange. Voir plus bas. (SU)

note: type: Plain text
en: Equivalent to B<%Y-%m-%d> (the ISO\ 8601 date format). (C99)
fr: Équivalent à B<%Y-%m-%d> (format de date ISO 8601). (C99)

note: type: Plain text
en: The ISO\ 8601 week-based year (see NOTES) with century as a decimal number.  The 4-digit year corresponding to the ISO week number (see B<%V>).  This has the same format and value as B<%Y>, except that if the ISO week number belongs to the previous or next year, that year is used instead. (TZ)
fr: L'année ISO 8601 basée sur les semaines (voir la section NOTES) sous forme de nombre décimal, avec le siècle. L'année sur quatre chiffres correspondant au numéro de la semaine ISO (consultez B<%V>). C'est le même format que B<%Y>, sauf que si le numéro de semaine appartient à l'année suivante ou précédente, c'est celle-ci qui est affichée à la place. (TZ)

note: type: Plain text
en: Like B<%G>, but without century, that is, with a 2-digit year (00-99). (TZ)
fr: Comme B<%G> sans le siècle, c'est-à-dire avec une année sur deux chiffres (00-99). (TZ)

note: type: Plain text
en: Equivalent to B<%b>.  (SU)
fr: Équivalent à B<%b>. (SU)

note: type: Plain text
en: The hour as a decimal number using a 24-hour clock (range 00 to 23).
fr: L'heure, sur 24 heures, sous forme de nombre décimal (entre 00 et 23).

note: type: Plain text
en: The hour as a decimal number using a 12-hour clock (range 01 to 12).
fr: L'heure, sur 12 heures, sous forme de nombre décimal (entre 01 et 12).

note: type: Plain text
en: The day of the year as a decimal number (range 001 to 366).
fr: Le numéro du jour dans l'année (entre 001 et 366).

note: type: Plain text
en: The hour (24-hour clock) as a decimal number (range 0 to 23); single digits are preceded by a blank.  (See also B<%H>.)  (TZ)
fr: L'heure (sur 24 heures) sous forme de nombre décimal (intervalle 0 à 23). Les chiffres uniques sont précédés d'un blanc (voir aussi B<%H>). (TZ).

note: type: Plain text
en: The hour (12-hour clock) as a decimal number (range 1 to 12); single digits are preceded by a blank.  (See also B<%I>.)  (TZ)
fr: L'heure (sur 12 heures) sous forme de nombre décimal (intervalle 1 à 12). Les chiffres uniques sont précédés d'un blanc (voir aussi B<%I>). (TZ).

note: type: Plain text
en: The month as a decimal number (range 01 to 12).
fr: Le numéro du mois (entre 01 et 12).

note: type: Plain text
en: The minute as a decimal number (range 00 to 59).
fr: La minute, sous forme de nombre décimal (00 à 59).

note: type: Plain text
en: A newline character. (SU)
fr: Un caractère saut-de-ligne. (SU)

note: type: Plain text
en: Either "AM" or "PM" according to the given time value, or the corresponding strings for the current locale.  Noon is treated as "PM" and midnight as "AM".
fr: L'une des deux chaînes «\ AM\ » ou «\ PM\ » en fonction de l'heure, ou la traduction de ces chaînes en fonctions de la localisation en cours. Midi est traité comme «\ PM\ » et minuit comme «\ AM\ ».

note: type: Plain text
en: Like B<%p> but in lowercase: "am" or "pm" or a corresponding string for the current locale. (GNU)
fr: Comme B<%p> mais en minuscule: «\ am\ » ou «\ pm\ » ou une chaîne locale équivalente. (GNU)

note: type: Plain text
en: The time in a.m. or p.m. notation.  In the POSIX locale this is equivalent to B<%I:%M:%S %p>.  (SU)
fr: L'heure en notation a.m. ou p.m. Dans la localisation POSIX, c'est équivalent à B<%I:%M:%S %p>. (SU)

note: type: Plain text
en: The time in 24-hour notation (B<%H:%M>).  (SU)  For a version including the seconds, see B<%T> below.
fr: L'heure en format 24 heures (B<%H:%M>). (SU). Pour avoir les secondes consultez B<%T>.

note: type: Plain text
en: The number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC). (TZ)
fr: Le nombre de secondes écoulées depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 UTC. (TZ).

note: type: Plain text
en: The second as a decimal number (range 00 to 60).  (The range is up to 60 to allow for occasional leap seconds.)
fr: La seconde, sous forme de nombre décimal (00-60). L'intervalle peut être supérieur à 60 pour autoriser des secondes de rattrapage.

note: type: Plain text
en: A tab character. (SU)
fr: Un caractère de tabulation. (SU)

note: type: Plain text
en: The time in 24-hour notation (B<%H:%M:%S>).  (SU)
fr: L'heure en notation 24 heures (B<%H:%M:%S>). (SU)

note: type: Plain text
en: The day of the week as a decimal, range 1 to 7, Monday being 1.  See also B<%w>.  (SU)
fr: Le jour de la semaine sous forme décimal, de 1 (lundi) à 7. Consultez aussi B<%w>. (SU)

note: type: Plain text
en: The week number of the current year as a decimal number, range 00 to 53, starting with the first Sunday as the first day of week 01.  See also B<%V> and B<%W>.
fr: Le numéro de la semaine dans l'année, sous forme de nombre décimal (00-53), en commençant le comptage au premier dimanche de l'année. Consultez aussi B<%V> et B<%W>.

note: type: Plain text
en: The ISO\ 8601 week number (see NOTES) of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the new year.  See also B<%U> and B<%W>.  (SU)
fr: Le numéro de semaine ISO 8601 (voir la section NOTES) de l'année en cours sous forme de nombre décimal dans l'intervalle 01-53, où la semaine 1 est la première ayant au moins 4 jours dans l'année en cours. Consultez aussi B<%U> et B<%W>. (SU)

note: type: Plain text
en: The day of the week as a decimal, range 0 to 6, Sunday being 0.  See also B<%u>.
fr: Le numéro du jour de la semaine, sous forme décimale (0-6), dimanche valant 0. Consultez aussi B<%u>.

note: type: Plain text
en: The week number of the current year as a decimal number, range 00 to 53, starting with the first Monday as the first day of week 01.
fr: Le numéro de la semaine dans l'année, sous forme de nombre décimal (00-53), en commençant le comptage au premier lundi de l'année.

note: type: Plain text
en: The preferred date representation for the current locale without the time.
fr: La représentation usuelle de la date, sans l'heure, dans la localisation en cours.

note: type: Plain text
en: The preferred time representation for the current locale without the date.
fr: La représentation usuelle de l'heure, sans la date, dans la localisation en cours.

note: type: Plain text
en: The year as a decimal number without a century (range 00 to 99).
fr: L'année, sous forme de nombre décimal, sans le siècle (entre 00 et 99).

note: type: Plain text
en: The year as a decimal number including the century.
fr: L'année, sous forme de nombre décimal, incluant le siècle.

note: type: Plain text
en: The I<+hhmm> or I<-hhmm> numeric timezone (that is, the hour and minute offset from UTC). (SU)
fr: Le fuseau horaire (c'est-à-dire le décalage en heures et minutes par rapport à UTC) sous forme numérique I<+hhmm> ou I<-hhmm>. (SU)

note: type: Plain text
en: The timezone name or abbreviation.
fr: Le nom ou l'abréviation du fuseau horaire.

note: Nov 05 -- Not in Linux/glibc, but is in some BSDs (according to their man pages) type: Plain text
en: The date and time in B<date>(1)  format. (TZ)  (Not supported in glibc2.)
fr: La date et l'heure au format B<date>(1). (TZ) (Non supporté par la glibc2)

note: type: Plain text
en: A literal \(aq%\(aq character.
fr: Un caractère «\ %\ ».

note: type: Plain text
en: Some conversion specifications can be modified by preceding the conversion specifier character by the B<E> or B<O> I<modifier> to indicate that an alternative format should be used.  If the alternative format or specification does not exist for the current locale, the behavior will be as if the unmodified conversion specification were used. (SU)  The Single UNIX Specification mentions B<%Ec>, B<%EC>, B<%Ex>, B<%EX>, B<%Ey>, B<%EY>, B<%Od>, B<%Oe>, B<%OH>, B<%OI>, B<%Om>, B<%OM>, B<%OS>, B<%Ou>, B<%OU>, B<%OV>, B<%Ow>, B<%OW>, B<%Oy>, where the effect of the B<O> modifier is to use alternative numeric symbols (say, roman numerals), and that of the E modifier is to use a locale-dependent alternative representation.
fr: Certaines spécifications de conversion peuvent être modifiées en faisant précéder le caractère spécificateur de conversion par le I<modificateur> B<E> ou B<O> pour indiquer un format de rechange. Si le format de rechange n'existe pas pour la localisation en cours, le comportement ne sera pas modifié. Les spécifications Single UNIX mentionnent B<%Ec>, B<%EC>, B<%Ex>, B<%EX>, B<%Ey>, B<%EY>, B<%Od>, B<%Oe>, B<%OH>, B<%OI>, B<%Om>, B<%OM>, B<%OS>, B<%Ou>, B<%OU>, B<%OV>, B<%Ow>, B<%OW>, B<%Oy>, où l'action du modificateur B<O> est d'utiliser un autre format numérique (par exemple des chiffres romains), et l'action de B<E> est d'utiliser une représentation dépendant de la localisation.

note: type: Plain text
en: The broken-down time structure I<tm> is defined in I<E<lt>time.hE<gt>>.  See also B<ctime>(3).
fr: Les champs de la structure I<tm> sont définis dans I<E<lt>time.hE<gt>>. Consultez aussi B<ctime>(3).

note: type: Plain text
en: Provided that the result string, including the terminating null byte, does not exceed I<max> bytes, B<strftime>()  returns the number of bytes (excluding the terminating null byte)  placed in the array I<s>.  If the length of the result string (including the terminating null byte)  would exceed I<max> bytes, then B<strftime>()  returns 0, and the contents of the array are undefined.  (This behavior applies since at least libc 4.4.4; very old versions of libc, such as libc 4.4.1, would return I<max> if the array was too small.)
fr: Si la taille de la chaîne de résultat ne dépasse pas I<max> octets (caractère NUL compris), la fonction B<strftime>() renvoie le nombre d'octets écrits dans le tableau I<s>, sans compter l'octet nul final. Si la longueur de la chaîne dépasse I<max> octets (caractère NUL compris), B<strftime>() renvoie 0, et le contenu de la chaîne est indéfini (ce comportement est valable depuis au moins la libc 4.4.4, des versions plus anciennes de la libc, comme la 4.4.1, renvoyaient I<max> si la chaîne était trop courte).

note: type: Plain text
en: Note that the return value 0 does not necessarily indicate an error.  For example, in many locales B<%p> yields an empty string.  An empty I<format> string will likewise yield an empty string.
fr: Remarquez qu'une valeur de retour nulle n'indique pas toujours une erreur. Dans de nombreuses localisations, par exemple, B<%p> renvoie une chaîne vide. Une chaîne I<format> vide renvoie aussi une chaîne vide.

note: type: Plain text
en: The environment variables B<TZ> and B<LC_TIME> are used.
fr: Les variables d'environnement B<TZ> et B<LC_TIME> sont utilisées.

note: type: Plain text
en: SVr4, C89, C99.  There are strict inclusions between the set of conversions given in ANSI C (unmarked), those given in the Single UNIX Specification (marked SU), those given in Olson's timezone package (marked TZ), and those given in glibc (marked GNU), except that B<%+> is not supported in glibc2.  On the other hand glibc2 has several more extensions.  POSIX.1 only refers to ANSI C; POSIX.2 describes under B<date>(1)  several extensions that could apply to B<strftime>()  as well.  The B<%F> conversion is in C99 and POSIX.1-2001.
fr: SVr4, C89, C99. Il y a une inclusion stricte entre les jeux de conversions fournies par C ANSI (sans marque), celles indiquées par les Spécifications Single UNIX (marquées SU), celles fournies par le paquet timezone d'Olson (marquées TZ), et celles de la glibc (marquées GNU), sauf pour B<%+> qui n'est pas supporté par glibc2. D'un autre côté glibc2 offre plusieurs extensions. POSIX.1 ne traite que les conversions C ANSI. POSIX.2 décrit à propos de B<date>(1) plusieurs extensions applicables également à B<strftime>(). La conversion B<%F> est dans C99 et POSIX.1-2001.

note: type: Plain text
en: In SUSv2, the B<%S> specifier allowed a range of 00 to 61, to allow for the theoretical possibility of a minute that included a double leap second (there never has been such a minute).
fr: Dans SUSv2, le B<%S> spécifié permettait un intervalle de 00 à 61, pour autoriser la possibilité théorique d'une minute incluant une double seconde de rattrapage (il n'y a jamais eu de telle minute).

note: type: SS
en: ISO 8601 week dates
fr: Numéros des semaines ISO 8601

note: type: Plain text
en: B<%G>, B<%g>, and B<%V> yield values calculated from the week-based year defined by the ISO\ 8601 standard.  In this system, weeks start on a Monday, and are numbered from 01, for the first week, up to 52 or 53, for the last week.  Week 1 is the first week where four or more days fall within the new year (or, synonymously, week 01 is: the first week of the year that contains a Thursday; or, the week that has 4 January in it).  When three of fewer days of the first calendar week of the new year fall within that year, then the ISO 8601 week-based system counts those days as part of week 53 of the preceding year.  For example, 1 January 2010 is a Friday, meaning that just three days of that calendar week fall in 2010.  Thus, the ISO\ 8601 week-based system considers these days to be part of week 53 (B<%V>)  of the year 2009 (B<%G>); week 01 of ISO\ 8601 year 2010 starts on Monday, 4 January 2010.
fr: B<%G>, B<%g> et B<%V> produisent des valeurs calculées sur la base des semaines de l'année définies par la norme ISO 8601. Dans ce système, les semaines démarrent le lundi et sont numérotées de 01, pour la première semaine, jusqu'à 52 ou 53, pour la dernière semaine. La semaine 1 est la première semaine pour laquelle au moins quatre jours sont dans l'année (ce qui revient au même que de la définir comme la semaine du premier jeudi de l'année ou la semaine du 4 janvier). Quand trois jours, ou moins, se trouvent dans la première semaine calendaire de la nouvelle année se trouvent dans cette année, alors le système de numérotation des semaines de l'ISO 8601 place ces jours dans la semaine 53 de l'année précédente. Par exemple, le 1er janvier 2010 est un vendredi, ce qui signifie que seulement 3 jours se trouvent dans la semaine calendaire du début 2010. l'ISO 8601 considère donc ces jours comme faisant partie de la semaine 53 (B<%V>) de l'année 2009 (B<%G>) ; la semaine 01 de l'année 2010 pour l'ISO 8601 démarre le lundi 4 janvier 2010.

note: HP-UX and Tru64 also have features like this. type: Plain text
en: Glibc provides some extensions for conversion specifications.  (These extensions are not specified in POSIX.1-2001, but a few other systems provide similar features.)  Between the \(aq%\(aq character and the conversion specifier character, an optional I<flag> and field I<width> may be specified.  (These precede the B<E> or B<O> modifiers, if present.)
fr: La glibc fournit des extensions pour les spécifications de conversion (ces extensions ne sont pas spécifiées par POSIX.1-2001 mais quelques autres systèmes fournissent des fonctionnalités similaires). Entre le caractère «\ %\ » et le caractère spécificateur de conversion, on peut spécifier un I<attribut> optionnel et un champ I<largeur> (ceux-ci précèdent les modificateurs B<E> ou B<0> s'ils sont présents).

note: type: Plain text
en: The following flag characters are permitted:
fr: Les caractères attributs suivants sont autorisés\ :

note: type: Plain text
en: (underscore)  Pad a numeric result string with spaces.
fr: (souligné) Compléter une chaîne de résultat numérique avec des espaces.

note: type: Plain text
en: (dash)  Do not pad a numeric result string.
fr: (tiret) Ne pas compléter une chaîne de résultat numérique.

note: type: Plain text
en: Pad a numeric result string with zeros even if the conversion specifier character uses space-padding by default.
fr: Compléter une chaîne de résultat numérique avec des zéros même si le caractère spécificateur de conversion utilise des espaces par défaut.

note: type: Plain text
en: Convert alphabetic characters in result string to uppercase.
fr: Convertir une chaîne alphabétique en une chaîne résultante en majuscule.

note: type: Plain text
en: Swap the case of the result string.  (This flag works only with certain conversion specifier characters, and of these, it is only really useful with B<%Z>.)
fr: Échanger la casse de la chaîne résultat (cet attribut ne fonctionne qu'avec certains caractères spécificateurs de conversion, et parmi ceux-ci, il n'est vraiment utile qu'avec B<%Z>).

note: type: Plain text
en: An optional decimal width specifier may follow the (possibly absent) flag.  If the natural size of the field is smaller than this width, then the result string is padded (on the left) to the specified width.
fr: Un spécificateur de largeur décimal optionnel peut suivre l'(éventuellement absent) attribut. Si la taille naturelle du champ est plus petite que cette largeur, la chaîne résultat sera alors complétée (sur la gauche) jusqu'à la largeur spécifiée.

note: type: Plain text
en: If the output string would exceed I<max> bytes, I<errno> is I<not> set.  This makes it impossible to distinguish this error case from cases where the I<format> string legitimately produces a zero-length output string.  POSIX.1-2001 does I<not> specify any I<errno> settings for B<strftime>().
fr: Si la chaîne de sortie dépasse I<max> octets, I<errno> n'est pas modifié. Cela empêche de distinguer ce cas d'erreur des cas où la chaîne I<format> aurait légitimement produit une chaîne de sortie de longueur nulle. POSIX.1-2001 I<ne> spécifie I<aucune> modification de I<errno> pour B<strftime>().

note: type: Plain text
en: Some buggy versions of B<gcc>(1)  complain about the use of B<%c>: I<warning: `%c' yields only last 2 digits of year in some locales>.  Of course programmers are encouraged to use B<%c>, it gives the preferred date and time representation.  One meets all kinds of strange obfuscations to circumvent this B<gcc>(1)  problem.  A relatively clean one is to add an intermediate function
fr: Certaines versions boguées de gcc se plaignent de l'utilisation de B<%c>\ : I<warning: `%c' yields only last 2 digits of year in some locales> (Attention\ : ne donne que les deux derniers chiffres de l'année dans certaines localisations). Bien sûr, les programmeurs sont encouragés à utiliser B<%c>, cela donne la représentation préférée de date et d'heure. Il y a eu des tas d'astuces bizarres pour éviter ce problème de B<gcc>(1). Une relativement propre est d'utiliser une fonction intermédiaire\ :

note: type: Plain text
en: Nowadays, B<gcc>(1)  provides the I<-Wno-format-y2k> option to prevent the warning, so that the above workaround is no longer required.
fr: De nos jours, B<gcc>(1) fournit une option I<-Wno-format-y2k> pour éviter l'avertissement, et la solution de contournement ci-dessus n'est plus nécessaire.

note: type: Plain text
en: B<RFC\ 2822-compliant date format> (with an English locale for %a and %b)
fr: B<format de date compatible RFC\ 2822> (avec des paramètres régionaux en anglais pour %a et %b)

note: type: Plain text
en: B<RFC\ 822-compliant date format> (with an English locale for %a and %b)
fr: B<format de date compatible RFC\ 822> (avec des paramètres régionaux en anglais pour %a et %b)

note: type: SS
en: Example program
fr: Programme exemple

note: type: Plain text
en: The program below can be used to experiment with B<strftime>().
fr: Le programme suivant peut être utilisé pour expérimenter B<strftime>().

note: type: Plain text
en: Some examples of the result string produced by the glibc implementation of B<strftime>()  are as follows:
fr: Voici quelques exemples de la chaîne résultat produite par l'implémentation glibc de B<strftime>()\ :

note: type: Plain text
en: $B< ./a.out \(aq%m\(aq>
    Result string is "11"
    $B< ./a.out \(aq%5m\(aq>
    Result string is "00011"
    $B< ./a.out \(aq%_5m\(aq>
    Result string is "   11"
fr: $B< ./a.out \(aq%m\(aq>
    La chaîne résultat est "11"
    $B< ./a.out \(aq%5m\(aq>
    La chaîne résultat est "00011"
    $B< ./a.out \(aq%_5m\(aq>
    La chaîne résultat est "   11"

note: type: Plain text
en:     if (strftime(outstr, sizeof(outstr), argv[1], tmp) == 0) {
            fprintf(stderr, "strftime returned 0");
            exit(EXIT_FAILURE);
        }
fr:     if (strftime(outstr, sizeof(outstr), argv[1], tmp) == 0) {
            fprintf(stderr, "strftime a renvoyé 0");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en: strptime - convert a string representation of time to a time tm structure
fr: strptime - Conversion d'une chaîne de date en une structure tm

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

note: type: Plain text
en: B<char *strptime(const char *>I<s>B<, const char *>I<format>B<,> B<struct tm *>I<tm>B<);>
fr: B<char *strptime(const char *>I<buf>B<, const char *>I<format>B<,> B<struct tm *>I<tm>B<);>

note: type: Plain text
en: The B<strptime>()  function is the converse of B<strftime>(3); it converts the character string pointed to by I<s> to values which are stored in the "broken-down time" structure pointed to by I<tm>, using the format specified by I<format>.
fr: La fonction B<strptime>() est complémentaire de la fonction B<strftime>(3). Elle convertit la chaîne de caractères pointée par I<buf> en une valeur qui est stockée dans la structure I<tm> pointée par l'argument I<tm>, la conversion étant réalisée en suivant les indications contenues dans la chaîne I<format>.

note: type: Plain text
en: The broken-down time structure I<tm> is defined in I<E<lt>time.hE<gt>> as follows:
fr: Les champs de la structure I<tm> définie dans I<E<lt>time.hE<gt>> sont\ :

note: type: Plain text
en: For more details on the I<tm> structure, see B<ctime>(3).
fr: Pour plus de détails sur la structure I<tm>, consultez B<ctime>(3).

note: type: Plain text
en: The I<format> argument is a character string that consists of field descriptors and text characters, reminiscent of B<scanf>(3).  Each field descriptor consists of a B<%> character followed by another character that specifies the replacement for the field descriptor.  All other characters in the I<format> string must have a matching character in the input string, except for whitespace, which matches zero or more whitespace characters in the input string.  There should be white\%space or other alphanumeric characters between any two field descriptors.
fr: Le paramètre I<format> contient des descripteurs de champs et du texte, rappelant B<scanf>(3). Chaque descripteur consiste en un caractère B<%> suivi d'un second caractère indiquant le champ à interpréter. Tous les autres sont considérés comme du texte, qui doit être présent dans la chaîne fournie en entrée. Toutefois un espace blanc se trouvant dans la chaîne de format peut être mis en correspondance avec zéro ou plusieurs espaces. Il devrait toujours y avoir un espace ou un autre caractère alphanumérique entre deux descripteurs de champs.

note: type: Plain text
en: The B<strptime>()  function processes the input string from left to right.  Each of the three possible input elements (whitespace, literal, or format) are handled one after the other.  If the input cannot be matched to the format string, the function stops.  The remainder of the format and input strings are not processed.
fr: La fonction B<strptime>() traite la chaîne d'entrée de gauche à droite. Les trois types d'éléments d'entrée possibles (espace, caractère littéral, conversion) sont manipulés l'un après l'autre. Si l'entrée ne peut pas être mise en correspondance avec la chaîne de format, la fonction s'arrête. Le reste du format et de la chaîne d'entrée ne sont pas traités.

note: type: Plain text
en: The supported input field descriptors are listed below.  In case a text string (such as the name of a day of the week or a month name)  is to be matched, the comparison is case insensitive.  In case a number is to be matched, leading zeros are permitted but not required.
fr: Les descripteurs applicables sont décrits ci-dessous. Dans le cas d'une chaîne de caractères (comme le nom d’un jour de la semaine ou d’un mois), la comparaison ne tient pas compte des majuscules/minuscules. Dans le cas d'un nombre, les zéros au début sont autorisés mais pas obligatoires.

note: type: Plain text
en: The B<%> character.
fr: Le caractère B<%>

note: type: TP
en: B<%a> or B<%A>
fr: B<%a> ou B<%A>

note: type: Plain text
en: The name of the day of the week according to the current locale, in abbreviated form or the full name.
fr: Le jour de la semaine en utilisant les noms correspondants à la localisation. Les noms abrégés ou entiers peuvent être utilisés.

note: type: TP
en: B<%b> or B<%B> or B<%h>
fr: B<%b> ou B<%B> ou B<%h>

note: type: Plain text
en: The month name according to the current locale, in abbreviated form or the full name.
fr: Le mois en utilisant les noms correspondants à la localisation. Les noms abrégés ou entiers peuvent être utilisés.

note: type: Plain text
en: The date and time representation for the current locale.
fr: La date et l'heure en utilisant le format de la localisation.

note: type: Plain text
en: The century number (0-99).
fr: Le numéro de siècle (0-99).

note: type: TP
en: B<%d> or B<%e>
fr: B<%d> ou B<%e>

note: type: Plain text
en: The day of month (1-31).
fr: Le jour du mois (1-31)

note: type: Plain text
en: Equivalent to B<%m/%d/%y>.  (This is the American style date, very confusing to non-Americans, especially since B<%d/%m/%y> is widely used in Europe.  The ISO 8601 standard format is B<%Y-%m-%d>.)
fr: La date, ainsi\ : B<%m/%d/%y>. C'est la date au format américain, très gênante pour les autres pays, notamment l'Europe qui utilise une notation B<%d/%m/%y>. Le format standard ISO 8601 est B<%Y-%m-%d>.

note: type: Plain text
en: The hour (0-23).
fr: L'heure (0-23)

note: type: Plain text
en: The hour on a 12-hour clock (1-12).
fr: L'heure (0-12)

note: type: Plain text
en: The day number in the year (1-366).
fr: Le numéro du jour dans l'année (001-366)

note: type: Plain text
en: The month number (1-12).
fr: Le numéro du mois (1-12)

note: type: Plain text
en: The minute (0-59).
fr: La minute (0-59)

note: type: Plain text
en: Arbitrary whitespace.
fr: Un espace blanc quelconque

note: type: Plain text
en: The locale's equivalent of AM or PM.  (Note: there may be none.)
fr: Équivalent local de AM ou PM (éventuellement rien).

note: type: Plain text
en: The 12-hour clock time (using the locale's AM or PM).  In the POSIX locale equivalent to B<%I:%M:%S %p>.  If I<t_fmt_ampm> is empty in the B<LC_TIME> part of the current locale, then the behavior is undefined.
fr: L'heure sur 12 heures avec l'équivalent local de AM ou PM. Dans la localisation POSIX, équivalent à B<%I:%M:%S %p>. Si le champ I<t_fmt_ampm> de la catégorie B<LC_TIME> de la localisation est vide, le comportement est indéfini.

note: type: Plain text
en: Equivalent to B<%H:%M>.
fr: Équivalent de B<%H:%M>.

note: type: Plain text
en: The second (0-60; 60 may occur for leap seconds; earlier also 61 was allowed).
fr: Les secondes (0-61, des secondes de rattrapages sont autorisées)

note: type: Plain text
en: Equivalent to B<%H:%M:%S>.
fr: Équivalent de B<%H:%M:%S>.

note: type: Plain text
en: The week number with Sunday the first day of the week (0-53).  The first Sunday of January is the first day of week 1.
fr: Le numéro de semaine (0-53), le premier dimanche de janvier étant le premier jour de la semaine 1.

note: type: Plain text
en: The ordinal number of the day of the week (0-6), with Sunday = 0.
fr: Le numéro du jour dans la semaine (0-6), en commençant le dimanche.

note: type: Plain text
en: The week number with Monday the first day of the week (0-53).  The first Monday of January is the first day of week 1.
fr: Le numéro de semaine (0-53), le premier lundi de janvier étant le premier jour de la semaine 1.

note: type: Plain text
en: The date, using the locale's date format.
fr: la date, en utilisant le format usuel de la localisation.

note: type: Plain text
en: The time, using the locale's time format.
fr: l'heure, en utilisant le format usuel de la localisation.

note: type: Plain text
en: The year within century (0-99).  When a century is not otherwise specified, values in the range 69-99 refer to years in the twentieth century (1969-1999); values in the range 00-68 refer to years in the twenty-first century (2000-2068).
fr: l'année sans le siècle (0-99; les zéros au début sont autorisés mais pas obligatoires). Lorsque le siècle n'est pas indiqué par une autre conversion, les années 69 à 99 sont considérées comme étant du vingtième siècle (1969 à 1999), et les années 00-68 du vingt-et-unième siècle (2000-2068).

note: type: Plain text
en: The year, including century (for example, 1991).
fr: L'année en incluant le siècle (par exemple, 1996)

note: type: Plain text
en: Some field descriptors can be modified by the E or O modifier characters to indicate that an alternative format or specification should be used.  If the alternative format or specification does not exist in the current locale, the unmodified field descriptor is used.
fr: Certains descripteurs peuvent être complétés par les caractères modificateurs E et O, indiquant qu'il faut employer un autre format ou une autre spécification. Si cet autre format, ou cette autre conversion n'est pas disponible dans la localisation en cours, le descripteur n'est pas modifié.

note: type: Plain text
en: The E modifier specifies that the input string may contain alternative locale-dependent versions of the date and time representation:
fr: Le modificateur E indique que la chaîne d'entrée peut contenir des versions différentes de la date et l'heure, en fonction de la localisation\ :

note: type: Plain text
en: The locale's alternative date and time representation.
fr: Une représentation différente de la date et l'heure.

note: type: Plain text
en: The name of the base year (period) in the locale's alternative representation.
fr: Le nom de l'année de base (période) dans la représentation locale alternative.

note: type: Plain text
en: The locale's alternative date representation.
fr: Une autre représentation de la date.

note: type: Plain text
en: The locale's alternative time representation.
fr: Une autre représentation de l'heure.

note: type: Plain text
en: The offset from B<%EC> (year only) in the locale's alternative representation.
fr: Le décalage (en année) par rapport à l'année B<%EC> dans la représentation locale alternative.

note: type: Plain text
en: The full alternative year representation.
fr: La représentation complète de l'année.

note: type: Plain text
en: The O modifier specifies that the numerical input may be in an alternative locale-dependent format:
fr: Le modificateur O indique que les saisies numériques peuvent être effectuées dans un format différent, dépendant de la localisation.

note: type: Plain text
en: The day of the month using the locale's alternative numeric symbols; leading zeros are permitted but not required.
fr: Le jour du mois. Les zéros en tête sont permis mais pas obligatoires.

note: type: Plain text
en: The hour (24-hour clock) using the locale's alternative numeric symbols.
fr: L'heure (sur 24 heures).

note: type: Plain text
en: The hour (12-hour clock) using the locale's alternative numeric symbols.
fr: L'heure (sur 12 heures).

note: type: Plain text
en: The month using the locale's alternative numeric symbols.
fr: Le numéro du mois.

note: type: Plain text
en: The minutes using the locale's alternative numeric symbols.
fr: Les minutes.

note: type: Plain text
en: The seconds using the locale's alternative numeric symbols.
fr: Les secondes.

note: type: Plain text
en: The week number of the year (Sunday as the first day of the week)  using the locale's alternative numeric symbols.
fr: Le numéro de la semaine.

note: type: Plain text
en: The ordinal number of the day of the week (Sunday=0),
     using the locale's alternative numeric symbols.
fr: Le numéro du jour dans la semaine, le dimanche étant zéro.

note: type: Plain text
en: The week number of the year (Monday as the first day of the week)  using the locale's alternative numeric symbols.
fr: Le numéro du jour de la semaine, en commençant le lundi.

note: type: Plain text
en: The year (offset from B<%C>)  using the locale's alternative numeric symbols.
fr: L'année (ou décalage par rapport à B<%C>) en utilisant les symboles numérique régionaux.

note: type: Plain text
en: The return value of the function is a pointer to the first character not processed in this function call.  In case the input string contains more characters than required by the format string, the return value points right after the last consumed input character.  In case the whole input string is consumed, the return value points to the null byte at the end of the string.  If B<strptime>()  fails to match all of the format string and therefore an error occurred, the function returns NULL.
fr: La fonction B<strptime>() renvoie un pointeur sur le premier caractère de la chaîne I<buf> n'ayant pas été traité. Dans le cas où la chaîne de saisie est plus longue que ce que réclame le format, la valeur renvoyée pointe juste après le dernier caractère d'entrée ayant été analysé. Si toute la chaîne a été traitée, le pointeur est dirigé sur le caractère NUL en fin de chaîne. Si B<strptime>() n'arrive pas à effectuer toutes les conversions, il renvoie NULL.

note: type: Plain text
en: In principle, this function does not initialize I<tm> but stores only the values specified.  This means that I<tm> should be initialized before the call.  Details differ a bit between different UNIX systems.  The glibc implementation does not touch those fields which are not explicitly specified, except that it recomputes the I<tm_wday> and I<tm_yday> field if any of the year, month, or day elements changed.
fr: En principe cette fonction n'initialise pas I<tm>, mais n'y stocke que les valeurs lues. Ceci signifie que le contenu de I<tm> doit être initialisé avant l'appel. Les détails diffèrent suivant les systèmes UNIX. L'implémentation de la bibliothèque C Gnu ne modifie pas les champs non mentionnés explicitement, sauf I<tm_wday>, et I<tm_yday> qui sont recalculés si un champ d'année, de mois ou de jour est modifié.

note: type: Plain text
en: This function is available since libc 4.6.8.  Linux libc4 and libc5 includes define the prototype unconditionally; glibc2 includes provide a prototype only when B<_XOPEN_SOURCE> or B<_GNU_SOURCE> are defined.
fr: Cette fonction n'est disponible que dans les versions de bibliothèque depuis la 4.6.8. Les bibliothèques Linux libc4 et libc5 incluaient toujours le prototype de cette fonction, la bibliothèque glibc 2 ne fournit le prototype que si les constantes B<_XOPEN_SOURCE> ou B<_GNU_SOURCE> sont définies.

note: type: Plain text
en: Before libc 5.4.13 whitespace (and the \(aqn\(aq and \(aqt\(aq specifications) was not handled, no \(aqE\(aq and \(aqO\(aq locale modifier characters were accepted, and the \(aqC\(aq specification was a synonym for the \(aqc\(aq specification.
fr: Avant la libc 5.4.13, les espaces (et les conversions « n » et « t ») n'étaient pas gérés ; les caractères de modification locale E et O n'étaient pas acceptés ; et la spécification « C » était un synonyme pour « c ».

note: In libc4 and libc5 the code for %I is broken (fixed in glibc; %OI was fixed in glibc 2.2.4). type: Plain text
en: The \(aqy\(aq (year in century) specification is taken to specify a year in the 20th century by libc4 and libc5.  It is taken to be a year in the range 1950-2049 by glibc 2.0.  It is taken to be a year in 1969-2068 since glibc 2.1.
fr: La conversion «\ y\ » (année dans le siècle) est toujours considérée comme appartenant au vingtième siècle dans les libc4 et libc5. Elle est prise dans l'intervalle 1950-2049 par la glibc 2.0, et 1969-2068 par la glibc 2.1.

note: type: Plain text
en: For reasons of symmetry, glibc tries to support for B<strptime>()  the same format characters as for B<strftime>(3).  (In most cases, the corresponding fields are parsed, but no field in I<tm> is changed.)  This leads to
fr: Pour des raisons de symétrie, la glibc essaye d'offrir pour B<strptime>() les mêmes caractères de formatage que ceux de B<strftime>(3) (dans la plupart des cas, les champs sont lus mais aucun membre de I<tm> n'est modifié). Ceci conduit à\ :

note: type: Plain text
en: Equivalent to B<%Y-%m-%d>, the ISO 8601 date format.
fr: Équivalent à B<%Y-%m-%d>, le format ISO 8601 pour la date.

note: type: Plain text
en: The year corresponding to the ISO week number, but without the century (0-99).
fr: L'année correspondant au numéro de semaine ISO, sans le siècle (0-99).

note: type: Plain text
en: The year corresponding to the ISO week number.  (For example, 1991.)
fr: L'année correspondant au numéro de semaine ISO (par exemple 1991).

note: type: Plain text
en: The day of the week as a decimal number (1-7, where Monday = 1).
fr: Le numéro du jour de la semaine (1-7, lundi valant 1).

note: type: Plain text
en: The ISO 8601:1988 week number as a decimal number (1-53).  If the week (starting on Monday) containing 1 January has four or more days in the new year, then it is considered week 1.  Otherwise, it is the last week of the previous year, and the next week is week 1.
fr: Le numéro de semaine ISO 8601:1988 (1-53). Si la semaine (commençant lundi) contenant le 1er janvier a quatre jours ou plus de la nouvelle année, elle est comptée en semaine 1. Sinon elle est considérée comme dernière semaine de l'année précédente, et c'est la suivante qui est la semaine 1.

note: type: Plain text
en: An RFC-822/ISO 8601 standard timezone specification.
fr: Spécification standard RFC-822/ISO 8601 pour le fuseau horaire.

note: type: Plain text
en: The timezone name.
fr: Le nom du fuseau horaire.

note: type: Plain text
en: Similarly, because of GNU extensions to B<strftime>(3), B<%k> is accepted as a synonym for B<%H>, and B<%l> should be accepted as a synonym for B<%I>, and B<%P> is accepted as a synonym for B<%p>.  Finally
fr: De même, à cause des extensions GNU de B<strftime>(3), B<%k> est accepté en synonyme de B<%H>, et B<%l> est accepté comme synonyme de B<%I>, et B<%P> en synonyme de B<%p>. Enfin,

note: type: Plain text
en: The number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  Leap seconds are not counted unless leap second support is available.
fr: Le nombre de secondes depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 (UTC). Les secondes de rattrapage ne sont pas comptées, sauf si un support spécifique est disponible.

note: type: Plain text
en: The glibc implementation does not require whitespace between two field descriptors.
fr: L'implémentation de la glibc n'impose pas la présence de caractères blancs entre deux descripteurs de champs.

note: type: Plain text
en: The following example demonstrates the use of B<strptime>()  and B<strftime>(3).
fr: L'exemple suivant montre l'utilisation de B<strptime>() et B<strftime>(3).

note: type: TH
en: 2008-11-14
fr: 14 novembre 2008

note: type: TH
en: Linux User's Manual
fr: Manuel de l'utilisateur Linux

note: type: Plain text
en: time - time a simple command or give resource usage
fr: time - Chronométrer ou évaluer les ressources employées par une commande simple

note: type: Plain text
en: B<time [>I<options>B<] >I<command>B< [>I<arguments...>B<] >
fr: B<time [>I<options>B<] >I<commande>B< [>I<arguments...>B<] >

note: type: Plain text
en: The B<time> command runs the specified program I<command> with the given arguments.  When I<command> finishes, B<time> writes a message to standard error giving timing statistics about this program run.  These statistics consist of (i) the elapsed real time between invocation and termination, (ii) the user CPU time (the sum of the I<tms_utime> and I<tms_cutime> values in a I<struct tms> as returned by B<times>(2)), and (iii) the system CPU time (the sum of the I<tms_stime> and I<tms_cstime> values in a I<struct tms> as returned by B<times>(2)).
fr: La fonction B<time> lance le programme représenté par la I<commande> indiquée, avec les I<arguments> fournis. Lorsque la I<commande> se termine, B<time> affiche un message sur la sortie d'erreur contenant des statistiques sur l'exécution du programme. Ces statistiques contiennent (i) le temps écoulé entre l'invocation et la fin de la commande, (ii) le temps CPU écoulé en mode utilisateur (la somme des valeurs I<tms_utime> et I<tms_cutime> de la structure I<struct tms> fournie par l'appel système B<times>(2)), et (iii) le temps CPU passé en mode système (la somme des champs I<tms_stime> et I<tms_cstime> de la I<struct tms> fournie par l'appel système B<times>(2)).

note: type: Plain text
en: Note: some shells (e.g., B<bash>(1))  have a built-in B<time> command that provides less functionality than the command described here.  To access the real command, you may need to specify its pathname (something like I</usr/bin/time>).
fr: Note\ : certains shells (comme par exemple B<bash>(1)) possèdent une commande B<time> qui fournit moins de possibilités que la commande décrite ici. Pour invoquer la commande réelle, il est possible que vous soyez obligé d'indiquer le chemin complet (I</usr/bin/time>).

note: type: Plain text
en: When in the POSIX locale, use the precise traditional format
fr: Dans la localisation POSIX, utiliser le format traditionnel

note: type: Plain text
en: (with numbers in seconds)  where the number of decimals in the output for %f is unspecified but is sufficient to express the clock tick accuracy, and at least one.
fr: (avec des nombres exprimés en secondes)  où le nombre de décimales dans le format %f n'est pas précisé, mais suffisant pour exprimer le top d'horloge précisément.

note: type: SH
en: EXIT STATUS
fr: CODE DE RETOUR

note: type: Plain text
en: If I<command> was invoked, the exit status is that of I<command>.  Otherwise it is 127 if I<command> could not be found, 126 if it could be found but could not be invoked, and some other nonzero value (1-125) if something else went wrong.
fr: Si la I<commande> a été invoquée, le code de sortie est celui de la I<commande>. Sinon, il s'agit de 127 si la I<commande> n'a pas été trouvée, 126 si elle a été trouvée mais n'a pas pu être invoquée, et une autre valeur non nulle (1-125) si quelque chose d'autre a échoué.

note: type: Plain text
en: The variables B<LANG>, B<LC_ALL>, B<LC_CTYPE>, B<LC_MESSAGES>, B<LC_NUMERIC>, B<NLSPATH>, and B<PATH> are used.  The last one to search for I<command>.  The remaining ones for the text and formatting of the output.
fr: Les variables B<LANG>, B<LC_ALL>, B<LC_CTYPE>, B<LC_MESSAGES>, B<LC_NUMERIC>, B<NLSPATH> et B<PATH> sont utilisées. La dernière sert à rechercher la I<commande>. Les autres servent au formatage du texte et de la sortie.

note: type: SH
en: GNU VERSION
fr: VERSION GNU

note: type: Plain text
en: Below a description of the GNU 1.7 version of B<time>.  Disregarding the name of the utility, GNU makes it output lots of useful information, not only about time used, but also on other resources like memory, I/O and IPC calls (where available).  The output is formatted using a format string that can be specified using the I<-f> option or the B<TIME> environment variable.
fr: Suit une description de la version GNU 1.7 de B<time>. Contrairement au nom de cet utilitaire, GNU ajoute un grand nombre d'informations utiles, concernant non seulement le temps écoulé, mais également d'autres ressources, comme la mémoire, les entrées-sorties ou les communications IPC (si disponibles). La sortie est formatée en utilisant une chaîne qui peut être transmise avec l'option I<-f> ou en utilisant la variable d'environnement B<TIME>.

note: type: Plain text
en: The default format string is:
fr: La chaîne de format par défaut est

note: type: Plain text
en: When the I<-p> option is given the (portable) output format
fr: Lorsque l'option I<-p> est fournie, le format de sortie (portable)

note: type: Plain text
en: is used.
fr: est utilisé.

note: type: SS
en: The format string
fr: Chaîne de format

note: type: Plain text
en: The format is interpreted in the usual printf-like way.  Ordinary characters are directly copied, tab, newline and backslash are escaped using \et, \en and \e\e, a percent sign is represented by %%, and otherwise % indicates a conversion.  The program B<time> will always add a trailing newline itself.  The conversions follow.  All of those used by B<tcsh>(1)  are supported.
fr: Le format est interprété comme d'habitude à la manière de B<printf>(3). Les caractères ordinaires sont copiés directement, les tabulations, sauts de lignes et barres obliques inversées (I<backslash>) sont protégés par \et, \en et \e\e. Un signe pourcent est représenté par %%, sinon % indique une conversion. Le programme B<time> ajoutera toujours un saut de ligne à la fin de la sortie. Les conversions se trouvent ci-dessous. Toutes celles utilisées par B<tcsh>(1) sont disponibles.

note: type: Plain text
en: B<Time>
fr: B<Temps>

note: type: Plain text
en: Elapsed real time (in [hours:]minutes:seconds).
fr: Temps réel écoulé (en [heures:]minutes:secondes).

note: type: Plain text
en: (Not in tcsh.) Elapsed real time (in seconds).
fr: (pas avec tcsh.) Temps réel écoulé (en secondes).

note: type: Plain text
en: Total number of CPU-seconds that the process spent in kernel mode.
fr: Nombre total de secondes-CPU passées par le processus en mode noyau.

note: type: Plain text
en: Total number of CPU-seconds that the process spent in user mode.
fr: Nombre total de secondes-CPU passées par le processus en mode utilisateur.

note: type: Plain text
en: Percentage of the CPU that this job got, computed as (%U + %S) / %E.
fr: Pourcentage de CPU obtenu par cette tâche, calculé comme (%U + %S) / %E.

note: type: Plain text
en: B<Memory>
fr: B<Mémoire>

note: type: Plain text
en: Maximum resident set size of the process during its lifetime, in Kbytes.
fr: Taille maximale du processus en mémoire physique durant son exécution, en kilooctets.

note: type: Plain text
en: (Not in tcsh.) Average resident set size of the process, in Kbytes.
fr: (pas avec tcsh) Taille moyenne du processus en mémoire physique durant son exécution, en kilooctets.

note: type: Plain text
en: Average total (data+stack+text) memory use of the process, in Kbytes.
fr: Mémoire moyenne (donnée + pile + code) utilisée par le processus, en kilooctets.

note: type: Plain text
en: Average size of the process's unshared data area, in Kbytes.
fr: Taille moyenne des données non partagées du processus, en kilooctets.

note: type: Plain text
en: (Not in tcsh.) Average size of the process's unshared stack space, in Kbytes.
fr: (pas avec tcsh.) Taille moyenne de la pile non partagée du processus, en kilooctets.

note: type: Plain text
en: Average size of the process's shared text space, in Kbytes.
fr: Taille moyenne du code partagé du processus, en kilooctets.

note: type: Plain text
en: (Not in tcsh.) System's page size, in bytes.  This is a per-system constant, but varies between systems.
fr: (pas avec tcsh.) Taille de page du système, en octets. Ceci est une constante sur un système, mais varie de système en système.

note: type: Plain text
en: Number of major page faults that occurred while the process was running.  These are faults where the page has to be read in from disk.
fr: Nombre de fautes de pages majeures durant l'exécution. Ce sont les fautes où des pages ont dû être rechargées depuis le disque.

note: type: Plain text
en: Number of minor, or recoverable, page faults.  These are faults for pages that are not valid but which have not yet been claimed by other virtual pages.  Thus the data in the page is still valid but the system tables must be updated.
fr: Nombre de fautes de pages mineures durant l'exécution. Ce sont les fautes où des pages ne sont plus valides, mais n'ont pas encore été réutilisées. Les données y sont encore présentes et seules les tables système doivent être mises à jour.

note: type: Plain text
en: Number of times the process was swapped out of main memory.
fr: Nombre de fois où le processus a été envoyé sur la mémoire de swap.

note: type: Plain text
en: Number of times the process was context-switched involuntarily (because the time slice expired).
fr: Nombre de fois où le processus a été préempté involontairement (sa tranche de temps ayant expiré).

note: type: Plain text
en: Number of waits: times that the program was context-switched voluntarily, for instance while waiting for an I/O operation to complete.
fr: Nombre de fois où le processus a été commuté volontairement, en passant en attente par exemple de la fin d'une entrée-sortie.

note: type: Plain text
en: B<I/O>
fr: B<Entrées/Sorties>

note: type: Plain text
en: Number of filesystem inputs by the process.
fr: Nombre de lectures depuis un fichier

note: type: Plain text
en: Number of filesystem outputs by the process.
fr: Nombre d'écritures dans un fichier

note: type: Plain text
en: Number of socket messages received by the process.
fr: Nombre de messages reçus par le processus sur une socket.

note: type: Plain text
en: Number of socket messages sent by the process.
fr: Nombre de messages envoyés par le processus sur une socket.

note: type: Plain text
en: Number of signals delivered to the process.
fr: Nombre de signaux délivrés au processus.

note: type: Plain text
en: (Not in tcsh.) Name and command-line arguments of the command being timed.
fr: (pas avec tcsh.) Nom de la commande examinée avec ses arguments.

note: type: Plain text
en: (Not in tcsh.) Exit status of the command.
fr: (pas avec tcsh.) Code de retour de la commande.

note: type: SS
en: GNU options
fr: Options GNU

note: type: Plain text
en: Specify output format, possibly overriding the format specified in the environment variable TIME.
fr: Préciser le format de sortie, en écrasant celui mentionné éventuellement dans la variable d'environnement TIME.

note: type: Plain text
en: Use the portable output format.
fr: Utiliser le format de sortie portable.

note: type: TP
en: B<-o >I<FILE>B<, --output=>I<FILE>
fr: B<-o >I<FICHIER>B<, --output=>I<FICHIER>

note: type: Plain text
en: Do not send the results to I<stderr>, but overwrite the specified file.
fr: Ne pas envoyer les résultats sur la sortie d'erreur standard, mais écraser le fichier indiqué.

note: type: Plain text
en: (Used together with -o.) Do not overwrite but append.
fr: En conjonction avec -o, ne pas écraser le fichier, mais ajouter les résultats à la fin.

note: type: Plain text
en: Give very verbose output about all the program knows about.
fr: Afficher des informations concernant le programme.

note: type: SS
en: GNU standard options
fr: Options standard GNU

note: type: Plain text
en: Print a usage message on standard output and exit successfully.
fr: Afficher un message d'aide sur la sortie standard et terminer normalement.

note: type: Plain text
en: Print version information on standard output, then exit successfully.
fr: Afficher le numéro de version sur la sortie standard et terminer normalement.

note: type: Plain text
en: Terminate option list.
fr: Terminer la liste des options.

note: type: Plain text
en: Not all resources are measured by all versions of UNIX, so some of the values might be reported as zero.  The present selection was mostly inspired by the data provided by 4.2 or 4.3BSD.
fr: Toutes les ressources ne sont pas disponibles avec toutes les versions d'UNIX, ainsi certaines valeurs peuvent être toujours à zéro. La sélection proposée a été essentiellement inspirée des données disponibles sur système BSD\ 4.2 ou 4.3.

note: type: Plain text
en: GNU time version 1.7 is not yet localized.  Thus, it does not implement the POSIX requirements.
fr: La version\ 1.7 GNU de time ne supporte pas encore la localisation.

note: type: Plain text
en: The environment variable B<TIME> was badly chosen.  It is not unusual for systems like B<autoconf>(1)  or B<make>(1)  to use environment variables with the name of a utility to override the utility to be used.  Uses like MORE or TIME for options to programs (instead of program pathnames) tend to lead to difficulties.
fr: Le choix de la variable d'environnement B<TIME> est une erreur. Il n'est pas rare que des systèmes comme B<autoconf>(1) ou B<make>(1) emploient une variable avec le nom d'un utilitaire pour remplacer l'invocation directe. L'utilisation de noms de variables comme B<MORE> ou B<TIME> au lieu des noms de programme conduit parfois à des problèmes.

note: type: Plain text
en: It seems unfortunate that I<-o> overwrites instead of appends.  (That is, the I<-a> option should be the default.)
fr: Il est plutôt malheureux que I<-o> écrase le fichier plutôt que d'y ajouter ses informations (le comportement de I<-a> devrait être celui par défaut).

note: type: Plain text
en: Mail suggestions and bug reports for GNU B<time> to
fr: Envoyez vos rapports de bogues et suggestions pour la version GNU de B<time> à

note: type: Plain text
en: Please include the version of B<time>, which you can get by running
fr: Indiquez bien la version de B<time>, que vous employez, en invoquant

note: .SH AUTHORS .TP .IP "David Keppel" Original version .IP "David MacKenzie" POSIXization, autoconfiscation, GNU getoptization, documentation, other bug fixes and improvements. .IP "Arne Henrik Juul" Helped with portability .IP "Francois Pinard" type: Plain text
en: and the operating system and C compiler you used.
fr: ainsi que le système d'exploitation et le compilateur C utilisés.

note: type: TH
en: 2011-09-09
fr: 9 septembre 2011

note: type: Plain text
en: time - get time in seconds
fr: time - Lire l'heure

note: type: Plain text
en: B<time>()  returns the time as the number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: B<time>()  renvoie la date sous la forme du nombre de secondes depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 (UTC).

note: type: Plain text
en: If I<t> is non-NULL, the return value is also stored in the memory pointed to by I<t>.
fr: Si I<t> n'est pas NULL, la valeur renvoyée est également stockée dans la structure vers laquelle il pointe.

note: type: Plain text
en: On success, the value of time in seconds since the Epoch is returned.  On error, I<((time_t)\ -1)> is returned, and I<errno> is set appropriately.
fr: S'il réussit, l'appel B<time> renvoie le nombre de secondes écoulées depuis l'époque. S'il échoue, la valeur I<((time_t)\ -1)> est renvoyée, et I<errno> contient le code d'erreur.

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

note: .br Under 4.3BSD, this call is obsoleted by .BR gettimeofday (2). type: Plain text
en: SVr4, 4.3BSD, C89, C99, POSIX.1-2001.  POSIX does not specify any error conditions.
fr: SVr4, BSD\ 4.3, C89, C99, POSIX.1-2001. POSIX ne précise pas de condition d'erreur.

note: type: Plain text
en: POSIX.1 defines I<seconds since the Epoch> using a formula that approximates the number of seconds between a specified time and the Epoch.  This formula takes account of the facts that all years that are evenly divisible by 4 are leap years, but years that are evenly divisible by 100 are not leap years unless they are also evenly divisible by 400, in which case they are leap years.  This value is not the same as the actual number of seconds between the time and the Epoch, because of leap seconds and because system clocks are not required to be synchronized to a standard reference.  The intention is that the interpretation of seconds since the Epoch values be consistent; see POSIX.1-2008 Rationale A.4.15 for further rationale.
fr: POSIX.1 définit le nombre de secondes écoulées depuis l'époque grâce à une formule qui est une approximation du nombre de secondes entre une date spécifiée et l'époque. Cette formule prend en compte le fait que les années divisibles par 4 sont bissextiles, sauf les années qui sont divisibles par 100 mais pas par 400. Cette valeur ne correspond donc pas toujours au véritable nombre de secondes écoulées depuis l'époque, à cause des secondes de rattrapage et parce que les horloges système ne sont pas forcément synchronisées avec une référence standard. Cependant elle reste cohérente au cours du temps. Consultez l'explication A.4.15 de POSIX.1-2008 pour plus de détails.

note: type: TH
en: 2012-10-28
fr: 28 octobre 2012

note: type: Plain text
en: time - overview of time and timers
fr: time - Panorama des fonctions liées au temps et aux temporisations

note: type: SS
en: Real time and process time
fr: Temps réel et temps processus

note: type: Plain text
en: I<Real time> is defined as time measured from some fixed point, either from a standard point in the past (see the description of the Epoch and calendar time below), or from some point (e.g., the start) in the life of a process (I<elapsed time>).
fr: Le I<temps réel> est défini comme le temps mesuré à partir d'un point fixe, soit un point standard dans le passé (voir la définition de l'époque et du temps calendaire ci\(hydessous), soit un point (p.ex. le démarrage) dans la vie d'un processus (I<temps écoulé>).

note: type: Plain text
en: I<Process time> is defined as the amount of CPU time used by a process.  This is sometimes divided into I<user> and I<system> components.  User CPU time is the time spent executing code in user mode.  System CPU time is the time spent by the kernel executing in system mode on behalf of the process (e.g., executing system calls).  The B<time>(1)  command can be used to determine the amount of CPU time consumed during the execution of a program.  A program can determine the amount of CPU time it has consumed using B<times>(2), B<getrusage>(2), or B<clock>(3).
fr: Le I<temps processus> est défini comme le temps CPU utilisé par un processus. Il est parfois divisé entre une partie I<utilisateur> et une partie I<système>. Le temps CPU utilisateur est le temps passé à exécuter du code en mode utilisateur. Le temps CPU système est le temps passé par le noyau en mode système pour le processus (p.ex. pendant des appels système). La commande B<time>(1) peut être utilisée pour déterminer le temps CPU utilisé pendant l'exécution du programme. Un programme peut déterminer le temps CPU qu'il a utilisé avec les fonctions B<times>(2), B<getrusage>(2) et B<clock>(3).

note: type: SS
en: The hardware clock
fr: L'horloge matérielle

note: type: Plain text
en: Most computers have a (battery-powered) hardware clock which the kernel reads at boot time in order to initialize the software clock.  For further details, see B<rtc>(4)  and B<hwclock>(8).
fr: La plupart des ordinateurs ont une horloge matérielle (alimentée par une pile) que le noyau lit au démarrage du système pour initialiser l'horloge logicielle. Pour plus de détails, consultez B<rtc>(4) et B<hwclock>(8).

note: type: SS
en: The software clock, HZ, and jiffies
fr: L'horloge logicielle, HZ, et les Jiffies

note: semtimedop(), mq_timedwait(), io_getevents(), poll() are the same futexes and thus sem_timedwait() seem to use high-res timers. type: Plain text
en: The accuracy of various system calls that set timeouts, (e.g., B<select>(2), B<sigtimedwait>(2))  and measure CPU time (e.g., B<getrusage>(2))  is limited by the resolution of the I<software clock>, a clock maintained by the kernel which measures time in I<jiffies>.  The size of a jiffy is determined by the value of the kernel constant I<HZ>.
fr: La précision de divers appels système qui définissent des délais (par exemple B<select>(2), B<sigtimedwait>(2)) ou qui mesurent le temps processeur (par exemple B<getrusage>(2)) est limitée par la résolution de l'I<horloge logicielle>, une horloge maintenue par le noyau qui mesure le temps en I<jiffies>. La durée d'un jiffy est déterminée par la valeur de la constante noyau I<HZ>.

note: type: Plain text
en: The value of I<HZ> varies across kernel versions and hardware platforms.  On i386 the situation is as follows: on kernels up to and including 2.4.x, HZ was 100, giving a jiffy value of 0.01 seconds; starting with 2.6.0, HZ was raised to 1000, giving a jiffy of 0.001 seconds.  Since kernel 2.6.13, the HZ value is a kernel configuration parameter and can be 100, 250 (the default) or 1000, yielding a jiffies value of, respectively, 0.01, 0.004, or 0.001 seconds.  Since kernel 2.6.20, a further frequency is available: 300, a number that divides evenly for the common video frame rates (PAL, 25 HZ; NTSC, 30 HZ).
fr: La précision de nombreux appels système et horodatages est limitée par la résolution de l'I<horloge logicielle>, une horloge maintenue par le noyau qui mesure le temps en I<jiffies>. La taille d'un jiffy est déterminée par la valeur de la constante du noyau I<HZ>. La valeur de I<HZ> varie d'une version du noyau et d'une architecture à une autre. Sur i386, la situation est la suivante\ : pour les noyaux jusqu'à 2.4.x inclus, HZ vaut 100, ce qui donne une valeur de jiffy de 10 millisecondes\ ; à partir de 2.6.0, HZ a été augmenté à 1000, ainsi un jiffy était équivalent à 1 milliseconde. Depuis le noyau 2.6.13, la valeur de HZ est un paramètre de configuration du noyau, et peut valoir 100, 250 (la valeur par défaut), ou 1000, donnant des valeurs de 10, 4 et 1 millisecondes, respectivement, pour un jiffy. Depuis le noyau 2.6.20, il est aussi possible d'utiliser 300\ ; cette valeur est divisible par les fréquences des formats vidéos les plus courants (PAL, 25\ Hz\ ; NTSC, 30\ Hz).

note: glibc gets this info with a little help from the ELF loader; see glibc elf/dl-support.c and kernel fs/binfmt_elf.c. type: Plain text
en: The B<times>(2)  system call is a special case.  It reports times with a granularity defined by the kernel constant I<USER_HZ>.  User-space applications can determine the value of this constant using I<sysconf(_SC_CLK_TCK)>.
fr: L'appel système B<times>(2) est un cas particulier. Il renvoie le temps avec une granularité définie par la constante du noyau I<USER_HZ>. Les applications utilisateur peuvent obtenir la valeur de cette constante avec I<sysconf(_SC_CLK_TCK)>.

note: type: SS
en: High-resolution timers
fr: Temporisations haute résolution

note: type: Plain text
en: Before Linux 2.6.21, the accuracy of timer and sleep system calls (see below) was also limited by the size of the jiffy.
fr: Avant Linux 2.6.21, la précision des appels système gérant les temporisations et les sommeils (voir plus loin) était limitée par la taille du « jiffy ».

note: type: Plain text
en: Since Linux 2.6.21, Linux supports high-resolution timers (HRTs), optionally configurable via B<CONFIG_HIGH_RES_TIMERS>.  On a system that supports HRTs, the accuracy of sleep and timer system calls is no longer constrained by the jiffy, but instead can be as accurate as the hardware allows (microsecond accuracy is typical of modern hardware).  You can determine whether high-resolution timers are supported by checking the resolution returned by a call to B<clock_getres>(2)  or looking at the "resolution" entries in I</proc/timer_list>.
fr: Depuis la version 2.6.21, Linux gère les temporisations haute résolution (HRT : high-resolution timers) de manière optionnelle en configurant B<CONFIG_HIGH_RES_TIMERS>. Sur les systèmes gérant les temporisations haute résolution, la précision des appels système gérant les temporisations et les sommeils n'est plus limitée par le «\ jiffy\ » et peut être aussi fine que le système ne le permette (une précision d'une microseconde est typique sur les matériels actuels). Vous pouvez savoir si les temporisations haute résolution sont gérées en vérifiant la précision renvoyée par un appel à B<clock_getres>(2) ou en regardant les entrées «\ resolution\ » du fichier I</proc/timer_list>.

note: type: Plain text
en: HRTs are not supported on all hardware architectures.  (Support is provided on x86, arm, and powerpc, among others.)
fr: Les temporisations haute résolution ne sont pas gérées par toutes les architectures matérielles. Cette gestion est disponible sur x86, arm et powerpc parmi d'autres.

note: type: SS
en: The Epoch
fr: L'époque (I<Epoch>)

note: type: Plain text
en: UNIX systems represent time in seconds since the I<Epoch>, 1970-01-01 00:00:00 +0000 (UTC).
fr: Les systèmes UNIX représentent le temps depuis l'époque (I<Epoch>), qui est le 1er\ janvier 1970 à\ 00:00:00 (UTC).

note: type: Plain text
en: A program can determine the I<calendar time> using B<gettimeofday>(2), which returns time (in seconds and microseconds) that have elapsed since the Epoch; B<time>(2)  provides similar information, but only with accuracy to the nearest second.  The system time can be changed using B<settimeofday>(2).
fr: Un programme peut déterminer le I<temps calendaire> avec B<gettimeofday>(2), qui renvoie le temps (en secondes et microsecondes) écoulé depuis l'époque\ ; B<time>(2) fournit une information similaire, mais avec une précision d'une seconde. Le temps système peut être modifié avec B<settimeofday>(2).

note: type: SS
en: Broken-down time
fr: Temps décomposé

note: type: Plain text
en: Certain library functions use a structure of type I<tm> to represent I<broken-down time>, which stores time value separated out into distinct components (year, month, day, hour, minute, second, etc.).  This structure is described in B<ctime>(3), which also describes functions that convert between calendar time and broken-down time.  Functions for converting between broken-down time and printable string representations of the time are described in B<ctime>(3), B<strftime>(3), and B<strptime>(3).
fr: Certaines fonctions de bibliothèque utilisent une structure de type I<tm> pour représenter le I<temps décomposé>, qui stocke le temps décomposé en composantes distinctes (année, mois, jour, heure, minute, seconde, etc.). Cette structure est décrite dans B<ctime>(3), qui décrit également les fonctions qui font la conversion entre temps calendaire et temps décomposé. Les fonctions permettant les conversions entre temps décomposé et représentation sous forme de chaîne de caractère sont décrites dans B<ctime>(3), B<strftime>(3) et B<strptime>(3).

note: type: SS
en: Sleeping and setting timers
fr: Dormir et placer des temporisations

note: type: Plain text
en: Various system calls and functions allow a program to sleep (suspend execution) for a specified period of time; see B<nanosleep>(2), B<clock_nanosleep>(2), and B<sleep>(3).
fr: Divers appels système et fonctions permettent à un programme de s'endormir (suspendre son exécution) pour une durée spécifiée. Consultez B<nanosleep>(2), B<clock_nanosleep>(2) et B<sleep>(3).

note: type: Plain text
en: Various system calls allow a process to set a timer that expires at some point in the future, and optionally at repeated intervals; see B<alarm>(2), B<getitimer>(2), B<timerfd_create>(2), and B<timer_create>(2).
fr: Divers appels système permettent à un processus de placer une temporisation qui expirera à un point donné dans le futur, et éventuellement à des intervalles répétés. Consultez B<alarm>(2), B<getitimer>(2), B<timerfd_create>(2) et B<timer_create>(2).

note: type: SS
en: Timer slack
fr: Temporisation relâchée

note: type: Plain text
en: Since Linux 2.6.28, it is possible to control the "timer slack" value for a thread.  The timer slack is the length of time by which the kernel may delay the wake-up of certain system calls that block with a timeout.  Permitting this delay allows the kernel to coalesce wake-up events, thus possibly reducing the number of system wake-ups and saving power.  For more details, see the description of B<PR_SET_TIMERSLACK> in B<prctl>(2).
fr: Depuis Linux 2.6.28, la valeur de « temporisation relâchée » peut être contrôlée pour un thread. La temporisation relâchée est l'intervalle de temps pendant lequel le noyau pourrait différer le réveil de certains appels qui bloquent avec un délai d'expiration. L'autorisation de ce délai permet au noyau de coalescer les événements de réveil, en réduisant donc éventuellement le nombre de réveils système et la consommation d'énergie. Veuillez consulter la description de B<PR_SET_TIMERSLACK> dans B<prctl>(2) pour obtenir plus de précisions.

note: type: Plain text
en: timegm, timelocal - inverses of gmtime and localtime
fr: timegm, timelocal - Fonctions réciproques de gmtime et localtime

note: type: Plain text
en: B<timelocal>(), B<timegm>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<timelocal>(), B<timegm>() : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: The functions B<timelocal>()  and B<timegm>()  are the inverses of B<localtime>(3)  and B<gmtime>(3).
fr: Les fonctions B<timelocal>() et B<timegm>() sont les réciproques de B<localtime>(3) et B<gmtime>(3).

note: type: Plain text
en: These functions are nonstandard GNU extensions that are also present on the BSDs.  Avoid their use; see NOTES.
fr: Ces fonctions sont des extensions non standard de GNU qui sont également présentes sur les BSD. Évitez de les utiliser ; consultez la section NOTES.

note: type: Plain text
en: The B<timelocal>()  function is equivalent to the POSIX standard function B<mktime>(3).  There is no reason to ever use it.
fr: La fonction B<timelocal>() est équivalente à la fonction standard POSIX B<mktime>(3). Il n'y a aucune raison de l'utiliser.

note: type: Plain text
en: For a portable version of B<timegm>(), set the B<TZ> environment variable to UTC, call B<mktime>(3)  and restore the value of B<TZ>.  Something like
fr: Afin d'obtenir une version portable de B<timegm>(), positionnez la variable d'environnement B<TZ> à UTC, appelez B<mktime>(3) et restaurez la valeur de B<TZ>. Soit un code similaire à\ :

note: type: Plain text
en: time_t
    my_timegm(struct tm *tm)
    {
        time_t ret;
        char *tz;
fr: time_t
    mon_timegm(struct tm *tm)
    {
        time_t ret;
        char *tz;

note: type: Plain text
en: timeradd, timersub, timercmp, timerclear, timerisset - timeval operations
fr: timeradd, timersub, timercmp, timerclear, timerisset - Opération timeval

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

note: type: Plain text
en: The macros are provided to operate on I<timeval> structures, defined in I<E<lt>sys/time.hE<gt>> as:
fr: Les macros sont fournies pour agir sur des structures I<timeval>, définie dans I<E<lt>sys/time.hE<gt>> par :

note: type: Plain text
en: B<timeradd>()  adds the time values in I<a> and I<b>, and places the sum in the I<timeval> pointed to by I<res>.  The result is normalized such that I<res-E<gt>tv_usec> has a value in the range 0 to 999,999.
fr: B<timeradd>() ajoute les valeurs des temps I<a> et I<b> et place le résultat dans la structure I<timeval> pointé par I<res>. Le résultat est normalisé de telle sorte que I<res-E<gt>tv_usec> ait une valeur comprise entre 0 et 999 999.

note: type: Plain text
en: B<timersub>()  subtracts the time value in I<b> from the time value in I<a>, and places the result in the I<timeval> pointed to by I<res>.  The result is normalized such that I<res-E<gt>tv_usec> has a value in the range 0 to 999,999.
fr: B<timersub>() soustrait la valeur du temps I<b> de la valeur du temps I<a> et place  le résultat dans la structure I<timeval> pointée par I<res>. Le résultat est normalisé de telle sorte que I<res-E<gt>tv_usec> ait une valeur comprise entre 0 et 999 999.

note: type: Plain text
en: B<timerclear>()  zeros out the I<timeval> structure pointed to by I<tvp>, so that it represents the Epoch: 1970-01-01 00:00:00 +0000 (UTC).
fr: B<timerclear>() met à zéro la structure I<timeval> pointée par I<tvp> de telle sorte qu'elle représente l'époque\ : 1er\ janvier 1970 à\ 00:00:00 (UTC).

note: type: Plain text
en: B<timerisset>()  returns true (nonzero) if either field of the I<timeval> structure pointed to by I<tvp> contains a nonzero value.
fr: B<timerisset>() renvoie vrai (non nul) si un des champs de la structure I<timeval> pointée par I<tvp> contient une valeur non nulle.

note: HP-UX, Tru64, Irix have a definition like: #define timercmp(tvp, uvp, cmp) #.     ((tvp)->tv_sec cmp (uvp)->tv_sec || #.     (tvp)->tv_sec == (uvp)->tv_sec && (tvp)->tv_usec cmp (uvp)->tv_usec) type: Plain text
en: B<timercmp>()  compares the timer values in I<a> and I<b> using the comparison operator I<CMP>, and returns true (nonzero) or false (0) depending on the result of the comparison.  Some systems (but not Linux/glibc), have a broken B<timercmp>()  implementation, in which I<CMP> of I<E<gt>=>, I<E<lt>=>, and I<==> do not work; portable applications can instead use
fr: B<timercmp>() compare les valeurs de timer de I<a> et I<b> en utilisant l'opérateur de comparaison I<CMP> et renvoie vrai (non nul) ou faux (0) en fonction du résultat de la comparaison. Certains systèmes (mais pas Linux avec la glibc), ont une mauvaise implémentation de B<timercmp>(), avec laquelle les valeurs I<E<gt>=>, I<E<lt>=> et I<==> de I<CMP> ne marchent pas ; les applications portables peuvent utiliser à la place :

note: type: Plain text
en: B<timerisset>()  and B<timercmp>()  return true (nonzero) or false (0).
fr: B<timerisset>() et B<timercmp>() renvoie vrai (non nul) ou faux (0).

note: type: Plain text
en: No errors are defined.
fr: Aucune erreur n'est définie.

note: type: Plain text
en: Not in POSIX.1-2001.  Present on most BSD derivatives.
fr: Pas dans POSIX.1-2001. Présentes dans la plupart des dérivées de BSD.

note: type: TH
en: 2012-10-22
fr: 22 octobre 2012

note: type: Plain text
en: times - get process times
fr: times - Obtenir les statistiques temporelles du processus

note: type: Plain text
en: B<times>()  stores the current process times in the I<struct tms> that I<buf> points to.  The I<struct tms> is as defined in I<E<lt>sys/times.hE<gt>>:
fr: La fonction B<times>() stocke les durées statistiques du processus en cours dans la structure I<struct tms> pointée par I<buf>. La structure I<struct tms> est définie ainsi dans I<E<lt>sys/times.hE<gt>>\ :

note: type: Plain text
en: struct tms {
        clock_t tms_utime;  /* user time */
        clock_t tms_stime;  /* system time */
        clock_t tms_cutime; /* user time of children */
        clock_t tms_cstime; /* system time of children */
    };
fr: struct tms {
        clock_t tms_utime;  /* durée utilisateur          */
        clock_t tms_stime;  /* durée système              */
        clock_t tms_cutime; /* durée utilisateur des fils */
        clock_t tms_cstime; /* durée système des fils     */

note: type: Plain text
en: The I<tms_utime> field contains the CPU time spent executing instructions of the calling process.  The I<tms_stime> field contains the CPU time spent in the system while executing tasks on behalf of the calling process.  The I<tms_cutime> field contains the sum of the I<tms_utime> and I<tms_cutime> values for all waited-for terminated children.  The I<tms_cstime> field contains the sum of the I<tms_stime> and I<tms_cstime> values for all waited-for terminated children.
fr: Le champ I<tms_utime> contient le temps CPU écoulé en exécutant les instructions du processus appelant. Le champ I<tms_stime> contient le temps CPU passé dans les fonctions système exécutées pour le compte du processus appelant. Le champ I<tms_cutime> contient la somme des valeurs de I<tms_utime> et I<tms_cutime> pour tous les processus fils terminés ayant été attendus. Le champ I<tms_cstime> contient la somme des valeurs de I<tms_stime> et I<tms_cstime> pour tous les processus fils terminés ayant été attendus.

note: type: Plain text
en: Times for terminated children (and their descendants)  are added in at the moment B<wait>(2)  or B<waitpid>(2)  returns their process ID.  In particular, times of grandchildren that the children did not wait for are never seen.
fr: Les durées des processus fils terminés (et de leurs descendants) sont ajoutées au moment où B<wait>(2) ou B<waitpid>(2) renvoient leur numéro de PID. En particulier, les durées des petits-fils que le fils n'a pas attendu ne sont jamais vues.

note: type: Plain text
en: All times reported are in clock ticks.
fr: Toutes les durées sont exprimées en tops d'horloge.

note: type: Plain text
en: B<times>()  returns the number of clock ticks that have elapsed since an arbitrary point in the past.  The return value may overflow the possible range of type I<clock_t>.  On error, I<(clock_t)\ -1> is returned, and I<errno> is set appropriately.
fr: B<times>() renvoie le nombre de tops d'horloge écoulés depuis un instant arbitraire dans le passé. Cette valeur peut déborder de l'intervalle contenu dans un I<clock_t>. En cas d'erreur I<(clock_t)\ -1> est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<tms> points outside the process's address space.
fr: I<tms> pointe en dehors de l'espace d'adressage du processus.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: The number of clock ticks per second can be obtained using:
fr: Le nombre de tops d'horloge par seconde peut être obtenu en utilisant :

note: type: Plain text
en: In POSIX.1-1996 the symbol B<CLK_TCK> (defined in I<E<lt>time.hE<gt>>)  is mentioned as obsolescent.  It is obsolete now.
fr: Dans POSIX.1-1996, le symbole B<CLK_TCK> (défini dans I<E<lt>time.hE<gt>>) est indiqué en voie d'obsolescence. Il est désormais obsolète.

note: See the description of times() in XSH, which says: The times of a terminated child process are included... when wait() or waitpid() returns the process ID of this terminated child. type: Plain text
en: In Linux kernel versions before 2.6.9, if the disposition of B<SIGCHLD> is set to B<SIG_IGN> then the times of terminated children are automatically included in the I<tms_cstime> and I<tms_cutime> fields, although POSIX.1-2001 says that this should happen only if the calling process B<wait>(2)s on its children.  This nonconformance is rectified in Linux 2.6.9 and later.
fr: Sous les noyaux Linux antérieurs à 2.6.9, si le traitement de B<SIGCHLD> est configuré avec B<SIG_IGN> alors les durées des enfants terminés sont automatiquement incluses dans les champs I<tms_cstime> et I<tms_cutime>, bien que POSIX.1-2001 précise que ceci ne doit se produire que si le processus appelant a fait un B<wait>(2) pour ses enfants. Cette non conformité est corrigée depuis Linux 2.6.9.

note: type: Plain text
en: On Linux, the I<buf> argument can be specified as NULL, with the result that B<times>()  just returns a function result.  However, POSIX does not specify this behavior, and most other UNIX implementations require a non-NULL value for I<buf>.
fr: Sous Linux, l'argument I<buf> peut être NULL, auquel cas B<times>() renvoie simplement son résultat. Cependant, ce comportement n'est pas spécifié par POSIX, et la plupart des implémentations requièrent une valeur non NULL de I<buf>.

note: type: Plain text
en: Note that B<clock>(3)  also returns a value of type I<clock_t>, but this value is measured in units of B<CLOCKS_PER_SEC>, not the clock ticks used by B<times>().
fr: Notez que B<clock>(3) renvoie aussi des valeurs de type I<clock_t>, mais cette valeur est mesurée en unités de B<CLOCKS_PER_SEC>, pas en tops d'horloge utilisés par B<times>().

note: .PP On older systems the number of clock ticks per second is given by the variable HZ. type: Plain text
en: On Linux, the "arbitrary point in the past" from which the return value of B<times>()  is measured has varied across kernel versions.  On Linux 2.4 and earlier this point is the moment the system was booted.  Since Linux 2.6, this point is I<(2^32/HZ) - 300> (i.e., about 429 million) seconds before system boot time.  This variability across kernel versions (and across UNIX implementations), combined with the fact that the returned value may overflow the range of I<clock_t>, means that a portable application would be wise to avoid using this value.  To measure changes in elapsed time, use B<clock_gettime>(2)  instead.
fr: Sous Linux, « l'instant arbitraire dans le passé » à partir duquel la valeur renvoyée par B<times>() est mesuré a varié suivant les versions du noyau. Sous Linux 2.4 et précédents, il s'agit du démarrage du système. Depuis Linux 2.6, cet instant est I<(2^32/HZ) - 300> (c'est-à-dire, à peu près 429 millions) secondes avant le démarrage du système. Cette variabilité à travers les versions du noyau (et à travers les implémentations UNIX) combinée avec le fait que la valeur renvoyée peut déborder de la plage de I<clock_t>, signifie que les applications portables seraient avisées de ne pas utiliser cette valeur. Pour mesurer les modifications d'un temps écoulé, utilisez plutôt B<clock_gettime>(2).

note: type: SS
en: Historical
fr: Historique

note: type: Plain text
en: SVr1-3 returns I<long> and the struct members are of type I<time_t> although they store clock ticks, not seconds since the Epoch.  V7 used I<long> for the struct members, because it had no type I<time_t> yet.
fr: SVr1-3 renvoie un I<long> et les membres de la structure sont de type I<time_t> bien qu'ils stockent des tops d'horloge et pas des secondes depuis l'époque. V7 utilisait des I<long> pour les membres des structures, car il n'avait pas encore de type I<time_t>.

note: The problem is that a syscall return of -4095 to -1 is interpreted by glibc as an error, and the wrapper converts the return value to -1. http://marc.info/?l=linux-kernel&m=119447727031225&w=2 "compat_sys_times() bogus until jiffies >= 0" November 2007 type: Plain text
en: A limitation of the Linux system call conventions on some architectures (notably i386) means that on Linux 2.6 there is a small time window (41 seconds) soon after boot when B<times>()  can return -1, falsely indicating that an error occurred.  The same problem can occur when the return value wraps passed the maximum value that can be stored in B<clock_t>.
fr: Une limitation des conventions d'appel système Linux sur certaines architectures (notamment i386) fait que sous linux 2.6, il y a une petite fenêtre de temps (41 secondes) après le démarrage où B<times>() peut retourner -1, indiquant à tort qu'une erreur est apparue. Le même problème peut survenir lorsque les enveloppes de valeurs renvoyées ont passé la valeur maximum qui puisse être stockée dans B<clock_t>.

note: type: TH
en: 2012-05-04
fr: 4 mai 2012

note: type: Plain text
en: tzfile - timezone information
fr: tzfile - Informations de zone horaire

note: type: Plain text
en: This page describes the structure of the timezone files used by B<tzset>(3).  These files are typically found under one of the directories I</usr/lib/zoneinfo> or I</usr/share/zoneinfo>.
fr: Cette page décrit la structure des fichiers d'informations de zone horaire utilisés par B<tzset>(3). Ces fichiers sont habituellement situés dans les répertoires I</usr/lib/zoneinfo> ou I</usr/share/zoneinfo>.

note: type: Plain text
en: Timezone information files begin with the magic characters "TZif" to identify them as timezone information files, followed by a character identifying the version of the file's format (as of 2005, either an ASCII NUL (\(aq\e0\(aq) or a \(aq2\(aq)  followed by fifteen bytes containing zeros reserved for future use, followed by six four-byte values of type I<long>, written in a "standard" byte order (the high-order byte of the value is written first).  These values are, in order:
fr: Les fichiers d'informations de zone horaire commencent par les caractères magiques « TZif » pour les identifier en tant que fichiers d'informations de zone horaire (Time Zone information file). Ces caractères sont suivis d'un caractère permettant d'identifier le format du fichier (en 2005, les seuls caractères autorisés sont l'ASCII NUL « \e0 » et le « 2 »), suivis de 15 octets contenant des zéros et réservés pour un usage futur, suivis de six valeurs sur 4 octets de type I<long>, écrites dans l'ordre « standard » (I<big endian>, le bit de poids fort en premier). Ces valeurs sont, dans l'ordre :

note: type: Plain text
en: The number of UTC/local indicators stored in the file.
fr: Nombre d'indicateurs UTC/local enregistrés dans le fichier.

note: type: Plain text
en: The number of standard/wall indicators stored in the file.
fr: Nombre d'indicateurs standard/locale enregistrés dans le fichier.

note: type: Plain text
en: The number of leap seconds for which data is stored in the file.
fr: Nombre de secondes de rattrapage pour lesquelles des données sont enregistrées dans le fichier.

note: type: Plain text
en: The number of "transition times" for which data is stored in the file.
fr: Nombre d'« instants de transition » pour lesquels des données sont enregistrées dans le fichier.

note: type: Plain text
en: The number of "local time types" for which data is stored in the file (must not be zero).
fr: Le nombre de « types d'heures locales » pour lesquelles des données sont enregistrées dans le fichier (ne doit pas être nul).

note: type: Plain text
en: The number of characters of "timezone abbreviation strings" stored in the file.
fr: Nombre de caractères de « chaînes d'abréviation de zone horaire » enregistrées dans le fichier.

note: type: Plain text
en: The above header is followed by I<tzh_timecnt> four-byte values of type I<long>, sorted in ascending order.  These values are written in "standard" byte order.  Each is used as a transition time (as returned by B<time>(2))  at which the rules for computing local time change.  Next come I<tzh_timecnt> one-byte values of type I<unsigned char>; each one tells which of the different types of "local time" types described in the file is associated with the same-indexed transition time.  These values serve as indices into an array of I<ttinfo> structures (with I<tzh_typecnt> entries) that appear next in the file; these structures are defined as follows:
fr: L'en-tête ci-dessus est suivi par les valeurs I<tzh_timecnt> sur 4 octets de type I<long>, triées par ordre croissant. Ces valeurs sont écrites dans l'ordre « standard » des octets. Chacune est utilisée comme un instant de transition (tel que renvoyé par l'appel système B<time>(2)) auquel les règles de calcul de l'heure locale changent. Ensuite, viennent les valeur I<tzh_timecnt> sur un octet de type I<unsigned char> ; chacune indiquant lequel des différents types « d'heure locale » décrits dans le fichier est associé avec l'instant de transition de même rang. Ces valeurs servent d'indice dans une table de structures I<ttinfo> (avec des entrées I<tzh_typecnt>) qui apparaissent ensuite dans le fichier. Ces structures sont définies ainsi :

note: type: Plain text
en: Each structure is written as a four-byte value for I<tt_gmtoff> of type I<long>, in a standard byte order, followed by a one-byte value for I<tt_isdst> and a one-byte value for I<tt_abbrind>.  In each structure, I<tt_gmtoff> gives the number of seconds to be added to UTC, I<tt_isdst> tells whether I<tm_isdst> should be set by B<localtime>(3), and I<tt_abbrind> serves as an index into the array of timezone abbreviation characters that follow the I<ttinfo> structure(s) in the file.
fr: Chaque structure est écrite sous forme d'une valeur de 4 octets, du type B<long>, dans l'ordre standard des octets pour I<tt_gmtoff>, suivie d'une valeur sur 1 octet pour I<tt_isdst> et d'une valeur sur 1 octet pour I<tt_abbrind>. Dans chaque structure, I<tt_gmtoff> indique le nombre de secondes à ajouter à UTC, I<tt_isdst> indique que I<tm_isdst> doit être définie par B<localtime>(3) et que I<tt_abbrind> sert d'index dans la table des caractères d'abréviation de la zone horaire qui suit les structures I<ttinfo> dans le fichier.

note: type: Plain text
en: Then there are I<tzh_leapcnt> pairs of four-byte values, written in standard byte order; the first value of each pair gives the time (as returned by B<time>(2))  at which a leap second occurs; the second gives the I<total> number of leap seconds to be applied after the given time.  The pairs of values are sorted in ascending order by time.
fr: Viennent ensuite I<tzh_leapcnt> paires de valeurs 4 octets, écrites dans l'ordre standard des octets. La première valeur de chaque paire donne l'instant (comme fourni par B<time>(2)) auquel s'insère une seconde de rattrapage. La seconde indique le nombre I<total> de secondes de rattrapage à insérer après l'instant donné. Ces paires sont classées en ordre croissant de temps.

note: type: Plain text
en: Then there are I<tzh_ttisstdcnt> standard/wall indicators, each stored as a one-byte value; they tell whether the transition times associated with local time types were specified as standard time or wall clock time, and are used when a timezone file is used in handling POSIX-style timezone environment variables.
fr: Ensuite se trouvent I<tzh_ttisstdcnt> indicateurs standard/locale, chacun enregistré sur un octet. Ils indiquent si les instants de transition associés aux types d'heures locales ont été spécifiés en heure standard ou locale, et servent lorsqu'un fichier de zone horaire permet de manipuler des variables d'environnement de zone horaire à la manière POSIX.

note: type: Plain text
en: Finally, there are I<tzh_ttisgmtcnt> UTC/local indicators, each stored as a one-byte value; they tell whether the transition times associated with local time types were specified as UTC or local time, and are used when a timezone file is used in handling POSIX-style timezone environment variables.
fr: Finalement se trouvent I<tzh_ttisgmtcnt> indicateurs UTC/local, chacun enregistré sur un octet. Ils indiquent si les instants de transition associés aux types d'heures locales ont été spécifiés en heure UTC ou locale, et servent lorsqu'un fichier de fuseau horaire permet de manipuler des variables d'environnement de zone horaire à la manière POSIX.

note: type: Plain text
en: B<localtime>(3)  uses the first standard-time I<ttinfo> structure in the file (or simply the first I<ttinfo> structure in the absence of a standard-time structure)  if either I<tzh_timecnt> is zero or the time argument is less than the first transition time recorded in the file.
fr: B<Localtime>(3) utilise la première structure I<ttinfo> en heure standard du fichier (ou simplement la première structure I<ttinfo> s'il n'y en a pas en heure standard), si I<tzh_timecnt> est nul, ou si son paramètre horaire est antérieur à la première transition enregistrée dans le fichier.

note: type: Plain text
en: For version-2-format timezone files, the above header and data is followed by a second header and data, identical in format except that eight bytes are used for each transition time or leap-second time.  After the second header and data comes a newline-enclosed, POSIX-TZ-environment-variable-style string for use in handling instants after the last transition time stored in the file (with nothing between the newlines if there is no POSIX representation for such instants).
fr: Pour les fichiers de fuseau horaire dans le format 2, l'en-tête et les données ci-dessus sont suivies d'un second en-tête et données, identiques en format sauf que 8 octets sont utilisés pour chaque transition ou secondes de rattrapage. Après le deuxième en-tête et données, arrive une chaîne, du même type que la variable d'environnement POSIX TZ, entourée de sauts de lignes. Cette chaîne est utilisée pour gérer les instants après la dernière transition stockée dans le fichier (avec rien entre les sauts de lignes s'il n'existe pas de représentation POSIX pour de tels instants).

note: type: Plain text
en: I<timezone/tzfile.h> in the glibc source tree
fr: I<timezone/tzfile.h> dans les sources de la glibc

note: type: TH
en: 2007-05-18
fr: 18 mai 2007

note: type: TH
en: Linux System Administration
fr: Manuel de l'administrateur Linux

note: type: Plain text
en: tzselect - select a timezone
fr: tzselect - Sélectionner un fuseau horaire

note: type: Plain text
en: The B<tzselect> program asks the user for information about the current location, and outputs the resulting timezone description to standard output.  The output is suitable as a value for the B<TZ> environment variable.
fr: Le programme B<tzselect> demande à l'utilisateur des informations sur son emplacement géographique, et fournit sur la sortie standard la description du fuseau horaire. Cette sortie est utilisable pour la variable d'environnement B<TZ>.

note: type: Plain text
en: All interaction with the user is done via standard input and standard error.
fr: Toutes les interactions avec l'utilisateur se font par l'entrée standard et la sortie d'erreur.

note: type: Plain text
en: The exit status is zero if a timezone was successfully obtained from the user, nonzero otherwise.
fr: Le code de sortie vaut zéro si un fuseau horaire a été obtenu correctement, et différent de zéro dans le cas contraire.

note: type: Plain text
en: Name of a Posix-compliant I<awk> program (default: B<awk>).
fr: Nom de l'interpréteur I<awk> compatible POSIX disponible sur le système (par défaut\ : B<awk>).

note: or perhaps /usr/local/etc/zoneinfo in some older systems. type: Plain text
en: Name of the directory containing timezone data files (default: I</usr/share/zoneinfo>).
fr: Nom du répertoire contenant les fichiers de données des fuseaux horaires (par défaut\ : I</usr/share/zoneinfo>).

note: type: Plain text
en: Table of ISO 3166 2-letter country codes and country names.
fr: Table des noms de pays et des codes sur deux lettres (ISO 3166).

note: type: Plain text
en: Table of country codes, latitude and longitude, TZ values, and descriptive comments.
fr: Table des codes de pays, latitudes, longitudes, fuseaux horaires et commentaires descriptifs.

note: type: Plain text
en: Time zone data file for timezone I<TZ>.
fr: Fichier de données de fuseau horaire pour I<TZ>.

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

note: type: Plain text
en: tzset, tzname, timezone, daylight - initialize time conversion information
fr: tzset, tzname, timezone, daylight - Initialiser des données pour les conversions de temps

note: type: Plain text
en: B<extern char *>I<tzname>B<[2];>
    B<extern long >I<timezone>B<;>
    B<extern int >I<daylight>B<;>
fr: B<extern char *>I<tzname>B<[2]>
    B<extern long >I<timezone>B<;>
    B<extern int >I<daylight>B<;>

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

note: type: Plain text
en: I<tzname>: _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE
fr: I<tzname> : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_SOURCE

note: type: Plain text
en: I<timezone>: _SVID_SOURCE || _XOPEN_SOURCE
fr: I<timezone> : _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: I<daylight>: _SVID_SOURCE || _XOPEN_SOURCE
fr: I<daylight> : _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: The B<tzset>()  function initializes the I<tzname> variable from the B<TZ> environment variable.  This function is automatically called by the other time conversion functions that depend on the timezone.  In a System-V-like environment, it will also set the variables I<timezone> (seconds West of UTC) and I<daylight> (to 0 if this timezone does not have any daylight saving time rules, or to nonzero if there is a time during the year when daylight saving time applies).
fr: La fonction B<tzset>() initialise la variable I<tzname> en utilisant la variable d'environnement B<TZ>. Cette fonction est appelée automatiquement par les autres fonctions de conversion dépendant du fuseau horaire. Dans un environnement type System V, elle remplira également les variables I<timezone> (secondes à l'ouest de Greenwich) et I<daylight> (à 0 si le fuseau n'a pas de changement d'heure saisonnier, ou à une valeur non nulle s'il y a des périodes durant l'année où le changement horaire s'applique).

note: type: Plain text
en: If the B<TZ> variable does not appear in the environment, the I<tzname> variable is initialized with the best approximation of local wall clock time, as specified by the B<tzfile>(5)-format file I<localtime> found in the system timezone directory (see below).  (One also often sees I</etc/localtime> used here, a symlink to the right file in the system timezone directory.)
fr: Si la variable B<TZ> n'apparaît pas dans l'environnement, I<tzname> est initialisée avec la meilleure approximation possible de l'heure locale, comme indiqué dans le fichier I<localtime>, au format B<tzfile>(5), se trouvant dans le répertoire système des fuseaux horaires (voir plus bas). (on utilise souvent I</etc/localtime> ici, en tant que lien symbolique vers le répertoire système des fuseaux horaires).

note: type: Plain text
en: If the B<TZ> variable does appear in the environment but its value is empty or its value cannot be interpreted using any of the formats specified below, Coordinated Universal Time (UTC) is used.
fr: Si la variable B<TZ> est présente dans l'environnement, mais que sa valeur est vide, ou si sa valeur ne peut pas être interprétée en utilisant le format indiqué plus bas, l'heure TU (temps universel, ou UTC) est utilisée.

note: type: Plain text
en: The value of B<TZ> can be one of three formats.  The first format is used when there is no daylight saving time in the local timezone:
fr: La valeur de B<TZ> peut prendre trois formats différents. Le premier correspond à un endroit où il n'y a pas de décalage heure d'hiver/heure d'été\ :

note: type: Plain text
en: The I<std> string specifies the name of the timezone and must be three or more alphabetic characters.  The I<offset> string immediately follows I<std> and specifies the time value to be added to the local time to get Coordinated Universal Time (UTC).  The I<offset> is positive if the local timezone is west of the Prime Meridian and negative if it is east.  The hour must be between 0 and 24, and the minutes and seconds 0 and 59.
fr: la chaîne I<std> indique le nom du fuseau horaire, constitué d'au moins trois caractères alphabétiques. La chaîne I<offset> suivant immédiatement I<std> indique la valeur à ajouter à l'heure locale pour obtenir l'heure TU. La valeur I<offset> est positive si l'emplacement est à l'ouest du méridien 0, et négative si elle est à l'est. L'heure doit être entre 0 et 24, les minutes et les secondes entre 0 et 59.

note: type: Plain text
en: The second format is used when there is daylight saving time:
fr: Le deuxième format est utilisé lorsqu'il existe des heures d'hiver et d'été différentes\ :

note: type: Plain text
en: There are no spaces in the specification.  The initial I<std> and I<offset> specify the standard timezone, as described above.  The I<dst> string and I<offset> specify the name and offset for the corresponding daylight saving timezone.  If the offset is omitted, it default to one hour ahead of standard time.
fr: Les champs I<std> et I<offset> initiaux indiquent le fuseau horaire comme précisé ci-dessus. Les chaînes I<dst> et I<offset> indiquent le fuseau et le décalage de la zone correspondant à l'heure d'été. Si l'offset est omis, une valeur par défaut est utilisée, correspondant à une heure de décalage vers l'avant.

note: type: Plain text
en: The I<start> field specifies when daylight saving time goes into effect and the I<end> field specifies when the change is made back to standard time.  These fields may have the following formats:
fr: Le champ I<start> indique la date de début de l'heure d'été, et I<end> indique la date de retour à l'heure d'hiver. Ces deux champs utilisent l'un des formats suivants\ :

note: type: Plain text
en: This specifies the Julian day with I<n> between 1 and 365.  Leap days are not counted.  In this format, February 29 can't be represented; February 28 is day 59, and March 1 is always day 60.
fr: Indique le jour julien, avec I<n> compris entre 1 et 365. Les jours intercalaires ne sont pas comptés. Dans ce format, le 29 février ne peut pas être représenté. Le 28 février est le jour 59, et le 1er mars est toujours le jour 60.

note: type: Plain text
en: This specifies the zero-based Julian day with I<n> between 0 and 365.  February 29 is counted in leap years.
fr: Indique le jour julien, avec I<n> compris entre 0 et 365. Le 29 février est compté pendant les années bissextiles.

note: type: TP
en: MI<m>.I<w>.I<d>
fr: MI<m>.I<s>.I<j>

note: type: Plain text
en: This specifies day I<d> (0 E<lt>= I<d> E<lt>= 6) of week I<w> (1 E<lt>= I<w> E<lt>= 5) of month I<m> (1 E<lt>= I<m> E<lt>= 12).  Week 1 is the first week in which day I<d> occurs and week 5 is the last week in which day I<d> occurs.  Day 0 is a Sunday.
fr: Indique le jour I<j> (0 E<lt>= I<j> E<lt>= 6) de la semaine I<s> (1 E<lt>= I<s> E<lt>= 5) du mois I<m> (1 E<lt>= I<m> E<lt>= 12). La semaine 1 est la première semaine du mois dans laquelle le jour I<j> apparaît, et la semaine 5 la dernière où le jour I<j> apparaît. Le jour 0 est Dimanche.

note: type: Plain text
en: The I<time> fields specify when, in the local time currently in effect, the change to the other time occurs.  If omitted, the default is 02:00:00.
fr: Le champ I<time> indique l'heure du changement, sous forme d'heure locale courante. Par défaut, la valeur est 02h00m00s.

note: type: Plain text
en: Here is an example for New Zealand, where the standard time (NZST) is 12 hours ahead of UTC, and daylight saving time (NZDT), 13 hours ahead of UTC, runs from the first Sunday in October to the third Sunday in March, and the changeovers happen at the default time of 02:00:00:
fr: L'exemple suivant correspond à la Nouvelle-Zélande. Son fuseau horaire (NZST) est 12 heures en avance sur le temps universel (UTC). L'heure d'été (NZDT) est 13 heures en avance sur UTC et débute le premier dimanche d'octobre pour finir le troisième dimanche de mars. Le changement d'heure s'effectue à 02h00m00s.

note: type: Plain text
en: The third format specifies that the timezone information should be read from a file:
fr: Le troisième format est utilisé pour indiquer que les informations de fuseau horaire doivent être lues depuis un fichier\ :

note: type: Plain text
en: If the file specification I<filespec> is omitted, the timezone information is read from the file I<localtime> in the system timezone directory, which nowadays usually is I</usr/share/zoneinfo>.  This file is in B<tzfile>(5)  format.  If I<filespec> is given, it specifies another B<tzfile>(5)-format file to read the timezone information from.  If I<filespec> does not begin with a \(aq/\(aq, the file specification is relative to the system timezone directory.
fr: Si le fichier I<filespec> n'est pas indiqué, les informations sont lues dans le fichier I<localtime> se trouvant dans le répertoire système des fuseaux horaires, habituellement I</usr/share/zoneinfo>. Ce fichier est au format B<tzfile>(5). Si I<filespec> est indique, il doit correspondre à un autre fichier au format B<tzfile>(5) où on lira les informations. Si I<filespec> ne commence pas par un «\ /\ », le chemin d'accès est considéré à partir du répertoire système des fuseaux horaires.

note: type: Plain text
en: Here's an example, once more for New Zealand:
fr: Voici un exemple, encore une fois pour la Nouvelle-Zélande :

note: type: Plain text
en: The system timezone directory used depends on the (g)libc version.  Libc4 and libc5 use I</usr/lib/zoneinfo>, and, since libc-5.4.6, when this doesn't work, will try I</usr/share/zoneinfo>.  Glibc2 will use the environment variable B<TZDIR>, when that exists.  Its default depends on how it was installed, but normally is I</usr/share/zoneinfo>.
fr: Le répertoire système employé pour les fuseaux horaires dépend de la version de la bibliothèque C. Les libc4 et libc5 utilisaient I</usr/lib/zoneinfo>, puis, à partir de la libc-5.4.6 le répertoire I</usr/share/zoneinfo> si le premier n'existait pas. La bibliothèque glibc 2 utilise le contenu de la variable d'environnement B<TZDIR> lorsqu'elle existe. Par défaut, c'est normalement I</usr/share/zoneinfo>.

note: type: Plain text
en: This timezone directory contains the files
fr: Les fichiers se trouvant dans le répertoire sont\ :

note: type: Plain text
en: localtime      local timezone file
    posixrules     rules for POSIX-style TZ's
fr: localtime      fichier d'information horaire locale
    posixrules     règles pour les TZ au format POSIX

note: type: Plain text
en: Often I</etc/localtime> is a symlink to the file I<localtime> or to the correct timezone file in the system timezone directory.
fr: Souvent, I</etc/localtime> est un lien symbolique vers I<localtime> ou vers le fichier correct dans le répertoire système des fuseaux horaires.

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD.
fr: SVr4, POSIX.1-2001, BSD 4.3.

note: type: Plain text
en: Note that the variable I<daylight> does not indicate that daylight saving time applies right now.  It used to give the number of some algorithm (see the variable I<tz_dsttime> in B<gettimeofday>(2)).  It has been obsolete for many years but is required by SUSv2.
fr: Remarquez que la variable I<daylight> n'indique pas si le changement d'heure saisonnier s'applique au moment de l'appel. Elle indique simplement le numéro d'un algorithme (voyez la variable I<tz_dsttime> dans B<gettimeofday>(2)). C'est obsolète depuis longtemps, mais obligatoire avec SUSv2.

note: type: Plain text
en: 4.3BSD had a function B<char *timezone(>I<zone>B<, >I<dst>B<)> that returned the name of the timezone corresponding to its first argument (minutes West of UTC).  If the second argument was 0, the standard name was used, otherwise the daylight saving time version.
fr: BSD\ 4.3 a une routine B<char *timezone(>I<zone>B<, >I<dst>B<)> qui renvoie le nom du fuseau horaire correspondant à son premier argument (minutes à l'ouest de Greenwich). Si le second argument est 0, le nom standard est fourni, sinon c'est le nom avec changement horaire saisonnier.

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

note: type: Plain text
en: utime, utimes - change file last access and modification times
fr: utime, utimes - Modifier la date d'accès ou de modification d'un fichier

note: type: Plain text
en: B<Note:> modern applications may prefer to use the interfaces described in B<utimensat>(2).
fr: B<Note:> les applications modernes peuvent utiliser les interfaces décrites dans B<utimensat>(2).

note: type: Plain text
en: The B<utime>()  system call changes the access and modification times of the inode specified by I<filename> to the I<actime> and I<modtime> fields of I<times> respectively.
fr: L'appel système B<utime>() change les dates d'accès et de modification de l'inœud indiqué par I<filename> pour les valeurs contenues respectivement dans les champs I<actime> et I<modtime> de I<times>.

note: type: Plain text
en: If I<times> is NULL, then the access and modification times of the file are set to the current time.
fr: Si I<times> est NULL, les dates d'accès et de modification sont mises à l'heure actuelle.

note: type: Plain text
en: Changing timestamps is permitted when: either the process has appropriate privileges, or the effective user ID equals the user ID of the file, or I<times> is NULL and the process has write permission for the file.
fr: La modification des horodatages est permise lorsque soit le processus a les privilèges appropriés, soit l'UID effectif est égal à l'UID du fichier, soit I<times> est nul et le processus a la permission d'écriture sur le fichier.

note: type: Plain text
en: The I<utimbuf> structure is:
fr: La structure I<utimbuf> est la suivante\ :

note: type: Plain text
en: struct utimbuf {
        time_t actime;       /* access time */
        time_t modtime;      /* modification time */
    };
fr: struct utimbuf {
        time_t actime;       /* heure d'accès  */
        time_t modtime;      /* heure de modification */
    };

note: type: Plain text
en: The B<utime>()  system call allows specification of timestamps with a resolution of 1 second.
fr: L'appel système B<utime>() permet des spécifications d'horodatages avec une résolution d'une seconde.

note: type: Plain text
en: The B<utimes>()  system call is similar, but the I<times> argument refers to an array rather than a structure.  The elements of this array are I<timeval> structures, which allow a precision of 1 microsecond for specifying timestamps.  The I<timeval> structure is:
fr: L'appel système B<utimes>() est similaire mais le paramètre I<times> fait référence à un tableau au lieu d'une structure. Les éléments de ce tableau sont des structures I<timeval>, qui permet une résolution d'une microseconde pour les horodatages. La structure I<timeval> est la suivante :

note: type: Plain text
en: struct timeval {
        long tv_sec;        /* seconds */
        long tv_usec;       /* microseconds */
    };
fr: struct timeval {
        long tv_sec;        /* secondes      */
        long tv_usec;       /* microsecondes */
    };

note: type: Plain text
en: I<times>[0] specifies the new access time, and I<times>[1] specifies the new modification time.  If I<times> is NULL, then analogously to B<utime>(), the access and modification times of the file are set to the current time.
fr: I<times>[0] indique la nouvelle heure d'accès, et I<times>[1] indique la nouvelle heure de modification. Si I<times> est NULL, de manière analogue à B<utime>(), les heures d'accès et modification du fichier sont définies à l'heure actuelle.

note: type: Plain text
en: Search permission is denied for one of the directories in the path prefix of I<path> (see also B<path_resolution>(7)).
fr: La permission de parcours est refusée pour un des répertoires contenu dans le chemin I<path>. (Consultez aussi B<path_resolution>(7))

note: type: Plain text
en: I<times> is NULL, the caller's effective user ID does not match the owner of the file, the caller does not have write access to the file, and the caller is not privileged (Linux: does not have either the B<CAP_DAC_OVERRIDE> or the B<CAP_FOWNER> capability).
fr: I<times> est NULL, l'UID effectif de l'appelant ne correspond pas au propriétaire du fichier, l'appelant n'a pas la permission d'écriture sur le fichier et l'appelant n'est pas privilégié (Linux : n'a ni la capacité B<CAP_DAC_OVERRIDE>, ni la capacité B<CAP_FOWNER>).

note: type: Plain text
en: I<filename> does not exist.
fr: I<filename> n'existe pas.

note: type: Plain text
en: I<times> is not NULL, the caller's effective UID does not match the owner of the file, and the caller is not privileged (Linux: does not have the B<CAP_FOWNER> capability).
fr: I<times> n'est pas NULL, l'UID effectif de l'appelant ne correspond pas au propriétaire du fichier et l'appelant n'est pas privilégié (Linux : n'a pas la capacité B<CAP_FOWNER>).

note: type: Plain text
en: I<path> resides on a read-only filesystem.
fr: I<path> se trouve sur un système de fichiers en lecture seule.

note: type: Plain text
en: B<utime>(): SVr4, POSIX.1-2001.  POSIX.1-2008 marks B<utime>()  as obsolete.
fr: B<utime>() : SVr4, POSIX.1-2001. POSIX.1-2008 marque B<utime>() comme étant obsolète.

note: type: Plain text
en: B<utimes>(): 4.3BSD, POSIX.1-2001.
fr: B<utimes>()\ : BSD 4.3, POSIX.1-2001.

note: type: Plain text
en: Linux does not allow changing the timestamps on an immutable file, or setting the timestamps to something other than the current time on an append-only file.
fr: Linux n'autorise pas la modification d'horodatages sur les fichiers immuables, ou l'horodatage avec autre chose que la date courante sur les fichiers en ajout seulement.

note: type: Plain text
en: In libc4 and libc5, B<utimes>()  is just a wrapper for B<utime>()  and hence does not allow a subsecond resolution.
fr: Dans libc4 et libc5, B<utimes>() est juste une enveloppe à B<utime>() et ne permet donc pas des résolutions inférieure à la seconde.

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

note: type: Plain text
en: utimensat, futimens - change file timestamps with nanosecond precision
fr: utimensat, futimens - Modifier les horodatages d'un fichier avec une précision d'une nanoseconde

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

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: B<utimensat>()  and B<futimens>()  update the timestamps of a file with nanosecond precision.  This contrasts with the historical B<utime>(2)  and B<utimes>(2), which permit only second and microsecond precision, respectively, when setting file timestamps.
fr: B<utimensat>() et B<futimens>() mettent à jour les horodatages d'un fichier avec une précision d'une nanoseconde. Ceci change de l'appel historique ou de B<utimes>(2), qui permettent seulement une précision d'une seconde et d'une microseconde respectivement pour l'établissement des horodatages de fichier.

note: type: Plain text
en: With B<utimensat>()  the file is specified via the pathname given in I<pathname>.  With B<futimens>()  the file whose timestamps are to be updated is specified via an open file descriptor, I<fd>.
fr: Avec B<utimensat>(), le fichier est indiqué à l'aide du chemin fournit dans I<pathname>. Avec B<futimens>(), le fichier dont les horodatages doit être mis à jour est indiqué par un descripteur de fichier ouvert, I<fd>.

note: type: Plain text
en: For both calls, the new file timestamps are specified in the array I<times>: I<times>[0] specifies the new "last access time" (I<atime>); I<times>[1] specifies the new "last modification time" (I<mtime>).  Each of the elements of I<times> specifies a time as the number of seconds and nanoseconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).  This information is conveyed in a structure of the following form:
fr: Pour les deux appels, les nouveaux horodatages de fichier sont indiqués dans le tableau I<times> : I<times>[0] indique l'horodatage du dernier accès (I<atime>) ; I<times>[1] indique l'horodatage de la dernière modification (I<mtime>). Chaque élément de I<times> indique une date par un nombre de secondes et de nanosecondes depuis l'époque (1er\ janvier 1970 à\ 00:00:00 UTC). Cette information est transmise dans une structure de la forme suivante :

note: type: Plain text
en: Updated file timestamps are set to the greatest value supported by the filesystem that is not greater than the specified time.
fr: L'horodatage mis à jour pour le fichier est configuré à la valeur la plus importante gérée par le système de fichiers et qui n'est pas supérieure à l'horodatage fourni

note: 2.6.22 was broken: it is not ignored type: Plain text
en: If the I<tv_nsec> field of one of the I<timespec> structures has the special value B<UTIME_NOW>, then the corresponding file timestamp is set to the current time.  If the I<tv_nsec> field of one of the I<timespec> structures has the special value B<UTIME_OMIT>, then the corresponding file timestamp is left unchanged.  In both of these cases, the value of the corresponding I<tv_sec> field is ignored.
fr: Si le champ I<tv_nsec> d'une des structures I<timespec> prend la valeur particulière B<UTIME_NOW>, alors l'horodatage correspondant du fichier est défini à l'heure actuelle. Si le champ I<tv_nsec> d'une des structures I<timespec> prend la valeur particulière B<UTIME_OMIT>, alors l'horodatage correspondant du fichier reste inchangé. Dans ces deux cas, la valeur du champ I<tv_sec> est ignoré.

note: type: Plain text
en: If I<times> is NULL, then both timestamps are set to the current time.
fr: Si I<times> est NULL, les deux horodatages sont définis à l'heure actuelle.

note: type: SS
en: Permissions requirements
fr: Droits d'accès nécessaires

note: type: Plain text
en: To set both file timestamps to the current time (i.e., I<times> is NULL, or both I<tv_nsec> fields specify B<UTIME_NOW>), either:
fr: Pour définir les deux horodatages à l'heure actuelle (c'est-à-dire quand I<times> vaut NULL ou que les deux champs I<tv_nsec> valent B<UTIME_NOW>), il faut :

note: 2.6.22 was broken here -- for futimens() the check is based on whether or not the file descriptor is writable, not on whether the caller's effective UID has write permission for the file referred to by the descriptor. type: Plain text
en: the caller must have write access to the file;
fr: soit que l'utilisateur ait les droits d'écriture sur le fichier ;

note: type: Plain text
en: the caller's effective user ID must match the owner of the file; or
fr: soit que l'identifiant effectif de l'appelant corresponde au propriétaire du fichier ;

note: type: Plain text
en: the caller must have appropriate privileges.
fr: ou que le processus appelant ait les privilèges nécessaires.

note: 2.6.22 was broken here: both must be something other than *either* UTIME_OMIT *or* UTIME_NOW. type: Plain text
en: To make any change other than setting both timestamps to the current time (i.e., I<times> is not NULL, and neither I<tv_nsec> field is B<UTIME_NOW> and neither I<tv_nsec> field is B<UTIME_OMIT>), either condition 2 or 3 above must apply.
fr: Pour pouvoir effectuer d'autres changements que de définir les horodatage à l'heure actuelle (c'est-à-dire quand I<times> n'est pas NULL et que ni le champ I<tv_nsec> ne vaut B<UTIME_NOW> ni le champ I<tv_nsec> ne vaut B<UTIME_OMIT>), les conditions 2 ou 3 ci-dessus s'appliquent.

note: type: Plain text
en: If both I<tv_nsec> fields are specified as B<UTIME_OMIT>, then no file ownership or permission checks are performed, and the file timestamps are not modified, but other error conditions may still be detected.
fr: Si les deux champs I<tv_nsec> valent B<UTIME_OMIT>, aucune vérification n'est effectuée sur le propriétaire ou les permissions et les horodatages ne sont pas modifiés, mais les autres situations d'erreur sont toujours détectées.

note: type: SS
en: utimensat() specifics
fr: Spécificités de utimensat()

note: FIXME . Say something about O_SEARCH?  (But it's not in current glibc (Mar 08), or kernel 2.6.25.) type: Plain text
en: If I<pathname> is relative, then by default it is interpreted relative to the directory referred to by the open file descriptor, I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<utimes>(2)  for a relative pathname).  See B<openat>(2)  for an explanation of why this can be useful.
fr: Si le chemin donné dans I<pathname> est relatif, il est par défaut interprété par rapport au répertoire référencé par le descripteur de fichier ouvert I<dirfd> (plutôt que par rapport au répertoire courant du processus, comme pour B<utimes>(2) pour les chemins relatifs). Consultez B<openat>(2) pour avoir les raisons pour lesquelles ceci peut être utile.

note: type: Plain text
en: The I<flags> field is a bit mask that may be 0, or include the following constant, defined in I<E<lt>fcntl.hE<gt>>:
fr: Le champ I<flags> est un champ de bits qui peut être nul ou inclure les constantes suivantes, définies dans I<E<lt>fcntl.hE<gt>> :

note: type: Plain text
en: If I<pathname> specifies a symbolic link, then update the timestamps of the link, rather than the file to which it refers.
fr: Si I<pathname> indique un lien symbolique, alors mettre à jour l'horodatage du lien, plutôt que le fichier pointé.

note: type: Plain text
en: On success, B<utimensat>()  and B<futimens>()  return 0.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'ils réussissent les appels B<utimensat>() et B<futimens>() renvoient zéro, sinon ils renvoient -1 et remplissent I<errno> avec le code d'erreur.

note: type: Plain text
en: I<times> is NULL, or both I<tv_nsec> values are B<UTIME_NOW>, and:
fr: I<times> est NULL ou les deux champs I<tv_nsec> valent B<UTIME_NOW>, et

note: But Linux 2.6.22 was broken here. Traditionally, utime()/utimes() gives the error EACCES for the case where the timestamp pointer argument is NULL (i.e., set both timestamps to the current time), and the file is owned by a user other than the effective UID of the caller, and the file is not writable
en: the effective user ID of the caller does not match the owner of the file, the caller does not have write access to the file, and the caller is not privileged (Linux: does not have either the B<CAP_FOWNER> or the B<CAP_DAC_OVERRIDE> capability); or,
fr: l'identifiant de l'utilisateur effectif de l'appelant ne correspond pas au propriétaire du fichier, l'appelant n'a pas la permission d'écriture sur le fichier et l'appelant n'est pas privilégié (Linux : n'a ni la capacité B<CAP_FOWNER>, ni la capacité B<CAP_DAC_OVERRIDE>) ; ou

note: EXT2_IMMUTABLE_FL and similar flags for other filesystems. type: Plain text
en: the file is marked immutable (see B<chattr>(1)).
fr: le fichier est marqué comme étant immuable (consultez B<chattr>(1)).

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

note: type: Plain text
en: (B<utimensat>())  I<pathname> is a relative pathname, but I<dirfd> is neither B<AT_FDCWD> nor a valid file descriptor.
fr: (B<utimensat>()) I<pathname> est un chemin relatif, mais I<dirfd> n'est ni B<AT_FDCWD> ni un descripteur de fichier valable.

note: type: Plain text
en: I<times> pointed to an invalid address; or, I<dirfd> was B<AT_FDCWD>, and I<pathname> is NULL or an invalid address.
fr: I<times> pointe vers une adresse incorrecte ; ou I<dirfd> valait B<AT_FDCWD> et I<pathname> est NULL ou une adresse incorrecte.

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

note: type: Plain text
en: Invalid value in one of the I<tv_nsec> fields (value outside range 0 to 999,999,999, and not B<UTIME_NOW> or B<UTIME_OMIT>); or an invalid value in one of the I<tv_sec> fields.
fr: Valeur incorrecte dans un des champs I<tv_nsec> (valeur en dehors de l'intervalle allant de 0 à 999.999.999 et ne valant ni B<UTIME_NOW> ni B<UTIME_OMIT>) ; ou une valeur incorrecte dans un des champs I<tv_sec>.

note: SUSv4 does not specify this error. type: Plain text
en: I<pathname> is NULL, I<dirfd> is not B<AT_FDCWD>, and I<flags> contains B<AT_SYMLINK_NOFOLLOW>.
fr: I<pathname> est NULL, I<dirfd> ne vaut pas B<AT_FDCWD> et I<flags> contient B<AT_SYMLINK_NOFOLLOW>.

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

note: type: Plain text
en: (B<utimensat>())  I<pathname> is too long.
fr: (B<utimensat>()) I<pathname> est trop long.

note: type: Plain text
en: (B<utimensat>())  A component of I<pathname> does not refer to an existing directory or file, or I<pathname> is an empty string.
fr: (B<utimensat>()) Un élément du chemin d'accès I<pathname> ne correspond pas un répertoire ou àun fichier existant ou I<pathname> est une chaîne vide.

note: type: Plain text
en: (B<utimensat>())  I<pathname> is a relative pathname, but I<dirfd> is neither B<AT_FDCWD> nor a file descriptor referring to a directory; or, one of the prefix components of I<pathname> is not a directory.
fr: (B<utimensat>()) I<pathname> est un chemin relatif, mais I<dirfd> n'est ni B<AT_FDCWD> ni un descripteur de fichier correspondant à un répertoire ; ou l'un des composants au début de I<pathname> n'est pas un répertoire.

note: type: Plain text
en: The caller attempted to change one or both timestamps to a value other than the current time, or to change one of the timestamps to the current time while leaving the other timestamp unchanged, (i.e., I<times> is not NULL, neither I<tv_nsec> field is B<UTIME_NOW>, and neither I<tv_nsec> field is B<UTIME_OMIT>)  and:
fr: L'appelant a essayé de modifier un horodatage (ou les deux) en une valeur autre que l'heure actuelle, ou de modifier un des horodatages en l'heure actuelle et en ne changeant pas l'autre horodatage (c'est-à-dire I<times> n'est pas NULL, aucun des deux champs I<tv_nsec> ne vaut B<UTIME_NOW> et aucun des deux champs I<tv_nsec> ne vaut B<UTIME_OMIT>) et :

note: type: Plain text
en: the caller's effective user ID does not match the owner of file, and the caller is not privileged (Linux: does not have the B<CAP_FOWNER> capability); or,
fr: l'identifiant d'utilisateur effectif de l'appelant ne correspond pas au propriétaire du fichier et l'appelant n'est pas privilégié (Linux : n'a pas la capacité B<CAP_FOWNER>).

note: Linux 2.6.22 was broken here: it was not consistent with the old utimes() implementation, since the case when both tv_nsec fields are UTIME_NOW, was not treated like the (times == NULL) case. EXT2_IMMUTABLE_FL EXT_APPPEND_FL and similar flags for other filesystems. Why the inconsistency (which is de
en: the file is marked append-only or immutable (see B<chattr>(1)).
fr: le fichier est marqué comme n'acceptant que des ajouts ou est immuable (voir B<chattr>(1)).

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: (B<utimensat>())  Search permission is denied for one of the prefix components of I<pathname>.
fr: (B<utimensat>()) Un élément au début du chemin d'accès I<pathname> ne permet pas le parcours.

note: type: Plain text
en: B<utimensat>()  was added to Linux in kernel 2.6.22; glibc support was added with version 2.6.
fr: B<utimensat>() a été ajouté à Linux dans le noyau 2.6.22 ; la glibc le gère depuis la version 2.6.

note: type: Plain text
en: Support for B<futimens>()  first appeared in glibc 2.6.
fr: La prise en charge de B<futimens>() est apparu dans la glibc 2.6.

note: type: Plain text
en: B<futimens>()  and B<utimensat>()  are specified in POSIX.1-2008.
fr: B<futimens>() et B<utimensat>() sont spécifiés dans POSIX.1-2008.

note: type: Plain text
en: B<utimensat>()  obsoletes B<futimesat>(2).
fr: B<utimensat>() rend B<futimesat>(2) obsolète.

note: type: Plain text
en: On Linux, timestamps cannot be changed for a file marked immutable, and the only change permitted for files marked append-only is to set the timestamps to the current time.  (This is consistent with the historical behavior of B<utime>(2)  and B<utimes>(2)  on Linux.)
fr: Sous Linux, les horodatages ne peuvent pas être modifiés pour un fichier marqué comme étant immuable, et la seule modification autorisée pour les fichier n'autorisant que des ajouts est de définir les horodatages à l'heure actuelle. (C'est cohérent avec le comportement historique de B<utime>(2) et de B<utimes>(2) sous Linux)

note: type: Plain text
en: On Linux, B<futimens>()  is a library function implemented on top of the B<utimensat>()  system call.  To support this, the Linux B<utimensat>()  system call implements a nonstandard feature: if I<pathname> is NULL, then the call modifies the timestamps of the file referred to by the file descriptor I<dirfd> (which may refer to any type of file).  Using this feature, the call I<futimens(fd,\ times)> is implemented as:
fr: Sous Linux, B<futimens>() est une fonction de bibliothèque implémentée à l'aide de l'appel système B<utimensat>(). Pour ceci, l'appel système B<utimensat>() de Linux implémente une fonctionnalité non standard : si I<pathname> est NULL, alors l'appel modifie les horodatages du fichier correspondant au descripteur de fichier I<dirfd> (qui peut correspondre à n'importe quel type de fichier). En utilisant cette fonctionnalité, l'appel I<futimens(fd,\ times)> est implémenté comme ceci :

note: type: Plain text
en: Several bugs afflict B<utimensat>()  and B<futimens>()  on kernels before 2.6.26.  These bugs are either nonconformances with the POSIX.1 draft specification or inconsistencies with historical Linux behavior.
fr: Plusieurs bogues affectent B<utimensat>() et B<futimens>() sur les noyaux antérieurs à 2.6.26. Ces bogues sont soit des non conformités avec le brouillon de la spécification POSIX.1 soit des incohérences avec le comportement historique de Linux.

note: type: Plain text
en: POSIX.1 specifies that if one of the I<tv_nsec> fields has the value B<UTIME_NOW> or B<UTIME_OMIT>, then the value of the corresponding I<tv_sec> field should be ignored.  Instead, the value of the I<tv_sec> field is required to be 0 (or the error B<EINVAL> results).
fr: POSIX.1 spécifie que si un des champs I<tv_nsec> prend la valeur B<UTIME_NOW> ou B<UTIME_OMIT>, alors la valeur du champs I<tv_sec> correspondant doit être ignorée. À la place, la valeur du champ I<tv_sec> doit être nul (ou une erreur B<EINVAL> sera produite).

note: Below, the long description of the errors from the previous bullet point (abridged because it's too much detail for a man page). .IP * If one of the .I tv_nsec fields is .BR UTIME_OMIT and the other is .BR UTIME_NOW , then the error .B EPERM should occur if the process's effective user ID does not m
en: Various bugs mean that for the purposes of permission checking, the case where both I<tv_nsec> fields are set to B<UTIME_NOW> isn't always treated the same as specifying I<times> as NULL, and the case where one I<tv_nsec> value is B<UTIME_NOW> and the other is B<UTIME_OMIT> isn't treated the same as specifying I<times> as a pointer to an array of structures containing arbitrary time values.  As a result, in some cases: a) file timestamps can be updated by a process that shouldn't have permission to perform updates; b) file timestamps can't be updated by a process that should have permission to perform updates; and c) the wrong I<errno> value is returned in case of an error.
fr: Ces bogues indiquent que pour ce qui est de la vérification des droits, le cas où les deux champs I<tv_nsec> ne valent pas B<UTIME_NOW> n'est pas toujours traité de la même façon que lorsque I<times> est NULL, et le cas où une des valeurs I<tv_nsec> vaut B<UTIME_NOW> et l'autre vaut B<UTIME_OMIT> n'est pas traité de la même façon que quand I<times> pointe vers un tableau de structures contenant des valeurs de temps arbitraires. De ce fait, il se peut que : a) des horodatages de fichier puissent être mis à jour par un processus qui ne devrait pas avoir le droit de faire ces mises à jour ; b) des horodatages de fichier ne puissent pas être mis à jour par un processus qui devrait avoir le droit de faire ces mises à jour ; et c) la mauvaise valeur d'I<errno> puisse être renvoyée en cas d'erreur.

note: This means that a process with a file descriptor that allows writing could change the timestamps of a file for which it does not have write permission; conversely, a process with a read-only file descriptor won't be able to update the timestamps of a file, even if it has write permission on the file
en: POSIX.1 says that a process that has I<write access to the file> can make a call with I<times> as NULL, or with I<times> pointing to an array of structures in which both I<tv_nsec> fields are B<UTIME_NOW>, in order to update both timestamps to the current time.  However, B<futimens>()  instead checks whether the I<access mode of the file descriptor allows writing>.
fr: POSIX.1 indique qu'un processus qui a les I<droits d'accès en écriture pour un fichier> peut faire un appel avec I<times> valant NULL ou avec I<times> pointant vers un tableau de structures dans lesquelles les deux champs I<tv_nsec> valent B<UTIME_NOW> pour mettre à jour les deux horodatages à l'heure actuelle. Cependant, B<futimens>() vérifie à la place si le I<mode d'accès du descripteur de fichier permet l'écriture>.

note: type: TH
en: 2013-02-12
fr: 12 février 2013

note: type: Plain text
en: zdump - timezone dumper
fr: zdump - Affichage du fuseau horaire

note: type: Plain text
en: B<zdump> [ B<--version> ] [ B<--help> ] [ B<-v> ] [ B<-c> [I<loyear>B<,>]I<hiyear> ] [ I<zonename> ... ]
fr: B<zdump> [ B<--version> ] [ B<--help> ] [ B<-v> ] [ B<-c> [I<année_de_début>B<,>]I<année_de_fin> ] [ I<fuseau> ... ]

note: type: Plain text
en: I<Zdump> prints the current time in each I<zonename> named on the command line.
fr: I<Zdump> affiche la date et l'heure actuelle dans chaque I<fuseau> horaire cité sur la ligne de commande.

note: type: Plain text
en: These options are available:
fr: Les options disponibles sont :

note: type: Plain text
en: Output version information and exit.
fr: Afficher le numéro de version et terminer.

note: type: Plain text
en: Output short usage and exit.
fr: Afficher un bref message d'aide et terminer.

note: type: Plain text
en: For each I<zonename> on the command line, print the time at the lowest possible time value, the time one day after the lowest possible time value, the times both one second before and exactly at each detected time discontinuity, the time at one day less than the highest possible time value, and the time at the highest possible time value.  Each line ends with B<isdst=1> if the given time is Daylight Saving Time or B<isdst=0> otherwise.
fr: Pour chaque I<fuseau> de la ligne de commande, afficher : la date et l'heure à la valeur la plus petite possible ; la date et l'heure un jour plus tard ; puis une seconde avant et à l'heure juste de chaque discontinuité temporelle ; et enfin la date et l'heure un jour avant la plus grande valeur possible et à cette valeur. Chaque ligne se termine avec B<isdst=1> si l'heure indiquée prend en compte le décalage d'été ou B<isdst=0> dans le cas contraire.

note: type: TP
en: B<-c >[I<loyear>B<,>]I<hiyear>
fr: B<-c> [I<année_de_début>B<,>]I<année_de_fin>

note: type: Plain text
en: Cut off the verbose output near the start of the given year(s).  The output still includes the lowest possible time value and one day after it, and the highest possible time value preceded by the time value one day before it.
fr: Arrêter la sortie volubile près du début de l'année ou des années indiquées. La sortie contient encore la date et l'heure à la valeur la plus petite possible et un jour plus tard, ainsi que la date et l'heure un jour avant la plus grande valeur possible et cette valeur.

note: type: Plain text
en: zic - timezone compiler
fr: zic - Compilation des informations de fuseau horaire

note: type: Plain text
en: B<zic> [ B<-v> ] [ B<-d> I<directory> ] [ B<-l> I<localtime> ] [ B<-p> I<posixrules> ] [ B<-L> I<leapsecondfilename> ] [ B<-s> ] [ B<-y> I<command> ] [ I<filename> \&... ]
fr: B<zic> [ B<-v> ] [ B<-d> I<répertoire> ] [ B<-l> I<heure_locale> ] [ B<-p> I<règles_posix> ] [ B<-L> I<fichier_secondes_rattrapage> ] [ B<-s> ] [ B<-y> I<commande> ] [ I<fichier> \&... ]

note: type: Plain text
en: I<Zic> reads text from the file(s) named on the command line and creates the time conversion information files specified in this input.  If a I<filename> is B<->, the standard input is read.
fr: B<Zic> lit le texte dans les fichiers indiqués sur la ligne de commande et crée les fichiers d'information pour les conversions horaires indiquées dans ces fichiers. Si un nom de I<fichier> est B<->, l'entrée standard est lue.

note: type: TP
en: B<-d >I<directory>
fr: B<-d> I<répertoire>

note: type: Plain text
en: Create time conversion information files in the named directory rather than in the standard directory named below.
fr: Crée les fichiers d'informations pour les conversions horaires dans le répertoire indiqué plutôt que dans le répertoire standard indiqué plus bas.

note: type: TP
en: B<-l >I<timezone>
fr: B<-l> I<fuseau_horaire>

note: type: Plain text
en: Use the given timezone as local time.  I<Zic> will act as if the input contained a link line of the form
fr: Utiliser le fuseau horaire indiqué comme heure locale. I<Zic> agira comme si l'entrée contenait une ligne de lien de la forme :

note: type: Plain text
en: Link	I<timezone>		localtime
fr: Link	I<fuseau_horaire>		heure_locale

note: type: TP
en: B<-p >I<timezone>
fr: B<-p> I<fuseau_horaire>

note: type: Plain text
en: Use the given timezone's rules when handling POSIX-format timezone environment variables.  I<Zic> will act as if the input contained a link line of the form
fr: Utiliser les règles de conversions horaires du fuseau indiqué lors de la gestion des variables d'environnement horaires POSIX. I<Zic> agira comme si l'entrée contenait une ligne de lien de la forme :

note: type: Plain text
en: Link	I<timezone>		posixrules
fr: Link	I<fuseau_horaire>		règles_posix

note: type: TP
en: B<-L >I<leapsecondfilename>
fr: B<-L> I<fichier_secondes_rattrapage>

note: type: Plain text
en: Read leap second information from the file with the given name.  If this option is not used, no leap second information appears in output files.
fr: Lire les informations concernant les secondes de rattrapage périodique à partir du fichier indiqué. Si cette option n'est pas indiquée, aucune seconde de rattrapage ne sera prise en compte dans les fichiers de sortie.

note: type: Plain text
en: Complain if a year that appears in a data file is outside the range of years representable by B<time>(2)  values.
fr: Refuser qu'une année indiquée dans le fichier de données soit en dehors de l'intervalle représentable par les valeurs de B<time>(2).

note: type: Plain text
en: Limit time values stored in output files to values that are the same whether they're taken to be signed or unsigned.  You can use this option to generate SVVS-compatible files.
fr: Limiter les valeurs de temps stockées dans les fichiers de sortie aux valeurs qui sont identiques en stockage signé et non signé. Cette option permet de générer des fichiers compatibles SVVS.

note: type: TP
en: B<-y >I<command>
fr: B<-y> I<commande>

note: type: Plain text
en: Use the given I<command> rather than B<yearistype> when checking year types (see below).
fr: Utiliser la I<commande> plutôt que B<yearistype> pour vérifier les types d'années (voir plus bas).

note: type: Plain text
en: Input lines are made up of fields.  Fields are separated from one another by any number of white space characters.  Leading and trailing white space on input lines is ignored.  An unquoted sharp character (#) in the input introduces a comment which extends to the end of the line the sharp character appears on.  White space characters and sharp characters may be enclosed in double quotes (") if they're to be used as part of a field.  Any line that is blank (after comment stripping) is ignored.  Nonblank lines are expected to be of one of three types: rule lines, zone lines, and link lines.
fr: Les lignes d'entrées sont composées de champs, séparés les uns des autres par un nombre quelconque de caractères blancs. Les espaces en début et fin de ligne sont ignorées. Un caractère dièse « # » non protégé en entrée introduit un commentaire qui s'étend jusqu'à la fin de la ligne où il apparaît. Les caractères blancs et les dièses peuvent être inclus entre guillemets « " » lorsqu'ils doivent faire partie d'un champ. Toute ligne vide (après suppression des commentaires) est ignorée. Les lignes non vides peuvent être de trois types : les lignes de règle, de zone, et de lien.

note: type: Plain text
en: A rule line has the form
fr: Une ligne de règle est de la forme :

note: type: Plain text
en: For example:
fr: Par exemple :

note: type: Plain text
en: The fields that make up a rule line are:
fr: Les champs composant une ligne de règle sont :

note: type: Plain text
en: Gives the (arbitrary) name of the set of rules this rule is part of.
fr: Indique le nom (arbitraire) du jeu de règles dont celle-ci fait partie.

note: type: Plain text
en: Gives the first year in which the rule applies.  Any integer year can be supplied; the Gregorian calendar is assumed.  The word I<minimum> (or an abbreviation) means the minimum year representable as an integer.  The word I<maximum> (or an abbreviation) means the maximum year representable as an integer.  Rules can describe times that are not representable as time values, with the unrepresentable times ignored; this allows rules to be portable among hosts with differing time value types.
fr: Indique la première année pour laquelle la règle s'applique. Tout nombre entier correspondant à une année peut être utilisé. On suppose qu'il s'agit du calendrier grégorien. Le mot I<minimum> (ou une abréviation) correspond à la plus petite année représentable par un entier. Le mot I<maximum> (ou une abréviation) correspond à la plus grande année représentable par un entier. Les règles peuvent décrire des dates qui ne sont pas représentables par des valeurs de I<time>(2). Ceci permet aux règles d'être générales quels que soient les types de données employés par la machine hôte.

note: type: Plain text
en: Gives the final year in which the rule applies.  In addition to I<minimum> and I<maximum> (as above), the word I<only> (or an abbreviation)  may be used to repeat the value of the B<FROM> field.
fr: Indique l'année finale pour laquelle la règle s'applique. En plus des symboles I<minimum> et I<maximum> (comme précédemment), le mot I<only> (ou une abréviation) permet de réutiliser la valeur du champ B<FROM>.

note: type: Plain text
en: Gives the type of year in which the rule applies.  If B<TYPE> is B<->, then the rule applies in all years between B<FROM> and B<TO> inclusive.  If B<TYPE> is something else, then I<zic> executes the command
fr: Indique le type des années où la règle s'applique. Si le B<TYPE> est « B<-> », la règle s'applique pour toutes les années entre B<FROM> et B<TO> comprises. Si le B<TYPE> a une autre valeur, B<zic> exécute la commande :

note: type: Plain text
en: B<yearistype> I<year> I<type>
fr: B<yearistype> I<année> I<type>

note: type: Plain text
en: to check the type of a year: an exit status of zero is taken to mean that the year is of the given type; an exit status of one is taken to mean that the year is not of the given type.
fr: pour vérifier le type de l'année : un code de sortie nul indique que l'année indiquée est du type considéré, un code de sortie valant 1 signifie que l'année n'est pas de ce type.

note: type: Plain text
en: Names the month in which the rule takes effect.  Month names may be abbreviated.
fr: Indique le mois auquel la règle prend effet. Les noms de mois peuvent être abrégés.

note: type: Plain text
en: Gives the day on which the rule takes effect.  Recognized forms include:
fr: Indique le jour auquel la règle prend effet. Les formes acceptées comprennent :

note: type: Plain text
en: 5	the fifth of the month
    lastSun	the last Sunday in the month
    lastMon	the last Monday in the month
    SunE<gt>=8	first Sunday on or after the eighth
    SunE<lt>=25	last Sunday on or before the 25th
fr: 5	Le 5 du mois
    lastSun	Le dernier dimanche du mois
    lastMon	Le dernier lundi du mois
    SunE<gt>=8	Le premier dimanche après le 8
    SunE<lt>=25	Le dernier dimanche avant le 25

note: type: Plain text
en: Names of days of the week may be abbreviated or spelled out in full.  Note that there must be no spaces within the B<ON> field.
fr: Les noms des jours de la semaine peuvent être abrégés. Il ne doit pas y avoir d'espace au sein du champ B<ON>.

note: type: Plain text
en: Gives the time of day at which the rule takes effect.  Recognized forms include:
fr: Indique l'heure à laquelle la règle prend effet. Diverses formes sont acceptées :

note: type: Plain text
en: 2	time in hours
    2:00	time in hours and minutes
    15:00	24-hour format time (for times after noon)
    1:28:14	time in hours, minutes, and seconds
    -	equivalent to 0
fr: 2	l'heure
    2:00	l'heure et les minutes
    15:00	un format sur 24 heures
    1:28:14	heure, minutes et secondes
    -	équivalent à 0

note: type: Plain text
en: where hour 0 is midnight at the start of the day, and hour 24 is midnight at the end of the day.  Any of these forms may be followed by the letter I<w> if the given time is local E<.q "wall clock"> time, I<s> if the given time is local E<.q standard> time, or I<u> (or I<g> or I<z>)  if the given time is universal time; in the absence of an indicator, wall clock time is assumed.
fr: L'heure vaut 0 à minuit au début de la journée, ou 24 à minuit à la fin de la journée. N'importe quelle forme ci-dessus peut être suivie des lettres I<w> si l'heure est locale (« wall clock », c'est-à-dire la pendule), I<s> s'il s'agit de l'heure locale standard, I<u> (ou I<g> ou I<z>) s'il s'agit de l'heure universelle. Sans indicateur, on suppose que c'est l'heure locale.

note: type: Plain text
en: Gives the amount of time to be added to local standard time when the rule is in effect.  This field has the same format as the B<AT> field (although, of course, the I<w> and I<s> suffixes are not used).
fr: Indique la quantité horaire à ajouter à l'heure locale lorsque la règle prend effet. Ce champ a le même format que le champ B<AT> (sauf que les suffixes I<w> et I<s> ne sont évidemment pas utilisés).

note: type: Plain text
en: Gives the E<.q "variable part"> (for example, the E<.q S> or E<.q D> in E<.q EST> or E<.q EDT )> of timezone abbreviations to be used when this rule is in effect.  If this field is B<->, the variable part is null.
fr: Indique la « partie variable » de l'abréviation du fuseau horaire (par exemple, « S » ou « D » dans « EST » ou « EDT ») lorsque la règle est en fonction. Si ce champ vaut « B<-> », la partie variable est nulle.

note: type: Plain text
en: A zone line has the form
fr: Une ligne de zone est de la forme :

note: type: Plain text
en: The fields that make up a zone line are:
fr: Les champs constituant une ligne de zone sont les suivants :

note: type: Plain text
en: The name of the timezone.  This is the name used in creating the time conversion information file for the zone.
fr: Le nom du fuseau horaire. Il s'agit du nom utilisé pour la création du fichier de données de conversions horaires pour cette zone.

note: type: Plain text
en: The amount of time to add to UTC to get standard time in this zone.  This field has the same format as the B<AT> and B<SAVE> fields of rule lines; begin the field with a minus sign if time must be subtracted from UTC.
fr: La quantité de temps à ajouter au temps universel pour obtenir l'heure standard dans la zone. Ce champ a le même format que les champs B<AT> et B<SAVE> des lignes de règles. On peut commencer le champ avec un signe moins « - » si la quantité doit être soustraite de l'UTC.

note: type: Plain text
en: The name of the rule(s) that apply in the timezone or, alternately, an amount of time to add to local standard time.  If this field is B<->, then standard time always applies in the timezone.
fr: Les noms des règles qui s'appliquent dans cette zone, ou bien la quantité horaire à ajouter au temps local standard de la zone. Si ce champ est « B<-> », l'heure standard s'applique toujours dans cette zone.

note: type: Plain text
en: The format for timezone abbreviations in this timezone.  The pair of characters B<%s> is used to show where the E<.q "variable part"> of the timezone abbreviation goes.  Alternately, a slash (/)  separates standard and daylight abbreviations.
fr: Le format pour l'abréviation du fuseau horaire dans cette zone. Les deux caractères B<%s> servent à indiquer où placer la « partie variable » de l'abréviation du fuseau. Éventuellement, une barre oblique « / » peut séparer les abréviations standard et d'heure d'été.

note: type: Plain text
en: The time at which the UTC offset or the rule(s) change for a location.  It is specified as a year, a month, a day, and a time of day.  If this is specified, the timezone information is generated from the given UTC offset and rule change until the time specified.  The month, day, and time of day have the same format as the IN, ON, and AT columns of a rule; trailing columns can be omitted, and default to the earliest possible value for the missing columns.
fr: Le moment où changent le décalage par rapport à l'UTC ou les règles pour le lieu. Ce moment est indiqué sous la forme d'une année, un mois, un jour, et une heure. Si elles sont spécifiées, les informations pour le fuseau horaire seront créées à partir de la règle ou du décalage UTC jusqu'au moment indiqué. Les valeurs doivent avoir le même format que pour les colonnes IN, ON, et AT d'une règle. Les colonnes suivantes peuvent être omises, la valeur par défaut étant le plus tôt possible pour les colonnes manquantes.

note: type: Plain text
en: The next line must be a E<.q continuation> line; this has the same form as a zone line except that the string E<.q Zone> and the name are omitted, as the continuation line will place information starting at the time specified as the B<UNTIL> field in the previous line in the file used by the previous line.  Continuation lines may contain an B<UNTIL> field, just as zone lines do, indicating that the next line is a further continuation.
fr: La ligne suivante doit être une ligne de « continuation » qui a la même forme qu'une ligne de zone, sauf que la chaîne « Zone » et le nom sont absents. Cette ligne de continuation va placer les informations commençant au moment précisé dans le champ B<UNTIL> de la ligne précédente dans le fichier utilisé par cette dernière. Les lignes de continuation peuvent avoir un champ B<UNTIL>, comme les lignes de zones, pour montrer que la ligne suivante est également une future continuation.

note: type: Plain text
en: A link line has the form
fr: Une ligne de lien est de la forme :

note: type: Plain text
en: The B<LINK-FROM> field should appear as the B<NAME> field in some zone line; the B<LINK-TO> field is used as an alternate name for that zone.
fr: Le champ B<LINK-FROM> doit exister sous forme de champ B<NAME> quelque part dans une ligne de zone. Le champ B<LINK-TO> sert de lien alternatif pour la zone.

note: type: Plain text
en: Except for continuation lines, lines may appear in any order in the input.
fr: À l'exception des lignes de continuation, toutes les autres lignes peuvent apparaître dans n'importe quel ordre.

note: type: Plain text
en: Lines in the file that describes leap seconds have the following form:
fr: Les lignes dans le fichier décrivant les secondes de rattrapage périodique doivent avoir la forme :

note: There's no need to document the following, since it's impossible for more than one leap second to be inserted or deleted at a time. The C Standard is in error in suggesting the possibility. See Terry J Quinn, The BIPM and the accurate measure of time, Proc IEEE 79, 7 (July 1991), 894-905. or .q ++ i
en: The B<YEAR>, B<MONTH>, B<DAY>, and B<HH:MM:SS> fields tell when the leap second happened.  The B<CORR> field should be E<.q +> if a second was added or E<.q -> if a second was skipped.  The B<R/S> field should be (an abbreviation of)  E<.q Stationary> if the leap second time given by the other fields should be interpreted as UTC or (an abbreviation of)  E<.q Rolling> if the leap second time given by the other fields should be interpreted as local wall clock time.
fr: Les champs B<YEAR>, B<MONTH>, B<DAY> et B<HH:MM:SS> indiquent le moment où la seconde de rattrapage apparaît. Le champ B<CORR> doit contenir un « + » si une seconde est ajoutée ou un « - » si une seconde est enlevée. Le champ B<R/S> doit être un B<S> (abréviation de I<Stationary>) si l'instant indiqué par les autres champs doit être interprété comme une heure UTC, ou bien B<R> (abréviation de I<Rolling>) si l'instant est en heure locale.

note: type: Plain text
en: /usr/local/etc/zoneinfo	standard directory used for created files
fr: /usr/local/etc/zoneinfo	Répertoire standard pour les fichiers créés

note: type: Plain text
en: For areas with more than two types of local time, you may need to use local standard time in the B<AT> field of the earliest transition time's rule to ensure that the earliest transition time recorded in the compiled file is correct.
fr: Pour les zones ayant plus de deux types d'heure locale, il peut être nécessaire d'utiliser l'heure locale standard dans le champ B<AT> de la première règle de transition pour s'assurer que la première heure de transition du fichier compilé soit correcte.
