xref: /illumos-gate/usr/src/cmd/sendmail/libsm/strio.c (revision bdfc6d18da790deeec2e0eb09c625902defe2498) 
1 /*
2  * Copyright (c) 2000-2002, 2004 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.43 2004/08/03 20:48:30 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 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 }
493