1/* $OpenBSD: findfp.c,v 1.15 2013/12/17 16:33:27 deraadt Exp $ */ 2/*- 3 * Copyright (c) 1990, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Chris Torek. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34#include <sys/param.h> 35#include <unistd.h> 36#include <stdio.h> 37#include <errno.h> 38#include <stdlib.h> 39#include <string.h> 40#include "local.h" 41#include "glue.h" 42#include "private/thread_private.h" 43 44#define ALIGNBYTES (sizeof(uintptr_t) - 1) 45#define ALIGN(p) (((uintptr_t)(p) + ALIGNBYTES) &~ ALIGNBYTES) 46 47#undef stdin 48#undef stdout 49#undef stderr 50 51int __sdidinit; 52 53#define NDYNAMIC 10 /* add ten more whenever necessary */ 54 55#define std(flags, file) \ 56 {0,0,0,flags,file,{0},0,__sF+file,__sclose,__sread,__sseek,__swrite, \ 57 {(unsigned char *)(__sFext+file), 0},NULL,0,{0},{0},{0},0,0} 58 59 /* the usual - (stdin + stdout + stderr) */ 60static FILE usual[FOPEN_MAX - 3]; 61static struct __sfileext usualext[FOPEN_MAX - 3]; 62static struct glue uglue = { 0, FOPEN_MAX - 3, usual }; 63static struct glue *lastglue = &uglue; 64_THREAD_PRIVATE_MUTEX(__sfp_mutex); 65 66static struct __sfileext __sFext[3]; 67FILE __sF[3] = { 68 std(__SRD, STDIN_FILENO), /* stdin */ 69 std(__SWR, STDOUT_FILENO), /* stdout */ 70 std(__SWR|__SNBF, STDERR_FILENO) /* stderr */ 71}; 72FILE* stdin = &__sF[0]; 73FILE* stdout = &__sF[1]; 74FILE* stderr = &__sF[2]; 75struct glue __sglue = { &uglue, 3, __sF }; 76 77static struct glue * 78moreglue(int n) 79{ 80 struct glue *g; 81 FILE *p; 82 struct __sfileext *pext; 83 static FILE empty; 84 char *data; 85 86 data = malloc(sizeof(*g) + ALIGNBYTES + n * sizeof(FILE) 87 + n * sizeof(struct __sfileext)); 88 if (data == NULL) 89 return (NULL); 90 g = (struct glue *)data; 91 p = (FILE *)ALIGN(data + sizeof(*g)); 92 pext = (struct __sfileext *) 93 (ALIGN(data + sizeof(*g)) + n * sizeof(FILE)); 94 g->next = NULL; 95 g->niobs = n; 96 g->iobs = p; 97 while (--n >= 0) { 98 *p = empty; 99 _FILEEXT_SETUP(p, pext); 100 p++; 101 pext++; 102 } 103 return (g); 104} 105 106/* 107 * Find a free FILE for fopen et al. 108 */ 109FILE * 110__sfp(void) 111{ 112 FILE *fp; 113 int n; 114 struct glue *g; 115 116 if (!__sdidinit) 117 __sinit(); 118 119 _THREAD_PRIVATE_MUTEX_LOCK(__sfp_mutex); 120 for (g = &__sglue; g != NULL; g = g->next) { 121 for (fp = g->iobs, n = g->niobs; --n >= 0; fp++) 122 if (fp->_flags == 0) 123 goto found; 124 } 125 126 /* release lock while mallocing */ 127 _THREAD_PRIVATE_MUTEX_UNLOCK(__sfp_mutex); 128 if ((g = moreglue(NDYNAMIC)) == NULL) 129 return (NULL); 130 _THREAD_PRIVATE_MUTEX_LOCK(__sfp_mutex); 131 lastglue->next = g; 132 lastglue = g; 133 fp = g->iobs; 134found: 135 fp->_flags = 1; /* reserve this slot; caller sets real flags */ 136 _THREAD_PRIVATE_MUTEX_UNLOCK(__sfp_mutex); 137 fp->_p = NULL; /* no current pointer */ 138 fp->_w = 0; /* nothing to read or write */ 139 fp->_r = 0; 140 fp->_bf._base = NULL; /* no buffer */ 141 fp->_bf._size = 0; 142 fp->_lbfsize = 0; /* not line buffered */ 143 fp->_file = -1; /* no file */ 144/* fp->_cookie = <any>; */ /* caller sets cookie, _read/_write etc */ 145 fp->_lb._base = NULL; /* no line buffer */ 146 fp->_lb._size = 0; 147 _FILEEXT_INIT(fp); 148 return (fp); 149} 150 151/* 152 * exit() and abort() call _cleanup() through the callback registered 153 * with __atexit_register_cleanup(), set whenever we open or buffer a 154 * file. This chicanery is done so that programs that do not use stdio 155 * need not link it all in. 156 * 157 * The name `_cleanup' is, alas, fairly well known outside stdio. 158 */ 159void 160_cleanup(void) 161{ 162 /* (void) _fwalk(fclose); */ 163 (void) _fwalk(__sflush); /* `cheating' */ 164} 165 166/* 167 * __sinit() is called whenever stdio's internal variables must be set up. 168 */ 169void 170__sinit(void) 171{ 172 _THREAD_PRIVATE_MUTEX(__sinit_mutex); 173 174 _THREAD_PRIVATE_MUTEX_LOCK(__sinit_mutex); 175 if (__sdidinit) { 176 /* bail out if caller lost the race */ 177 _THREAD_PRIVATE_MUTEX_UNLOCK(__sinit_mutex); 178 return; 179 } 180 181 /* Initialize stdin/stdout/stderr (for the recursive mutex). http://b/18208568. */ 182 for (size_t i = 0; i < 3; ++i) { 183 _FILEEXT_SETUP(__sF+i, __sFext+i); 184 } 185 /* Initialize the pre-allocated (but initially unused) streams. */ 186 for (size_t i = 0; i < FOPEN_MAX - 3; ++i) { 187 _FILEEXT_SETUP(usual+i, usualext+i); 188 } 189 190 /* make sure we clean up on exit */ 191 __atexit_register_cleanup(_cleanup); /* conservative */ 192 __sdidinit = 1; 193 194 _THREAD_PRIVATE_MUTEX_UNLOCK(__sinit_mutex); 195} 196