/* Copyright (C) 2002 Manuel Novoa III * My stdio library for linux and (soon) elks. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! * * This code is currently under development. Also, I plan to port * it to elks which is a 16-bit environment with a fairly limited * compiler. Therefore, please refrain from modifying this code * and, instead, pass any bug-fixes, etc. to me. Thanks. Manuel * * ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */ /* 8-05-2002 * Changed fflush() behavior to no-op for r/w streams in read-mode. * This falls under undefined behavior wrt ANSI/ISO C99, but * SUSv3 seems to treat it as a no-op and it occurs in some apps. * Fixed a problem with _stdio_fwrite() not checking for underlying * write() failures. * Fixed both _stdio_fwrite() and _stdio_fread() to make sure that * the putc and getc macros were disabled if the stream was in * and error state. * The above changes should take care of a problem initially reported * by "Steven J. Hill" . * * 8-25-2002 * Changed fclose behavior when custom streams were enabled. Previously, * the cookie pointer was set to NULL as a debugging aid. However, * some of the perl 5.8 test rely on being able to close stderr and * still try writing to it. So now, the cookie pointer and handler * function pointers are set to that it is a "normal" file with a * file descriptor of -1. Note: The cookie pointer is reset to NULL * if the FILE struct is free'd by fclose. * * Nov 21, 2002 * Added internal function _wstdio_fwrite. * Jan 3, 2003 * Fixed a bug in _wstdio_fwrite. * * Jan 22, 2003 * Fixed a bug related file position in append mode. _stdio_fwrite now * seeks to the end of the stream when append mode is set and we are * transitioning to write mode, so that subsequent ftell() return * values are correct. * Also fix _stdio_fopen to support fdopen() with append specified when * the underlying file didn't have O_APPEND set. It now sets the * O_APPEND flag as recommended by SUSv3 and is done by glibc. * * May 15, 2003 * Modify __stdio_fread to deal with fake streams used by *sscanf. * Set EOF to end of buffer when fmemopen used on a readonly stream. * Note: I really need to run some tests on this to see what the * glibc code does in each case. * * Sept 21, 2003 * Modify _stdio_READ to conform with C99, as stdio input behavior upon * encountering EOF changed with Defect Report #141. In the current * standard, the stream's EOF indicator is "sticky". Once it is set, * all further input from the stream should fail until the application * explicitly clears the EOF indicator (clearerr(), file positioning), * even if more data becomes available. * Fixed a bug in fgets. Wasn't checking for read errors. * Minor thread locking optimizations to avoid some unnecessary locking. * Remove the explicit calls to __builtin_* funcs, as we really need to * implement a more general solution. */ /* Before we include anything, convert L_ctermid to L_ctermid_function * and undef L_ctermid if defined. This is necessary as L_ctermid is * a SUSv3 standard macro defined in stdio.h. */ #ifdef L_ctermid #define L_ctermid_function #undef L_ctermid #endif #define _ISOC99_SOURCE /* for ULLONG primarily... */ #define _GNU_SOURCE #define _STDIO_UTILITY /* for _stdio_fdout and _uintmaxtostr. */ #include #include #include #include #include #include #include #include #include #include #include #include #ifndef O_LARGEFILE /* uClibc undefines this if no large file support. */ #ifdef __STDIO_LARGE_FILES #error missing define for O_LARGEFILE! #endif #define O_LARGEFILE 0 #endif /**********************************************************************/ /* First deal with some build issues... */ #ifndef __STDIO_THREADSAFE /* Just build empty object files if any of these were defined. */ /* Note though that we do keep the various *_unlocked names as aliases. */ #undef L___fsetlocking #undef L___flockfile #undef L___ftrylockfile #undef L___funlockfile #endif #ifndef __STDIO_LARGE_FILES /* Just build empty object files if any of these were defined. */ #undef L_fopen64 #undef L_freopen64 #undef L_ftello64 #undef L_fseeko64 #undef L_fsetpos64 #undef L_fgetpos64 #endif /**********************************************************************/ #ifndef __STDIO_THREADSAFE #if defined(__BCC__) && 0 #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \ asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \ RETURNTYPE NAME PARAMS #else #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \ strong_alias(NAME,NAME##_unlocked) \ RETURNTYPE NAME PARAMS #endif #define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream) #if defined(__BCC__) && 0 #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \ asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \ void NAME PARAMS #else #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \ strong_alias(NAME,NAME##_unlocked) \ void NAME PARAMS #endif #define __STDIO_THREADLOCK_OPENLIST #define __STDIO_THREADUNLOCK_OPENLIST #else /* __STDIO_THREADSAFE */ #include #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \ RETURNTYPE NAME PARAMS \ { \ RETURNTYPE retval; \ __STDIO_THREADLOCK(STREAM); \ retval = NAME##_unlocked ARGS ; \ __STDIO_THREADUNLOCK(STREAM); \ return retval; \ } \ RETURNTYPE NAME##_unlocked PARAMS #define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream) #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \ void NAME PARAMS \ { \ __STDIO_THREADLOCK(stream); \ NAME##_unlocked ARGS ; \ __STDIO_THREADUNLOCK(stream); \ } \ void NAME##_unlocked PARAMS #define __STDIO_THREADLOCK_OPENLIST \ pthread_mutex_lock(&_stdio_openlist_lock) #define __STDIO_THREADUNLOCK_OPENLIST \ pthread_mutex_unlock(&_stdio_openlist_lock) #define __STDIO_THREADTRYLOCK_OPENLIST \ pthread_mutex_trylock(&_stdio_openlist_lock) #endif /* __STDIO_THREADSAFE */ /**********************************************************************/ #ifdef __STDIO_WIDE #define __STDIO_FILE_INIT_UNGOT { 0, 0 }, { 0, 0 }, #else #define __STDIO_FILE_INIT_UNGOT { 0, 0 }, #endif #ifdef __STDIO_GETC_MACRO #define __STDIO_FILE_INIT_BUFGETC(x) x, #else #define __STDIO_FILE_INIT_BUFGETC(x) #endif #ifdef __STDIO_PUTC_MACRO #define __STDIO_FILE_INIT_BUFPUTC(x) x, #else #define __STDIO_FILE_INIT_BUFPUTC(x) #endif #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) #define __STDIO_FILE_INIT_NEXT(next) (next), #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ #define __STDIO_FILE_INIT_NEXT(next) #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ #ifdef __STDIO_BUFFERS #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \ (buf), (buf)+(bufsize), (buf), (buf), #else #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) #endif #ifdef __STDIO_GLIBC_CUSTOM_STREAMS #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \ &((stream).filedes), { _cs_read, _cs_write, NULL, _cs_close }, #else #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) #endif #ifdef __STDIO_MBSTATE #define __STDIO_FILE_INIT_MBSTATE \ { 0, 0 }, #else #define __STDIO_FILE_INIT_MBSTATE #endif #ifdef __STDIO_THREADSAFE #define __STDIO_FILE_INIT_THREADSAFE \ 0, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP, #else #define __STDIO_FILE_INIT_THREADSAFE #endif #define __STDIO_INIT_FILE_STRUCT(stream, flags, filedes, next, buf, bufsize) \ { (flags), \ __STDIO_FILE_INIT_UNGOT \ (filedes), \ __STDIO_FILE_INIT_NEXT(next) \ __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \ __STDIO_FILE_INIT_BUFGETC((buf)) \ __STDIO_FILE_INIT_BUFPUTC((buf)) \ __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \ __STDIO_FILE_INIT_MBSTATE \ __STDIO_FILE_INIT_THREADSAFE \ } /* TODO: mbstate and builtin buf */ #ifdef __STDIO_GLIBC_CUSTOM_STREAMS /* TODO -- what does glibc do for undefined funcs? errno set? */ #define __READ(STREAMPTR,BUF,SIZE) \ ((((STREAMPTR)->gcs.read) == NULL) ? -1 : \ (((STREAMPTR)->gcs.read)((STREAMPTR)->cookie,(BUF),(SIZE)))) #define __WRITE(STREAMPTR,BUF,SIZE) \ ((((STREAMPTR)->gcs.write) == NULL) ? -1 : \ (((STREAMPTR)->gcs.write)((STREAMPTR)->cookie,(BUF),(SIZE)))) #define __CLOSE(STREAMPTR) \ ((((STREAMPTR)->gcs.close) == NULL) ? 0 : \ (((STREAMPTR)->gcs.close)((STREAMPTR)->cookie))) #else /* __STDIO_GLIBC_CUSTOM_STREAMS */ #define __READ(STREAMPTR,BUF,SIZE) \ (read((STREAMPTR)->filedes,(BUF),(SIZE))) #define __WRITE(STREAMPTR,BUF,SIZE) \ (write((STREAMPTR)->filedes,(BUF),(SIZE))) #define __CLOSE(STREAMPTR) \ (close((STREAMPTR)->filedes)) #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ /**********************************************************************/ /* POSIX functions */ /**********************************************************************/ #ifdef L_getw /* SUSv2 Legacy function -- need not be reentrant. */ int getw(FILE *stream) { int aw[1]; #ifdef __STDIO_WIDE return (fread_unlocked((void *)aw, sizeof(int), 1, stream) > 0) ? (*aw) : EOF; #else /* __STDIO_WIDE */ return (_stdio_fread((unsigned char *)(aw), sizeof(int), stream) == sizeof(int)) ? (*aw) : EOF; #endif /* __STDIO_WIDE */ } #endif /**********************************************************************/ #ifdef L_putw /* SUSv2 Legacy function -- need not be reentrant. */ int putw(int w, FILE *stream) { int aw[1]; *aw = w; /* In case 'w' is in a register... */ #ifdef __STDIO_WIDE return (fwrite_unlocked((void *)aw, sizeof(int), 1, stream) == 1) ? 0 : EOF; #else /* __STDIO_WIDE */ return (_stdio_fwrite((unsigned char *)aw, sizeof(int), stream) == sizeof(int)) ? 0 : EOF; #endif /* __STDIO_WIDE */ } #endif /**********************************************************************/ #ifdef L_fileno /* Reentrancy handled by UNLOCKED() macro. */ UNLOCKED(int,fileno,(register FILE *stream),(stream)) { #ifdef __STDIO_GLIBC_CUSTOM_STREAMS return ( (stream && (stream->cookie == &(stream->filedes)) && (stream->filedes >= 0)) ? stream->filedes : (__set_errno(EBADF), -1) ); #else /* __STDIO_GLIBC_CUSTOM_STREAMS */ return ((stream && stream->filedes >= 0)) ? stream->filedes : (__set_errno(EBADF), -1); #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ } #endif /**********************************************************************/ #ifdef L_fdopen /* No reentrancy issues. */ FILE *fdopen(int filedes, const char *mode) { register char *cur_mode; /* TODO -- use intptr_t?? (also fopencookie) */ return (((int)(cur_mode = (char *) fcntl(filedes, F_GETFL))) != -1) ? _stdio_fopen(cur_mode, mode, NULL, filedes) : NULL; } #endif /**********************************************************************/ #ifdef L_fopen64 /* No reentrancy issues. */ FILE *fopen64(const char * __restrict filename, const char * __restrict mode) { return _stdio_fopen(filename, mode, NULL, -2); } #endif /**********************************************************************/ #ifdef L_ctermid_function /* Not required to be reentrant. */ char *ctermid(register char *s) { static char sbuf[L_ctermid]; #ifdef __BCC__ /* Currently elks doesn't support /dev/tty. */ if (!s) { s = sbuf; } *s = 0; return s; #else /* glibc always returns /dev/tty for linux. */ return strcpy((s ? s : sbuf), "/dev/tty"); #endif } #endif /**********************************************************************/ /* BSD functions */ /**********************************************************************/ #ifdef L_setbuffer /* No reentrancy issues. */ void setbuffer(FILE * __restrict stream, register char * __restrict buf, size_t size) { #ifdef __STDIO_BUFFERS setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size); #else /* __STDIO_BUFFERS */ /* Nothing to do. */ #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ #ifdef L_setlinebuf /* No reentrancy issues. */ void setlinebuf(FILE * __restrict stream) { #ifdef __STDIO_BUFFERS setvbuf(stream, NULL, _IOLBF, (size_t) 0); #else /* __STDIO_BUFFERS */ /* Nothing to do. */ #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ /* GLIBC functions */ /**********************************************************************/ #ifdef L_fcloseall /* NOTE: GLIBC difference!!! -- fcloseall * According to the info pages, glibc actually fclose()s all open files. * Apparently, glibc's new version only fflush()s and unbuffers all * writing streams to cope with unordered destruction of c++ static * objects. Here we implement the old behavior as default. */ /* Not reentrant. */ int fcloseall (void) { #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) register FILE *stream; int rv; _stdio_term(); /* Let _stdio_term() do all the work. */ rv = 0; for (stream = _stdio_openlist ; stream ; stream = stream->nextopen) { if (stream->modeflags & (__FLAG_WRITING|__FLAG_ERROR)) { /* TODO -- is this correct? Maybe ferror set before flush... * could check if pending writable but what if term unbuffers? * in that case, could clear error flag... */ rv = EOF; /* Only care about failed writes. */ } } /* Make sure _stdio_term() does nothing on exit. */ _stdio_openlist = NULL; return rv; #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ return 0; #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ } #endif /**********************************************************************/ #ifdef L_fmemopen #ifdef __STDIO_GLIBC_CUSTOM_STREAMS typedef struct { size_t pos; size_t len; size_t eof; int dynbuf; unsigned char *buf; FILE *fp; } __fmo_cookie; #define COOKIE ((__fmo_cookie *) cookie) static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize) { size_t count = COOKIE->len - COOKIE->pos; /* Note: 0 < bufsize < SSIZE_MAX because of _stdio_READ. */ if (!count) { /* EOF! */ return 0; } if (bufsize > count) { bufsize = count; } #if 1 /* TODO - choose code option */ memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize); COOKIE->pos += bufsize; #else { register char *p = COOKIE->buf + COOKIE->pos; count = bufsize; while (count) { *buf++ = *p++; --count; } COOKIE->pos += bufsize; } #endif return bufsize; } static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize) { size_t count; /* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */ /* If appending, need to seek to end of file!!!! */ if (COOKIE->fp->modeflags & __FLAG_APPEND) { COOKIE->pos = COOKIE->eof; } count = COOKIE->len - COOKIE->pos; if (bufsize > count) { bufsize = count; if (count == 0) { /* We're at the end of the buffer... */ __set_errno(EFBIG); return -1; } } #if 1 /* TODO - choose code option */ memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); COOKIE->pos += bufsize; if (COOKIE->pos > COOKIE->eof) { COOKIE->eof = COOKIE->pos; if (bufsize < count) { /* New eof and still room in buffer? */ *(COOKIE->buf + COOKIE->pos) = 0; } } #else { register char *p = COOKIE->buf + COOKIE->pos; size_t i = bufsize; while (i > 0) { *p++ = *buf++; --i; } COOKIE->pos += bufsize; if (COOKIE->pos > COOKIE->eof) { COOKIE->eof = COOKIE->pos; if (bufsize < count) { /* New eof and still room in buffer? */ *p = 0; } } } #endif return bufsize; } /* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */ static int fmo_seek(register void *cookie, __offmax_t *pos, int whence) { __offmax_t p = *pos; /* Note: fseek already checks that whence is legal, so don't check here * unless debugging. */ assert(((unsigned int) whence) <= 2); if (whence != SEEK_SET) { p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof; } /* Note: glibc only allows seeking in the buffer. We'll actually restrict * to the data. */ /* Check for offset < 0, offset > eof, or offset overflow... */ if (((uintmax_t) p) > COOKIE->eof) { return -1; } COOKIE->pos = *pos = p; return 0; } static int fmo_close(register void *cookie) { if (COOKIE->dynbuf) { free(COOKIE->buf); } free(cookie); return 0; } #undef COOKIE static const cookie_io_functions_t _fmo_io_funcs = { fmo_read, fmo_write, fmo_seek, fmo_close }; /* TODO: If we have buffers enabled, it might be worthwile to add a pointer * to the FILE in the cookie and have read, write, and seek operate directly * on the buffer itself (ie replace the FILE buffer with the cookie buffer * and update FILE bufstart, etc. whenever we seek). */ FILE *fmemopen(void *s, size_t len, const char *modes) { FILE *fp; register __fmo_cookie *cookie; size_t i; if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) { cookie->len = len; cookie->eof = cookie->pos = 0; /* pos and eof adjusted below. */ cookie->dynbuf = 0; if (((cookie->buf = s) == NULL) && (len > 0)) { if ((cookie->buf = malloc(len)) == NULL) { goto EXIT_cookie; } cookie->dynbuf = 1; *cookie->buf = 0; /* If we're appending, treat as empty file. */ } #ifndef __BCC__ fp = fopencookie(cookie, modes, _fmo_io_funcs); #else fp = fopencookie(cookie, modes, &_fmo_io_funcs); #endif /* Note: We don't need to worry about locking fp in the thread case * as the only possible access would be a close or flush with * nothing currently in the FILE's write buffer. */ if (fp != NULL) { cookie->fp = fp; if (fp->modeflags & __FLAG_READONLY) { cookie->eof = len; } if ((fp->modeflags & __FLAG_APPEND) && (len > 0)) { for (i = 0 ; i < len ; i++) { if (cookie->buf[i] == 0) { break; } } cookie->eof = cookie->pos = i; /* Adjust eof and pos. */ } return fp; } } if (!s) { free(cookie->buf); } EXIT_cookie: free(cookie); return NULL; } #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ #endif /**********************************************************************/ #ifdef L_open_memstream #ifdef __STDIO_GLIBC_CUSTOM_STREAMS #define COOKIE ((__oms_cookie *) cookie) typedef struct { char *buf; size_t len; size_t pos; size_t eof; char **bufloc; size_t *sizeloc; } __oms_cookie; /* Nothing to do here, as memstreams are write-only. */ /* static ssize_t oms_read(void *cookie, char *buf, size_t bufsize) */ /* { */ /* } */ static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize) { register char *newbuf; size_t count; /* Note: we already know bufsize < SSIZE_MAX... */ count = COOKIE->len - COOKIE->pos - 1; assert(COOKIE->pos < COOKIE->len); /* Always nul-terminate! */ if (bufsize > count) { newbuf = realloc(COOKIE->buf, COOKIE->len + bufsize - count); if (newbuf) { *COOKIE->bufloc = COOKIE->buf = newbuf; COOKIE->len += (bufsize - count); } else { bufsize = count; if (count == 0) { __set_errno(EFBIG); /* TODO: check glibc errno setting... */ return -1; } } } memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); COOKIE->pos += bufsize; if (COOKIE->pos > COOKIE->eof) { *COOKIE->sizeloc = COOKIE->eof = COOKIE->pos; COOKIE->buf[COOKIE->eof] = 0; /* Need to nul-terminate. */ } return bufsize; } static int oms_seek(register void *cookie, __offmax_t *pos, int whence) { __offmax_t p = *pos; register char *buf; size_t leastlen; /* Note: fseek already checks that whence is legal, so don't check here * unless debugging. */ assert(((unsigned int) whence) <= 2); if (whence != SEEK_SET) { p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof; } /* Note: glibc only allows seeking in the buffer. We'll actually restrict * to the data. */ /* Check for offset < 0, offset >= too big (need nul), or overflow... */ if (((uintmax_t) p) >= SIZE_MAX - 1) { return -1; } leastlen = ((size_t) p) + 1; /* New pos + 1 for nul if necessary. */ if (leastlen >= COOKIE->len) { /* Need to grow buffer... */ buf = realloc(COOKIE->buf, leastlen); if (buf) { *COOKIE->bufloc = COOKIE->buf = buf; COOKIE->len = leastlen; memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */ } else { /* TODO: check glibc errno setting... */ return -1; } } *pos = COOKIE->pos = --leastlen; if (leastlen > COOKIE->eof) { memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0); *COOKIE->sizeloc = COOKIE->eof; } return 0; } static int oms_close(void *cookie) { free(cookie); return 0; } #undef COOKIE static const cookie_io_functions_t _oms_io_funcs = { NULL, oms_write, oms_seek, oms_close }; /* TODO: If we have buffers enabled, it might be worthwile to add a pointer * to the FILE in the cookie and operate directly on the buffer itself * (ie replace the FILE buffer with the cookie buffer and update FILE bufstart, * etc. whenever we seek). */ FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc) { register __oms_cookie *cookie; register FILE *fp; if ((cookie = malloc(sizeof(__oms_cookie))) != NULL) { if ((cookie->buf = malloc(cookie->len = BUFSIZ)) == NULL) { goto EXIT_cookie; } *cookie->buf = 0; /* Set nul terminator for buffer. */ *(cookie->bufloc = bufloc) = cookie->buf; *(cookie->sizeloc = sizeloc) = cookie->eof = cookie->pos = 0; #ifndef __BCC__ fp = fopencookie(cookie, "w", _oms_io_funcs); #else fp = fopencookie(cookie, "w", &_oms_io_funcs); #endif /* Note: We don't need to worry about locking fp in the thread case * as the only possible access would be a close or flush with * nothing currently in the FILE's write buffer. */ if (fp != NULL) { return fp; } } if (cookie->buf != NULL) { free(cookie->buf); } EXIT_cookie: free(cookie); return NULL; } #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ #endif /**********************************************************************/ #ifdef L_fopencookie #ifdef __STDIO_GLIBC_CUSTOM_STREAMS /* NOTE: GLIBC difference!!! -- fopencookie * According to the info pages, glibc allows seeking within buffers even if * no seek function is supplied. We don't. */ /* NOTE: GLIBC difference!!! -- fopencookie * When compiled without large file support, the offset pointer for the * cookie_seek function is off_t * and not off64_t * as for glibc. */ /* Currently no real reentrancy issues other than a possible double close(). */ #ifndef __BCC__ FILE *fopencookie(void * __restrict cookie, const char * __restrict mode, cookie_io_functions_t io_functions) { FILE *stream; /* Fake an fdopen guaranteed to pass the _stdio_fopen basic agreement * check without an fcntl call. */ if ((stream = _stdio_fopen(((char *)(INT_MAX-1)), mode, NULL, INT_MAX)) /* TODO: use intptr_t? */ != NULL ) { stream->filedes = -1; stream->gcs = io_functions; stream->cookie = cookie; } #if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) /* I we don't have buffers or threads, we only need to worry about * custom streams on the open list, as no flushing is necessary and * no locking of possible underlying normal streams need be done. * We do need to explicitly close custom streams on termination of stdio, * and we need to lock the list as it can be modified by fclose(). */ __STDIO_THREADLOCK_OPENLIST; stream->nextopen = _stdio_openlist; /* New files are inserted at */ _stdio_openlist = stream; /* the head of the list. */ __STDIO_THREADUNLOCK_OPENLIST; #endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */ return stream; } #else /* __BCC__ */ /* NOTE: GLIBC difference!!! -- fopencookie (bcc only) * Since bcc doesn't support passing of structs, we define fopencookie as a * macro in terms of _fopencookie which takes a struct * for the io functions * instead. */ FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode, register cookie_io_functions_t *io_functions) { register FILE *stream; /* Fake an fdopen guaranteed to pass the _stdio_fopen basic agreement * check without an fcntl call. */ if ((stream = _stdio_fopen(((char *)(INT_MAX-1)), mode, NULL, INT_MAX)) /* TODO: use intptr_t? */ != NULL ) { stream->filedes = -1; stream->gcs.read = io_functions->read; stream->gcs.write = io_functions->write; stream->gcs.seek = io_functions->seek; stream->gcs.close = io_functions->close; stream->cookie = cookie; } #if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) /* I we don't have buffers or threads, we only need to worry about * custom streams on the open list, as no flushing is necessary and * no locking of possible underlying normal streams need be done. * We do need to explicitly close custom streams on termination of stdio, * and we need to lock the list as it can be modified by fclose(). */ __STDIO_THREADLOCK_OPENLIST; stream->nextopen = _stdio_openlist; /* New files are inserted at */ _stdio_openlist = stream; /* the head of the list. */ __STDIO_THREADUNLOCK_OPENLIST; #endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */ return stream; } #endif /* __BCC__ */ #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ #endif /**********************************************************************/ #ifdef L___fbufsize /* Not reentrant. */ size_t __fbufsize(register FILE * __restrict stream) { #ifdef __STDIO_BUFFERS return (stream->modeflags & __FLAG_NBF) ? 0 : (stream->bufend - stream->bufstart); #else /* __STDIO_BUFFERS */ return 0; #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ #ifdef L___freading /* No reentrancy issues. */ int __freading(FILE * __restrict stream) { return stream->modeflags & (__FLAG_READING|__FLAG_READONLY); } #endif /**********************************************************************/ #ifdef L___fwriting /* No reentrancy issues. */ int __fwriting(FILE * __restrict stream) { return stream->modeflags & (__FLAG_WRITING|__FLAG_WRITEONLY); } #endif /**********************************************************************/ #ifdef L___freadable /* No reentrancy issues. */ int __freadable(FILE * __restrict stream) { return ~(stream->modeflags & __FLAG_WRITEONLY); } #endif /**********************************************************************/ #ifdef L___fwritable /* No reentrancy issues. */ int __fwritable(FILE * __restrict stream) { return ~(stream->modeflags & __FLAG_READONLY); } #endif /**********************************************************************/ #ifdef L___flbf /* No reentrancy issues. */ int __flbf(FILE * __restrict stream) { #ifdef __STDIO_BUFFERS return (stream->modeflags & __FLAG_LBF); #else /* __STDIO_BUFFERS */ /* TODO -- Even though there is no buffer, return flag setting? */ return __FLAG_NBF; #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ #ifdef L___fpurge /* Not reentrant. */ void __fpurge(register FILE * __restrict stream) { #ifdef __STDIO_BUFFERS #ifdef __STDIO_PUTC_MACRO stream->bufputc = /* Must disable putc. */ #endif /* __STDIO_PUTC_MACRO */ #ifdef __STDIO_GETC_MACRO stream->bufgetc = /* Must disable getc. */ #endif stream->bufpos = stream->bufread = stream->bufstart; /* Reset pointers. */ #endif /* __STDIO_BUFFERS */ /* Reset r/w flags and clear ungots. */ stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING|__MASK_UNGOT); } #endif /**********************************************************************/ #ifdef L___fpending /* Not reentrant. */ #ifdef __STDIO_WIDE #warning Unlike the glibc version, this __fpending returns bytes in buffer for wide streams too! link_warning(__fpending, "This version of __fpending returns bytes remaining in buffer for both narrow and wide streams. glibc's version returns wide chars in buffer for the wide stream case.") #endif /* __STDIO_WIDE */ size_t __fpending(register FILE * __restrict stream) { #ifdef __STDIO_BUFFERS /* TODO -- should we check this? should we set errno? just assert? */ return (stream->modeflags & (__FLAG_READING|__FLAG_READONLY)) ? 0 : (stream->bufpos - stream->bufstart); #else /* __STDIO_BUFFERS */ return 0; #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ #ifdef L__flushlbf /* No reentrancy issues. */ void _flushlbf(void) { #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */ #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ /* Nothing to do. */ #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ } #endif /**********************************************************************/ #ifdef L___fsetlocking /* NOT threadsafe!!! (I don't think glibc's is either) * * This interacts badly with internal locking/unlocking. If you use this routine, * make sure the file isn't being accessed by any other threads. Typical use would * be to change to user locking immediately after opening the stream. */ #ifdef __UCLIBC_MJN3_ONLY__ link_warning(__fsetlocking, "Oddly enough, __fsetlocking() is NOT threadsafe.") #endif int __fsetlocking(FILE *stream, int locking_mode) { #ifdef __STDIO_THREADSAFE int old_mode; #endif assert((FSETLOCKING_QUERY == 0) && (FSETLOCKING_INTERNAL == 1) && (FSETLOCKING_BYCALLER == 2)); assert(((unsigned int) locking_mode) <= 2); #ifdef __STDIO_THREADSAFE old_mode = stream->user_locking; assert(((unsigned int) old_mode) <= 1); /* Must be 0 (internal) or 1 (user). */ if (locking_mode != FSETLOCKING_QUERY) { /* In case we're not debugging, treat any unknown as a request to * set internal locking, in order to match glibc behavior. */ stream->user_locking = (locking_mode == FSETLOCKING_BYCALLER); } return 2 - old_mode; #else return FSETLOCKING_BYCALLER; /* Well, without thread support... */ #endif } #endif /**********************************************************************/ #ifdef L_flockfile void flockfile(FILE *stream) { #ifdef __STDIO_THREADSAFE pthread_mutex_lock(&stream->lock); #endif } #endif /**********************************************************************/ #ifdef L_ftrylockfile int ftrylockfile(FILE *stream) { #ifdef __STDIO_THREADSAFE return pthread_mutex_trylock(&stream->lock); #else return 1; #endif } #endif /**********************************************************************/ #ifdef L_funlockfile void funlockfile(FILE *stream) { #ifdef __STDIO_THREADSAFE pthread_mutex_unlock(&stream->lock); #endif } #endif /**********************************************************************/ #ifdef L_getline ssize_t getline(char **__restrict lineptr, size_t *__restrict n, FILE *__restrict stream) { return __getdelim(lineptr, n, '\n', stream); } #endif /**********************************************************************/ #ifdef L_getdelim weak_alias(__getdelim,getdelim); #define GETDELIM_GROWBY 64 ssize_t __getdelim(char **__restrict lineptr, size_t *__restrict n, int delimiter, register FILE *__restrict stream) { register char *buf; size_t pos; int c; if (!lineptr || !n || !stream) { /* Be compatable with glibc... even */ __set_errno(EINVAL); /* though I think we should assert here */ return -1; /* if anything. */ } if (!(buf = *lineptr)) { /* If passed NULL for buffer, */ *n = 0; /* ignore value passed and treat size as 0. */ } pos = 1; /* Make sure we have space for terminating nul. */ __STDIO_THREADLOCK(stream); do { if (pos >= *n) { if (!(buf = realloc(buf, *n + GETDELIM_GROWBY))) { __set_errno(ENOMEM); /* Emulate old uClibc implementation. */ break; } *n += GETDELIM_GROWBY; *lineptr = buf; } } while (((c = (getc_unlocked)(stream)) != EOF) /* Disable the macro */ && ((buf[pos++ - 1] = c) != delimiter)); __STDIO_THREADUNLOCK(stream); if (--pos) { buf[pos] = 0; return pos; } return -1; /* Either initial realloc failed or first read was EOF. */ } #endif /**********************************************************************/ /* my extension functions */ /**********************************************************************/ #ifdef L__stdio_fsfopen /* * Stack|Static File open -- open a file where the FILE is either * stack or staticly allocated. */ /* No reentrancy issues. */ FILE *_stdio_fsfopen(const char * __restrict filename, const char * __restrict mode, register FILE * __restrict stream) { #ifdef __STDIO_BUFFERS stream->modeflags = __FLAG_FBF; #if __STDIO_BUILTIN_BUF_SIZE > 0 stream->bufstart = stream->builtinbuf; stream->bufend = stream->builtinbuf + sizeof(stream->builtinbuf); #else /* __STDIO_BUILTIN_BUF_SIZE > 0 */ stream->bufend = stream->bufstart = NULL; #endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */ #endif /* __STDIO_BUFFERS */ return _stdio_fopen(filename, mode, stream, -1); } #endif /**********************************************************************/ /* stdio internal functions */ /**********************************************************************/ #ifdef L__stdio_adjpos /* According to the ANSI/ISO C99 definition of ungetwc() * For a text or binary stream, the value of its file position indicator * after a successful call to the ungetwc function is unspecified until * all pushed­back wide characters are read or discarded. * Note however, that this applies only to _user_ calls to ungetwc. We * need to allow for internal calls by scanf. * So we store the byte count * of the first ungot wide char in ungot_width. If it is 0 (user case) * then the file position is treated as unknown. */ /* Internal function -- not reentrant. */ int _stdio_adjpos(register FILE * __restrict stream, register __offmax_t *pos) { __offmax_t r; int cor = stream->modeflags & __MASK_UNGOT; /* handle ungots */ assert(cor <= 2); #ifdef __STDIO_WIDE /* Assumed narrow stream so correct if wide. */ if (cor && (stream->modeflags & __FLAG_WIDE)) { if ((((stream->modeflags & __MASK_UNGOT) > 1) || stream->ungot[1])) { return -1; /* App did ungetwc, so position is indeterminate. */ } if (stream->modeflags & __MASK_UNGOT) { cor = cor - 1 + stream->ungot_width[1]; } if (stream->state.mask > 0) { /* Incomplete character (possible bad) */ cor -= stream->ungot_width[0]; } } #endif /* __STDIO_WIDE */ #ifdef __STDIO_BUFFERS if (stream->modeflags & __FLAG_WRITING) { cor -= (stream->bufpos - stream->bufstart); /* pending writes */ } if (stream->modeflags & __FLAG_READING) { cor += (stream->bufread - stream->bufpos); /* extra's read */ } #endif /* __STDIO_BUFFERS */ r = *pos; return ((*pos -= cor) > r) ? -cor : cor; } #endif /**********************************************************************/ #ifdef L__stdio_lseek /* * This function is only called by fseek and ftell. * fseek -- doesn't care about pos val, just success or failure. * ftell -- needs pos val but offset == 0 and whence == SET_CUR. */ /* Internal function -- not reentrant. */ int _stdio_lseek(register FILE *stream, register __offmax_t *pos, int whence) { __offmax_t res; #ifdef __STDIO_GLIBC_CUSTOM_STREAMS if (stream->cookie != &stream->filedes) { return (((stream->gcs.seek == NULL) || ((stream->gcs.seek)(stream->cookie, pos, whence) < 0)) ? -1 : 0); } #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ #ifdef __STDIO_LARGE_FILES res = lseek64(stream->filedes, *pos, whence); #else res = lseek(stream->filedes, *pos, whence); #endif /* __STDIO_LARGE_FILES */ return (res >= 0) ? ((*pos = res), 0) : -1; } #endif /**********************************************************************/ #ifdef L__stdio_fread /* * NOTE!!! This routine is meant to be callable by both narrow and wide * functions. However, if called by a wide function, there must be * NO pending ungetwc()s!!! */ /* Unlike write, it's ok for read to return fewer than bufsize, since * we may not need all of them. */ static ssize_t _stdio_READ(register FILE *stream, unsigned char *buf, size_t bufsize) { ssize_t rv; /* NOTE: C99 change: Input fails once the stream's EOF indicator is set. */ if ((bufsize == 0) || (stream->modeflags & __FLAG_EOF)) { return 0; } if (bufsize > SSIZE_MAX) { bufsize = SSIZE_MAX; } #ifdef __BCC__ TRY_READ: #endif rv = __READ(stream, buf, bufsize); if (rv > 0) { #ifdef __STDIO_GLIBC_CUSTOM_STREAMS assert(rv <= bufsize); /* buggy user handler... TODO: check? */ if (rv > bufsize) { /* Num reported written > number requested */ rv = bufsize; /* Treat as a full read??? */ } #endif } else if (rv == 0) { stream->modeflags |= __FLAG_EOF; } else { #ifdef __BCC__ if (errno == EINTR) { goto TRY_READ; } #endif stream->modeflags |= __FLAG_ERROR; rv = 0; } return rv; } /* Internal function -- not reentrant. */ size_t _stdio_fread(unsigned char *buffer, size_t bytes, register FILE *stream) { __stdio_validate_FILE(stream); /* debugging only */ #ifdef __STDIO_BUFFERS if (stream->modeflags #ifdef __STDIO_AUTO_RW_TRANSITION & (__FLAG_WRITEONLY) #else /* __STDIO_AUTO_RW_TRANSITION */ /* ANSI/ISO and SUSv3 require not currently writing. */ & (__FLAG_WRITEONLY|__FLAG_WRITING) #endif /* __STDIO_AUTO_RW_TRANSITION */ ) { #ifdef __STDIO_PUTC_MACRO stream->bufputc = stream->bufstart; /* Must disable putc. */ #endif /* __STDIO_PUTC_MACRO */ stream->modeflags |= __FLAG_ERROR; /* TODO: This is for posix behavior if writeonly. To save space, we * use this errno for read attempt while writing, as no errno is * specified by posix for this case, even though the restriction is * mentioned in fopen(). */ __set_errno(EBADF); return 0; } /* We need to disable putc and getc macros in case of error */ #if defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) #ifdef __STDIO_PUTC_MACRO stream->bufputc = #endif /* __STDIO_GETC_MACRO */ #ifdef __STDIO_GETC_MACRO stream->bufgetc = #endif /* __STDIO_GETC_MACRO */ stream->bufstart; #endif /* defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) */ if (stream->modeflags & __MASK_BUFMODE) { /* If the stream is readable and not fully buffered, we must first * flush all line buffered output streams. Do this before the * error check as this may be a read/write line-buffered stream. * Note: Uses an implementation-specific hack!!! */ fflush_unlocked((FILE *) &_stdio_openlist); } #ifdef __STDIO_AUTO_RW_TRANSITION if ((stream->modeflags & __FLAG_WRITING) && (fflush_unlocked(stream) == EOF) ) { return 0; /* Fail if we need to fflush but can't. */ } #endif /* __STDIO_AUTO_RW_TRANSITION */ stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */ { register unsigned char *p = (unsigned char *) buffer; /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */ while (bytes && (stream->modeflags & __MASK_UNGOT)) { #ifdef __STDIO_WIDE assert(stream->modeflags & __FLAG_NARROW); #endif /* __STDIO_WIDE */ *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT]; stream->ungot[1] = 0; --bytes; } /* Now get any other needed chars from the buffer or the file. */ FROM_BUF: while (bytes && (stream->bufpos < stream->bufread)) { --bytes; *p++ = *stream->bufpos++; } if (bytes > 0) { ssize_t len; if (stream->filedes == -2) { stream->modeflags |= __FLAG_EOF; goto DONE; } /* The buffer is exhausted, but we still need chars. */ stream->bufpos = stream->bufread = stream->bufstart; if (bytes <= stream->bufend - stream->bufread) { /* We have sufficient space in the buffer. */ len = _stdio_READ(stream, stream->bufread, stream->bufend - stream->bufread); if (len > 0) { stream->bufread += len; goto FROM_BUF; } } else { /* More bytes needed than fit in the buffer, so read */ /* directly into caller's buffer. */ len = _stdio_READ(stream, p, bytes); if (len > 0) { p += len; bytes -= len; goto FROM_BUF; /* Redundant work, but stops extra read. */ } } } #ifdef __STDIO_GETC_MACRO if (!(stream->modeflags & (__FLAG_WIDE|__MASK_UNGOT|__MASK_BUFMODE|__FLAG_ERROR)) ) { stream->bufgetc = stream->bufread; /* Enable getc macro. */ } #endif DONE: __stdio_validate_FILE(stream); /* debugging only */ return (p - (unsigned char *)buffer); } #else /* __STDIO_BUFFERS --------------------------------------- */ if (stream->modeflags #ifdef __STDIO_AUTO_RW_TRANSITION & (__FLAG_WRITEONLY) #else /* __STDIO_AUTO_RW_TRANSITION */ /* ANSI/ISO and SUSv3 require not currently writing. */ & (__FLAG_WRITEONLY|__FLAG_WRITING) #endif /* __STDIO_AUTO_RW_TRANSITION */ ) { stream->modeflags |= __FLAG_ERROR; /* TODO: This is for posix behavior if writeonly. To save space, we * use this errno for read attempt while writing, as no errno is * specified by posix for this case, even though the restriction is * mentioned in fopen(). */ __set_errno(EBADF); return 0; } #ifdef __STDIO_AUTO_RW_TRANSITION stream->modeflags &= ~(__FLAG_WRITING); /* Make sure Writing flag clear. */ #endif /* __STDIO_AUTO_RW_TRANSITION */ stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */ { register unsigned char *p = (unsigned char *) buffer; /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */ while (bytes && (stream->modeflags & __MASK_UNGOT)) { #ifdef __STDIO_WIDE assert(stream->modeflags & __FLAG_NARROW); #endif /* __STDIO_WIDE */ *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT]; stream->ungot[1] = 0; --bytes; } while (bytes > 0) { ssize_t len = _stdio_READ(stream, p, (unsigned) bytes); if (len == 0) { break; } p += len; bytes -= len; } __stdio_validate_FILE(stream); /* debugging only */ return (p - (unsigned char *)buffer); } #endif /* __STDIO_BUFFERS */ } #endif /**********************************************************************/ #ifdef L__stdio_fwrite /* * If buffer == NULL, attempt to fflush and return number of chars * remaining in buffer (0 if successful fflush). */ /* WARNING!!!! Current standards say that termination due to an asyncronous * signal may not result in stdio streams being flushed. This libary makes * an effort to do so but there is no way, short of blocking signals for * each _stdio_fwrite call, that we can maintain the correct state if a * signal is recieved mid-call. So any stream in mid-_stdio_fwrite could * not some flush data or even duplicate-flush some data. It is possible * to avoid the duplicate-flush case by setting/clearing the stream * error flag before/after the write process, but it doesn't seem worth * the trouble. */ /* Like standard write, but always does a full write unless error, plus * deals correctly with bufsize > SSIZE_MAX... not much on an issue on linux * but definitly could be on Elks. Also on Elks, always loops for EINTR.. * Returns number of bytes written, so a short write indicates an error */ static size_t _stdio_WRITE(register FILE *stream, register const unsigned char *buf, size_t bufsize) { size_t todo; ssize_t rv, stodo; todo = bufsize; while (todo) { stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX; rv = __WRITE(stream, buf, stodo); if (rv >= 0) { #ifdef __STDIO_GLIBC_CUSTOM_STREAMS assert(rv <= stodo); /* buggy user handler... TODO: check? */ if (rv > stodo) { /* Num reported written > number requested */ rv = stodo; /* Treat as a full write??? */ } #endif todo -= rv; buf += rv; } else #ifdef __BCC__ if (errno != EINTR) #endif { stream->modeflags |= __FLAG_ERROR; break; } } return bufsize - todo; } /* Internal function -- not reentrant. */ size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes, register FILE *stream) { #ifdef __STDIO_BUFFERS register const unsigned char *p; __stdio_validate_FILE(stream); /* debugging only */ if ((stream->modeflags & __FLAG_READONLY) #ifndef __STDIO_AUTO_RW_TRANSITION /* ANSI/ISO requires either at EOF or currently not reading. */ || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF)) == __FLAG_READING) #endif /* __STDIO_AUTO_RW_TRANSITION */ ) { stream->modeflags |= __FLAG_ERROR; /* TODO: This is for posix behavior if readonly. To save space, we * use this errno for write attempt while reading, as no errno is * specified by posix for this case, even though the restriction is * mentioned in fopen(). */ __set_errno(EBADF); return 0; } #ifdef __STDIO_AUTO_RW_TRANSITION /* If reading, deal with ungots and read-buffered chars. */ if (stream->modeflags & __FLAG_READING) { if (((stream->bufpos < stream->bufread) || (stream->modeflags & __MASK_UNGOT)) /* If appending, we might as well seek to end to save a seek. */ /* TODO: set EOF in fseek when appropriate? */ && fseek(stream, 0L, ((stream->modeflags & __FLAG_APPEND) ? SEEK_END : SEEK_CUR)) ) { /* Note: This differs from glibc's apparent behavior of not setting the error flag and discarding the buffered read data. */ stream->modeflags |= __FLAG_ERROR; /* fseek may not set this. */ return 0; /* Fail if we need to fseek but can't. */ } /* Always reset even if fseek called (saves a test). */ #ifdef __STDIO_GETC_MACRO stream->bufgetc = #endif /* __STDIO_GETC_MACRO */ stream->bufpos = stream->bufread = stream->bufstart; } else #endif if ((stream->modeflags & (__FLAG_WRITING|__FLAG_APPEND)) == __FLAG_APPEND) { /* Append mode, but not currently writing. Need to seek to end for proper * ftell() return values. Don't worry if the stream isn't seekable. */ __offmax_t pos[1]; *pos = 0; if (_stdio_lseek(stream, pos, SEEK_END) && (errno != EPIPE)) { /* Too big? */ stream->modeflags |= __FLAG_ERROR; return 0; } } #ifdef __STDIO_PUTC_MACRO /* We need to disable putc macro in case of error */ stream->bufputc = stream->bufstart; #endif /* __STDIO_GETC_MACRO */ /* Clear both reading and writing flags. We need to clear the writing * flag in case we're fflush()ing or in case of an error. */ stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING); { const unsigned char *buf0 = buffer; size_t write_count = 1; /* 0 means a write failed */ if (!buffer) { /* fflush the stream */ FFLUSH: { size_t count = stream->bufpos - stream->bufstart; p = stream->bufstart; if (stream->filedes == -2) { /* TODO -- document this hack! */ stream->modeflags |= __FLAG_WRITING; return (!buffer) ? 0 : ((buffer - buf0) + bytes); } { write_count = _stdio_WRITE(stream, p, count); p += write_count; count -= write_count; } stream->bufpos = stream->bufstart; while (count) { *stream->bufpos++ = *p++; --count; } if (!buffer) { /* fflush case... */ __stdio_validate_FILE(stream); /* debugging only */ return stream->bufpos - stream->bufstart; } } } #if 1 /* TODO: If the stream is buffered, we may be able to omit. */ if ((stream->bufpos == stream->bufstart) /* buf empty */ && (stream->bufend - stream->bufstart <= bytes) /* fills */ && (stream->filedes != -2)) { /* not strinf fake file */ /* so want to do a direct write of supplied buffer */ { size_t rv = _stdio_WRITE(stream, buffer, bytes); buffer += rv; bytes -= rv; } } else #endif /* otherwise buffer not empty and/or data fits */ { size_t count = stream->bufend - stream->bufpos; p = buffer; if (count > bytes) { count = bytes; } bytes -= count; while (count) { *stream->bufpos++ = *buffer++; --count; } if (write_count) { /* no write errors */ if (bytes) { goto FFLUSH; } if (stream->modeflags & __FLAG_LBF) { while (p < buffer) { /* check for newline. */ if (*p++ == '\n') { goto FFLUSH; } } } } } #ifdef __STDIO_PUTC_MACRO if (!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE|__FLAG_ERROR))) { /* Not wide, no errors and fully buffered, so enable putc macro. */ stream->bufputc = stream->bufend; } #endif /* __STDIO_GETC_MACRO */ stream->modeflags |= __FLAG_WRITING; /* Ensure Writing flag is set. */ __stdio_validate_FILE(stream); /* debugging only */ return buffer - buf0; } #else /* __STDIO_BUFFERS --------------------------------------- */ __stdio_validate_FILE(stream); /* debugging only */ if ((stream->modeflags & __FLAG_READONLY) #ifndef __STDIO_AUTO_RW_TRANSITION /* ANSI/ISO requires either at EOF or currently not reading. */ || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF)) == __FLAG_READING) #endif /* __STDIO_AUTO_RW_TRANSITION */ ) { stream->modeflags |= __FLAG_ERROR; /* TODO: This is for posix behavior if readonly. To save space, we * use this errno for write attempt while reading, as no errno is * specified by posix for this case, even though the restriction is * mentioned in fopen(). */ __set_errno(EBADF); return 0; } /* We always clear the reading flag in case at EOF. */ stream->modeflags &= ~(__FLAG_READING); /* Unlike the buffered case, we set the writing flag now since we don't * need to do anything here for fflush(). */ stream->modeflags |= __FLAG_WRITING; { register unsigned char *p = (unsigned char *) buffer; ssize_t rv = _stdio_WRITE(stream, p, bytes); p += rv; bytes -= rv; __stdio_validate_FILE(stream); /* debugging only */ return (p - (unsigned char *)buffer); } #endif /* __STDIO_BUFFERS *****************************************/ } #endif /**********************************************************************/ #ifdef L__stdio_init /* Internal functions -- _stdio_init() and __stdio_validate_FILE * are not reentrant, but _stdio_term() is through fflush(). * Also, the _cs_{read|write|close} functions are not reentrant. */ #ifndef NDEBUG void __stdio_validate_FILE(FILE *stream) { if (stream->filedes == -2) { /* fake FILE for sprintf, scanf, etc. */ return; } __STDIO_THREADLOCK(stream); #ifdef __STDIO_BUFFERS assert(stream->bufstart <= stream->bufread); if (stream->modeflags & (__FLAG_READING)) { assert(stream->bufpos <= stream->bufread); } assert(stream->bufread <= stream->bufend); assert(stream->bufpos <= stream->bufend); if ((stream->modeflags & __MASK_BUFMODE) == __FLAG_NBF) { assert(stream->bufstart == stream->bufend); } assert((stream->modeflags & __MASK_BUFMODE) <= __FLAG_NBF); #endif #ifdef __STDIO_PUTC_MACRO assert(stream->bufstart <= stream->bufputc); assert(stream->bufputc <= stream->bufend); if (stream->bufstart < stream->bufputc) { assert(stream->bufputc == stream->bufend); assert(stream->modeflags & (__FLAG_WRITING)); assert(!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_READONLY)) ); } #endif #ifdef __STDIO_GETC_MACRO assert(stream->bufstart <= stream->bufgetc); assert(stream->bufgetc <= stream->bufread); if (stream->bufstart < stream->bufgetc) { assert(stream->modeflags & (__FLAG_READING)); assert(!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_WRITEONLY)) ); } #endif assert((stream->modeflags & __MASK_UNGOT) != __MASK_UNGOT); if (stream->modeflags & __MASK_UNGOT1) { assert(stream->ungot[1] <= 1); } if (stream->modeflags & __MASK_UNGOT) { assert(!(stream->modeflags & __FLAG_EOF)); } assert((stream->modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY)) != (__FLAG_READONLY|__FLAG_WRITEONLY)); /* TODO -- filepos? ungot_width? filedes? nextopen? */ __STDIO_THREADUNLOCK(stream); } #endif #ifdef __STDIO_GLIBC_CUSTOM_STREAMS ssize_t _cs_read(void *cookie, char *buf, size_t bufsize) { return read(*((int *) cookie), buf, bufsize); } ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize) { return write(*((int *) cookie), (char *) buf, bufsize); } int _cs_close(void *cookie) { return close(*((int *) cookie)); } #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ #ifdef __STDIO_BUFFERS static unsigned char _fixed_buffers[2 * BUFSIZ]; #define bufin (_fixed_buffers) #define bufout (_fixed_buffers + BUFSIZ) #endif /* __STDIO_BUFFERS */ static FILE _stdio_streams[] = { __STDIO_INIT_FILE_STRUCT(_stdio_streams[0], __FLAG_LBF|__FLAG_READONLY, \ 0, _stdio_streams + 1, bufin, BUFSIZ ), __STDIO_INIT_FILE_STRUCT(_stdio_streams[1], __FLAG_LBF|__FLAG_WRITEONLY, \ 1, _stdio_streams + 2, bufout, BUFSIZ ), __STDIO_INIT_FILE_STRUCT(_stdio_streams[2], __FLAG_NBF|__FLAG_WRITEONLY, \ 2, 0, 0, 0 ) }; FILE *stdin = _stdio_streams + 0; FILE *stdout = _stdio_streams + 1; FILE *stderr = _stdio_streams + 2; #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) #ifdef __STDIO_BUFFERS FILE *_stdio_openlist = _stdio_streams; #else /* __STDIO_BUFFERS */ FILE *_stdio_openlist = NULL; #endif /* __STDIO_BUFFERS */ #ifdef __STDIO_THREADSAFE pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; void __stdio_init_mutex(pthread_mutex_t *m) { static const pthread_mutex_t __stdio_mutex_initializer = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer)); } #endif /* __STDIO_THREADSAFE */ /* TODO - do we need to lock things, or do we just assume we're the only * remaining thread? */ /* Note: We assume here that we are the only remaining thread. */ void _stdio_term(void) { #if defined(__STDIO_GLIBC_CUSTOM_STREAMS) || defined(__STDIO_THREADSAFE) register FILE *ptr; #endif /* TODO: if called via a signal handler for a signal mid _stdio_fwrite, * the stream may be in an unstable state... what do we do? * perhaps set error flag before and clear when done if successful? */ #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) #ifdef __STDIO_THREADSAFE /* First, forceably unlock the open file list and all files. * Note: Set locking mode to "by caller" to save some overhead later. */ __stdio_init_mutex(&_stdio_openlist_lock); for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) { ptr->user_locking = 1; __stdio_init_mutex(&ptr->lock); } #endif /* __STDIO_THREADSAFE */ #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ #ifdef __STDIO_BUFFERS /* TODO -- set an alarm and flush each file "by hand"? to avoid blocking? */ /* Now flush all streams. */ fflush_unlocked(NULL); #endif /* __STDIO_BUFFERS */ /* Next close all custom streams in case of any special cleanup, but * don't use fclose() because that pulls in free and malloc. Also, * don't worry about removing them from the list. Just set the cookie * pointer to NULL so that an error will be generated if someone tries * to use the stream. */ #ifdef __STDIO_GLIBC_CUSTOM_STREAMS for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) { if (ptr->cookie != &ptr->filedes) { /* custom stream */ __CLOSE(ptr); ptr->cookie = NULL; /* Generate an error if used later. */ #if 0 /* #ifdef __STDIO_BUFFERS */ } else { /* TODO: "unbuffer" files like glibc does? Inconsistent with * custom stream handling above, but that's necessary to deal * with special user-defined close behavior. */ stream->bufpos = stream->bufread = stream->bufend #ifdef __STDIO_GETC_MACRO = stream->bufgetc #endif #ifdef __STDIO_PUTC_MACRO = stream->bufputc #endif = stream->bufstart; #endif /* __STDIO_BUFFERS */ } } #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ } #if defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) void _stdio_init(void) { #ifdef __STDIO_BUFFERS int old_errno = errno; /* stdin and stdout uses line buffering when connected to a tty. */ _stdio_streams[0].modeflags ^= (1-isatty(0)) * __FLAG_LBF; _stdio_streams[1].modeflags ^= (1-isatty(1)) * __FLAG_LBF; __set_errno(old_errno); #endif /* __STDIO_BUFFERS */ #ifndef __UCLIBC__ /* __stdio_term is automatically when exiting if stdio is used. * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */ atexit(_stdio_term); #endif /* __UCLIBC__ */ } #endif /* defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) */ #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ #endif /**********************************************************************/ /* ANSI/ISO functions. */ /**********************************************************************/ #ifdef L_remove #include #include /* No reentrancy issues. */ int remove(register const char *filename) { int old_errno = errno; /* SUSv3 says equivalent to rmdir() if a directory, and unlink() * otherwise. Hence, we need to try rmdir() first. */ return (((rmdir(filename) == 0) || ((errno == ENOTDIR) && ((__set_errno(old_errno), unlink(filename)) == 0))) ? 0 : -1); } #endif /**********************************************************************/ /* rename is a syscall #ifdef L_rename int rename(const char *old, const char *new); #endif */ /**********************************************************************/ /* TODO: tmpfile */ /* #ifdef L_tmpfile */ /* FILE *tmpfile(void); */ /* #endif */ /**********************************************************************/ /* TODO: tmpname */ /* #ifdef L_tmpname */ /* char *tmpname(char *s); */ /* #endif */ /**********************************************************************/ #ifdef L_fclose /* We need to be careful here to avoid deadlock when threading, as we * need to lock both the file and the open file list. This can clash * with fflush. Since fflush is much more common, we do the extra * work here. */ int fclose(register FILE *stream) { #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) register FILE *ptr; int rv = 0; #ifdef __STDIO_THREADSAFE /* Need two non-heirchal mutexs... be careful to avoid deadlock*/ do { __STDIO_THREADLOCK(stream); if (__STDIO_THREADTRYLOCK_OPENLIST == 0) { break; } __STDIO_THREADUNLOCK(stream); usleep(10000); } while (1); #endif /* __STDIO_THREADSAFE */ __stdio_validate_FILE(stream); /* debugging only */ #ifdef __STDIO_BUFFERS if (stream->modeflags & __FLAG_WRITING) { rv = fflush_unlocked(stream); /* Write any pending buffered chars. */ } /* Also disables putc macro if used. */ #ifdef __STDIO_GETC_MACRO /* Not necessary after fflush, but always do this to reduce size. */ stream->bufgetc = stream->bufstart; /* Disable getc macro for safety. */ #endif /* __STDIO_GETC_MACRO */ #endif /* __STDIO_BUFFERS */ /* Remove file from open list before closing file descriptor. */ ptr = _stdio_openlist; if (ptr == stream) { _stdio_openlist = stream->nextopen; } else { while (ptr) { if (ptr->nextopen == stream) { ptr->nextopen = stream->nextopen; break; } ptr = ptr->nextopen; } } __STDIO_THREADUNLOCK_OPENLIST; /* We're done with the open file list. */ if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */ rv = EOF; } #ifdef __STDIO_GLIBC_CUSTOM_STREAMS stream->cookie = &(stream->filedes); stream->gcs.read = _cs_read; stream->gcs.write = _cs_write; stream->gcs.seek = 0; /* The internal seek func handles normals. */ stream->gcs.close = _cs_close; #endif stream->filedes = -1; /* To aid debugging... */ #ifdef __STDIO_BUFFERS if (stream->modeflags & __FLAG_FREEBUF) { free(stream->bufstart); } #endif /* __STDIO_BUFFERS */ /* TODO -- leave the stream locked to catch any dangling refs? */ __STDIO_THREADUNLOCK(stream); /* At this point, any dangling refs to the stream are the result of * a programming bug... so free the unlocked stream. */ if (stream->modeflags & __FLAG_FREEFILE) { #ifdef __STDIO_GLIBC_CUSTOM_STREAMS stream->cookie = NULL; /* To aid debugging... */ #endif free(stream); } return rv; #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ int rv = 0; __STDIO_THREADLOCK(stream); __stdio_validate_FILE(stream); /* debugging only */ if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */ rv = EOF; } #ifdef __STDIO_GLIBC_CUSTOM_STREAMS stream->cookie = &(stream->filedes); stream->gcs.read = _cs_read; stream->gcs.write = _cs_write; stream->gcs.seek = 0; /* The internal seek func handles normals. */ stream->gcs.close = _cs_close; #endif stream->filedes = -1; /* To aid debugging... */ __STDIO_THREADUNLOCK(stream); /* At this point, any dangling refs to the stream are the result of * a programming bug... so free the unlocked stream. */ if (stream->modeflags & __FLAG_FREEFILE) { #ifdef __STDIO_GLIBC_CUSTOM_STREAMS stream->cookie = NULL; /* To aid debugging... */ #endif free(stream); } return rv; #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS )*/ } #endif /**********************************************************************/ #ifdef L_fflush /* * Special cases: * stream == NULL means fflush all writing streams (ANSI/ISO). * stream == (FILE *) &_stdio_openlist -- implementation-specific hack * meaning fflush all line buffered writing streams */ /* * NOTE: ANSI/ISO difference!!! According to the standard, fflush is only * defined for write-only streams, or read/write streams whose last op * was a write. However, reading is allowed for a read/write stream if * a file positioning operation was done (fseek, fsetpos) even though there * is no guarantee of flushing the write data in that case. Hence, for * this case we keep a flag to indicate whether or not the buffer needs to * be flushed even if the last operation was a read. This falls under the * implementation-defined behavior. Otherwise, we would need to flush * every time we did fseek, etc. even if we were still in the buffer's range. */ /* Since the stream pointer arg is allowed to be NULL, or the address of the * stdio open file list if stdio is buffered in this implementation, we can't * use the UNLOCKED() macro here. */ #ifndef __STDIO_THREADSAFE strong_alias(fflush_unlocked,fflush) #else /* __STDIO_THREADSAFE */ int fflush(register FILE *stream) { int retval; if ((stream != NULL) #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) && (stream != (FILE *) &_stdio_openlist) #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ ) { __STDIO_THREADLOCK(stream); retval = fflush_unlocked(stream); __STDIO_THREADUNLOCK(stream); } else { retval = fflush_unlocked(stream); } return retval; } #endif /* __STDIO_THREADSAFE */ int fflush_unlocked(register FILE *stream) { #ifdef __STDIO_BUFFERS int rv = 0; unsigned short mask = (__FLAG_NBF|__FLAG_LBF); #ifndef NDEBUG if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) { __stdio_validate_FILE(stream); /* debugging only */ } #endif if (stream == (FILE *) &_stdio_openlist) { /* fflush all line-buffered */ stream = NULL; mask = __FLAG_LBF; } if (stream == NULL) { /* flush all (line) buffered writing streams */ /* Note -- We have to lock the list even in the unlocked function. */ __STDIO_THREADLOCK_OPENLIST; /* TODO -- Can we work around locking the list to avoid keeping it * locked if the write blocks? */ for (stream = _stdio_openlist; stream; stream = stream->nextopen) { if (((stream->modeflags ^ __FLAG_NBF) & mask) && (stream->modeflags & __FLAG_WRITING) && fflush(stream)) { rv = EOF; } } __STDIO_THREADUNLOCK_OPENLIST; } else if (stream->modeflags & __FLAG_WRITING) { if (_stdio_fwrite(NULL, 0, stream) > 0) { /* flush buffer contents. */ rv = -1; /* Not all chars written. */ } #ifdef __UCLIBC_MJN3_ONLY__ #warning WISHLIST: Add option to test for undefined behavior of fflush. #endif /* __UCLIBC_MJN3_ONLY__ */ #if 0 } else if (stream->modeflags & (__FLAG_READING|__FLAG_READONLY)) { /* ANSI/ISO says behavior in this case is undefined but also says you * shouldn't flush a stream you were reading from. As usual, glibc * caters to broken programs and simply ign