system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-10-06 16:40:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add an implementation of open_memstream() and open_wmemstream(). These

Browse source 
routines provide write-only stdio FILE objects that store their data in a
dynamically allocated buffer.  They are a string builder interface somewhat
akin to a completely dynamic sbuf.

Reviewed by:	bde, jilles (earlier versions)
MFC after:	1 month
This commit is contained in:
John Baldwin 2013-02-27 19:50:46 +00:00
parent 4b9b732ac0
commit 9240031ac6
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=247411
12 changed files with 1070 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
include/stdio.h
View file

@ -346,6 +346,7 @@ char *tempnam(const char *, const char *);
FILE *fmemopen(void * __restrict, size_t, const char * __restrict);
ssize_t getdelim(char ** __restrict, size_t * __restrict, int,
FILE * __restrict);
FILE *open_memstream(char **, size_t *);
int renameat(int, const char *, int, const char *);
int vdprintf(int, const char * __restrict, __va_list);

1
include/wchar.h
View file

@ -207,6 +207,7 @@ int wcwidth(wchar_t);
#if __POSIX_VISIBLE >= 200809 || __BSD_VISIBLE
size_t mbsnrtowcs(wchar_t * __restrict, const char ** __restrict, size_t,
size_t, mbstate_t * __restrict);
FILE *open_wmemstream(wchar_t **, size_t *);
wchar_t *wcpcpy(wchar_t * __restrict, const wchar_t * __restrict);
wchar_t *wcpncpy(wchar_t * __restrict, const wchar_t * __restrict, size_t);
wchar_t *wcsdup(const wchar_t *) __malloc_like;

4
lib/libc/stdio/Makefile.inc
View file

@ -14,6 +14,7 @@ SRCS+= _flock_stub.c asprintf.c clrerr.c dprintf.c \
ftell.c funopen.c fvwrite.c fwalk.c fwide.c fwprintf.c fwscanf.c \
fwrite.c getc.c getchar.c getdelim.c getline.c \
gets.c getw.c getwc.c getwchar.c makebuf.c mktemp.c \
open_memstream.c open_wmemstream.c \
perror.c printf.c printf-pos.c putc.c putchar.c \
puts.c putw.c putwc.c putwchar.c \
refill.c remove.c rewind.c rget.c scanf.c setbuf.c setbuffer.c \
@ -36,7 +37,7 @@ MAN+= fclose.3 ferror.3 fflush.3 fgetln.3 fgets.3 fgetwln.3 fgetws.3 \
flockfile.3 \
fopen.3 fputs.3 \
fputws.3 fread.3 fseek.3 funopen.3 fwide.3 getc.3 \
getline.3 getwc.3 mktemp.3 \
getline.3 getwc.3 mktemp.3 open_memstream.3 \
printf.3 printf_l.3 putc.3 putwc.3 remove.3 scanf.3 scanf_l.3 setbuf.3 \
stdio.3 tmpnam.3 \
ungetc.3 ungetwc.3 wprintf.3 wscanf.3
@ -60,6 +61,7 @@ MLINKS+=getc.3 fgetc.3 getc.3 getc_unlocked.3 getc.3 getchar.3 \
MLINKS+=getline.3 getdelim.3
MLINKS+=getwc.3 fgetwc.3 getwc.3 getwchar.3
MLINKS+=mktemp.3 mkdtemp.3 mktemp.3 mkstemp.3 mktemp.3 mkstemps.3
MLINKS+=open_memstream.3 open_wmemstream.3
MLINKS+=printf.3 asprintf.3 printf.3 dprintf.3 printf.3 fprintf.3 \
printf.3 snprintf.3 printf.3 sprintf.3 \
printf.3 vasprintf.3 printf.3 vdprintf.3 \

2
lib/libc/stdio/Symbol.map
View file

