open_wmemstream

       #include <stdio.h>

       FILE *fmemopen(void *buf, size_t size, const char *mode);

       FILE *open_memstream(char **ptr, size_t *sizeloc);

       #include <wchar.h>

       FILE *open_wmemstream(wchar_t **ptr, size_t *sizeloc);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       fmemopen(), open_memstream(), open_wmemstream():
           Since glibc 2.10:
               _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L
           Before glibc 2.10:
               _GNU_SOURCE

DESCRIPTION
       The  fmemopen()  function opens a stream that permits the access speci-
       fied by mode.  The stream allows I/O to be performed on the  string  or
       memory  buffer  pointed  to  by buf.  This buffer must be at least size
       bytes long.

       The argument mode is the same as for fopen(3).  If  mode  specifies  an
       append  mode,  then the initial file position is set to the location of
       the first null byte ('\0') in the buffer; otherwise  the  initial  file
       position  is set to the start of the buffer.  Since glibc 2.9, the let-
       ter 'b' may be specified as the second character in  mode.   This  pro-
       vides  "binary"  mode:  writes  don't implicitly add a terminating null
       byte, and fseek(3) SEEK_END is relative to the end of the buffer (i.e.,
       the  value  specified  by  the  size argument), rather than the current
       string length.

       When a stream that has been opened for writing is  flushed  (fflush(3))
       or  closed (fclose(3)), a null byte is written at the end of the buffer
       if there is space.  The caller should ensure  that  an  extra  byte  is
       available  in  the buffer (and that size counts that byte) to allow for
       this.

       Attempts to write more than size bytes  to  the  buffer  result  in  an
       error.   (By  default,  such errors will be visible only when the stdio
       buffer is flushed.  Disabling buffering with the following call may  be
       useful to detect errors at the time of an output operation:

           setbuf(stdream, NULL);

       Alternatively,  the  caller  can explicitly set buf as the stdio stream
       buffer, at the same time informing stdio of the buffer's size, using:

           setbuffer(stream, buf, size);

       In a stream opened for reading, null bytes ('\0') in the buffer do  not
       cause read operations to return an end-of-file indication.  A read from
       cally grows as required.  After closing the stream, the  caller  should
       free(3) this buffer.

       When the stream is closed (fclose(3)) or flushed (fflush(3)), the loca-
       tions pointed to by ptr and sizeloc are  updated  to  contain,  respec-
       tively,  a  pointer  to  the buffer and the current size of the buffer.
       These values remain valid only as long as the caller performs  no  fur-
       ther  output  on  the stream.  If further output is performed, then the
       stream must again be flushed before trying to access these variables.

       A null byte is maintained at the end of the buffer.  This byte  is  not
       included in the size value stored at sizeloc.

       The  stream's  file position can be changed with fseek(3) or fseeko(3).
       Moving the file position past the end of the data already written fills
       the intervening space with zeros.

       The  open_wmemstream()  is similar to open_memstream(), but operates on
       wide characters instead of bytes.

RETURN VALUE
       Upon successful completion fmemopen(), open_memstream() and  open_wmem-
       stream()  return a FILE pointer.  Otherwise, NULL is returned and errno
       is set to indicate the error.

VERSIONS
       fmemopen() and open_memstream() were already available in glibc  1.0.x.
       open_wmemstream() is available since glibc 2.4.

ATTRIBUTES
       For   an   explanation   of   the  terms  used  in  this  section,  see
       attributes(7).

       +------------------+---------------+---------+
       |Interface         | Attribute     | Value   |
       +------------------+---------------+---------+
       |fopenmem(),       | Thread safety | MT-Safe |
       |open_memstream(), |               |         |
       |open_wmemstream   |               |         |
       +------------------+---------------+---------+

CONFORMING TO
       POSIX.1-2008.  These functions are not specified in  POSIX.1-2001,  and
       are not widely available on other systems.

       POSIX.1-2008  specifies  that  'b'  in mode shall be ignored.  However,
       Technical Corrigendum 1 adjusts the standard to  allow  implementation-
       specific  treatment  for this case, thus permitting the glibc treatment
       of 'b'.

NOTES
       There is no file descriptor associated with the file stream returned by
       these  functions (i.e., fileno(3) will return an error if called on the
       returned stream).
       file position to the first null byte, but (if the file offset is  reset
       to  a  location other than the end of the stream) does not force subse-
       quent writes to append at the end of the stream.

       If the mode argument to fmemopen() specifies append ("a" or "a+"),  and
       the size argument does not cover a null byte in buf, then, according to
       POSIX.1-2008, the initial file position should be set to the next  byte
       after  the  end  of the buffer.  However, in this case the glibc fmemo-
       pen() sets the file position to -1.

       To specify binary mode for fmemopen() the 'b' must be the second  char-
       acter  in  mode.   Thus, for example, "wb+" has the desired effect, but
       "w+b" does not.  This is inconsistent with the  treatment  of  mode  by
       fopen(3).

       The glibc 2.9 addition of "binary" mode for fmemopen() silently changed
       the ABI: previously, fmemopen() ignored 'b' in mode.

EXAMPLE
       The program  below  uses  fmemopen()  to  open  an  input  buffer,  and
       open_memstream()  to  open a dynamically sized output buffer.  The pro-
       gram scans its input string (taken from the  program's  first  command-
       line  argument) reading integers, and writes the squares of these inte-
       gers to the output buffer.  An example of the output produced  by  this
       program is the following:

           $ ./a.out '1 23 43'
           size=11; ptr=1 529 1849

   Program source

       #define _GNU_SOURCE
       #include <string.h>
       #include <stdio.h>
       #include <stdlib.h>

       #define handle_error(msg) \
           do { perror(msg); exit(EXIT_FAILURE); } while (0)

       int
       main(int argc, char *argv[])
       {
           FILE *out, *in;
           int v, s;
           size_t size;
           char *ptr;

           if (argc != 2) {
               fprintf(stderr, "Usage: %s <file>\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           in = fmemopen(argv[1], strlen(argv[1]), "r");
           if (in == NULL)
               if (s == -1)
                   handle_error("fprintf");
           }
           fclose(in);
           fclose(out);
           printf("size=%zu; ptr=%s\n", size, ptr);
           free(ptr);
           exit(EXIT_SUCCESS);
       }

SEE ALSO
       fopen(3), fopencookie(3)

COLOPHON
       This  page  is  part of release 4.04 of the Linux man-pages project.  A
       description of the project, information about reporting bugs,  and  the
       latest     version     of     this    page,    can    be    found    at
       http://www.kernel.org/doc/man-pages/.

GNU                               2015-03-29                       FMEMOPEN(3)
Man Pages Copyright Respective Owners. Site Copyright (C) 1994 - 2019 Hurricane Electric. All Rights Reserved.