1/*
2 * Copyright (c) 2000-2005 Sendmail, 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: stdio.c,v 1.71 2005/06/14 23:07:20 ca Exp $")
17#include <unistd.h>
18#include <errno.h>
19#include <fcntl.h>
20#include <string.h> /* FreeBSD: FD_ZERO needs <string.h> */
21#include <sys/stat.h>
22#include <sm/time.h>
23#include <sm/heap.h>
24#include <sm/assert.h>
25#include <sm/varargs.h>
26#include <sm/io.h>
27#include <sm/setjmp.h>
28#include <sm/conf.h>
29#include <sm/fdset.h>
30#include "local.h"
31
32static int sm_stdsetmode __P((SM_FILE_T *, const int *));
33static int sm_stdgetmode __P((SM_FILE_T *, int *));
34
35/*
36** Overall:
37** Small standard I/O/seek/close functions.
38** These maintain the `known seek offset' for seek optimization.
39*/
40
41/*
42** SM_STDOPEN -- open a file with stdio behavior
43**
44** Not associated with the system's stdio in libc.
45**
46** Parameters:
47** fp -- file pointer to be associated with the open
48** info -- pathname of the file to be opened
49** flags -- indicates type of access methods
50** rpool -- ignored
51**
52** Returns:
53** Failure: -1 and set errno
54** Success: 0 or greater (fd of file from open(2)).
55**
56*/
57
58/* ARGSUSED3 */
59int
60sm_stdopen(fp, info, flags, rpool)
61 SM_FILE_T *fp;
62 const void *info;
63 int flags;
64 const void *rpool;
65{
66 char *path = (char *) info;
67 int oflags;
68
69 switch (SM_IO_MODE(flags))
70 {
71 case SM_IO_RDWR:
72 oflags = O_RDWR;
73 break;
74 case SM_IO_RDWRTR:
75 oflags = O_RDWR | O_CREAT | O_TRUNC;
76 break;
77 case SM_IO_RDONLY:
78 oflags = O_RDONLY;
79 break;
80 case SM_IO_WRONLY:
81 oflags = O_WRONLY | O_CREAT | O_TRUNC;
82 break;
83 case SM_IO_APPEND:
84 oflags = O_APPEND | O_WRONLY | O_CREAT;
85 break;
86 case SM_IO_APPENDRW:
87 oflags = O_APPEND | O_RDWR | O_CREAT;
88 break;
89 default:
90 errno = EINVAL;
91 return -1;
92 }
93#ifdef O_BINARY
94 if (SM_IS_BINARY(flags))
95 oflags |= O_BINARY;
96#endif /* O_BINARY */
97 fp->f_file = open(path, oflags,
98 S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
99 if (fp->f_file < 0)
100 return -1; /* errno set by open() */
101
102 if (oflags & O_APPEND)
103 (void) (*fp->f_seek)((void *)fp, (off_t)0, SEEK_END);
104
105 return fp->f_file;
106}
107
108/*
109** SM_STDREAD -- read from the file
110**
111** Parameters:
112** fp -- file pointer to read from
113** buf -- location to place read data
114** n -- number of bytes to read
115**
116** Returns:
117** Failure: -1 and sets errno
118** Success: number of bytes read
119**
120** Side Effects:
121** Updates internal offset into file.
122*/
123
124ssize_t
125sm_stdread(fp, buf, n)
126 SM_FILE_T *fp;
127 char *buf;
128 size_t n;
129{
130 register int ret;
131
132 ret = read(fp->f_file, buf, n);
133
134 /* if the read succeeded, update the current offset */
135 if (ret > 0)
136 fp->f_lseekoff += ret;
137 return ret;
138}
139
140/*
141** SM_STDWRITE -- write to the file
142**
143** Parameters:
144** fp -- file pointer ro write to
145** buf -- location of data to be written
146** n - number of bytes to write
147**
148** Returns:
149** Failure: -1 and sets errno
150** Success: number of bytes written
151*/
152
153ssize_t
154sm_stdwrite(fp, buf, n)
155 SM_FILE_T *fp;
156 char const *buf;
157 size_t n;
158{
159 return write(fp->f_file, buf, n);
160}
161
162/*
163** SM_STDSEEK -- set the file offset position
164**
165** Parmeters:
166** fp -- file pointer to position
167** offset -- how far to position from "base" (set by 'whence')
168** whence -- indicates where the "base" of the 'offset' to start
169**
170** Results:
171** Failure: -1 and sets errno
172** Success: the current offset
173**
174** Side Effects:
175** Updates the internal value of the offset.
176*/
177
178off_t
179sm_stdseek(fp, offset, whence)
180 SM_FILE_T *fp;
181 off_t offset;
182 int whence;
183{
184 register off_t ret;
185
186 ret = lseek(fp->f_file, (off_t) offset, whence);
187 if (ret != (off_t) -1)
188 fp->f_lseekoff = ret;
189 return ret;
190}
191
192/*
193** SM_STDCLOSE -- close the file
194**
195** Parameters:
196** fp -- the file pointer to close
197**
198** Returns:
199** Success: 0 (zero)
200** Failure: -1 and sets errno
201*/
202
203int
204sm_stdclose(fp)
205 SM_FILE_T *fp;
206{
207 return close(fp->f_file);
208}
209
210/*
211** SM_STDSETMODE -- set the access mode for the file
212**
213** Called by sm_stdsetinfo().
214**
215** Parameters:
216** fp -- file pointer
217** mode -- new mode to set the file access to
218**
219** Results:
220** Success: 0 (zero);
221** Failure: -1 and sets errno
222*/
223
224static int
225sm_stdsetmode(fp, mode)
226 SM_FILE_T *fp;
227 const int *mode;
228{
229 int flags = 0;
230
231 switch (SM_IO_MODE(*mode))
232 {
233 case SM_IO_RDWR:
234 flags |= SMRW;
235 break;
236 case SM_IO_RDONLY:
237 flags |= SMRD;
238 break;
239 case SM_IO_WRONLY:
240 flags |= SMWR;
241 break;
242 case SM_IO_APPEND:
243 default:
244 errno = EINVAL;
245 return -1;
246 }
247 fp->f_flags = fp->f_flags & ~SMMODEMASK;
248 fp->f_flags |= flags;
249 return 0;
250}
251
252/*
253** SM_STDGETMODE -- for getinfo determine open mode
254**
255** Called by sm_stdgetinfo().
256**
257** Parameters:
258** fp -- the file mode being determined
259** mode -- internal mode to map to external value
260**
261** Results:
262** Failure: -1 and sets errno
263** Success: external mode value
264*/
265
266static int
267sm_stdgetmode(fp, mode)
268 SM_FILE_T *fp;
269 int *mode;
270{
271 switch (fp->f_flags & SMMODEMASK)
272 {
273 case SMRW:
274 *mode = SM_IO_RDWR;
275 break;
276 case SMRD:
277 *mode = SM_IO_RDONLY;
278 break;
279 case SMWR:
280 *mode = SM_IO_WRONLY;
281 break;
282 default:
283 errno = EINVAL;
284 return -1;
285 }
286 return 0;
287}
288
289/*
290** SM_STDSETINFO -- set/modify information for a file
291**
292** Parameters:
293** fp -- file to set info for
294** what -- type of info to set
295** valp -- location of data used for setting
296**
297** Returns:
298** Failure: -1 and sets errno
299** Success: >=0
300*/
301
302int
303sm_stdsetinfo(fp, what, valp)
304 SM_FILE_T *fp;
305 int what;
306 void *valp;
307{
308 switch (what)
309 {
310 case SM_IO_WHAT_MODE:
311 return sm_stdsetmode(fp, (const int *)valp);
312
313 default:
314 errno = EINVAL;
315 return -1;
316 }
317}
318
319/*
320** SM_GETINFO -- get information about the open file
321**
322** Parameters:
323** fp -- file to get info for
324** what -- type of info to get
325** valp -- location to place found info
326**
327** Returns:
328** Success: may or may not place info in 'valp' depending
329** on 'what' value, and returns values >=0. Return
330** value may be the obtained info
331** Failure: -1 and sets errno
332*/
333
334int
335sm_stdgetinfo(fp, what, valp)
336 SM_FILE_T *fp;
337 int what;
338 void *valp;
339{
340 switch (what)
341 {
342 case SM_IO_WHAT_MODE:
343 return sm_stdgetmode(fp, (int *)valp);
344
345 case SM_IO_WHAT_FD:
346 return fp->f_file;
347
348 case SM_IO_WHAT_SIZE:
349 {
350 struct stat st;
351
352 if (fstat(fp->f_file, &st) == 0)
353 return st.st_size;
354 else
355 return -1;
356 }
357
358 case SM_IO_IS_READABLE:
359 {
360 fd_set readfds;
361 struct timeval timeout;
362
363 if (SM_FD_SETSIZE > 0 && fp->f_file >= SM_FD_SETSIZE)
364 {
365 errno = EINVAL;
366 return -1;
367 }
368 FD_ZERO(&readfds);
369 SM_FD_SET(fp->f_file, &readfds);
370 timeout.tv_sec = 0;
371 timeout.tv_usec = 0;
372 if (select(fp->f_file + 1, FDSET_CAST &readfds,
373 NULL, NULL, &timeout) > 0 &&
374 SM_FD_ISSET(fp->f_file, &readfds))
375 return 1;
376 return 0;
377 }
378
379 default:
380 errno = EINVAL;
381 return -1;
382 }
383}
384
385/*
386** SM_STDFDOPEN -- open file by primitive 'fd' rather than pathname
387**
388** I/O function to handle fdopen() stdio equivalence. The rest of
389** the functions are the same as the sm_stdopen() above.
390**
391** Parameters:
392** fp -- the file pointer to be associated with the open
393** name -- the primitive file descriptor for association
394** flags -- indicates type of access methods
395** rpool -- ignored
396**
397** Results:
398** Success: primitive file descriptor value
399** Failure: -1 and sets errno
400*/
401
402/* ARGSUSED3 */
403int
404sm_stdfdopen(fp, info, flags, rpool)
405 SM_FILE_T *fp;
406 const void *info;
407 int flags;
408 const void *rpool;
409{
410 int oflags, tmp, fdflags, fd = *((int *) info);
411
412 switch (SM_IO_MODE(flags))
413 {
414 case SM_IO_RDWR:
415 oflags = O_RDWR | O_CREAT;
416 break;
417 case SM_IO_RDONLY:
418 oflags = O_RDONLY;
419 break;
420 case SM_IO_WRONLY:
421 oflags = O_WRONLY | O_CREAT | O_TRUNC;
422 break;
423 case SM_IO_APPEND:
424 oflags = O_APPEND | O_WRONLY | O_CREAT;
425 break;
426 case SM_IO_APPENDRW:
427 oflags = O_APPEND | O_RDWR | O_CREAT;
428 break;
429 default:
430 errno = EINVAL;
431 return -1;
432 }
433#ifdef O_BINARY
434 if (SM_IS_BINARY(flags))
435 oflags |= O_BINARY;
436#endif /* O_BINARY */
437
438 /* Make sure the mode the user wants is a subset of the actual mode. */
439 if ((fdflags = fcntl(fd, F_GETFL, 0)) < 0)
440 return -1;
441 tmp = fdflags & O_ACCMODE;
442 if (tmp != O_RDWR && (tmp != (oflags & O_ACCMODE)))
443 {
444 errno = EINVAL;
445 return -1;
446 }
447 fp->f_file = fd;
448 if (oflags & O_APPEND)
449 (void) (*fp->f_seek)(fp, (off_t)0, SEEK_END);
450 return fp->f_file;
451}
452
453/*
454** SM_IO_FOPEN -- open a file
455**
456** Same interface and semantics as the open() system call,
457** except that it returns SM_FILE_T* instead of a file descriptor.
458**
459** Parameters:
460** pathname -- path of file to open
461** flags -- flags controlling the open
462** ... -- option "mode" for opening the file
463**
464** Returns:
465** Raises an exception on heap exhaustion.
466** Returns NULL and sets errno if open() fails.
467** Returns an SM_FILE_T pointer on success.
468*/
469
470SM_FILE_T *
471#if SM_VA_STD
472sm_io_fopen(char *pathname, int flags, ...)
473#else /* SM_VA_STD */
474sm_io_fopen(pathname, flags, va_alist)
475 char *pathname;
476 int flags;
477 va_dcl
478#endif /* SM_VA_STD */
479{
480 MODE_T mode;
481 SM_FILE_T *fp;
482 int ioflags;
483
484 if (flags & O_CREAT)
485 {
486 SM_VA_LOCAL_DECL
487
488 SM_VA_START(ap, flags);
489 mode = (MODE_T) SM_VA_ARG(ap, int);
490 SM_VA_END(ap);
491 }
492 else
493 mode = 0;
494
495 switch (flags & O_ACCMODE)
496 {
497 case O_RDONLY:
498 ioflags = SMRD;
499 break;
500 case O_WRONLY:
501 ioflags = SMWR;
502 break;
503 case O_RDWR:
504 ioflags = SMRW;
505 break;
506 default:
507 sm_abort("sm_io_fopen: bad flags 0%o", flags);
508 }
509
510 fp = sm_fp(SmFtStdio, ioflags, NULL);
511 fp->f_file = open(pathname, flags, mode);
512 if (fp->f_file == -1)
513 {
514 fp->f_flags = 0;
515 fp->sm_magic = NULL;
516 return NULL;
517 }
518 return fp;
519}