1/* 2 * Copyright (c) 2000-2002, 2004 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1990, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Chris Torek. 9 * 10 * By using this file, you agree to the terms and conditions set 11 * forth in the LICENSE file which can be found at the top level of 12 * the sendmail distribution. 13 */ 14 15#include <sm/gen.h> 16SM_RCSID("@(#)$Id: fopen.c,v 1.63 2013-11-22 20:51:42 ca Exp $") 17#include <errno.h> 18#include <setjmp.h> 19#include <sm/time.h> 20#include <sm/heap.h> 21#include <sm/signal.h> 22#include <sm/assert.h> 23#include <sm/io.h> 24#include <sm/clock.h> 25#include "local.h" 26 27static void openalrm __P((int)); 28static void reopenalrm __P((int)); 29extern int sm_io_fclose __P((SM_FILE_T *)); 30 31static jmp_buf OpenTimeOut, ReopenTimeOut; 32 33/* 34** OPENALRM -- handler when timeout activated for sm_io_open() 35** 36** Returns flow of control to where setjmp(OpenTimeOut) was set. 37** 38** Parameters: 39** sig -- unused 40** 41** Returns: 42** does not return 43** 44** Side Effects: 45** returns flow of control to setjmp(OpenTimeOut). 46** 47** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 48** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 49** DOING. 50*/ 51 52/* ARGSUSED0 */ 53static void 54openalrm(sig) 55 int sig; 56{ 57 longjmp(OpenTimeOut, 1); 58} 59/* 60** REOPENALRM -- handler when timeout activated for sm_io_reopen() 61** 62** Returns flow of control to where setjmp(ReopenTimeOut) was set. 63** 64** Parameters: 65** sig -- unused 66** 67** Returns: 68** does not return 69** 70** Side Effects: 71** returns flow of control to setjmp(ReopenTimeOut). 72** 73** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 74** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 75** DOING. 76*/ 77 78/* ARGSUSED0 */ 79static void 80reopenalrm(sig) 81 int sig; 82{ 83 longjmp(ReopenTimeOut, 1); 84} 85 86/* 87** SM_IO_OPEN -- open a file of a specific type 88** 89** Parameters: 90** type -- type of file to open 91** timeout -- time to complete the open 92** info -- info describing what is to be opened (type dependent) 93** flags -- user selected flags 94** rpool -- pointer to rpool to be used for this open 95** 96** Returns: 97** Raises exception on heap exhaustion. 98** Aborts if type is invalid. 99** Returns NULL and sets errno 100** - when the type specific open fails 101** - when open vector errors 102** - when flags not set or invalid 103** Success returns a file pointer to the opened file type. 104*/ 105 106SM_FILE_T * 107sm_io_open(type, timeout, info, flags, rpool) 108 const SM_FILE_T *type; 109 int SM_NONVOLATILE timeout; /* this is not the file type timeout */ 110 const void *info; 111 int flags; 112 const void *rpool; 113{ 114 register SM_FILE_T *fp; 115 int ioflags; 116 SM_EVENT *evt = NULL; 117 118 ioflags = sm_flags(flags); 119 120 if (ioflags == 0) 121 { 122 /* must give some indication/intent */ 123 errno = EINVAL; 124 return NULL; 125 } 126 127 if (timeout == SM_TIME_DEFAULT) 128 timeout = SM_TIME_FOREVER; 129 if (timeout == SM_TIME_IMMEDIATE) 130 { 131 errno = EAGAIN; 132 return NULL; 133 } 134 135 fp = sm_fp(type, ioflags, NULL); 136 137 /* Okay, this is where we set the timeout. */ 138 if (timeout != SM_TIME_FOREVER) 139 { 140 if (setjmp(OpenTimeOut) != 0) 141 { 142 errno = EAGAIN; 143 return NULL; 144 } 145 evt = sm_seteventm(timeout, openalrm, 0); 146 } 147 148 if ((*fp->f_open)(fp, info, flags, rpool) < 0) 149 { 150 fp->f_flags = 0; /* release */ 151 fp->sm_magic = NULL; /* release */ 152 return NULL; 153 } 154 155 /* We're back. So undo our timeout and handler */ 156 if (evt != NULL) 157 sm_clrevent(evt); 158 159#if SM_RPOOL 160 if (rpool != NULL) 161 sm_rpool_attach_x(rpool, sm_io_fclose, fp); 162#endif 163 164 return fp; 165} 166/* 167** SM_IO_DUP -- duplicate a file pointer 168** 169** Parameters: 170** fp -- file pointer to duplicate 171** 172** Returns: 173** Success - the duplicated file pointer 174** Failure - NULL (was an invalid file pointer or too many open) 175** 176** Increments the duplicate counter (dup_cnt) for the open file pointer. 177** The counter counts the number of duplicates. When the duplicate 178** counter is 0 (zero) then the file pointer is the only one left 179** (no duplicates, it is the only one). 180*/ 181 182SM_FILE_T * 183sm_io_dup(fp) 184 SM_FILE_T *fp; 185{ 186 187 SM_REQUIRE_ISA(fp, SmFileMagic); 188 if (fp->sm_magic != SmFileMagic) 189 { 190 errno = EBADF; 191 return NULL; 192 } 193 if (fp->f_dup_cnt >= INT_MAX - 1) 194 { 195 /* Can't let f_dup_cnt wrap! */ 196 errno = EMFILE; 197 return NULL; 198 } 199 fp->f_dup_cnt++; 200 return fp; 201} 202/* 203** SM_IO_REOPEN -- open a new file using the old file pointer 204** 205** Parameters: 206** type -- file type to be opened 207** timeout -- time to complete the reopen 208** info -- information about what is to be "re-opened" (type dep.) 209** flags -- user flags to map to internal flags 210** rpool -- rpool file to be associated with 211** fp -- the file pointer to reuse 212** 213** Returns: 214** Raises an exception on heap exhaustion. 215** Aborts if type is invalid. 216** Failure: returns NULL 217** Success: returns "reopened" file pointer 218*/ 219 220SM_FILE_T * 221sm_io_reopen(type, timeout, info, flags, rpool, fp) 222 const SM_FILE_T *type; 223 int SM_NONVOLATILE timeout; 224 const void *info; 225 int flags; 226 const void *rpool; 227 SM_FILE_T *fp; 228{ 229 int ioflags, ret; 230 SM_FILE_T *fp2; 231 SM_EVENT *evt = NULL; 232 233 if ((ioflags = sm_flags(flags)) == 0) 234 { 235 (void) sm_io_close(fp, timeout); 236 return NULL; 237 } 238 239 if (!Sm_IO_DidInit) 240 sm_init(); 241 242 if (timeout == SM_TIME_DEFAULT) 243 timeout = SM_TIME_FOREVER; 244 if (timeout == SM_TIME_IMMEDIATE) 245 { 246 /* 247 ** Filling the buffer will take time and we are wanted to 248 ** return immediately. So... 249 */ 250 251 errno = EAGAIN; 252 return NULL; 253 } 254 /* Okay, this is where we set the timeout. */ 255 if (timeout != SM_TIME_FOREVER) 256 { 257 if (setjmp(ReopenTimeOut) != 0) 258 { 259 errno = EAGAIN; 260 return NULL; 261 } 262 263 evt = sm_seteventm(timeout, reopenalrm, 0); 264 } 265 266 /* 267 ** There are actually programs that depend on being able to "reopen" 268 ** descriptors that weren't originally open. Keep this from breaking. 269 ** Remember whether the stream was open to begin with, and which file 270 ** descriptor (if any) was associated with it. If it was attached to 271 ** a descriptor, defer closing it; reopen("/dev/stdin", "r", stdin) 272 ** should work. This is unnecessary if it was not a Unix file. 273 */ 274 275 if (fp != NULL) 276 { 277 if (fp->sm_magic != SmFileMagic) 278 fp->f_flags = SMFEOF; /* hold on to it */ 279 else 280 { 281 /* flush the stream; ANSI doesn't require this. */ 282 (void) sm_io_flush(fp, SM_TIME_FOREVER); 283 (void) sm_io_close(fp, SM_TIME_FOREVER); 284 } 285 } 286 287 fp2 = sm_fp(type, ioflags, fp); 288 ret = (*fp2->f_open)(fp2, info, flags, rpool); 289 290 /* We're back. So undo our timeout and handler */ 291 if (evt != NULL) 292 sm_clrevent(evt); 293 294 if (ret < 0) 295 { 296 fp2->f_flags = 0; /* release */ 297 fp2->sm_magic = NULL; /* release */ 298 return NULL; 299 } 300 301 /* 302 ** We're not preserving this logic (below) for sm_io because it is now 303 ** abstracted at least one "layer" away. By closing and reopening 304 ** the 1st fd used should be the just released one (when Unix 305 ** behavior followed). Old comment:: 306 ** If reopening something that was open before on a real file, try 307 ** to maintain the descriptor. Various C library routines (perror) 308 ** assume stderr is always fd STDERR_FILENO, even if being reopen'd. 309 */ 310 311#if SM_RPOOL 312 if (rpool != NULL) 313 sm_rpool_attach_x(rpool, sm_io_close, fp2); 314#endif 315 316 return fp2; 317} 318/* 319** SM_IO_AUTOFLUSH -- link another file to this for auto-flushing 320** 321** When a read occurs on fp, fp2 will be flushed iff there is no 322** data waiting on fp. 323** 324** Parameters: 325** fp -- the file opened for reading. 326** fp2 -- the file opened for writing. 327** 328** Returns: 329** The old flush file pointer. 330*/ 331 332SM_FILE_T * 333sm_io_autoflush(fp, fp2) 334 SM_FILE_T *fp; 335 SM_FILE_T *fp2; 336{ 337 SM_FILE_T *savefp; 338 339 SM_REQUIRE_ISA(fp, SmFileMagic); 340 if (fp2 != NULL) 341 SM_REQUIRE_ISA(fp2, SmFileMagic); 342 343 savefp = fp->f_flushfp; 344 fp->f_flushfp = fp2; 345 return savefp; 346} 347/* 348** SM_IO_AUTOMODE -- link another file to this for auto-moding 349** 350** When the mode (blocking or non-blocking) changes for fp1 then 351** update fp2's mode at the same time. This is to be used when 352** a system dup() has generated a second file descriptor for 353** another sm_io_open() by file descriptor. The modes have been 354** linked in the system and this formalizes it for sm_io internally. 355** 356** Parameters: 357** fp1 -- the first file 358** fp2 -- the second file 359** 360** Returns: 361** nothing 362*/ 363 364void 365sm_io_automode(fp1, fp2) 366 SM_FILE_T *fp1; 367 SM_FILE_T *fp2; 368{ 369 SM_REQUIRE_ISA(fp1, SmFileMagic); 370 SM_REQUIRE_ISA(fp2, SmFileMagic); 371 372 fp1->f_modefp = fp2; 373 fp2->f_modefp = fp1; 374} 375