Index: lib/libc/stdio/fmemopen.c =================================================================== --- lib/libc/stdio/fmemopen.c (revision 246200) +++ lib/libc/stdio/fmemopen.c (working copy) @@ -1,32 +1,33 @@ /*- -Copyright (C) 2013 Pietro Cerutti + * Copyright (C) 2013 Pietro Cerutti + * + * 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 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 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. + */ -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 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 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 __FBSDID("$FreeBSD$"); #include +#include #include #include #include @@ -36,36 +37,36 @@ struct fmemopen_cookie { char *buf; /* pointer to the memory region */ - char own; /* did we allocate the buffer ourselves? */ + bool own; /* did we allocate the buffer ourselves? */ char bin; /* is this a binary buffer? */ size_t size; /* buffer length in bytes */ size_t len; /* data length in bytes */ size_t off; /* current offset into the buffer */ }; -static int fmemopen_read (void *cookie, char *buf, int nbytes); -static int fmemopen_write (void *cookie, const char *buf, int nbytes); -static fpos_t fmemopen_seek (void *cookie, fpos_t offset, int whence); -static int fmemopen_close (void *cookie); +static int fmemopen_read(void *cookie, char *buf, int nbytes); +static int fmemopen_write(void *cookie, const char *buf, int nbytes); +static fpos_t fmemopen_seek(void *cookie, fpos_t offset, int whence); +static int fmemopen_close(void *cookie); FILE * -fmemopen (void * __restrict buf, size_t size, const char * __restrict mode) +fmemopen(void * __restrict buf, size_t size, const char * __restrict mode) { struct fmemopen_cookie *ck; FILE *f; int flags, rc; - /* + /* * Retrieve the flags as used by open(2) from the mode argument, and * validate them. - * */ - rc = __sflags (mode, &flags); + */ + rc = __sflags(mode, &flags); if (rc == 0) { errno = EINVAL; return (NULL); } - /* + /* * There's no point in requiring an automatically allocated buffer * in write-only mode. */ @@ -74,8 +75,7 @@ return (NULL); } - /* Allocate a cookie. */ - ck = malloc (sizeof (struct fmemopen_cookie)); + ck = malloc(sizeof(struct fmemopen_cookie)); if (ck == NULL) { return (NULL); } @@ -86,9 +86,9 @@ /* Check whether we have to allocate the buffer ourselves. */ ck->own = ((ck->buf = buf) == NULL); if (ck->own) { - ck->buf = malloc (size); + ck->buf = malloc(size); if (ck->buf == NULL) { - free (ck); + free(ck); return (NULL); } } @@ -107,22 +107,22 @@ /* * The size of the current buffer contents is set depending on the * mode: - * + * * for append (text-mode), the position of the first NULL byte, or the * size of the buffer if none is found * * for append (binary-mode), the size of the buffer - * + * * for read, the size of the buffer - * + * * for write, 0 */ switch (mode[0]) { case 'a': if (ck->bin) { - /* - * This isn't useful, since the buffer isn't - * allowed to grow. + /* + * This isn't useful, since the buffer isn't allowed + * to grow. */ ck->off = ck->len = size; } else @@ -136,16 +136,15 @@ break; } - /* Actuall wrapper. */ - f = funopen ((void *)ck, + f = funopen(ck, flags & O_WRONLY ? NULL : fmemopen_read, flags & O_RDONLY ? NULL : fmemopen_write, fmemopen_seek, fmemopen_close); if (f == NULL) { if (ck->own) - free (ck->buf); - free (ck); + free(ck->buf); + free(ck); return (NULL); } @@ -153,13 +152,13 @@ * Turn off buffering, so a write past the end of the buffer * correctly returns a short object count. */ - setvbuf (f, (char *) NULL, _IONBF, 0); + setvbuf(f, NULL, _IONBF, 0); return (f); } static int -fmemopen_read (void *cookie, char *buf, int nbytes) +fmemopen_read(void *cookie, char *buf, int nbytes) { struct fmemopen_cookie *ck = cookie; @@ -169,7 +168,7 @@ if (nbytes == 0) return (0); - memcpy (buf, ck->buf + ck->off, nbytes); + memcpy(buf, ck->buf + ck->off, nbytes); ck->off += nbytes; @@ -177,7 +176,7 @@ } static int -fmemopen_write (void *cookie, const char *buf, int nbytes) +fmemopen_write(void *cookie, const char *buf, int nbytes) { struct fmemopen_cookie *ck = cookie; @@ -187,7 +186,7 @@ if (nbytes == 0) return (0); - memcpy (ck->buf + ck->off, buf, nbytes); + memcpy(ck->buf + ck->off, buf, nbytes); ck->off += nbytes; @@ -207,7 +206,7 @@ } static fpos_t -fmemopen_seek (void *cookie, fpos_t offset, int whence) +fmemopen_seek(void *cookie, fpos_t offset, int whence) { struct fmemopen_cookie *ck = cookie; @@ -246,14 +245,14 @@ } static int -fmemopen_close (void *cookie) +fmemopen_close(void *cookie) { struct fmemopen_cookie *ck = cookie; if (ck->own) - free (ck->buf); + free(ck->buf); - free (ck); + free(ck); return (0); } Index: tools/regression/lib/libc/stdio/test-fmemopen.c =================================================================== --- tools/regression/lib/libc/stdio/test-fmemopen.c (revision 246200) +++ tools/regression/lib/libc/stdio/test-fmemopen.c (working copy) @@ -38,7 +38,7 @@ #include void -test_preexisting () +test_preexisting() { /* * Use a pre-existing buffer. @@ -54,56 +54,56 @@ int rc; /* Open a FILE * using fmemopen. */ - fp = fmemopen (buf, sizeof(buf), "w"); - assert (fp != NULL); + fp = fmemopen(buf, sizeof(buf), "w"); + assert(fp != NULL); /* Write to the buffer. */ - nofw = fwrite (str, 1, sizeof(str), fp); - assert (nofw == sizeof(str)); + nofw = fwrite(str, 1, sizeof(str), fp); + assert(nofw == sizeof(str)); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); /* Re-open the FILE * to read back the data. */ - fp = fmemopen (buf, sizeof(buf), "r"); - assert (fp != NULL); + fp = fmemopen(buf, sizeof(buf), "r"); + assert(fp != NULL); /* Read from the buffer. */ - bzero (buf2, sizeof(buf2)); - nofr = fread (buf2, 1, sizeof(buf2), fp); - assert (nofr == sizeof(buf2)); + bzero(buf2, sizeof(buf2)); + nofr = fread(buf2, 1, sizeof(buf2), fp); + assert(nofr == sizeof(buf2)); /* * Since a write on a FILE * retrieved by fmemopen * will add a '\0' (if there's space), we can check * the strings for equality. */ - assert (strcmp(str, buf2) == 0); + assert(strcmp(str, buf2) == 0); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); /* Now open a FILE * on the first 4 bytes of the string. */ - fp = fmemopen (str, 4, "w"); - assert (fp != NULL); + fp = fmemopen(str, 4, "w"); + assert(fp != NULL); /* * Try to write more bytes than we shoud, we'll get a short count (4). */ - nofw = fwrite (str2, 1, sizeof(str2), fp); - assert (nofw == 4); + nofw = fwrite(str2, 1, sizeof(str2), fp); + assert(nofw == 4); /* Close the FILE *. */ - rc = fclose (fp); + rc = fclose(fp); /* Check that the string was not modified after the first 4 bytes. */ - assert (strcmp (str, str3) == 0); + assert(strcmp(str, str3) == 0); } void -test_autoalloc () +test_autoalloc() { /* * Let fmemopen allocate the buffer. @@ -116,32 +116,32 @@ int rc; /* Open a FILE * using fmemopen. */ - fp = fmemopen (NULL, 512, "w+"); - assert (fp != NULL); + fp = fmemopen(NULL, 512, "w+"); + assert(fp != NULL); /* fill the buffer */ for (i = 0; i < 512; i++) { - nofw = fwrite ("a", 1, 1, fp); - assert (nofw == 1); + nofw = fwrite("a", 1, 1, fp); + assert(nofw == 1); } /* Get the current position into the stream. */ - pos = ftell (fp); - assert (pos == 512); + pos = ftell(fp); + assert(pos == 512); /* * Try to write past the end, we should get a short object count (0) */ - nofw = fwrite ("a", 1, 1, fp); - assert (nofw == 0); + nofw = fwrite("a", 1, 1, fp); + assert(nofw == 0); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); } void -test_data_length () +test_data_length() { /* * Here we test that a read operation doesn't go past the end of the @@ -158,57 +158,57 @@ int rc; /* Open a FILE * for updating our buffer. */ - fp = fmemopen (buf, sizeof(buf), "w+"); - assert (fp != NULL); + fp = fmemopen(buf, sizeof(buf), "w+"); + assert(fp != NULL); /* Write our string into the buffer. */ - nofw = fwrite (str, 1, sizeof(str), fp); - assert (nofw == sizeof(str)); + nofw = fwrite(str, 1, sizeof(str), fp); + assert(nofw == sizeof(str)); /* * Now seek to the end and check that ftell * gives us sizeof(str). */ - rc = fseek (fp, 0, SEEK_END); - assert (rc == 0); - pos = ftell (fp); - assert (pos == sizeof(str)); + rc = fseek(fp, 0, SEEK_END); + assert(rc == 0); + pos = ftell(fp); + assert(pos == sizeof(str)); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); /* Reopen the buffer for appending. */ - fp = fmemopen (buf, sizeof(buf), "a+"); - assert (fp != NULL); + fp = fmemopen(buf, sizeof(buf), "a+"); + assert(fp != NULL); /* We should now be writing after the first string. */ - nofw = fwrite (str2, 1, sizeof(str2), fp); - assert (nofw == sizeof(str2)); + nofw = fwrite(str2, 1, sizeof(str2), fp); + assert(nofw == sizeof(str2)); /* Rewind the FILE *. */ - rc = fseek (fp, 0, SEEK_SET); - assert (rc == 0); + rc = fseek(fp, 0, SEEK_SET); + assert(rc == 0); /* Make sure we're at the beginning. */ - pos = ftell (fp); - assert (pos == 0); + pos = ftell(fp); + assert(pos == 0); /* Read the whole buffer. */ - nofr = fread (str3, 1, sizeof(buf), fp); - assert (nofr == sizeof(str3)); + nofr = fread(str3, 1, sizeof(buf), fp); + assert(nofr == sizeof(str3)); /* Make sure the two strings are there. */ - assert (strncmp (str3, str, sizeof(str) - 1) == 0); - assert (strncmp (str3 + sizeof(str) - 1, str2, sizeof(str2)) == 0); + assert(strncmp(str3, str, sizeof(str) - 1) == 0); + assert(strncmp(str3 + sizeof(str) - 1, str2, sizeof(str2)) == 0); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); } void -test_binary () +test_binary() { /* * Make sure that NULL bytes are never appended when opening a buffer @@ -222,31 +222,31 @@ int rc, i; /* Pre-fill the buffer. */ - memset (buf, 'A', sizeof(buf)); + memset(buf, 'A', sizeof(buf)); /* Open a FILE * in binary mode. */ - fp = fmemopen (buf, sizeof(buf), "w+b"); - assert (fp != NULL); + fp = fmemopen(buf, sizeof(buf), "w+b"); + assert(fp != NULL); /* Write some data into it. */ - nofw = fwrite (str, 1, strlen(str), fp); - assert (nofw == strlen(str)); + nofw = fwrite(str, 1, strlen(str), fp); + assert(nofw == strlen(str)); /* Make sure that the buffer doesn't contain any NULL bytes. */ for (i = 0; i < sizeof(buf); i++) - assert (buf[i] != '\0'); + assert(buf[i] != '\0'); /* Close the FILE *. */ - rc = fclose (fp); - assert (rc == 0); + rc = fclose(fp); + assert(rc == 0); } int -main (void) +main(void) { - test_autoalloc (); - test_preexisting (); - test_data_length (); - test_binary (); + test_autoalloc(); + test_preexisting(); + test_data_length(); + test_binary(); return (0); }