fmemopen(3) Library Functions Manual fmemopen(3) NOM fmemopen - Ouvrir de la memoire en tant que flux BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include FILE *fmemopen(void tampon[.taille], size_t taille, const char *mode); Exigences de macros de test de fonctionnalites pour la glibc (consulter feature_test_macros(7)) : fmemopen() : Depuis la glibc 2.10 : _POSIX_C_SOURCE >= 200809L Avant la glibc 2.10 : _GNU_SOURCE DESCRIPTION La fonction fmemopen() ouvre un flux qui permet l'acces specifie par mode. Le flux permet d'effectuer des entrees/sorties sur la chaine ou le tampon memoire pointe par tampon. L'argument mode specifie le mode d'ouverture du flux et peut avoir pour valeurs : r Le flux est ouvert en lecture. w Le flux est ouvert en ecriture. a Ajout ; le flux est ouvert en ecriture, la position initiale du tampon etant definie au premier octet de valeur zero. r+ Le flux est ouvert en lecture et en ecriture. w+ Le flux est ouvert en lecture et en ecriture. Le contenu du tampon est ecrase (autrement dit, '\0' est place dans le premier octet du tampon. a+ Ajout ; le flux est ouvert en lecture et ecriture, la position initiale du tampon etant definie au premier octet de valeur zero. Le flux conserve la notion de position actuelle qui est l'endroit du tampon ou la prochaine operation d'entree/sortie aura lieu. La position actuelle est automatiquement mise a jour par les operations d'entrees/sorties. Elle peut aussi etre definie de maniere explicite a l'aide de fseek(3) et obtenue a l'aide de ftell(3). Dans tous les modes autres que Ajout, la position actuelle est initialisee au debut du tampon. En mode Ajout, si aucun octet de valeur zero n'est trouve dans le tampon, la position actuelle est initialisee a taille+1. Si l'argument tampon vaut NULL, alors la fonction fmemopen() alloue un tampon de taille octets. C'est utile pour les applications qui veulent ecrire des donnees dans un tampon temporaire et les lire ensuite. La position initiale est definie au debut du tampon. Le tampon est automatiquement supprime lorsque le flux est ferme. Notez que l'appelant ne peut pas obtenir de pointeur vers le tampon temporaire alloue avec cette fonction (voir a ce sujet open_memstream(3)). Si tampon est different de NULL, il doit pointer vers un tampon d'une taille minimale de taille octets alloues par l'appelant. Lorsqu'un flux ouvert en ecriture est vide (consultez fflush(3)), ou ferme (consultez fclose(3)), un octet nul est ecrit a la fin du tampon s'il y a de la place. Pour ce faire, l'appelant doit s'assurer qu'un octet supplementaire est disponible dans le tampon (et que taille en tient compte). Avec un flux ouvert en lecture, si le tampon contient des octets de valeur ('\0'), les operations de lecture ne renverront pas une indication de fin de fichier. Une lecture depuis le tampon n'indiquera la fin du fichier que lorsque la position actuelle du tampon aura atteint la valeur taille. Les operations d'ecriture s'effectuent soit a la position actuelle (pour les modes autres que Ajout), ou a une position correspondant a la taille du flux (pour les mode Ajout). Essayer d'ecrire plus de taille octets dans le tampon cree une erreur. Par defaut, de telles erreurs ne seront visibles (en l'absence de donnees) que lorsque le tampon stdio sera vide. Desactiver cette mise en tampon avec l'appel suivant peut s'averer utile pour detecter les erreurs au moment d'une operation de sortie : setbuf(flux, NULL); VALEUR RENVOYEE En cas de succes, fmemopen() renvoie un pointeur de type FILE. Sinon, elle renvoie NULL et errno contient le code d'erreur. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |fmemopen(), | Securite des threads | MT-Safe | +---------------------------------+--------------------------+---------+ STANDARDS POSIX.1-2008. HISTORIQUE glibc 1.0.x. POSIX.1-2008. POSIX.1-2008 specifie que << b >> dans mode sera ignore. Cependant, Technical Corrigendum 1 ajuste la norme pour permettre un traitement specifique a l'implementation dans ce cas, permettant ainsi a la glibc de traiter << b >>. Avec la glibc 2.22, le mode binaire a ete supprime (voir ci-dessous), de nombreux bogues anciens dans l'implementation de fmemopen() ont ete resolus et un nouveau symbole versionne a ete cree pour cette interface. Mode binaire De la glibc 2.9 a la glibc 2.21, l'implementation dans la glibc de fmemopen() prenait en charge un mode << binaire >> qui pouvait etre active en specifiant la lettre << b >> comme second caractere de mode. Dans ce mode, les operations d'ecriture n'ajoutaient pas de maniere implicite l'octet de valeur zero terminal, et la valeur SEEK_END du troisieme argument de fseek(3) est relative a la fin du tampon (c'est-a-dire la valeur specifiee par l'argument taille), et non a la longueur de la chaine courante. Un bogue de l'API affectait l'implementation du mode binaire : pour indiquer le mode binaire, le << b >> doit etre le second caractere de mode. Ainsi, par exemple, << wb+ >> a le comportement attendu, mais pas << w+b >>. Ce n'etait pas coherent avec le traitement de mode par fopen(3). Le mode binaire a ete supprime a partir de la version 2.22 de la glibc et un << b >> specifie dans mode n'a dorenavant aucun effet. NOTES Il n'y a pas de descripteur de fichier associe avec le flux renvoye par cette fonction (par exemple, fileno(3) retournera une erreur si elle est appelee avec un tel flux). BOGUES Avant la glibc 2.22, si taille est egale a zero, fmemopen() echoue avec l'erreur EINVAL. Il est plus coherent dans ce cas de creer un flux renvoyant la fin de fichier au premier essai de lecture, et c'est ce que fait l'implementation de la glibc depuis la glibc 2.22. Avant la glibc 2.22, indiquer un mode d'ajout (<< a >> ou << a+ >>) pour fmemopen() definit la position initiale du fichier au premier octet de valeur zero, mais ne force pas l'ajout des ecritures suivantes a la fin du flux si la position actuelle dans le fichier est reinitialisee a un autre endroit que la fin du flux. Ce bogue a ete corrige avec la glibc 2.22. Avant la glibc 2.22, si l'argument mode de fmemopen() indiquait un ajout (<< a >> ou << a+ >>), et si l'argument taille ne couvrait pas d'octet de valeur zero dans tampon, alors, d'apres POSIX.1-2008, la position initiale du fichier devait etre definie a l'octet qui suit la fin du tampon. Dans ce cas cependant, l'implementation de fmemopen() de la glibc definissait la position du fichier a -1. Ce bogue a ete corrige avec la glibc 2.22. Avant la glibc 2.22, lorsqu'un appel a fseek(3) avec une valeur de depart egale a SEEK_END etait effectue sur un flux cree a l'aide de fmemopen(), le decalage etait soustrait a la position de fin de flux au lieu d'y etre ajoute. Ce bogue a ete corrige a partir de la glibc 2.22. L'ajout du mode << binaire >> dans la glibc 2.9 pour fmemopen() a modifie silencieusement l'ABI : auparavant, fmemopen() ignorait << b >> dans mode. EXEMPLES Le programme ci-dessous utilise fmemopen() pour ouvrir un tampon d'entree et open_memstream(3) pour ouvrir un tampon de sortie de taille dynamique. Ce programme scrute la chaine en entree (recuperee du premier argument de la ligne de commande du programme) sous forme d'entiers, et ecrit le carre de ces entiers dans le tampon de sortie. Voici un exemple de la sortie produite par ce programme : $ ./a.out '1 23 43' taille=11; ptr=1 529 1849 Source du programme #define _GNU_SOURCE #include #include #include #include int main(int argc, char *argv[]) { FILE *out, *in; int v, s; size_t taille; char *ptr; if (argc != 2) { fprintf(stderr, "Utilisation : %s '...'\n", argv[0]); exit(EXIT_FAILURE); } in = fmemopen(argv[1], strlen(argv[1]), "r"); if (in == NULL) err(EXIT_FAILURE, "fmemopen"); out = open_memstream(&ptr, taille); if (out == NULL) err(EXIT_FAILURE, "open_memstream"); for (;;) { s = fscanf(in, "%d", &v); if (s <= 0) break; s = fprintf(out, "%d ", v * v); if (s == -1) err(EXIT_FAILURE, "fprintf"); } fclose(in); fclose(out); printf("taille=%zu; ptr=%s\n", taille, ptr); free(ptr); exit(EXIT_SUCCESS); } VOIR AUSSI fopen(3), fopencookie(3), open_memstream(3) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Lucien Gentis Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 fmemopen(3)