1 /*
2 * Copyright (c) 2000-2002, 2004, 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 #pragma ident "%Z%%M% %I% %E% SMI"
16
17 #include <sm/gen.h>
18 SM_IDSTR(id, "@(#)$Id: strio.c,v 1.44 2005/06/09 21:40:19 ca Exp $")
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <sm/rpool.h>
25 #include <sm/io.h>
26 #include <sm/heap.h>
27 #include <sm/conf.h>
28 #include "local.h"
29
30 static int sm_strsetmode __P((SM_FILE_T*, const int *));
31 static int sm_strgetmode __P((SM_FILE_T*, int *));
32
33 /*
34 ** Cookie structure for the "strio" file type
35 */
36
37 struct sm_str_obj
38 {
39 char *strio_base;
40 char *strio_end;
41 size_t strio_size;
42 size_t strio_offset;
43 int strio_flags;
44 const void *strio_rpool;
45 };
46
47 typedef struct sm_str_obj SM_STR_OBJ_T;
48
49 /*
50 ** SM_STRGROW -- increase storage space for string
51 **
52 ** Parameters:
53 ** s -- current cookie
54 ** size -- new storage size request
55 **
56 ** Returns:
57 ** true iff successful.
58 */
59
60 static bool sm_strgrow __P((SM_STR_OBJ_T *, size_t));
61
62 static bool
63 sm_strgrow(s, size)
64 SM_STR_OBJ_T *s;
65 size_t size;
66 {
67 register void *p;
68
69 if (s->strio_size >= size)
70 return true;
71 p = sm_realloc(s->strio_base, size);
72 if (p == NULL)
73 return false;
74 s->strio_base = p;
75 s->strio_end = s->strio_base + size;
76 s->strio_size = size;
77 return true;
78 }
79
80 /*
81 ** SM_STRREAD -- read a portion of the string
82 **
83 ** Parameters:
84 ** fp -- the file pointer
85 ** buf -- location to place read data
86 ** n -- number of bytes to read
87 **
88 ** Returns:
89 ** Failure: -1 and sets errno
90 ** Success: >=0, number of bytes read
91 */
92
93 ssize_t
94 sm_strread(fp, buf, n)
95 SM_FILE_T *fp;
96 char *buf;
97 size_t n;
98 {
99 register SM_STR_OBJ_T *s = fp->f_cookie;
100 int len;
101
102 if (!(s->strio_flags & SMRD) && !(s->strio_flags & SMRW))
103 {
104 errno = EBADF;
105 return -1;
106 }
107 len = SM_MIN(s->strio_size - s->strio_offset, n);
108 (void) memmove(buf, s->strio_base + s->strio_offset, len);
109 s->strio_offset += len;
110 return len;
111 }
112
113 /*
114 ** SM_STRWRITE -- write a portion of the string
115 **
116 ** Parameters:
117 ** fp -- the file pointer
118 ** buf -- location of data for writing
119 ** n -- number of bytes to write
120 **
121 ** Returns:
122 ** Failure: -1 and sets errno
123 ** Success: >=0, number of bytes written
124 */
125
126 ssize_t
127 sm_strwrite(fp, buf, n)
128 SM_FILE_T *fp;
129 char const *buf;
130 size_t n;
131 {
132 register SM_STR_OBJ_T *s = fp->f_cookie;
133
134 if (!(s->strio_flags & SMWR) && !(s->strio_flags & SMRW))
135 {
136 errno = EBADF;
137 return -1;
138 }
139 if (n + s->strio_offset > s->strio_size)
140 {
141 if (!sm_strgrow(s, n + s->strio_offset))
142 return 0;
143 }
144 (void) memmove(s->strio_base + s->strio_offset, buf, n);
145 s->strio_offset += n;
146 return n;
147 }
148
149 /*
150 ** SM_STRSEEK -- position the offset pointer for the string
151 **
152 ** Only SM_IO_SEEK_SET, SM_IO_SEEK_CUR and SM_IO_SEEK_END are valid
153 ** values for whence.
154 **
155 ** Parameters:
156 ** fp -- the file pointer
157 ** offset -- number of bytes offset from "base"
158 ** whence -- determines "base" for 'offset'
159 **
160 ** Returns:
161 ** Failure: -1 and sets errno
162 ** Success: >=0, number of bytes read
163 */
164
165 off_t
166 sm_strseek(fp, offset, whence)
167 SM_FILE_T *fp;
168 off_t offset;
169 int whence;
170 {
171 register off_t ret;
172 register SM_STR_OBJ_T *s = fp->f_cookie;
173
174 reseek:
175 switch (whence)
176 {
177 case SM_IO_SEEK_SET:
178 ret = offset;
179 break;
180 case SM_IO_SEEK_CUR:
181 ret = s->strio_offset + offset;
182 break;
183 case SM_IO_SEEK_END:
184 ret = s->strio_size;
185 break;
186 default:
187 errno = EINVAL;
188 return -1;
189 }
190 if (ret < 0 || ret > (off_t)(size_t)(-1)) /* XXX ugly */
191 return -1;
192 if ((size_t) ret > s->strio_size)
193 {
194 if (sm_strgrow(s, (size_t)ret))
195 goto reseek;
196
197 /* errno set by sm_strgrow */
198 return -1;
199 }
200 s->strio_offset = (size_t) ret;
201 return ret;
202 }
203
204 /*
205 ** SM_STROPEN -- open a string file type
206 **
207 ** Parameters:
208 ** fp -- file pointer open to be associated with
209 ** info -- initial contents (NULL for none)
210 ** flags -- flags for methods of access (was mode)
211 ** rpool -- resource pool to use memory from (if applicable)
212 **
213 ** Results:
214 ** Success: 0 (zero)
215 ** Failure: -1 and sets errno
216 */
217
218 int
219 sm_stropen(fp, info, flags, rpool)
220 SM_FILE_T *fp;
221 const void *info;
222 int flags;
223 const void *rpool;
224 {
225 register SM_STR_OBJ_T *s;
226
227 #if SM_RPOOL
228 s = sm_rpool_malloc_x(rpool, sizeof(SM_STR_OBJ_T));
229 #else /* SM_RPOOL */
230 s = sm_malloc(sizeof(SM_STR_OBJ_T));
231 if (s == NULL)
232 return -1;
233 #endif /* SM_RPOOL */
234
235 fp->f_cookie = s;
236 s->strio_rpool = rpool;
237 s->strio_offset = 0;
238 s->strio_size = 0;
239 s->strio_base = NULL;
240 s->strio_end = 0;
241
242 switch (flags)
243 {
244 case SM_IO_RDWR:
245 s->strio_flags = SMRW;
246 break;
247 case SM_IO_RDONLY:
248 s->strio_flags = SMRD;
249 break;
250 case SM_IO_WRONLY:
251 s->strio_flags = SMWR;
252 break;
253 case SM_IO_APPEND:
254 if (s->strio_rpool == NULL)
255 sm_free(s);
256 errno = EINVAL;
257 return -1;
258 default:
259 if (s->strio_rpool == NULL)
260 sm_free(s);
261 errno = EINVAL;
262 return -1;
263 }
264
265 if (info != NULL)
266 {
267 s->strio_base = sm_strdup_x(info);
268 if (s->strio_base == NULL)
269 {
270 int save_errno = errno;
271
272 if (s->strio_rpool == NULL)
273 sm_free(s);
274 errno = save_errno;
275 return -1;
276 }
277 s->strio_size = strlen(info);
278 s->strio_end = s->strio_base + s->strio_size;
279 }
280 return 0;
281 }
282
283 /*
284 ** SM_STRCLOSE -- close the string file type and free resources
285 **
286 ** Parameters:
287 ** fp -- file pointer
288 **
289 ** Results:
290 ** Success: 0 (zero)
291 */
292
293 int
294 sm_strclose(fp)
295 SM_FILE_T *fp;
296 {
297 SM_STR_OBJ_T *s = fp->f_cookie;
298
299 #if !SM_RPOOL
300 sm_free(s->strio_base);
301 s->strio_base = NULL;
302 #endif /* !SM_RPOOL */
303 return 0;
304 }
305
306 /*
307 ** SM_STRSETMODE -- set mode info for the file
308 **
309 ** Note: changing the mode can be a safe way to have the "parent"
310 ** set up a string that the "child" is not to modify
311 **
312 ** Parameters:
313 ** fp -- the file pointer
314 ** mode -- location of new mode to set
315 **
316 ** Results:
317 ** Success: 0 (zero)
318 ** Failure: -1 and sets errno
319 */
320
321 static int
322 sm_strsetmode(fp, mode)
323 SM_FILE_T *fp;
324 const int *mode;
325 {
326 register SM_STR_OBJ_T *s = fp->f_cookie;
327 int flags;
328
329 switch (*mode)
330 {
331 case SM_IO_RDWR:
332 flags = SMRW;
333 break;
334 case SM_IO_RDONLY:
335 flags = SMRD;
336 break;
337 case SM_IO_WRONLY:
338 flags = SMWR;
339 break;
340 case SM_IO_APPEND:
341 errno = EINVAL;
342 return -1;
343 default:
344 errno = EINVAL;
345 return -1;
346 }
347 s->strio_flags &= ~SMMODEMASK;
348 s->strio_flags |= flags;
349 return 0;
350 }
351
352 /*
353 ** SM_STRGETMODE -- get mode info for the file
354 **
355 ** Parameters:
356 ** fp -- the file pointer
357 ** mode -- location to store current mode
358 **
359 ** Results:
360 ** Success: 0 (zero)
361 ** Failure: -1 and sets errno
362 */
363
364 static int
365 sm_strgetmode(fp, mode)
366 SM_FILE_T *fp;
367 int *mode;
368 {
369 register SM_STR_OBJ_T *s = fp->f_cookie;
370
371 switch (s->strio_flags & SMMODEMASK)
372 {
373 case SMRW:
374 *mode = SM_IO_RDWR;
375 break;
376 case SMRD:
377 *mode = SM_IO_RDONLY;
378 break;
379 case SMWR:
380 *mode = SM_IO_WRONLY;
381 break;
382 default:
383 errno = EINVAL;
384 return -1;
385 }
386 return 0;
387 }
388
389 /*
390 ** SM_STRSETINFO -- set info for the file
391 **
392 ** Currently only SM_IO_WHAT_MODE is supported for 'what'.
393 **
394 ** Parameters:
395 ** fp -- the file pointer
396 ** what -- type of information to set
397 ** valp -- location to data for doing set
398 **
399 ** Results:
400 ** Failure: -1 and sets errno
401 ** Success: sm_strsetmode() return [0 (zero)]
402 */
403
404 int
405 sm_strsetinfo(fp, what, valp)
406 SM_FILE_T *fp;
407 int what;
408 void *valp;
409 {
410 switch(what)
411 {
412 case SM_IO_WHAT_MODE:
413 return sm_strsetmode(fp, (int *) valp);
414 default:
415 errno = EINVAL;
416 return -1;
417 }
418 }
419
420 /*
421 ** SM_STRGETINFO -- get info for the file
422 **
423 ** Currently only SM_IO_WHAT_MODE is supported for 'what'.
424 **
425 ** Parameters:
426 ** fp -- the file pointer
427 ** what -- type of information requested
428 ** valp -- location to return information in
429 **
430 ** Results:
431 ** Failure: -1 and sets errno
432 ** Success: sm_strgetmode() return [0 (zero)]
433 */
434
435 int
436 sm_strgetinfo(fp, what, valp)
437 SM_FILE_T *fp;
438 int what;
439 void *valp;
440 {
441 switch(what)
442 {
443 case SM_IO_WHAT_MODE:
444 return sm_strgetmode(fp, (int *) valp);
445 default:
446 errno = EINVAL;
447 return -1;
448 }
449 }
450
451 /*
452 ** SM_STRIO_INIT -- initializes a write-only string type
453 **
454 ** Original comments below. This function does not appear to be used anywhere.
455 ** The same functionality can be done by changing the mode of the file.
456 ** ------------
457 ** sm_strio_init initializes an SM_FILE_T structure as a write-only file
458 ** that writes into the specified buffer:
459 ** - Use sm_io_putc, sm_io_fprintf, etc, to write into the buffer.
460 ** Attempts to write more than size-1 characters into the buffer will fail
461 ** silently (no error is reported).
462 ** - Use sm_io_fflush to nul terminate the string in the buffer
463 ** (the write pointer is not advanced).
464 ** No memory is allocated either by sm_strio_init or by sm_io_{putc,write} etc.
465 **
466 ** Parameters:
467 ** fp -- file pointer
468 ** buf -- memory location for stored data
469 ** size -- size of 'buf'
470 **
471 ** Results:
472 ** none.
473 */
474
475 void
476 sm_strio_init(fp, buf, size)
477 SM_FILE_T *fp;
478 char *buf;
479 size_t size;
480 {
481 fp->sm_magic = SmFileMagic;
482 fp->f_flags = SMWR | SMSTR;
483 fp->f_file = -1;
484 fp->f_bf.smb_base = fp->f_p = (unsigned char *) buf;
485 fp->f_bf.smb_size = fp->f_w = (size ? size - 1 : 0);
486 fp->f_lbfsize = 0;
487 fp->f_r = 0;
488 fp->f_read = NULL;
489 fp->f_seek = NULL;
490 fp->f_getinfo = NULL;
491 fp->f_setinfo = NULL;
492 }