@ -156,6 +156,8 @@ FBSD_1.3 {
putwc_l;
putwchar_l;
fmemopen;
open_memstream;
open_wmemstream;
};
FBSDprivate_1.0 {

154
lib/libc/stdio/open_memstream.3 Normal file
View file

@ -0,0 +1,154 @@
.\" Copyright (c) 2013 Advanced Computing Technologies LLC
.\" Written by: John H. Baldwin <jhb@FreeBSD.org>
.\" All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\" notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\" notice, this list of conditions and the following disclaimer in the
.\" documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\" $FreeBSD$
.\"
.Dd February 27, 2013
.Dt OPEN_MEMSTREAM 3
.Os
.Sh NAME
.Nm open_memstream ,
.Nm open_wmemstream
.Nd dynamic memory buffer stream open functions
.Sh LIBRARY
.Lb libc
.Sh SYNOPSIS
.In stdio.h
.Ft FILE *
.Fn open_memstream "char **bufp" "size_t **sizep"
.In wchar.h
.Ft FILE *
.Fn open_wmemstream "wchar_t **bufp" "size_t **sizep"
.Sh DESCRIPTION
The
.Fn open_memstream
and
.Fn open_wmemstream
functions create a write-only, seekable stream backed by a dynamically
allocated memory buffer.
The
.Fn open_memstream
function creates a byte-oriented stream,
while the
.Fn open_wmemstream
function creates a wide-oriented stream.
.Pp
Each stream maintains a current position and size.
Initially,
the position and size are set to zero.
Each write begins at the current position and advances it the number of
successfully written bytes for
.Fn open_memstream
or wide characters for
.Fn open_wmemstream .
If a write moves the current position beyond the length of the buffer,
the length of the buffer is extended and a null character is appended to the
buffer.
.Pp
A stream's buffer always contains a null character at the end of the buffer
that is not included in the current length.
.Pp
If a stream's current position is moved beyond the current length via a
seek operation and a write is performed,
the characters between the current length and the current position are filled
with null characters before the write is performed.
.Pp
After a successful call to
.Xr fclose 3
or
.Xr fflush 3 ,
the pointer referenced by
.Fa bufp
will contain the start of the memory buffer and the variable referenced by
.Fa sizep
will contain the smaller of the current position and the current buffer length.
.Pp
After a successful call to
.Xr fflush 3,
the pointer referenced by
.Fa bufp
and the variable referenced by
.Fa sizep
are only valid until the next write operation or a call to
.Xr fclose 3.
.Pp
Once a stream is closed,
the allocated buffer referenced by
.Fa bufp
should be released via a call to
.Xr free 3
when it is no longer needed.
.Sh IMPLEMENTATION NOTES
Internally all I/O streams are effectively byte-oriented,
so using wide-oriented operations to write to a stream opened via
.Fn open_wmemstream
results in wide characters being expanded to a stream of multibyte characters
in stdio's internal buffers.
These multibyte characters are then converted back to wide characters when
written into the stream.
As a result,
the wide-oriented streams maintain an internal multibyte character conversion
state that is cleared on any seek opertion that changes the current position.
This should have no effect as long as wide-oriented output operations are used
on a wide-oriented stream.
.Sh RETURN VALUES
Upon successful completion,
.Fn open_memstream
and
.Fn open_wmemstream
return a
.Tn FILE
pointer.
Otherwise,
.Dv NULL
is returned and the global variable
.Va errno
is set to indicate the error.
.Sh ERRORS
.Bl -tag -width Er
.It Bq Er EINVAL
The
.Fa bufp
or
.Fa sizep
argument was
.Dv NULL .
.It Bq Er ENOMEM
Memory for the stream or buffer could not be allocated.
.Sh SEE ALSO
.Xr fclose 3 ,
.Xr fflush 3 ,
.Xr fopen 3 ,
.Xr free 3 ,
.Xr fseek 3 ,
.Xr sbuf 3 ,
.Xr stdio 3
.Sh STANDARDS
The
.Fn open_memstream
and
.Fn open_wmemstream
functions conform to
.St -p1003.1-2008 .

209
lib/libc/stdio/open_memstream.c Normal file
View file

@ -0,0 +1,209 @@
/*-
* Copyright (c) 2013 Advanced Computing Technologies LLC
* Written by: John H. Baldwin <jhb@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "namespace.h"
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include "un-namespace.h"
/* XXX: There is no FPOS_MAX. This assumes fpos_t is an off_t. */
#define FPOS_MAX OFF_MAX
struct memstream {
char **bufp;
size_t *sizep;
ssize_t len;
fpos_t offset;
};
static int
memstream_grow(struct memstream *ms, fpos_t newoff)
{
char *buf;
ssize_t newsize;
if (newoff < 0 || newoff >= SSIZE_MAX)
newsize = SSIZE_MAX - 1;
else
newsize = newoff;
if (newsize > ms->len) {
buf = realloc(*ms->bufp, newsize + 1);
if (buf != NULL) {
#ifdef DEBUG
fprintf(stderr, "MS: %p growing from %zd to %zd\n",
ms, ms->len, newsize);
#endif
memset(buf + ms->len + 1, 0, newsize - ms->len);
*ms->bufp = buf;
ms->len = newsize;
return (1);
}
return (0);
}
return (1);
}
static void
memstream_update(struct memstream *ms)
{
assert(ms->len >= 0 && ms->offset >= 0);
*ms->sizep = ms->len < ms->offset ? ms->len : ms->offset;
}
static int
memstream_write(void *cookie, const char *buf, int len)
{
struct memstream *ms;
ssize_t tocopy;
ms = cookie;
if (!memstream_grow(ms, ms->offset + len))
return (-1);
tocopy = ms->len - ms->offset;
if (len < tocopy)
tocopy = len;
memcpy(*ms->bufp + ms->offset, buf, tocopy);
ms->offset += tocopy;
memstream_update(ms);
#ifdef DEBUG
fprintf(stderr, "MS: write(%p, %d) = %zd\n", ms, len, tocopy);
#endif
return (tocopy);
}
static fpos_t
memstream_seek(void *cookie, fpos_t pos, int whence)
{
struct memstream *ms;
#ifdef DEBUG
fpos_t old;
#endif
ms = cookie;
#ifdef DEBUG
old = ms->offset;
#endif
switch (whence) {
case SEEK_SET:
/* _fseeko() checks for negative offsets. */
assert(pos >= 0);
ms->offset = pos;
break;
case SEEK_CUR:
/* This is only called by _ftello(). */
assert(pos == 0);
break;
case SEEK_END:
if (pos < 0) {
if (pos + ms->len < 0) {
#ifdef DEBUG
fprintf(stderr,
"MS: bad SEEK_END: pos %jd, len %zd\n",
(intmax_t)pos, ms->len);
#endif
errno = EINVAL;
return (-1);
}
} else {
if (FPOS_MAX - ms->len < pos) {
#ifdef DEBUG
fprintf(stderr,
"MS: bad SEEK_END: pos %jd, len %zd\n",
(intmax_t)pos, ms->len);
#endif
errno = EOVERFLOW;
return (-1);
}
}
ms->offset = ms->len + pos;
break;
}
memstream_update(ms);
#ifdef DEBUG
fprintf(stderr, "MS: seek(%p, %jd, %d) %jd -> %jd\n", ms, (intmax_t)pos,
whence, (intmax_t)old, (intmax_t)ms->offset);
#endif
return (ms->offset);
}
static int
memstream_close(void *cookie)
{
free(cookie);
return (0);
}
FILE *
open_memstream(char **bufp, size_t *sizep)
{
struct memstream *ms;
int save_errno;
FILE *fp;
if (bufp == NULL || sizep == NULL) {
errno = EINVAL;
return (NULL);
}
*bufp = calloc(1, 1);
if (*bufp == NULL)
return (NULL);
ms = malloc(sizeof(*ms));
if (ms == NULL) {
save_errno = errno;
free(*bufp);
*bufp = NULL;
errno = save_errno;
return (NULL);
}
ms->bufp = bufp;
ms->sizep = sizep;
ms->len = 0;
ms->offset = 0;
memstream_update(ms);
fp = funopen(ms, NULL, memstream_write, memstream_seek,
memstream_close);
if (fp == NULL) {
save_errno = errno;
free(ms);
free(*bufp);
*bufp = NULL;
errno = save_errno;
return (NULL);
}
fwide(fp, -1);
return (fp);
}

271
lib/libc/stdio/open_wmemstream.c Normal file
View file

@ -0,0 +1,271 @@
/*-
* Copyright (c) 2013 Advanced Computing Technologies LLC
* Written by: John H. Baldwin <jhb@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "namespace.h"
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include "un-namespace.h"
/* XXX: There is no FPOS_MAX. This assumes fpos_t is an off_t. */
#define FPOS_MAX OFF_MAX
struct wmemstream {
wchar_t **bufp;
size_t *sizep;
ssize_t len;
fpos_t offset;
mbstate_t mbstate;
};
static int
wmemstream_grow(struct wmemstream *ms, fpos_t newoff)
{
wchar_t *buf;
ssize_t newsize;
if (newoff < 0 || newoff >= SSIZE_MAX / sizeof(wchar_t))
newsize = SSIZE_MAX / sizeof(wchar_t) - 1;
else
newsize = newoff;
if (newsize > ms->len) {
buf = realloc(*ms->bufp, (newsize + 1) * sizeof(wchar_t));
if (buf != NULL) {
#ifdef DEBUG
fprintf(stderr, "WMS: %p growing from %zd to %zd\n",
ms, ms->len, newsize);
#endif
wmemset(buf + ms->len + 1, 0, newsize - ms->len);
*ms->bufp = buf;
ms->len = newsize;
return (1);
}
return (0);
}
return (1);
}
static void
wmemstream_update(struct wmemstream *ms)
{
assert(ms->len >= 0 && ms->offset >= 0);
*ms->sizep = ms->len < ms->offset ? ms->len : ms->offset;
}
/*
* Based on a starting multibyte state and an input buffer, determine
* how many wchar_t's would be output. This doesn't use mbsnrtowcs()
* so that it can handle embedded null characters.
*/
static size_t
wbuflen(const mbstate_t *state, const char *buf, int len)
{
mbstate_t lenstate;
size_t charlen, count;
count = 0;
lenstate = *state;
while (len > 0) {
charlen = mbrlen(buf, len, &lenstate);
if (charlen == (size_t)-1)
return (-1);
if (charlen == (size_t)-2)
break;
if (charlen == 0)
/* XXX: Not sure how else to handle this. */
charlen = 1;
len -= charlen;
buf += charlen;
count++;
}
return (count);
}
static int
wmemstream_write(void *cookie, const char *buf, int len)
{
struct wmemstream *ms;
ssize_t consumed, wlen;
size_t charlen;
ms = cookie;
wlen = wbuflen(&ms->mbstate, buf, len);
if (wlen < 0) {
errno = EILSEQ;
return (-1);
}
if (!wmemstream_grow(ms, ms->offset + wlen))
return (-1);
/*
* This copies characters one at a time rather than using
* mbsnrtowcs() so it can properly handle embedded null
* characters.
*/
consumed = 0;
while (len > 0 && ms->offset < ms->len) {
charlen = mbrtowc(*ms->bufp + ms->offset, buf, len,
&ms->mbstate);
if (charlen == (size_t)-1) {
if (consumed == 0) {
errno = EILSEQ;
return (-1);
}
/* Treat it as a successful short write. */
break;
}
if (charlen == 0)
/* XXX: Not sure how else to handle this. */
charlen = 1;
if (charlen == (size_t)-2) {
consumed += len;
len = 0;
} else {
consumed += charlen;
buf += charlen;
len -= charlen;
ms->offset++;
}
}
wmemstream_update(ms);
#ifdef DEBUG
fprintf(stderr, "WMS: write(%p, %d) = %zd\n", ms, len, consumed);
#endif
return (consumed);
}
static fpos_t
wmemstream_seek(void *cookie, fpos_t pos, int whence)
{
struct wmemstream *ms;
fpos_t old;
ms = cookie;
old = ms->offset;
switch (whence) {
case SEEK_SET:
/* _fseeko() checks for negative offsets. */
assert(pos >= 0);
ms->offset = pos;
break;
case SEEK_CUR:
/* This is only called by _ftello(). */
assert(pos == 0);
break;
case SEEK_END:
if (pos < 0) {
if (pos + ms->len < 0) {
#ifdef DEBUG
fprintf(stderr,
"WMS: bad SEEK_END: pos %jd, len %zd\n",
(intmax_t)pos, ms->len);
#endif
errno = EINVAL;
return (-1);
}
} else {
if (FPOS_MAX - ms->len < pos) {
#ifdef DEBUG
fprintf(stderr,
"WMS: bad SEEK_END: pos %jd, len %zd\n",
(intmax_t)pos, ms->len);
#endif
errno = EOVERFLOW;
return (-1);
}
}
ms->offset = ms->len + pos;
break;
}
/* Reset the multibyte state if a seek changes the position. */
if (ms->offset != old)
memset(&ms->mbstate, 0, sizeof(ms->mbstate));
wmemstream_update(ms);
#ifdef DEBUG
fprintf(stderr, "WMS: seek(%p, %jd, %d) %jd -> %jd\n", ms,
(intmax_t)pos, whence, (intmax_t)old, (intmax_t)ms->offset);
#endif
return (ms->offset);
}
static int
wmemstream_close(void *cookie)
{
free(cookie);
return (0);
}
FILE *
open_wmemstream(wchar_t **bufp, size_t *sizep)
{
struct wmemstream *ms;
int save_errno;
FILE *fp;
if (bufp == NULL || sizep == NULL) {
errno = EINVAL;
return (NULL);
}
*bufp = calloc(1, sizeof(wchar_t));
if (*bufp == NULL)
return (NULL);
ms = malloc(sizeof(*ms));
if (ms == NULL) {
save_errno = errno;
free(*bufp);
*bufp = NULL;
errno = save_errno;
return (NULL);
}
ms->bufp = bufp;
ms->sizep = sizep;
ms->len = 0;
ms->offset = 0;
memset(&ms->mbstate, 0, sizeof(mbstate_t));
wmemstream_update(ms);
fp = funopen(ms, NULL, wmemstream_write, wmemstream_seek,
wmemstream_close);
if (fp == NULL) {
save_errno = errno;
free(ms);
free(*bufp);
*bufp = NULL;
errno = save_errno;
return (NULL);
}
fwide(fp, 1);
return (fp);
}

4
tools/regression/lib/libc/stdio/Makefile
View file

@ -1,6 +1,8 @@
# $FreeBSD$
TESTS= test-getdelim test-perror test-print-positional test-printbasic test-printfloat test-scanfloat
TESTS= test-fmemopen test-getdelim test-open_memstream test-open_wmemstream \
test-perror test-print-positional test-printbasic test-printfloat \
test-scanfloat
CFLAGS+= -lm
.PHONY: tests

203
tools/regression/lib/libc/stdio/test-open_memstream.c Normal file
View file

@ -0,0 +1,203 @@
/*-
* Copyright (c) 2013 Advanced Computing Technologies LLC
* Written by: John H. Baldwin <jhb@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
static char *buf;
static size_t len;
static void
assert_stream(const char *contents)
{
if (strlen(contents) != len)
printf("bad length %zd for \"%s\"\n", len, contents);
else if (strncmp(buf, contents, strlen(contents)) != 0)
printf("bad buffer \"%s\" for \"%s\"\n", buf, contents);
}
static void
open_group_test(void)
{
FILE *fp;
off_t eob;
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
fprintf(fp, "hello my world");
fflush(fp);
assert_stream("hello my world");
eob = ftello(fp);
rewind(fp);
fprintf(fp, "good-bye");
fseeko(fp, eob, SEEK_SET);
fclose(fp);
assert_stream("good-bye world");
free(buf);
}
static void
simple_tests(void)
{
static const char zerobuf[] =
{ 'f', 'o', 'o', 0, 0, 0, 0, 'b', 'a', 'r', 0 };
char c;
FILE *fp;
fp = open_memstream(&buf, NULL);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad length pointer");
fp = open_memstream(NULL, &len);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad buffer pointer");
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
fflush(fp);
assert_stream("");
if (fwide(fp, 0) >= 0)
printf("stream is not byte-oriented\n");
fprintf(fp, "fo");
fflush(fp);
assert_stream("fo");
fputc('o', fp);
fflush(fp);
assert_stream("foo");
rewind(fp);
fflush(fp);
assert_stream("");
fseek(fp, 0, SEEK_END);
fflush(fp);
assert_stream("foo");
/*
* Test seeking out past the current end. Should zero-fill the
* intermediate area.
*/
fseek(fp, 4, SEEK_END);
fprintf(fp, "bar");
fflush(fp);
/*
* Can't use assert_stream() here since this should contain
* embedded null characters.
*/
if (len != 10)
printf("bad length %zd for zero-fill test\n", len);
else if (memcmp(buf, zerobuf, sizeof(zerobuf)) != 0)
printf("bad buffer for zero-fill test\n");
fseek(fp, 3, SEEK_SET);
fprintf(fp, " in ");
fflush(fp);
assert_stream("foo in ");
fseek(fp, 0, SEEK_END);
fflush(fp);
assert_stream("foo in bar");
rewind(fp);
if (fread(&c, sizeof(c), 1, fp) != 0)
printf("fread did not fail\n");
else if (!ferror(fp))
printf("error indicator not set after fread\n");
else
clearerr(fp);
fseek(fp, 4, SEEK_SET);
fprintf(fp, "bar baz");
fclose(fp);
assert_stream("foo bar baz");
free(buf);
}
static void
seek_tests(void)
{
FILE *fp;
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
if (fseeko(fp, (offset), (whence)) == 0) \
printf("fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
else if (errno != (error)) \
printf("fseeko(%s, %s) failed with %d rather than %s\n",\
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
} while (0)
#define SEEK_OK(offset, whence, result) do { \
if (fseeko(fp, (offset), (whence)) != 0) \
printf("fseeko(%s, %s) failed: %s\n", \
__STRING(offset), __STRING(whence), strerror(errno)); \
else if (ftello(fp) != (result)) \
printf("fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
} while (0)
SEEK_FAIL(-1, SEEK_SET, EINVAL);
SEEK_FAIL(-1, SEEK_CUR, EINVAL);
SEEK_FAIL(-1, SEEK_END, EINVAL);
fprintf(fp, "foo");
SEEK_OK(-1, SEEK_CUR, 2);
SEEK_OK(0, SEEK_SET, 0);
SEEK_OK(-1, SEEK_END, 2);
SEEK_OK(OFF_MAX - 1, SEEK_SET, OFF_MAX - 1);
SEEK_FAIL(2, SEEK_CUR, EOVERFLOW);
fclose(fp);
}
int
main(int ac, char **av)
{
open_group_test();
simple_tests();
seek_tests();
return (0);
}

10
tools/regression/lib/libc/stdio/test-open_memstream.t Normal file
View file

@ -0,0 +1,10 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

203
tools/regression/lib/libc/stdio/test-open_wmemstream.c Normal file
View file

@ -0,0 +1,203 @@
/*-
* Copyright (c) 2013 Advanced Computing Technologies LLC
* Written by: John H. Baldwin <jhb@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
static wchar_t *buf;
static size_t len;
static void
assert_stream(const wchar_t *contents)
{
if (wcslen(contents) != len)
printf("bad length %zd for \"%ls\"\n", len, contents);
else if (wcsncmp(buf, contents, wcslen(contents)) != 0)
printf("bad buffer \"%ls\" for \"%ls\"\n", buf, contents);
}
static void
open_group_test(void)
{
FILE *fp;
off_t eob;
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
fwprintf(fp, L"hello my world");
fflush(fp);
assert_stream(L"hello my world");
eob = ftello(fp);
rewind(fp);
fwprintf(fp, L"good-bye");
fseeko(fp, eob, SEEK_SET);
fclose(fp);
assert_stream(L"good-bye world");
free(buf);
}
static void
simple_tests(void)
{
static const wchar_t zerobuf[] =
{ L'f', L'o', L'o', 0, 0, 0, 0, L'b', L'a', L'r', 0 };
wchar_t c;
FILE *fp;
fp = open_wmemstream(&buf, NULL);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad length pointer");
fp = open_wmemstream(NULL, &len);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad buffer pointer");
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
fflush(fp);
assert_stream(L"");
if (fwide(fp, 0) <= 0)
printf("stream is not wide-oriented\n");
fwprintf(fp, L"fo");
fflush(fp);
assert_stream(L"fo");
fputwc(L'o', fp);
fflush(fp);
assert_stream(L"foo");
rewind(fp);
fflush(fp);
assert_stream(L"");
fseek(fp, 0, SEEK_END);
fflush(fp);
assert_stream(L"foo");
/*
* Test seeking out past the current end. Should zero-fill the
* intermediate area.
*/
fseek(fp, 4, SEEK_END);
fwprintf(fp, L"bar");
fflush(fp);
/*
* Can't use assert_stream() here since this should contain
* embedded null characters.
*/
if (len != 10)
printf("bad length %zd for zero-fill test\n", len);
else if (memcmp(buf, zerobuf, sizeof(zerobuf)) != 0)
printf("bad buffer for zero-fill test\n");
fseek(fp, 3, SEEK_SET);
fwprintf(fp, L" in ");
fflush(fp);
assert_stream(L"foo in ");
fseek(fp, 0, SEEK_END);
fflush(fp);
assert_stream(L"foo in bar");
rewind(fp);
if (fread(&c, sizeof(c), 1, fp) != 0)
printf("fread did not fail\n");
else if (!ferror(fp))
printf("error indicator not set after fread\n");
else
clearerr(fp);
fseek(fp, 4, SEEK_SET);
fwprintf(fp, L"bar baz");
fclose(fp);
assert_stream(L"foo bar baz");
free(buf);
}
static void
seek_tests(void)
{
FILE *fp;
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
if (fseeko(fp, (offset), (whence)) == 0) \
printf("fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
else if (errno != (error)) \
printf("fseeko(%s, %s) failed with %d rather than %s\n",\
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
} while (0)
#define SEEK_OK(offset, whence, result) do { \
if (fseeko(fp, (offset), (whence)) != 0) \
printf("fseeko(%s, %s) failed: %s\n", \
__STRING(offset), __STRING(whence), strerror(errno)); \
else if (ftello(fp) != (result)) \
printf("fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
} while (0)
SEEK_FAIL(-1, SEEK_SET, EINVAL);
SEEK_FAIL(-1, SEEK_CUR, EINVAL);
SEEK_FAIL(-1, SEEK_END, EINVAL);
fwprintf(fp, L"foo");
SEEK_OK(-1, SEEK_CUR, 2);
SEEK_OK(0, SEEK_SET, 0);
SEEK_OK(-1, SEEK_END, 2);
SEEK_OK(OFF_MAX - 1, SEEK_SET, OFF_MAX - 1);
SEEK_FAIL(2, SEEK_CUR, EOVERFLOW);
fclose(fp);
}
int
main(int ac, char **av)
{
open_group_test();
simple_tests();
seek_tests();
return (0);
}

10
tools/regression/lib/libc/stdio/test-open_wmemstream.t Normal file
View file

@ -0,0 +1,10 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable