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