source/lib/xfile.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    stdio replacement
   4    Copyright (C) Andrew Tridgell 2001
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 /*
  21   stdio is very convenient, but on some systems the file descriptor
  22   in FILE* is 8 bits, so it fails when more than 255 files are open.
  23
  24   XFILE replaces stdio. It is less efficient, but at least it works
  25   when you have lots of files open
  26
  27   The main restriction on XFILE is that it doesn't support seeking,
  28   and doesn't support O_RDWR. That keeps the code simple.
  29 */
  30
  31 #include "includes.h"
  32
  33 #define XBUFSIZE BUFSIZ
  34
  35 static XFILE _x_stdin =  { 0, NULL, NULL, XBUFSIZE, 0, O_RDONLY, X_IOFBF, 0 };
  36 static XFILE _x_stdout = { 1, NULL, NULL, XBUFSIZE, 0, O_WRONLY, X_IOLBF, 0 };
  37 static XFILE _x_stderr = { 2, NULL, NULL, 0, 0, O_WRONLY, X_IONBF, 0 };
  38
  39 XFILE *x_stdin = &_x_stdin;
  40 XFILE *x_stdout = &_x_stdout;
  41 XFILE *x_stderr = &_x_stderr;
  42
  43 #define X_FLAG_EOF 1
  44 #define X_FLAG_ERROR 2
  45 #define X_FLAG_EINVAL 3
  46
  47 /* simulate setvbuf() */
  48 int x_setvbuf(XFILE *f, char *buf, int mode, size_t size)
  49 {
  50         x_fflush(f);
  51         if (f->bufused) return -1;
  52
  53         /* on files being read full buffering is the only option */
  54         if ((f->open_flags & O_ACCMODE) == O_RDONLY) {
  55                 mode = X_IOFBF;
  56         }
  57
  58         /* destroy any earlier buffer */
  59         SAFE_FREE(f->buf);
  60         f->buf = 0;
  61         f->bufsize = 0;
  62         f->next = NULL;
  63         f->bufused = 0;
  64         f->buftype = mode;
  65
  66         if (f->buftype == X_IONBF) return 0;
  67
  68         /* if buffering then we need some size */
  69         if (size == 0) size = XBUFSIZE;
  70
  71         f->bufsize = size;
  72         f->bufused = 0;
  73
  74         return 0;
  75 }
  76
  77 /* allocate the buffer */
  78 static int x_allocate_buffer(XFILE *f)
  79 {
  80         if (f->buf) return 1;
  81         if (f->bufsize == 0) return 0;
  82         f->buf = (char *)SMB_MALLOC(f->bufsize);
  83         if (!f->buf) return 0;
  84         f->next = f->buf;
  85         return 1;
  86 }
  87
  88
  89 /* this looks more like open() than fopen(), but that is quite deliberate.
  90    I want programmers to *think* about O_EXCL, O_CREAT etc not just
  91    get them magically added
  92 */
  93 XFILE *x_fopen(const char *fname, int flags, mode_t mode)
  94 {
  95         XFILE *ret;
  96
  97         ret = SMB_MALLOC_P(XFILE);
  98         if (!ret) {
  99                 return NULL;
 100         }
 101
 102         memset(ret, 0, sizeof(XFILE));
 103
 104         if ((flags & O_ACCMODE) == O_RDWR) {
 105                 /* we don't support RDWR in XFILE - use file
 106                    descriptors instead */
 107                 SAFE_FREE(ret);
 108                 errno = EINVAL;
 109                 return NULL;
 110         }
 111
 112         ret->open_flags = flags;
 113
 114         ret->fd = sys_open(fname, flags, mode);
 115         if (ret->fd == -1) {
 116                 SAFE_FREE(ret);
 117                 return NULL;
 118         }
 119
 120         x_setvbuf(ret, NULL, X_IOFBF, XBUFSIZE);
 121
 122         return ret;
 123 }
 124
 125 XFILE *x_fdup(const XFILE *f)
 126 {
 127         XFILE *ret;
 128         int fd;
 129
 130         fd = dup(x_fileno(f));
 131         if (fd < 0) {
 132                 return NULL;
 133         }
 134
 135         ret = SMB_CALLOC_ARRAY(XFILE, 1);
 136         if (!ret) {
 137                 close(fd);
 138                 return NULL;
 139         }
 140
 141         ret->fd = fd;
 142         ret->open_flags = f->open_flags;
 143         x_setvbuf(ret, NULL, X_IOFBF, XBUFSIZE);
 144         return ret;
 145 }
 146
 147 /* simulate fclose() */
 148 int x_fclose(XFILE *f)
 149 {
 150         int ret;
 151
 152         /* make sure we flush any buffered data */
 153         x_fflush(f);
 154
 155         ret = close(f->fd);
 156         f->fd = -1;
 157         if (f->buf) {
 158                 /* make sure data can't leak into a later malloc */
 159                 memset(f->buf, 0, f->bufsize);
 160                 SAFE_FREE(f->buf);
 161         }
 162         /* check the file descriptor given to the function is NOT one of the static
 163          * descriptor of this libreary or we will free unallocated memory
 164          * --sss */
 165         if (f != x_stdin && f != x_stdout && f != x_stderr) {
 166                 SAFE_FREE(f);
 167         }
 168         return ret;
 169 }
 170
 171 /* simulate fwrite() */
 172 size_t x_fwrite(const void *p, size_t size, size_t nmemb, XFILE *f)
 173 {
 174         ssize_t ret;
 175         size_t total=0;
 176
 177         /* we might be writing unbuffered */
 178         if (f->buftype == X_IONBF ||
 179             (!f->buf && !x_allocate_buffer(f))) {
 180                 ret = write(f->fd, p, size*nmemb);
 181                 if (ret == -1) return -1;
 182                 return ret/size;
 183         }
 184
 185
 186         while (total < size*nmemb) {
 187                 size_t n = f->bufsize - f->bufused;
 188                 n = MIN(n, (size*nmemb)-total);
 189
 190                 if (n == 0) {
 191                         /* it's full, flush it */
 192                         x_fflush(f);
 193                         continue;
 194                 }
 195
 196                 memcpy(f->buf + f->bufused, total+(const char *)p, n);
 197                 f->bufused += n;
 198                 total += n;
 199         }
 200
 201         /* when line buffered we need to flush at the last linefeed. This can
 202            flush a bit more than necessary, but that is harmless */
 203         if (f->buftype == X_IOLBF && f->bufused) {
 204                 int i;
 205                 for (i=(size*nmemb)-1; i>=0; i--) {
 206                         if (*(i+(const char *)p) == '\n') {
 207                                 x_fflush(f);
 208                                 break;
 209                         }
 210                 }
 211         }
 212
 213         return total/size;
 214 }
 215
 216 /* thank goodness for asprintf() */
 217  int x_vfprintf(XFILE *f, const char *format, va_list ap)
 218 {
 219         char *p;
 220         int len, ret;
 221         va_list ap2;
 222
 223         VA_COPY(ap2, ap);
 224
 225         len = vasprintf(&p, format, ap2);
 226         if (len <= 0) return len;
 227         ret = x_fwrite(p, 1, len, f);
 228         SAFE_FREE(p);
 229         return ret;
 230 }
 231
 232  int x_fprintf(XFILE *f, const char *format, ...)
 233 {
 234         va_list ap;
 235         int ret;
 236
 237         va_start(ap, format);
 238         ret = x_vfprintf(f, format, ap);
 239         va_end(ap);
 240         return ret;
 241 }
 242
 243 /* at least fileno() is simple! */
 244 int x_fileno(const XFILE *f)
 245 {
 246         return f->fd;
 247 }
 248
 249 /* simulate fflush() */
 250 int x_fflush(XFILE *f)
 251 {
 252         int ret;
 253
 254         if (f->flags & X_FLAG_ERROR) return -1;
 255
 256         if ((f->open_flags & O_ACCMODE) != O_WRONLY) {
 257                 errno = EINVAL;
 258                 return -1;
 259         }
 260
 261         if (f->bufused == 0 || !f->buf) return 0;
 262
 263         ret = write(f->fd, f->buf, f->bufused);
 264         if (ret == -1) return -1;
 265
 266         f->bufused -= ret;
 267         if (f->bufused > 0) {
 268                 f->flags |= X_FLAG_ERROR;
 269                 memmove(f->buf, ret + (char *)f->buf, f->bufused);
 270                 return -1;
 271         }
 272
 273         return 0;
 274 }
 275
 276 /* simulate setbuffer() */
 277 void x_setbuffer(XFILE *f, char *buf, size_t size)
 278 {
 279         x_setvbuf(f, buf, buf?X_IOFBF:X_IONBF, size);
 280 }
 281
 282 /* simulate setbuf() */
 283 void x_setbuf(XFILE *f, char *buf)
 284 {
 285         x_setvbuf(f, buf, buf?X_IOFBF:X_IONBF, XBUFSIZE);
 286 }
 287
 288 /* simulate setlinebuf() */
 289 void x_setlinebuf(XFILE *f)
 290 {
 291         x_setvbuf(f, NULL, X_IOLBF, 0);
 292 }
 293
 294
 295 /* simulate feof() */
 296 int x_feof(XFILE *f)
 297 {
 298         if (f->flags & X_FLAG_EOF) return 1;
 299         return 0;
 300 }
 301
 302 /* simulate ferror() */
 303 int x_ferror(XFILE *f)
 304 {
 305         if (f->flags & X_FLAG_ERROR) return 1;
 306         return 0;
 307 }
 308
 309 /* fill the read buffer */
 310 static void x_fillbuf(XFILE *f)
 311 {
 312         int n;
 313
 314         if (f->bufused) return;
 315
 316         if (!f->buf && !x_allocate_buffer(f)) return;
 317
 318         n = read(f->fd, f->buf, f->bufsize);
 319         if (n <= 0) return;
 320         f->bufused = n;
 321         f->next = f->buf;
 322 }
 323
 324 /* simulate fgetc() */
 325 int x_fgetc(XFILE *f)
 326 {
 327         int ret;
 328
 329         if (f->flags & (X_FLAG_EOF | X_FLAG_ERROR)) return EOF;
 330
 331         if (f->bufused == 0) x_fillbuf(f);
 332
 333         if (f->bufused == 0) {
 334                 f->flags |= X_FLAG_EOF;
 335                 return EOF;
 336         }
 337
 338         ret = *(unsigned char *)(f->next);
 339         f->next++;
 340         f->bufused--;
 341         return ret;
 342 }
 343
 344 /* simulate fread */
 345 size_t x_fread(void *p, size_t size, size_t nmemb, XFILE *f)
 346 {
 347         size_t total = 0;
 348         while (total < size*nmemb) {
 349                 int c = x_fgetc(f);
 350                 if (c == EOF) break;
 351                 (total+(char *)p)[0] = (char)c;
 352                 total++;
 353         }
 354         return total/size;
 355 }
 356
 357 /* simulate fgets() */
 358 char *x_fgets(char *s, int size, XFILE *stream)
 359 {
 360         char *s0 = s;
 361         int l = size;
 362         while (l>1) {
 363                 int c = x_fgetc(stream);
 364                 if (c == EOF) break;
 365                 *s++ = (char)c;
 366                 l--;
 367                 if (c == '\n') break;
 368         }
 369         if (l==size || x_ferror(stream)) {
 370                 return 0;
 371         }
 372         *s = 0;
 373         return s0;
 374 }
 375
 376 /* trivial seek, works only for SEEK_SET and SEEK_END if SEEK_CUR is
 377  * set then an error is returned */
 378 off_t x_tseek(XFILE *f, off_t offset, int whence)
 379 {
 380         if (f->flags & X_FLAG_ERROR)
 381                 return -1;
 382
 383         /* only SEEK_SET and SEEK_END are supported */
 384         /* SEEK_CUR needs internal offset counter */
 385         if (whence != SEEK_SET && whence != SEEK_END) {
 386                 f->flags |= X_FLAG_EINVAL;
 387                 errno = EINVAL;
 388                 return -1;
 389         }
 390
 391         /* empty the buffer */
 392         switch (f->open_flags & O_ACCMODE) {
 393         case O_RDONLY:
 394                 f->bufused = 0;
 395                 break;
 396         case O_WRONLY:
 397                 if (x_fflush(f) != 0)
 398                         return -1;
 399                 break;
 400         default:
 401                 errno = EINVAL;
 402                 return -1;
 403         }
 404
 405         f->flags &= ~X_FLAG_EOF;
 406         return (off_t)sys_lseek(f->fd, offset, whence);
 407 }