AIO_FSYNC   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Section: Manuel du programmeur Linux (3)
Updated: 14 novembre 2003
Sommaire  



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
aio_fsync - Synchronisation de fichier asynchrone  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <aio.h>

int aio_fsync(int op, struct aiocb *aiocbp);

Liez avec -lrt.  




DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction aio_fsync() effectue une synchronisation de toutes les opérations d'E/S asynchrones en cours associées à aiocbp->aio_fildes.

Plus précisément, si op est positionné à O_SYNC, toutes les opérations d'E/S actuellement en file d'attente seront achevées comme par un appel à fsync(2), avec op positionné à O_DSYNC. Cet appel est la version asynchrone de l'appel fdatasync(2). Veuillez noter qu'il s'agit seulement d'une requête - cet appel n'attend pas la fin de l'E/S.

À part aio_fildes, le seul membre de la structure pointée par aiocbp qui soit utilisé par cet appel est le membre aio_sigevent (une structure struct sigevent) qui indique le type de notification asynchrone désiré à l'achèvement. Tous les autres membres sont ignorés.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
En cas de réussite (la requête de synchronisation a été mise avec succès dans la file d'attente), la fonction renvoie 0. En cas d'erreur, -1 est renvoyé et errno est positionnée en conséquence.  



ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
EAGAIN
Pas de ressources disponibles.
EBADF
aio_fildes n'est pas un descripteur de fichier valide ouvert en écriture.
EINVAL
Le fichier ne supporte pas les E/S synchronisées, ou op n'est pas O_SYNC ou O_DSYNC.
 



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
POSIX.1-2001.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
aio_cancel(3), aio_error(3), aio_read(3), aio_return(3), aio_suspend(3), aio_write(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Alain Portal <aportal AT univ-montp2 DOT fr> le 6 juillet 2005 et révisée le 6 juin 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 aio_fsync ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.  




NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
btowc - Convertir un octet en caractère large  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <wchar.h>

wint_t btowc (int c);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction btowc() prend l'entier c, considéré comme une séquence multi-octets de longueur 1, en débutant dans l'état de décalage initial, le convertit en caractère large, puis le renvoie. Si c n'est pas EOF ou une séquence multi-octets valide de longueur 1, la fonction btowc() renvoie WEOF.  



VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction btowc() renvoie le caractère large converti à partir de l'octet c. Si c est EOF ou n'est pas une séquence multi-octets de longueur 1, elle renvoie WEOF.  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99, POSIX.1-2001.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de la fonction btowc() dépend de la catégorie LC_CTYPE de la localisation.

Cette fonction ne devrait jamais être utilisée. Elle ne permet pas d'encoder des séquences ayant plusieurs états, et manipule inutilement les octets un par un dans une séquence multi-octets. Utilisez la fonction mbtowc() à la place.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
mbtowc(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 28 août 2000 et révisée le 22 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 btowc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/malloc.3
man2html: unable to open or read file ../man3/rpc.3
man2html: unable to open or read file ../man3/cerf.3
man2html: unable to open or read file ../man3/erf.3

 .  



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
execl, execlp, execle, execv, execvp - Exécuter un programme  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <unistd.h>

extern char **environ;

int execl (const char *path, const char *arg, ...);
int execlp (const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,
..., char * const envp[]);
int execv (const char *path, char *const argv[]);
int execvp (const char *file, char *const argv[]);  




DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La famille de fonctions exec() remplace l'image mémoire du processus appelant par un nouveau processus. Les fonctions décrites dans cette page sont en réalité des frontaux pour l'appel système execve(2). (Voir la page de execve(2) pour des informations détaillées sur le remplacement du processus appelant.)

L'argument initial de toutes ces fonctions est le chemin d'accès du fichier à exécuter.

Les arguments const char *arg ainsi que les points de suspension des fonctions execl(), execlp(), et execle() peuvent être vues comme des arg0, arg1, ..., argn. Ensemble, ils décrivent une liste d'un ou plusieurs pointeurs sur des chaînes de caractères terminées par des caractères nuls, qui constituent les arguments disponibles pour le programme à exécuter. Par convention, le premier argument doit pointer sur le nom du fichier associé au programme à exécuter. La liste des arguments doit se terminer par un pointeur NULL, et puisque ce sont des fonctions variadiques, ce pointeur doit être transtypé (char *) NULL.

Les fonctions execv() et execvp() utilisent un tableau de pointeurs sur des chaînes de caractères terminées par des caractères nuls, qui constituent les arguments disponibles pour le programme à exécuter. Par convention, le premier argument doit pointer sur le nom du fichier associé au programme à exécuter. Le tableau de pointeur doit se terminer par un pointeur NULL.

La fonction execle() peut également indiquer l'environnement du processus à exécuter en faisant suivre le pointeur NULL qui termine la liste d'arguments, ou le pointeur NULL de la table par un paramètre supplémentaire. Ce paramètre est un tableau de pointeurs sur des chaînes de caractères terminées par des caractères nuls, qui doit se terminer par un pointeur NULL. Les autres fonctions fournissent au nouveau processus l'environnement constitué par la variable externe environ. Certaines de ces fonctions ont une sémantique spécifique.  




Sémantique spécifique pour execlp() et execvp()   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Les fonctions execlp() et execvp() agiront comme le shell dans la recherche du fichier exécutable si le nom fourni ne contient pas de slash « / ». Le chemin de recherche est spécifié dans la variable d'environnement PATH. Si cette variable n'est pas définie, le chemin par défaut sera « /bin:/usr/bin: ». De plus, certaines erreurs sont traitées de manière spécifique.

Si la permission d'accès au fichier est refusée (execve(2) renvoie EACCES), ces fonctions continueront à parcourir le reste du chemin de recherche. Si aucun fichier n'est trouvé, elles reviendront, et errno contiendra le code d'erreur EACCES.

Si l'entête d'un fichier n'est pas reconnu (execve(2) renvoie ENOEXEC), ces fonctions exécuteront un shell (/bin/sh) avec le chemin d'accès au fichier en tant que premier argument. Si ceci échoue, aucune recherche supplémentaire n'est effectuée.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Si l'une quelconque des fonctions exec() revient à l'appelant, c'est qu'une erreur a eu lieu. La valeur de retour est -1, et errno contient le code d'erreur.  



ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Toutes ces fonctions peuvent échouer et positionner errno sur n'importe quelle erreur décrite dans la fonction execve(2).  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
POSIX.1-2001.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Sur certains systèmes, le chemin de recherche par défaut (employé si l'environnement ne contient pas la variable PATH) contient le répertoire courant à la suite de /bin et /usr/bin, afin d'éviter les chevaux de Troie. Linux utilise encore le répertoire courant en premier dans ce chemin de recherche par défaut.

Le comportement de execlp() et execvp() lorsqu'une erreur se produit est une pratique historique mais n'a traditionnellement jamais été documenté, ni spécifié dans le standard POSIX. Lorsque l'erreur ETXTBSY se déclenche (fichier exécutable ouvert en écriture par un autre processus), BSD (et peut-être d'autres systèmes) endorment le processus appelant puis réiterent l'opération. Linux considère cette situation comme une erreur grave, et revient immédiatement.

Habituellement, les fonctions execlp() et execvp() ignoraient toutes les erreurs sauf celles décrites ci-dessus, ENOMEM et E2BIG. Désormais, elles reviennent à l'appelant si une autre erreur que celles-ci se produit.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
sh(1), execve(2), fork(2), ptrace(2), fexecve(3), environ(7)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 23 octobre 1996 et révisée le 8 janvier 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 exec ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/gets.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
fgetwc, getwc - Lire une chaîne de caractères larges dans un flux  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <stdio.h>

#include <wchar.h> wint_t fgetwc (FILE * flux); wint_t getwc (FILE * flux);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction fgetwc() est l'équivalent, pour les caractères larges, de la fonction fgetc(3). Elle lit un caractère large depuis le flux et le renvoie. Si la fin du fichier est rencontrée, elle retourne WEOF. Si une erreur se produit lors de la conversion du caractère large, errno est remplie avec EILSEQ et WEOF est retourné.

La fonction fgetwc() fonctionne de manière identique à fgetwc(). Elle peut être implémentée sous forme de macro, et peut évaluer ses arguments plus d'une fois. Il n'existe plus aucune raison de l'utiliser.

Pour des versions de ces fonctions ignorant les verrouillages, voir unlocked_stdio(3).  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction fgetwc() renvoie le caractère large suivant du flux ou WEOF.  



ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Hormis les erreurs habituelles, on peut rencontrer :
EILSEQ
Les données lues depuis le flux d'entrée ne forment pas des caractères corrects.
 



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99, POSIX.1-2001.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de fgetwc() dépend de la catégorie LC_CTYPE de la localisation courante.

En l'absence d'informations supplémentaires passées à l'appel fopen(3), il est normal de présumer que fgetwc() va lire une séquence multi-caractères du flux puis la convertir en une chaîne à caractères larges.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
fgetws(3), fputwc(3), ungetwc(3), unlocked_stdio(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Thierry Vignaud <tvignaud AT mandriva DOT com> en 1999 et révisée le 17 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 fgetwc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/puts.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
fputwc, putwc - Écrire un caractère large dans un fichier  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <stdio.h>

#include <wchar.h> wint_t fputwc (wchar_t wc, FILE * fichier); wint_t putwc (wchar_t wc, FILE * fichier);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction fputwc() est l'équivalent, pour les caractères larges, de la fonction fputc(3). Elle écrit le caractère large wc dans fichier. Si ferror(fichier) devient vraie, WEOF est renvoyé. Si une erreur de conversion du caractère large se produit, errno est remplie avec EILSEQ et WEOF est renvoyé. Sinon wc est renvoyé.

La fonction putwc() est identique à fputwc(). Elle peut être implémentée comme une macro et donc évaluer plusieurs fois son argument. Il n'y a plus aucune raison de l'utiliser.

Pour des versions de ces fonctions ignorant les verrouillages, voir unlocked_stdio(3).  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction fputwc() renvoie wc si aucune erreur ne s'est produite, ou WEOF sinon.  



ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
En plus des erreurs usuelles associées à fputc(), on peut rencontrer :
EILSEQ
La conversion de wc vers l'encodage du fichier a échoué.
 



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99, POSIX.1-2001.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de fputwc() dépend de la valeur de la locale LC_CTYPE courante.

En l'absence d'informations supplémentaires passées à l'appel fopen(3), il est raisonnable de penser que fputwc() écrira en fait la séquence multi-octets correspondant au caractère large wc.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
fgetwc(3), fputws(3), unlocked_stdio(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Thierry Vignaud <tvignaud AT mandriva DOT com> en 2000 et révisée le 17 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 fputwc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/gets.3
man2html: unable to open or read file ../man3/getfsent.3
man2html: unable to open or read file ../man3/fgetwc.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
malloc, calloc, free, realloc - Allocation et libération dynamiques de mémoire  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <stdlib.h>

void * calloc (size_t nmemb, size_t size);

void * malloc (size_t size);
void free (void * ptr);
void * realloc (void * ptr, size_t size);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
calloc() alloue la mémoire nécessaire pour un tableau de nmemb éléments, chacun d'eux représentant size octets, et renvoie un pointeur vers la mémoire allouée. Cette zone est remplie avec des zéros. Si nmemb ou size vaut 0, calloc() renvoie soit NULL, soit une valeur de pointeur unique qui pourra être passé ultérieurement avec succés à free().

malloc() alloue size octets, et renvoie un pointeur sur la mémoire allouée. Le contenu de la zone de mémoire n'est pas initialisé. Si nmemb ou size vaut 0, malloc() renvoie soit NULL, soit une valeur de pointeur unique qui pourra être passé ultérieurement avec succés à free().

free() libère l'espace mémoire pointé par ptr, qui a été obtenu lors d'un appel antérieur à malloc(), calloc() ou realloc(). Si le pointeur ptr n'a pas été obtenu par l'un de ces appels, ou s'il a déjà été libéré avec free(), le comportement est indéterminé. Si ptr est NULL, aucune tentative de libération n'a lieu.

realloc() modifie la taille du bloc de mémoire pointé par ptr pour l'amener à une taille de size octets. realloc() conserve le contenu de la zone mémoire minimum entre la nouvelle et l'ancienne taille. Le contenu de la zone de mémoire nouvellement allouée n'est pas initialisé. Si ptr est NULL, l'appel est équivalent à malloc(size), pour toutes les valeurs de size. Si size vaut zéro, et ptr n'est pas NULL, l'appel est équivalent à free(ptr). Si ptr n'est pas NULL, il doit avoir été obtenu par un appel antérieur à malloc(), calloc() ou realloc(). Si la zone pointée était déplacée, un free(ptr) est effectué.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
calloc() et malloc() renvoient un pointeur sur la mémoire allouée, qui est correctement alignée pour n'importe quel type de variable. Si elles échouent, elles renvoient NULL. NULL peut également être renvoyé par un appel réussi à malloc() avec un argument size de zéro, ou par un appel réussi de realloc() avec nmemb ou size égal à zéro.

free() ne renvoie pas de valeur.

realloc() renvoie un pointeur sur la mémoire nouvellement allouée, qui est correctement alignée pour n'importe quel type de variable, et qui peut être différent de ptr, ou NULL si la demande échoue. Si size vaut zéro, realloc renvoie NULL ou un pointeur acceptable pour free(). Si realloc() échoue, le bloc mémoire original reste intact, il n'est ni libéré ni déplacé.  




CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C89, C99.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Normalement, malloc() alloue la mémoire du tas et ajuste la taille de celui-ci suivant les besoins en utilisant sbrk(2). Lors de l'allocation de blocs mémoire plus grands que MMAP_THRESHOLD octets, l'implémentation malloc() de la glibc alloue la mémoire comme une projection anonyme privée avec mmap(2). MMAP_THRESHOLD vaut 128 Ko par défaut, mais peut être ajustée avec mallopt(3). Les allocations effectuées avec mmap(2) ne sont pas affectées par la limite de ressources RLIMIT_DATA (voir getrlimit(2)).

Le standard Unix98 réclame que malloc(), calloc() et realloc() remplissent errno avec ENOMEM en cas d'échec. La glibc suppose qu'il en est ainsi (et les versions glibc de cette routine le font). Si vous utilisez une implémentation personnelle de malloc() qui ne définit pas errno, certaines routines de bibliothèques peuvent échouer sans donner de raison dans errno.

Lorsqu'un programme se plante durant un appel à malloc(), calloc(), realloc() ou free(), ceci est presque toujours le signe d'une corruption du tas (zone de mémoire dans laquelle sont allouées les variables dynamiques). Ceci survient généralement en cas de débordement d'un bloc mémoire alloué, ou en libérant deux fois le même pointeur.

Les versions récentes de la bibliothèque C de Linux (libc postérieures à 5.4.23) et la bibliothèque glibc 2.x incluent une implémentation de malloc() dont on peut configurer le comportement à l'aide de variables d'environnement. Quand la variable MALLOC_CHECK_ existe, les appels à malloc() emploient une implémentation spéciale, moins efficace mais plus tolérante à l'encontre des bogues simples comme le double appel de free() avec le même argument, ou un débordement de tampon d'un seul octet (bogues de surpassement d'une unité, ou oubli d'un octet nul final d'une chaîne). Il n'est toutefois pas possible de pallier toutes les erreurs de ce type, et l'on risque de voir des fuites de mémoire se produire.

Si la variable MALLOC_CHECK_ vaut zéro, toutes les corruptions du tas détectées sont ignorées silencieusement ; si elle vaut 1, un message de diagnostique est affiché sur stderr. Si cette variable vaut 2, la fonction abort(3) est appelée immédiatement. Si cette variable vaut 3, un message de diagnostique est affiché sur stderr et le programme abandonne. L'utilisation d'une valeur MALLOC_CHECK_ non nulle est particulièrement utile car un crash pourrait sinon se produire ultérieurement, et serait très difficile à diagnostiquer.  




BOGUES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Par défaut, Linux suit une stratégie d'allocation optimiste. Ceci signifie que lorsque malloc() renvoie une valeur non nulle, il n'y a aucune garantie que la mémoire soit véritablement disponible. C'est vraiment un bogue craignos. Dans le cas où le système manque de mémoire, un ou plusieurs processus seront tués par l'infâme exterminateur de gestion mémoire. Dans le cas où Linux est utilisé dans des circonstances où il n'est pas souhaitable de perdre soudainement des processus lancés aléatoirement, et si de plus la version du noyau est suffisamment récente, on peut désactiver ce comportement en utilisant une commande du style :

# echo 2 > /proc/sys/vm/overcommit_memory

Voir également les fichiers vm/overcommit-accounting et sysctl/vm.txt dans le répertoire de la documentation du noyau.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
brk(2), mmap(2), alloca(3), posix_memalign(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 4 novembre 1996 et révisée le 6 juin 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 malloc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.  




NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
mbrtowc - Convertir une séquence multi-octets en caractère large  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <wchar.h>

size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
L'usage principal de cette fonction est celui avec s non NULL et pwc non NULL. Dans ce cas, la fonction mbrtowc() examine au plus n octets de la séquence commençant en s, en extrait le prochain caractère multi-octets complet, et le place en *pwc. Elle met à jour l'état de décalage *ps. Si le caractère large obtenu n'est pas L'\0', elle renvoie le nombre d'octets lus depuis s. Si le caractère large obtenu est L'\0', elle réinitialise l'état de décalage *ps et renvoie zéro.

Si les n octets commençant en s ne contiennent pas de caractère large complet, mbrtowc() renvoie (size_t) -2. Cela peut se produire même si n >= MB_CUR_MAX, lorsque la séquence multi-octets contient des séquences de décalage redondantes.

Si la séquence multi-octets commençant en s contient une séquence invalide avant le prochain caractère complet, mbrtowc() renvoie (size_t) -1 et place dans errno la valeur EILSEQ. Dans ce cas, les effets sur *ps sont indéfinis.

Une autre situation est possible, si s est non NULL, mais pwc est NULL. Dans ce cas, mbrtowc() se comporte comme précédemment, mais n'enregistre pas le caractère large obtenu.

Un troisième cas se présente si s est NULL. Alors, pwc et n sont ignorés. Si l'état de conversion représenté par *ps indique une conversion multi-octets incomplète, la fonction mbrtowc() renvoie (size_t) -1, remplit errno avec EILSEQ, et laisse *ps dans un état indéfini. Sinon, la fonction mbrtowc() remet *ps dans l'état initial et renvoie 0.

Dans tous ces cas, si ps est un pointeur NULL, une zone de mémoire statique propre à mbrtowc() est utiliséé à sa place. Sinon, *ps doit être un objet mbstate_t valide. Un tel objet mbstate_t noté a peut être initialisé en le mettant à zéro, par exemple ainsi :

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




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction mbrtowc() renvoie le nombre d'octets balayés depuis la séquence commençant en s, si un caractère large non nul a été reconnu. Elle renvoie zéro si un caractère large nul est rencontré. Elle renvoie (size_t) -1 et remplit errno avec EILSEQ, si une séquence invalide est trouvée. Elle renvoie (size_t) -2 si elle n'a pas trouvé de caractère entier, et si n doit être augmenté.  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de mbrtowc() dépend de la catégorie LC_CTYPE de la localisation.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
mbsrtowcs(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 29 août 2000 et révisée le 29 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 mbrtowc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.  




NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
mbtowc - Convertir une séquences multi-octets en caractères étendus  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <stdlib.h>

int mbtowc (wchar_t *pwc, const char *s, size_t n);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
L'utilisation habituelle de cette fonction est avec s et pwc tous deux différents NULL. Dans ce cas, la fonction mbtowc() examine au plus n octets de la chaîne multi-octets commençant à l'adresse s, extrait le premier caractère multi-octets complet, le convertit en caractère large et le stocke dans *pwc. Elle met à jour l'état interne de décalage, connu d'elle seule. Si s ne pointe pas sur un octet nul, elle renvoie le nombre d'octets qui ont été consommés dans s, sinon, elle renvoie zéro.

Si les n octets débutant en s ne contiennent pas un caractère multi-octets complet, ou s'il s'agit d'une séquence invalide, mbtowc() renvoie -1. Ceci peut se produire même si n est supérieur ou égal à MB_CUR_MAX, si la chaîne multi-octets contient des séquences de décalage redondantes.

Un autre cas possible se présent si s est non NULL, mais pwc est NULLL. Dans ce cas, la fonction mbtowc() se comporte comme ci-dessus, mais ne stocke par le caractère large en mémoire.

Un troisième cas est possible si s est NULL. Alors, pwc et n sont ignorés. La fonction mbtowc() réinitialise l'état de décalage, qu'elle seule connait, et renvoie une valeur non nulle si l'encodage à un état de décalage non trivial, ou zéro si l'encodage est sans état.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Si s est non NULL, la fonction mbtowc() renvoie le nombre d'octets consommés à partir de s, ou zéro si s pointe sur un octet nul, ou encore -1 en cas d'erreur.

Si s est NULL, la fonction mbtowc() renvoie une valeur non-nulle si l'encodage a un état de décalage non trivial, ou zéro si l'encodage est sans état.  




CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de mbtowc() dépend de la catégorie LC_CTYPE de la localisation en cours.

Cette fonction n'est pas sûre en contexte multi-threads. La fonction mbrtowc(3) fournit une meilleure interface pour la même fonctionnalité.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
MB_CUR_MAX(3), mbrtowc(3), mbstowcs(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 4 novembre 1996 et révisée le 10 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 mbtowc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/mpool.3
man2html: unable to open or read file ../man3/pthread_key_create.3
man2html: unable to open or read file ../man3/pthread_key_create.3
man2html: unable to open or read file ../man3/puts.3
man2html: unable to open or read file ../man3/fputwc.3
man2html: unable to open or read file ../man3/malloc.3
man2html: unable to open or read file ../man3/re_comp.3
man2html: unable to open or read file ../man3/regex.3
man2html: unable to open or read file ../man3/rpc.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
rexec - Renvoyer un flux sur une commande distante  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

int rexec(char **ahost, int inport, char *user, 
          char *passwd, char *cmd, int *fd2p);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Cette interface est rendue obsolète par rcmd(3).

La fonction rexec() cherche l'hôte *ahost en utilisant gethostbyname(3). Elle renvoie -1 si l'hôte n'existe pas. Autrement, *ahost est configuré avec le nom standard de l'hôte. Si un nom d'utilisateur et un mot de passe sont également spécifiés, ils sont utilisés pour s'authentifier sur l'hôte ; autrement, on cherche les informations appropriées dans l'environnement puis dans le fichier .netrc de l'utilisateur situé dans le répertoire personnel. Si cela échoue, on demande l'information à l'utilisateur.

Le port inport spécifie quel port Internet DARPA sera utilisé pour la connexion ; l'appel getservbyname(exec, tcp) (voir getservent(3)) renverra un pointeur sur une structure qui contient le port nécessaire. Le protocole de la connexion est décrit en détails dans rexecd(8).

Si la connexion réussit, une socket dans le domaine Internet de type SOCK_STREAM est renvoyée à l'appelant et est fournie à la commande distante comme stdin et stdout. Si fd2p est non nul, un canal auxilliaire sur un processus de contrôle sera configuré et un descripteur de celui-ci sera placé dans *fd2p. Le processus de contrôle renverra une sortie de diagnostic de la commande (unité 2) sur ce canal et acceptera les octets sur ce même canal comme étant des numéros de signaux Unix à transmettre au groupe du processus de la commande. L'information de diagnostic n'inclut pas l'échec d'autorisation distante. Une connexion secondaire est configurée après que l'autorisation ait été vérifiée. Si fd2p est 0, stderr (unité 2 de la commande distante) sera la même que stdout et aucun canal supplémentaire ne sera utilisé pour envoyer des signaux arbitraires au processus distant, bien qu'il soit possible d'obtenir son attention en transmettant des données supplémentaires.  




CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Pas dans POSIX.1-2001. Présente sur les BSD, Solaris et beaucoup d'autres systèmes. La fonction rexec() est apparue dans BSD 4.2 .  



BOGUES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction rexec() envoie des mots de passe non cryptés sur le réseau.

Le service sous-jacent est considéré comme un gros trou de sécurité et ne devrait pas être activé sur bien des machines ; voir rexecd(8) pour plus d'explications.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
rcmd(3), rexecd(8)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Alain Portal <aportal AT univ-montp2 DOT fr> le 12 juillet 2006 et révisée le 8 janvier 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 rexec ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.  




NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
rpc - Bibliothèque de fonctions pour les appels de procédures à distance  



SYNOPSIS ET DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Ndt : RPC = Remote Procedure Call.

Ces routines permettent à des programmes C de faire des appels de procédures vers d'autres machines à travers le réseau. D'abord, le client invoque une procédure pour envoyer un paquet de données vers le serveur. À la réception du paquet, le serveur appelle une routine de distribution pour exécuter le service demandé, et renvoyer une réponse. Finalement, l'appel de procédure revient au client.

Pour permettre l'utilisation de ces routines, incluez le fichier d'entête To take use of these routines, include the header file <rpc/rpc.h>.

Les prototypes plus loin utilisent les types suivants :


typedef int bool_t;

typedef bool_t (*xdrproc_t) (XDR *, void *,...);

typedef bool_t (*resultproc_t) (caddr_t resp,
                                struct sockaddr_in *raddr);

Voir les fichiers d'entête pour la déclaration des types AUTH, CLIENT, SVCXPRT et XDR.

void auth_destroy(AUTH *auth);
Cette macro détruit les informations d'authentification associée avec auth. La destruction implique généralement la désallocation de données privées. Le comportement est indéfini si on essaye d'utiliser auth après avoir invoqué auth_destroy().

AUTH *authnone_create(void);
Crée et renvoie un descripteur d'authentification RPC transmettant avec chaque appel de procédure une information d'authentification nulle. C'est le comportement par défaut pour les RPC.

AUTH *authunix_create(char *host, int uid, int gid,
                      int len, int *aup_gids);
Crée et renvoie un descripteur d'authentification RPC Unix, contenant des informations d'identification. L'argument host est le nom de la machine sur laquelle l'information est créée. uid est l'identification de l'utilisateur gid est l'identification du groupe de l'utilisateur len et aup_gids concernent la table des groupes supplémentaires auxquels l'utilisateur appartient. On peut facilement se faire passer pour quelqu'un d'autre.

AUTH *authunix_create_default(void);
Appelle authunix_create() avec les arguments appropriés.

int callrpc(char *host, unsigned long prognum,
            unsigned long versnum, unsigned long procnum,
            char *in, char *out,
            xdrproc_t inproc, xdrproc_t outproc);
Appelle la procédure distante associée aux arguments prognum, versnum, et procnum sur la machine, host. L'argument in est l'adresse du ou des arguments d'entrée de la procédure, out celle de l'emplacement où stocker le ou les résultats, inproc sert à encoder les paramètres d'entrée de la procédure, et outproc à décoder les résultats de la procédure. Cette routine renvoie zéro si elle réussit, ou la valeur de enum clnt_stat transposée en un nombre entier si elle échoue. La routine clnt_perrno() permet de traduire les codes d'échec en messages.
Attention : l'appel d'une procédure distante avec cette routine emploie le protocole UDP/IP pour le transport, voir clntudp_create() pour certaines restrictions. Vous n'avez aucun contrôle sur le délai maximal ou sur l'authentification avec cette routine.

enum clnt_stat clnt_broadcast(unsigned long prognum,
                     unsigned long versnum, unsigned long procnum,
                     char *in, char *out,
                     xdrproc_t inproc, xdrproc_t outproc,
                     resultproc_t eachresult);
Comme callrpc(), sauf que le message d'appel est diffusé sur tous les réseaux connectés. À chaque réception d'une réponse, cette routine appelle la fonction eachresult(), dont la forme est :
eachresult(char *out, struct sockaddr_in *addr);
out est du même type que le out passé à clnt_broadcast(), avec la différence que la sortie de la procédure distante est décodée ici. addr pointe vers l'adresse de la machine qui a envoyé le résultat. Si eachresult() renvoie zéro, clnt_broadcast() attend d'autres réponses. Sinon elle revient avec le code de retour approprié.
Attention : les sockets broadcast sont limitées en ce qui concerne la taille maximale des données. Pour l'Ethernet, cette valeur (MTU) vaut 1500 octets.

enum clnt_stat clnt_call(CLIENT *clnt, unsigned long procnum,
                    xdrproc_t inproc, xdrproc_t outproc,
                    char *in, char *out, struct timeval tout);
Une macro qui appelle la procédure distante procnum associée avec le descripteur de client clnt, qui est obtenu grâce à une routine de création de client RPC comme clnt_create(). L'argument in est l'adresse du ou des arguments d'entrée de la procédure, out celle de l'emplacement où stocker le ou les résultats, inproc sert à encoder les paramètres d'entrée de la procédure, et outproc à décoder les résultats de la procédure. tout est le délai maximal accordé pour la réalisation de la procédure.

clnt_destroy(CLIENT *clnt);
Une macro qui détruit le descripteur de client RPC ce qui implique généralement la libération de structures de données privées, y compris clnt lui même. Le comportement est indéfini si on tente d'utiliser clnt après avoir appelé clnt_destroy(). Si la bibliothèque RPC avait ouvert la socket associée, elle sera également fermée. Sinon, la socket reste ouverte.

CLIENT *clnt_create(char *host, unsigned long prog,
                    unsigned long vers, char *proto);
Routine générique de création de client. host identifie le nom de l'hôte distant où se trouve le serveur. proto indique le type de protocole de transport à employer. Les valeurs actuellement supportées pour ce champ sont « udp » et « tcp ». Des valeurs par défaut sont configurées pour les délais, mais peuvent être modifiées à l'aide de clnt_control().
Attention : l'utilisation du protocole UDP a des inconvénients. Comme les messages RPC basés sur UDP ne peuvent contenir que 8 Ko de données encodées, ce protocole ne peut pas être utilisé pour des procédures nécessitant de gros arguments, ou renvoyant d'énormes résultats.

bool_t clnt_control(CLIENT *cl, int req, char *info);
Une macro employée pour modifier ou récupérer des informations diverses à propos d'un objet client. req indique le type d'opération, et info est un pointeur sur l'information. Pour UDP comme pour TCP, les valeurs autorisées pour req et le type des arguments sont :
CLSET_TIMEOUT  struct timeval // définir le délai total
CLGET_TIMEOUT  struct timeval // lire le délai total
Note : Si vous fixez le délai avec clnt_control(), le dernier argument de clnt_call() sera ignoré lors des appels ultérieurs.
CLGET_SERVER_ADDR  struct sockaddr_in  // lire l'adresse des serveurs
Les opérations suivantes sont valides pour le protocole UDP seulement :
CLSET_RETRY_TIMEOUT  struct timeval // fixer le délai de répétition
CLGET_RETRY_TIMEOUT  struct timeval // lire le délai de répétition
Le délai de répétition est le temps pendant lequel les « RPC UDP » attendent une réponse du serveur avant retransmettre la requête.

clnt_freeres(CLIENT * clnt, xdrproc_t outproc, char *out);
Une macro qui libère toutes les données allouées par le système RPC/XDR lorsqu'il a décodé les résultats d'un appel RPC. L'argument out est l'adresse des résultats, et outproc est la routine XDR décodant les résultats. Cette fonction renvoie 1 si les résultats ont été correctement libérés, et zéro sinon.

void clnt_geterr(CLIENT *clnt, struct rpc_err *errp);
Une macro qui copie la structure d'erreur depuis le descripteur de client vers la structure se trouvant à l'adresse errp.

void clnt_pcreateerror(char *s);
Affiche un message sur la sortie d'erreur standard, indiquant pourquoi un descripteur de client RPC ne peut pas être créé. Ce message est préfixé avec la chaîne s et un deux-points est inséré. À utiliser lorsque les appels clnt_create(), clntraw_create(), clnttcp_create(), ou clntudp_create() échouent.

void clnt_perrno(enum clnt_stat stat);
Affiche un message sur la sortie d'erreur standard, correspondant à la condition indiquée par stat. À utiliser après callrpc().

clnt_perror(CLIENT *clnt, char *s);
Affiche un message sur la sortie d'erreur standard indiquant pourquoi un appel RPC a échoué. clnt est le descripteur utilisé pour l'appel. Ce message est préfixé avec la chaîne s et un deux-points est inséré. À utiliser après clnt_call().

char *clnt_spcreateerror(char *s);
Comme clnt_pcreateerror(), sauf qu'il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnée statique, écrasée à chaque appel.

char *clnt_sperrno(enum clnt_stat stat);
Emploie les même arguments que clnt_perrno(), mais au lieu d'envoyer un message sur la sortie d'erreur standard indiquant pourquoi un appel RPC a échoué, renvoie un pointeur sur une chaîne contenant le message. La chaîne se termine par un NEWLINE.
clnt_sperrno() est utilisée à la place de clnt_perrno() si le programme n'a pas de sortie d'erreur standard (un serveur par exemple n'en a généralement pas), ou si le programmeur ne veut pas que le message soit affiché avec printf(3), ou si un format de message différent de celui fourni par clnt_perrno() doit être utilisé. Note : contrairement à clnt_sperror() et clnt_spcreaterror(), clnt_sperrno() renvoie un pointeur sur une zone de donnée statique, mais le résultat ne sera pas écrasé à chaque appel.

char *clnt_sperror(CLIENT *rpch, char *s);
Comme clnt_perror(), sauf que (comme clnt_sperrno()) il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnée statique, écrasée à chaque appel.

CLIENT *clntraw_create(unsigned long prognum, unsigned long versnum);
Cette routine crée un simili client RPC pour le programme distant prognum, de version versnum. Le mécanisme de transport pour les messages est en réalité un tampon dans l'espace d'adresse du processus, ainsi le serveur RPC doit se trouver dans le même espace d'adresse. Voir svcraw_create(). Cela permet de simuler une RPC et de mesurer la surcharge des procédures RPC comme les temps d'aller-retour sans interférence due au noyau. Cette routine renvoie NULL si elle échoue.

CLIENT *clnttcp_create(struct sockaddr_in *addr,
                unsigned long prognum, unsigned long versnum,
                int *sockp, unsigned int sendsz, unsigned int recvsz);
Cette routine crée un client RPC pour le programme distant prognum, de version versnum ; Le client utilise TCP/IP pour le transport. Le programme distant se trouve à l'adresse Internet *addr. Si %addr->sin_port vaut zéro, alors il est rempli avec le numéro de port sur lequel le programme distant est en écoute (on consulte le service portmap distant pour obtenir cette information). L'argument sockp est une socket ; si c'est RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et remplit sockp. Comme les RPC basées sur TCP utilisent des entrées-sorties avec tampons, l'utilisateur peut spécifier la taille des tampons d'entrée et de sortie avec les paramètres sendsz et recvsz. Des valeurs nulles réclament l'utilisation de tampons de tailles optimales. Cette routine renvoie NULL si elle échoue.

CLIENT *clntudp_create(struct sockaddr_in *addr,
                unsigned long prognum, unsigned long versnum,
                struct timeval wait, int *sockp);
Cette routine crée un client RPC pour le programme distant prognum, de version versnum ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet *addr. Si addr->sin_port vaut zéro, alors il est rempli avec le numéro de port sur lequel le programme distant est en écoute (on consulte le service portmap distant pour obtenir cette information). L'argument sockp est une socket ; si c'est RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et remplit sockp. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par wait jusqu'à la réception d'une réponse ou jusqu'au dépassement du temps maximal. Ce délai total pour l'appel est spécifié par la fonction clnt_call().
Attention : comme les messages des RPC basées sur UDP ne peuvent contenir que 8 Ko de données encodées, ce protocole ne peut pas être utilisé pour des procédures nécessitant de gros arguments, ou renvoyant d'énormes résultats.

CLIENT *clntudp_bufcreate(struct sockaddr_in *addr,
            unsigned long prognum, unsigned long versnum,
            struct timeval wait, int *sockp,
            unsigned int sendsize, unsigned int recosize);
Cette routine crée un client RPC pour le programme distant prognum, de version versnum ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet *addr. %addr->sin_port vaut zéro, alors il est rempli avec le numéro de port sur lequel le programme distant est en écoute (on consulte le service portmap distant pour obtenir cette information). L'argument sockp est une socket ; si c'est RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et remplit sockp. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par wait jusqu'à la réception d'une réponse ou jusqu'au dépassement du temps maximal. Ce délai total pour l'appel est spécifié par la fonction clnt_call().
Cette routine permet au programmeur de préciser la taille maximale des tampons en émission et réception pour les messages RPC basés sur UDP.

void get_myaddress(struct sockaddr_in *addr);
Fournit l'adresse IP de la machine dans la structure *addr, sans consulter les routines de bibliothèques qui manipulent /etc/hosts. Le numéro de port est toujours rempli avec htons(PMAPPORT).

struct pmaplist *pmap_getmaps(struct sockaddr_in *addr);
Une interface utilisateur pour le service portmap renvoyant une liste des associations en cours entre programmes RPC et ports sur l'hôte situé à l'adresse IP indiquée dans *addr. Cette routine peut renvoyer NULL. La commande rpcinfo -p utilise cette fonction

unsigned short pmap_getport(struct sockaddr_in *addr,
                    unsigned long prognum, unsigned long versnum,
                    unsigned int protocol);
Une interface utilisateur pour le service portmap qui renvoie le numéro de port sur lequel est en écoute le service associé au programme numéro prognum, de version versnum, en utilisant le protocole de transport associé avec protocol. La valeur de l'argument protocol est normalement IPPROTO_UDP ou IPPROTO_TCP. Une valeur de retour nulle signifie qu'aucune association n'existe ou qu'une erreur du système RPC s'est produite en tentant de contacter le service portmap distant. Dans ce cas, la variable globale rpc_createerr() contient le code RPC de l'erreur.

enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr,
                    unsigned long prognum, unsigned long versnum,
                    unsigned long procnum, char *in, char *out,
                    xdrproc_t inproc, xdrproc_t outproc,
                    struct timeval tout, unsigned long *portp);
Une interface utilisateur pour le service portmap qui demande au programme portmap sur l'hôte se trouvant à l'adresse IP indiquée dans *addr de faire en notre nom un appel RPC pour une procédure se trouvant sur cet hôte. Le paramètre *portp sera modifié pour contenir le numéro de port du programme si la procédure réussit. Les définitions des autres arguments sont présentées à propos de callrpc() et de clnt_call(). Cette procédure devrait être utilisée pour faire un « ping » et rien d'autre. Voir aussi clnt_broadcast().

bool_t pmap_set(unsigned long prognum, unsigned long versnum,
                unsigned int protocol, unsigned short port);
Une interface utilisateur pour le service portmap qui établit une association entre le triplet [prognum, versnum, protocol] et le port sur la machine du service portmap La valeur du protocol est normalement IPPROTO_UDP ou IPPROTO_TCP. Cette routine renvoie 1 si elle réussit, et zéro sinon. Elle est automatiquement invoquée par svc_register().

bool_t pmap_unset(unsigned long prognum, unsigned long versnum);
Une interface utilisateur vers le service portmap qui détruit toute association entre le triplet [prognum, versnum, *] et les ports de la machine où se trouve le service portmap. Cette routine renvoie 1 si elle réussit, et zéro sinon.

int registerrpc(unsigned long prognum, unsigned long versnum,
                unsigned long procnum, char *(*procname)(char *),
                xdrproc_t inproc, xdrproc_t outproc);
Enregistre la procédure procname avec le service RPC. Si une requête arrive pour le programme prognum, de version versnum, et pour la procédure procnum, procname sera appelée avec un pointeur vers ses paramètres d'entrée. progname doit renvoyer un pointeur vers ses résultats statiques. inproc est utilisée pour décoder les paramètres d'entrée alors que outproc sert à encode les résultats. Cette routine renvoie zéro si l'enregistrement à réussi, et -1 sinon.
Attention : les procédures enregistrées de cette manière sont accessibles avec le protocole de transport UDP/IP. Voir svcudp_create() pour ses restrictions.

struct rpc_createerr rpc_createerr;
Une variable globale dont la valeur est fixée par toute routine RPC de création de client qui échoue. Utilisez la routine clnt_pcreateerror() pour afficher la raison de l'échec.

void svc_destroy(SVCXPRT *xprt);
Une macro qui détruit le descripteur de transport RPC xprt. La destruction implique normalement la libération de structures de données privées, y compris xprt lui-même. Le comportement est indéfini si on essaye d'utiliser xprt après avoir appelé cette routine.

fd_set svc_fdset;
Une variable globale représentant le masque de bits des descripteurs de fichier en lecture du côté serveur RPC. Elle est utilisable avec l'appel système select(2). Ce n'est intéressant que si l'implémentation d'un service n'appelle pas svc_run(), mais assure son propre traitement d'événements asynchrones. Cette variable est en lecture seule (ne passez pas son adresse à select(2) !), et elle peut changer après un appel svc_getreqset() ou une routine de création.

int svc_fds;
Similaire à svc_fdset, mais limitée à 32 descripteurs. Cette interface est rendue obsolète par svc_fdset.

svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui libère toutes les données allouées par le système RPC/XDR lorsqu'il décode les arguments d'une procédure de service avec svc_getargs(). Cette routine renvoie 1 si les arguments ont été correctement libérés, et zéro sinon.

svc_getargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui décode les arguments d'une requête RPC associée avec le descripteur de transport RPC xprt. L'argument in est l'adresse où les arguments seront stockés, inproc est la routine XDR pour décoder les arguments. Cette routine renvoie 1 si le décodage réussit, et zéro sinon.

struct sockaddr_in *svc_getcaller(SVCXPRT *xprt);
La manière correcte d'obtenir l'adresse réseau de l'appelant d'une procédure associée avec le descripteur de transport RPC.

void svc_getreqset(fd_set *rdfds);
Cette routine n'est intéressante que si l'implémentation d'un service n'appelle pas svc_run(), mais emploie à la place un traitement personnalisé des événements asynchrones. On l'invoque lorsque l'appel système select(2) a déterminé qu'une requête RPC est arrivée sur l'une des sockets RPC. rdfds est le masque de bits des descripteurs de fichiers en résultant. La routine revient lorsque toutes les sockets associées avec les valeurs de rdfds ont été servies.

void svc_getreq(int rdfds);
Similaire à svc_getreqset(), mais limitée à 32 descripteurs. Cette interface est rendue obsolète par svc_getreqset().

bool_t svc_register(SVCXPRT *xprt, unsigned long prognum,
                    unsigned long versnum,
                    void (*dispatch)(svc_req *, SVCXPRT *),
                    unsigned long protocol);
Associer prognum et versnum avec la procédure de distribution dispatch. Si protocol vaut zéro, le service n'est pas enregistré avec le service portmap. Si protocol est non nul, alors l'association entre le triplet [prognum,versnum,protocol] et xprt->xp_port est établie par l'intermédiaire du service portmap local (en général protocol vaut zéro, IPPROTO_UDP ou IPPROTO_TCP). La procédure dispatch a la forme suivante :
dispatch(struct svc_req *request, SVCXPRT *xprt );
La routine svc_register() renvoie 1 si elle réussit et 0 sinon.

void svc_run(void);
Cette routine ne revient jamais. Elle attend l'arrivée de requêtes RPC et appelle les procédures de service appropriées en utilisant svc_getreq(). Cette procédure est la plupart du temps en attente autour d'un appel système select(2).

bool_t svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);
Appelée par une routine de distribution de services RPC pour envoyer le résultat d'un appel de procédure distante. L'argument xprt est le descripteur de transport associé à la requête, outproc est la routine XDR utilisée pour encoder les résultats, et out est l'adresse des résultats. Cette routine renvoie 1 si elle réussit, et 0 sinon.

void svc_unregister(unsigned long prognum, unsigned long versnum);
Supprimer toute association du doublet [prognum, versnum] vers les routines de distribution, et du triplet [prognum, versnum, *] vers le numéro de port.

void svcerr_auth(SVCXPRT *xprt, enum auth_stat why);
Appelée par une routine de distribution de service qui refuse d'exécuter un appel de procédure distante à cause d'une erreur d'authentification.

void svcerr_decode(SVCXPRT *xprt);
Appelée par une routine de distribution de service qui n'arrive pas à décoder ses arguments. Voir aussi svc_getargs().

void svcerr_noproc(SVCXPRT *xprt);
Appelée par une routine de distribution de service qui n'implémente pas le numéro de procédure que l'appelant réclame.

void svcerr_noprog(SVCXPRT *xprt);
Appelée quand le programme désiré n'est pas enregistré dans le service RPC. L'implémentation d'un service n'a normalement pas besoin de cette routine.

void svcerr_progvers(SVCXPRT *xprt);
Appelée quand le numéro de version du programme désiré n'est pas enregistré dans le service RPC. L'implémentation d'un service n'a normalement pas besoin de cette routine.

void svcerr_systemerr(SVCXPRT *xprt);
Appelée par une routine de distribution de service lorsqu'elle détecte une erreur système non couverte par un protocole. Par exemple, si un service ne peut plus allouer de place, il peut appeler cette routine.

void svcerr_weakauth(SVCXPRT *xprt);
Appelée par une routine de distribution de service qui refuse d'exécuter un appel de procédure distante à cause d'un manque de paramètres d'authentification. La routine appelle svcerr_auth(xprt, AUTH_TOOWEAK).

SVCXPRT *svcfd_create(int fd, unsigned int sendsize,
                      unsigned int recvsize);
Créer un service au-dessus de n'importe quel descripteur ouvert. Typiquement ces descripteurs sont des sockets pour un protocole connecté comme TCP. sendsize et recvsize indiquent les tailles pour les tampons d'émission et de réception. Si ces tailles valent zéro, une valeur optimale est choisie.

SVCXPRT *svcraw_create(void);
Cette routine crée un simili transport de service RPC vers lequel il renvoie un pointeur. Le transport est en fait un tampon au sein de l'espace d'adressage du processus. Le client RPC correspondant doit donc résider dans le même espace d'adresse. Voir clntraw_create(). Cela permet de simuler une RPC et de mesurer la surcharge des procédures RPC comme les temps d'aller-retour sans interférence due au noyau. Cette routine renvoie NULL si elle échoue.

SVCXPRT *svctcp_create(int sock, unsigned int send_buf_size,
                       unsigned int recv_buf_size);
Cette routine crée un transport de service RPC basé sur TCP/IP sur lequel elle renvoie un pointeur. Il est associé avec la socket sock, qui peut être RPC_ANYSOCK, auquel cas une nouvelle socket est créée. Si la socket n'est pas associée à un port TCP local, cette routine l'associe à un port quelconque. Après réussite, xprt->xp_sock est le descripteur de la socket de transport, et xprt->xp_port est le numéro de port. Cette routine renvoie NULL si elle échoue. Comme les RPC basées sur TCP utilisent des entrées-sorties avec tampon, les utilisateurs peuvent fixer la taille des tampons. Une taille nulle implique l'allocation automatique de tampons de tailles optimales.

SVCXPRT *svcudp_bufcreate(int sock, unsigned int sendsize,
                          unsigned int recosize);
Cette routine crée un transport de service RPC basé sur UDP/IP et renvoie un pointeur dessus. Le transport est associé avec la socket sock, qui peut être RPC_ANYSOCK, auquel cas une nouvelle socket est créée. Si la socket n'est pas associée à un port UDP local, cette routine l'associe à un port quelconque. Après réussite, xprt->xp_sock est le descripteur de transport, et xprt->xp_port est le numéro de port. Cette routine renvoie NULL si elle échoue.
Ceci permet à l'utilisateur de préciser la taille maximale d'un paquet UDP en émission ou en réception de messages RPC.

SVCXPRT *svcudp_create(int sock);
Cet appel est équivalent à svcudp_bufcreate(sock,SZ,SZ) avec une taille SZ par défaut.

bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);
Utilisée pour encoder les messages de réponse RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

bool_t xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);
Utilisée pour décrire les identités UNIX. Cette routine est utile pour les programmeurs qui veulent engendrer ces identités sans utiliser le système RPC d'authentification.

void xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);
Utilisée pour créer les entêtes de message RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);
Utilisée pour créer les messages d'appel RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
Utilisée pour créer les informations d'authentification RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

bool_t xdr_pmap(XDR *xdrs, struct pmap *regs);
Utilisée pour créer les paramètres des divers procédures portmap. Cette routine est utile pour les programmeurs qui désirent créer ces paramètres sans utiliser l'interface pmap.

bool_t xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);
Utilisée pour créer la liste des associations des ports. Cette routine est utile pour les programmeurs qui désirent créer ces paramètres sans utiliser l'interface pmap.

bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);
Utilisée pour créer les messages de rejet RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);
Utilisée pour créer les messages de réponse RPC. Cette routine est utile pour les programmeurs qui désirent engendrer des messages de style RPC sans employer le service RPC complet.

void xprt_register(SVCXPRT *xprt);
Après la création d'un descripteur RPC de transport, il doit être enregistré dans le service RPC. Cette routine modifie la variable globale svc_fds(). L'implémentation d'un service ne nécessite pas cette routine habituellement.

void xprt_unregister(SVCXPRT *xprt);
Avant qu'un descripteur RPC de transport soit détruit, il doit se désinscrire du service RPC. Cette routine modifie la variable globale svc_fds. L'implémentation d'un service ne nécessite pas cette routine habituellement.
 



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
rpc_secure(3)
Les manuels suivants :
Remote Procedure Calls: Protocol Specification
Remote Procedure Call Programming Guide
rpcgen Programming Guide
RPC: Remote Procedure Call Protocol Specification, RFC 1050, Sun Microsystems, Inc., USC-ISI.  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 31 août 2000 et révisée le 14 janvier 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 rpc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.  




NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
sigvec, sigblock, sigsetmask, siggetmask, sigmask - API signaux BSD  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <signal.h>

int sigvec(int sig, struct sigvec *vec, struct sigvec *ovec);

int sigmask(int signum);

int sigblock(int mask);

int sigsetmask(int mask);

int siggetmask(void);

Exigences de macros de test de fonctionalités pour la glibc (voir feature_test_macros(7)) :

Pour toutes les fonctions décrites ci-dessus : _BSD_SOURCE  




DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Ces fonctions sont fournies dans la glibc comme interface de compatibilité pour les programmes qui utilisent l'API signaux BSD historique. Cette API est obsolète, les nouvelles applications devraient utiliser l'API signaux POSIX. (sigaction(2), sigprocmask(2), etc.)

La fonction sigvec() configure et/ou récupère le dispositif du signal sig (comme l'appel POSIX sigaction(2)). Si vec n'est pas NULL, il pointe sur une structure sigvec qui définit le nouveau dispositif pour sig. Si ovec n'est pas NULL, il pointe sur une structure sigvec qui est utilisée pour renvoyer le dispositif précédent de sig. Pour obtenir le dispositif courant de sig sans le modifier, vous devez spécifier NULL pour vec, et un pointeur non NULL pour ovec.

Les dispositifs pour SIGKILL et SIGSTOP ne peuvent pas être modifiés.

La structure sigvec à la forme suivante :


struct sigvec {
    void (*sv_handler)();  /* Dispositif du signal*/
    int    sv_mask;        /* Signaux à bloquer dans le gestionnaire */
    int    sv_flags;       /* Drapeaux */
};

Le champ sv_handler spécifie le dispositif du signal et est soit l'adresse de la fonction gestionnaire de signal, soit SIG_DFL signifiant que le dispositif par défaut s'applique au signal, soit SIG_IGN signifiant que le signal est ignoré.

Si sv_handler spécifie l'adresse d'un gestionnaire de signal, sv_mask spécifie un masque de signaux qui seront bloqués pendant que le gestionnaire s'exécute. De plus, le signal pour lequel le gestionnaire est appelé est également bloqué par défaut. Toute tentative de bloquer SIGKILL ou SIGSTOP est silencieusement ignorée.

Si sv_handler spécifie l'adresse d'un gestionnaire de signal, le champ sv_flags spécifie des attributs contrôlant ce qui se passe lorsque le gestionnaire est appelé. Ce champ peut contenir zéro ou plus des attributs suivants :

SV_INTERRUPT
Si le gestionnaire de signaux interrompt un appel système bloquant, l'appel système ne sera pas relancé au retour du gestionnaire. À la place, il échouera avec l'erreur EINTR. Si cet attribut n'est pas spécifié, les appels système sont relancés par défaut.
SV_RESETHAND
Réinitialiser le dispositif du signal à sa valeur par défaut avant d'appeler le gestionnaire de signaux. Si cet attribut n'est pas spécifié, le gestionnaire reste positionné jusqu'à ce qu'il soit explicitement supprimé par un appel ultérieur à sigvec() ou jusqu'à ce que le processus effectue un execve(2).
SV_ONSTACK
Gère le signal sur la pile de signaux spécifique (historiquement positionné sous BSD avec la fonction obsolète sigstack() ; la fonction POSIX qui la remplace est sigaltstack(2)).

La fonction sigmask() construit et renvoie un masque de signaux pour signum. Par exemple, on peut initialiser le champ vec.sv_mask passé à sigvec() avec un code tel que le suivant :


    vec.sv_mask = sigmask(SIGQUIT) | sigpause(SIGABRT);
                /* Bloquer SIGQUIT et SIGABRT pendant
                   l'exécution du gestionnaire */

La fonction sigblock() ajoute les signaux de mask au masque de signaux du processus (comme l'appel POSIX sigprocmask(SIG_BLOCK)), et renvoie le masque de signaux précédent du processus. Toute tentative de bloquer SIGKILL ou SIGSTOP est silencieusement ignorée.

La fonction sigsetmask() configure le masque de signaux du processus à la valeur donnée dans mask (comme l'appel POSIX sigprocmask(SIG_SETMASK)), et renvoie le masque de signaux précédent du processus.

La fonction siggetmask() renvoie le masque de signaux courant du processus. Cet appel est équivalent à sigblock(0).  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Si elle réussit, la fonction sigvec() renvoie 0. Si elle échoue, elle renvoie -1 et écrit errno pour indiquer l'erreur.

Les fonctions sigblock() et sigsetmask() renvoient le masque de signaux précédent.

La fonction sigmask() renvoie le masque de signaux pour signum.  




ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Voir la section ERREURS des pages de manuel sigaction(2) et sigprocmask(2).  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Toutes ces fonctions étaient dans BSD 4.3, excepté siggetmask(), dont l'origine n'est pas claire. Ces fonctions sont obsolètes. Ne les utilisez pas dans de nouveaux programmes.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Sur BSD 4.3, la fonction signal() fournit une sémantique fiable (comme lorsqu'on appelle sigvec() avec vec.sv_mask valant 0). Sur System V, la fonction signal() fournit une sémantique non fiable. POSIX.1-2001 laisse ces aspects de signal() non spécifiés. Voir signal(2) pour plus de détails.

Afin d'attendre un signal, BSD et System V fournissent tous les deux une fonction nommée sigpause(3), mais cette fonction n'a pas le même argument sur les deux systèmes. Voir sigpause(3) pour les détails.  




VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
kill(2), pause(2), sigaction(2), signal(2), sigprocmask(2), raise(3), sigpause(3), sigset(3), signal(7)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Alain Portal <aportal AT univ-montp2 DOT fr> le 12 juillet 2006 et révisée le 6 juin 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 sigvec ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/rpc.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
trunc, truncf, truncl - Arrondir à l'entier le plus proche vers zéro  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <math.h>

double trunc(double x);

float truncf(float x);
long double truncl(long double x);

Exigences de macros de test de fonctionalités pour la glibc (voir feature_test_macros(7)) :

trunc(), truncf(), truncl() : _XOPEN_SOURCE >= 600 || _ISOC99_SOURCE ; ou cc -std=c99  




DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Ces fonctions arrondissent leur argument à l'entier le plus proche de valeur absolue inférieure ou égale.  



VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La valeur arrondie. Si x est entier ou infini, la valeur renvoyée est xlui-même.  



ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Aucune.  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Pour utiliser les fonctions de la bibliothèque mathématique, il ne faut pas oublier d'ajouter l'argument -lm sur la ligne de commande de cc(1) ou ld(1), lors de l'édition des liens.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
ceil(3), floor(3), lrint(3), nearbyint(3), rint(3), round(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 7 juin 2001 et révisée le 19 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 trunc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/gets.3
 



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
ungetwc - Remettre un caractère large dans un flux  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#include <wchar.h>

wint_t ungetwc (wint_t wc, FILE *flux);
 



DESCRIPTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction ungetwc() est l'équivalent de la fonction ungetc(3) pour les caractères larges. Elle remet un caractère large dans le flux et renvoie sa valeur.

Si wc est WEOF, WEOF est renvoyé. Si wc est un caractère large non valide, errno est remplie avec EILSEQ et WEOF est renvoyé.

Si wc est un caractère large valide, celui-ci est remis dans le flux et devient alors disponible pour de nouvelles opérations de lecture de caractères larges. Le pointeur de fichier est décrémenté de un ou plus. L'indicateur de fin de fichier est réinitialisé. L'image du fichier sur disque n'est pas affectée.

NB : wc n'a pas besoin d'être le dernier caractère large lu depuis le flux ; ce peut être n'importe quel autre caractère large.

Si l'implémentation supporte la remise dans le flux de caractères multiples, les caractères larges seront lus dans l'ordre inverse. Cependant, seulement un niveau de réinjection est garanti.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La fonction ungetwc() renvoie wc en cas de succès ou WEOF en cas d'erreur.  



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
C99.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Le comportement de ungetwc() dépend de la catégorie LC_CTYPE de la localisation courante.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
fgetwc(3)  



TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Thierry Vignaud <tvignaud AT mandriva DOT com> en 2000 et révisée le 17 décembre 2007.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 ungetwc ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

man2html: unable to open or read file ../man3/posix_memalign.3


 



Sommaire   Début   Suivant   Sommaire   Préc.page.lue   Accueil
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
Sémantique spécifique pour execlp() et execvp()
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
CONFORMITÉ
NOTES
BOGUES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
CONFORMITÉ
BOGUES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS ET DESCRIPTION
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION
NOM
SYNOPSIS
DESCRIPTION
VALEUR RENVOYÉE
CONFORMITÉ
NOTES
VOIR AUSSI
TRADUCTION

Table des mots clés   Début   Suivant   Sommaire   Préc.page.lue   Accueil
EAGAINERREURS
EBADFERREURS
EILSEQERREURS
EINVALERREURS
SV_INTERRUPTDESCRIPTION
SV_ONSTACKDESCRIPTION
SV_RESETHANDDESCRIPTION



Ce document a été créé par man2html suivi de man2html.pl, le 19/10/2008 07:56:03, en utilisant les pages de 'man'.
 

Valid HTML 4.01 Transitional