libc/stdio/fmemopen.c

   1 /* Copyright (C) 2004       Manuel Novoa III    <mjn3@codepoet.org>
   2  *
   3  * GNU Library General Public License (LGPL) version 2 or later.
   4  *
   5  * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
   6  */
   7
   8 #include <features.h>
   9
  10 #ifdef __USE_GNU
  11 #include "_stdio.h"
  12
  13
  14 #ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
  15 #error no custom streams!
  16 #endif
  17
  18 typedef struct {
  19         size_t pos;
  20         size_t len;
  21         size_t eof;
  22         int dynbuf;
  23         unsigned char *buf;
  24         FILE *fp;
  25 } __fmo_cookie;
  26
  27 #define COOKIE ((__fmo_cookie *) cookie)
  28
  29 static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize)
  30 {
  31         size_t count = COOKIE->len - COOKIE->pos;
  32
  33         /* Note: 0 < bufsize < SSIZE_MAX because of _stdio_READ. */
  34         if (!count) {                           /* EOF! */
  35                 return 0;
  36         }
  37
  38         if (bufsize > count) {
  39                 bufsize = count;
  40         }
  41
  42         memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize);
  43         COOKIE->pos += bufsize;
  44
  45         return bufsize;
  46 }
  47
  48 static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize)
  49 {
  50         size_t count;
  51
  52         /* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */
  53
  54         /* If appending, need to seek to end of file!!!! */
  55         if (COOKIE->fp->__modeflags & __FLAG_APPEND) {
  56                 COOKIE->pos = COOKIE->eof;
  57         }
  58
  59         count = COOKIE->len - COOKIE->pos;
  60
  61         if (bufsize > count) {
  62                 bufsize = count;
  63                 if (count == 0) {               /* We're at the end of the buffer... */
  64                         __set_errno(EFBIG);
  65                         return -1;
  66                 }
  67         }
  68
  69         memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
  70         COOKIE->pos += bufsize;
  71
  72         if (COOKIE->pos > COOKIE->eof) {
  73                 COOKIE->eof = COOKIE->pos;
  74                 if (bufsize < count) {  /* New eof and still room in buffer? */
  75                         *(COOKIE->buf + COOKIE->pos) = 0;
  76                 }
  77         }
  78
  79         return bufsize;
  80 }
  81
  82 /* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */
  83 static int fmo_seek(register void *cookie, __offmax_t *pos, int whence)
  84 {
  85         __offmax_t p = *pos;
  86
  87         /* Note: fseek already checks that whence is legal, so don't check here
  88          * unless debugging. */
  89         assert(((unsigned int) whence) <= 2);
  90
  91         if (whence != SEEK_SET) {
  92                 p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof;
  93         }
  94
  95         /* Note: glibc only allows seeking in the buffer.  We'll actually restrict
  96          * to the data. */
  97         /* Check for offset < 0, offset > eof, or offset overflow... */
  98         if (((uintmax_t) p) > COOKIE->eof) {
  99                 return -1;
 100         }
 101
 102         COOKIE->pos = *pos = p;
 103         return 0;
 104 }
 105
 106 static int fmo_close(register void *cookie)
 107 {
 108         if (COOKIE->dynbuf) {
 109                 free(COOKIE->buf);
 110         }
 111         free(cookie);
 112         return 0;
 113 }
 114
 115 #undef COOKIE
 116
 117 static const cookie_io_functions_t _fmo_io_funcs = {
 118         fmo_read, fmo_write, fmo_seek, fmo_close
 119 };
 120
 121 /* TODO: If we have buffers enabled, it might be worthwile to add a pointer
 122  * to the FILE in the cookie and have read, write, and seek operate directly
 123  * on the buffer itself (ie replace the FILE buffer with the cookie buffer
 124  * and update FILE bufstart, etc. whenever we seek). */
 125
 126 FILE *fmemopen(void *s, size_t len, const char *modes)
 127 {
 128         FILE *fp;
 129         register __fmo_cookie *cookie;
 130         size_t i;
 131
 132         if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) {
 133                 cookie->len = len;
 134                 cookie->eof = cookie->pos = 0; /* pos and eof adjusted below. */
 135                 cookie->dynbuf = 0;
 136                 if (((cookie->buf = s) == NULL) && (len > 0)) {
 137                         if ((cookie->buf = malloc(len)) == NULL) {
 138                                 goto EXIT_cookie;
 139                         }
 140                         cookie->dynbuf = 1;
 141                         *cookie->buf = 0;       /* If we're appending, treat as empty file. */
 142                 }
 143
 144 #ifndef __BCC__
 145                 fp = fopencookie(cookie, modes, _fmo_io_funcs);
 146 #else
 147                 fp = fopencookie(cookie, modes, &_fmo_io_funcs);
 148 #endif
 149                 /* Note: We don't need to worry about locking fp in the thread case
 150                  * as the only possible access would be a close or flush with
 151                  * nothing currently in the FILE's write buffer. */
 152
 153                 if (fp != NULL) {
 154                         cookie->fp = fp;
 155                         if (fp->__modeflags & __FLAG_READONLY) {
 156                                 cookie->eof = len;
 157                         }
 158                         if ((fp->__modeflags & __FLAG_APPEND) && (len > 0)) {
 159                                 for (i = 0 ; i < len ; i++) {
 160                                         if (cookie->buf[i] == 0) {
 161                                                 break;
 162                                         }
 163                                 }
 164                                 cookie->eof = cookie->pos = i; /* Adjust eof and pos. */
 165                         }
 166
 167                         __STDIO_STREAM_VALIDATE(fp);
 168
 169                         return fp;
 170                 }
 171         }
 172
 173         if (!s) {
 174                 free(cookie->buf);
 175         }
 176  EXIT_cookie:
 177         free(cookie);
 178
 179         return NULL;
 180 }
 181 #endif