# open_memstream

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           open_memstream, open_wmemstream — open a dynamic memory buffer
           stream
    


## SYNOPSIS



           #include <stdio.h>
    
           FILE *open_memstream(char **_bufp_ , size_t *_sizep_);
    
           #include <wchar.h>
    
           FILE *open_wmemstream(wchar_t **_bufp_ , size_t *_sizep_);
    


## DESCRIPTION



           The _open_memstream_() and _open_wmemstream_() functions shall create
           an I/O stream associated with a dynamically allocated memory
           buffer. The stream shall be opened for writing and shall be
           seekable.
    
           The stream associated with a call to _open_memstream_() shall be
           byte-oriented.
    
           The stream associated with a call to _open_wmemstream_() shall be
           wide-oriented.
    
           The stream shall maintain a current position in the allocated
           buffer and a current buffer length. The position shall be
           initially set to zero (the start of the buffer). Each write to the
           stream shall start at the current position and move this position
           by the number of successfully written bytes for _open_memstream_()
           or the number of successfully written wide characters for
           _open_wmemstream_().  The length shall be initially set to zero. If
           a write moves the position to a value larger than the current
           length, the current length shall be set to this position. In this
           case a null character for _open_memstream_() or a null wide
           character for _open_wmemstream_() shall be appended to the current
           buffer. For both functions the terminating null is not included in
           the calculation of the buffer length.
    
           After a successful _fflush_() or _fclose_(), the pointer referenced by
           _bufp_ shall contain the address of the buffer, and the variable
           pointed to by _sizep_ shall contain the smaller of the current
           buffer length and the number of bytes for _open_memstream_(), or the
           number of wide characters for _open_wmemstream_(), between the
           beginning of the buffer and the current file position indicator.
    
           After a successful _fflush_() the pointer referenced by _bufp_ and the
           variable referenced by _sizep_ remain valid only until the next
           write operation on the stream or a call to _fclose_().
    
           After a successful _fclose_(), the pointer referenced by _bufp_ can be
           passed to _free_().
    


## RETURN VALUE



           Upon successful completion, these functions shall return a pointer
           to the object controlling the stream. Otherwise, a null pointer
           shall be returned, and _errno_ shall be set to indicate the error.
    


## ERRORS



           These functions shall fail if:
    
           **EMFILE**{STREAM_MAX} streams are currently open in the calling
                  process.
    
           These functions may fail if:
    
           **EINVAL** _bufp_ or _sizep_ are NULL.
    
           **EMFILE**{FOPEN_MAX} streams are currently open in the calling
                  process.
    
           **ENOMEM** Memory for the stream or the buffer could not be allocated.
    
           _The following sections are informative._
    


## EXAMPLES



               #include <stdio.h>
               #include <stdlib.h>
    
               int
               main (void)
               {
                   FILE *stream;
                   char *buf;
                   size_t len;
                   off_t eob;
    
                   stream = open_memstream (&buf, &len);
                   if (stream == NULL)
                       /* handle error */ ;
                   fprintf (stream, "hello my world");
                   fflush (stream);
                   printf ("buf=%s, len=%zu\n", buf, len);
                   eob = ftello(stream);
                   fseeko (stream, 0, SEEK_SET);
                   fprintf (stream, "good-bye");
                   fseeko (stream, eob, SEEK_SET);
                   fclose (stream);
                   printf ("buf=%s, len=%zu\n", buf, len);
                   free (buf);
                   return 0;
               }
    
           This program produces the following output:
    
               buf=hello my world, len=14
               buf=good-bye world, len=14
    


## APPLICATION USAGE



           The buffer created by these functions should be freed by the
           application after closing the stream, by means of a call to
           _free_().
    


## RATIONALE



           These functions are similar to _fmemopen_() except that the memory
           is always allocated dynamically by the function, and the stream is
           opened only for output.
    


## FUTURE DIRECTIONS



           None.
    


* * *