1/*
2 * Copyright (c) 1999-2002 Sendmail, Inc. and its suppliers.
3 *	All rights reserved.
4 *
5 * By using this file, you agree to the terms and conditions set
6 * forth in the LICENSE file which can be found at the top level of
7 * the sendmail distribution.
8 *
9 */
10
11#pragma ident	"%Z%%M%	%I%	%E% SMI"
12
13#include <sm/gen.h>
14SM_RCSID("@(#)$Id: strl.c,v 1.31 2002/01/20 01:41:25 gshapiro Exp $")
15#include <sm/config.h>
16#include <sm/string.h>
17
18/*
19**  Notice: this file is used by libmilter. Please try to avoid
20**	using libsm specific functions.
21*/
22
23/*
24**  XXX the type of the length parameter has been changed
25**  from size_t to ssize_t to avoid theoretical problems with negative
26**  numbers passed into these functions.
27**  The real solution to this problem is to make sure that this doesn't
28**  happen, but for now we'll use this workaround.
29*/
30
31/*
32**  SM_STRLCPY -- size bounded string copy
33**
34**	This is a bounds-checking variant of strcpy.
35**	If size > 0, copy up to size-1 characters from the nul terminated
36**	string src to dst, nul terminating the result.  If size == 0,
37**	the dst buffer is not modified.
38**	Additional note: this function has been "tuned" to run fast and tested
39**	as such (versus versions in some OS's libc).
40**
41**	The result is strlen(src).  You can detect truncation (not all
42**	of the characters in the source string were copied) using the
43**	following idiom:
44**
45**		char *s, buf[BUFSIZ];
46**		...
47**		if (sm_strlcpy(buf, s, sizeof(buf)) >= sizeof(buf))
48**			goto overflow;
49**
50**	Parameters:
51**		dst -- destination buffer
52**		src -- source string
53**		size -- size of destination buffer
54**
55**	Returns:
56**		strlen(src)
57*/
58
59size_t
60sm_strlcpy(dst, src, size)
61	register char *dst;
62	register const char *src;
63	ssize_t size;
64{
65	register ssize_t i;
66
67	if (size-- <= 0)
68		return strlen(src);
69	for (i = 0; i < size && (dst[i] = src[i]) != 0; i++)
70		continue;
71	dst[i] = '\0';
72	if (src[i] == '\0')
73		return i;
74	else
75		return i + strlen(src + i);
76}
77
78/*
79**  SM_STRLCAT -- size bounded string concatenation
80**
81**	This is a bounds-checking variant of strcat.
82**	If strlen(dst) < size, then append at most size - strlen(dst) - 1
83**	characters from the source string to the destination string,
84**	nul terminating the result.  Otherwise, dst is not modified.
85**
86**	The result is the initial length of dst + the length of src.
87**	You can detect overflow (not all of the characters in the
88**	source string were copied) using the following idiom:
89**
90**		char *s, buf[BUFSIZ];
91**		...
92**		if (sm_strlcat(buf, s, sizeof(buf)) >= sizeof(buf))
93**			goto overflow;
94**
95**	Parameters:
96**		dst -- nul-terminated destination string buffer
97**		src -- nul-terminated source string
98**		size -- size of destination buffer
99**
100**	Returns:
101**		total length of the string tried to create
102**		(= initial length of dst + length of src)
103*/
104
105size_t
106sm_strlcat(dst, src, size)
107	register char *dst;
108	register const char *src;
109	ssize_t size;
110{
111	register ssize_t i, j, o;
112
113	o = strlen(dst);
114	if (size < o + 1)
115		return o + strlen(src);
116	size -= o + 1;
117	for (i = 0, j = o; i < size && (dst[j] = src[i]) != 0; i++, j++)
118		continue;
119	dst[j] = '\0';
120	if (src[i] == '\0')
121		return j;
122	else
123		return j + strlen(src + i);
124}
125/*
126**  SM_STRLCAT2 -- append two strings to dst obeying length and
127**		'\0' terminate it
128**
129**		strlcat2 will append at most len - strlen(dst) - 1 chars.
130**		terminates with '\0' if len > 0
131**		dst = dst "+" src1 "+" src2
132**		use this instead of sm_strlcat(dst,src1); sm_strlcat(dst,src2);
133**		for better speed.
134**
135**	Parameters:
136**		dst -- "destination" string.
137**		src1 -- "from" string 1.
138**		src2 -- "from" string 2.
139**		len -- max. length of "destination" string.
140**
141**	Returns:
142**		total length of the string tried to create
143**		(= initial length of dst + length of src)
144**		if this is greater than len then an overflow would have
145**		occurred.
146**
147*/
148
149size_t
150sm_strlcat2(dst, src1, src2, len)
151	register char *dst;
152	register const char *src1;
153	register const char *src2;
154	ssize_t len;
155{
156	register ssize_t i, j, o;
157
158	/* current size of dst */
159	o = strlen(dst);
160
161	/* max. size is less than current? */
162	if (len < o + 1)
163		return o + strlen(src1) + strlen(src2);
164
165	len -= o + 1;	/* space left in dst */
166
167	/* copy the first string; i: index in src1; j: index in dst */
168	for (i = 0, j = o; i < len && (dst[j] = src1[i]) != 0; i++, j++)
169		continue;
170
171	/* src1: end reached? */
172	if (src1[i] != '\0')
173	{
174		/* no: terminate dst; there is space since i < len */
175		dst[j] = '\0';
176		return j + strlen(src1 + i) + strlen(src2);
177	}
178
179	len -= i;	/* space left in dst */
180
181	/* copy the second string; i: index in src2; j: index in dst */
182	for (i = 0; i < len && (dst[j] = src2[i]) != 0; i++, j++)
183		continue;
184	dst[j] = '\0';	/* terminate dst; there is space since i < len */
185	if (src2[i] == '\0')
186		return j;
187	else
188		return j + strlen(src2 + i);
189}
190
191/*
192**  SM_STRLCPYN -- concatenate n strings and assign the result to dst
193**		while obeying length and '\0' terminate it
194**
195**		dst = src1 "+" src2 "+" ...
196**		use this instead of sm_snprintf() for string values
197**		and repeated sm_strlc*() calls for better speed.
198**
199**	Parameters:
200**		dst -- "destination" string.
201**		len -- max. length of "destination" string.
202**		n -- number of strings
203**		strings...
204**
205**	Returns:
206**		total length of the string tried to create
207**		(= initial length of dst + length of src)
208**		if this is greater than len then an overflow would have
209**		occurred.
210*/
211
212size_t
213#ifdef __STDC__
214sm_strlcpyn(char *dst, ssize_t len, int n, ...)
215#else /* __STDC__ */
216sm_strlcpyn(dst, len, n, va_alist)
217	register char *dst;
218	ssize_t len;
219	int n;
220	va_dcl
221#endif /* __STDC__ */
222{
223	register ssize_t i, j;
224	char *str;
225	SM_VA_LOCAL_DECL
226
227	SM_VA_START(ap, n);
228
229	if (len-- <= 0) /* This allows space for the terminating '\0' */
230	{
231		i = 0;
232		while (n-- > 0)
233			i += strlen(SM_VA_ARG(ap, char *));
234		SM_VA_END(ap);
235		return i;
236	}
237
238	j = 0;	/* index in dst */
239
240	/* loop through all source strings */
241	while (n-- > 0)
242	{
243		str = SM_VA_ARG(ap, char *);
244
245		/* copy string; i: index in str; j: index in dst */
246		for (i = 0; j < len && (dst[j] = str[i]) != 0; i++, j++)
247			continue;
248
249		/* str: end reached? */
250		if (str[i] != '\0')
251		{
252			/* no: terminate dst; there is space since j < len */
253			dst[j] = '\0';
254			j += strlen(str + i);
255			while (n-- > 0)
256				j += strlen(SM_VA_ARG(ap, char *));
257			SM_VA_END(ap);
258			return j;
259		}
260	}
261	SM_VA_END(ap);
262
263	dst[j] = '\0';	/* terminate dst; there is space since j < len */
264	return j;
265}
266
267#if 0
268/*
269**  SM_STRLAPP -- append string if it fits into buffer.
270**
271**	If size > 0, copy up to size-1 characters from the nul terminated
272**	string src to dst, nul terminating the result.  If size == 0,
273**	the dst buffer is not modified.
274**
275**	This routine is useful for appending strings in a loop, e.g, instead of
276**	s = buf;
277**	for (ptr, ptr != NULL, ptr = next->ptr)
278**	{
279**		(void) sm_strlcpy(s, ptr->string, sizeof buf - (s - buf));
280**		s += strlen(s);
281**	}
282**	replace the loop body with:
283**		if (!sm_strlapp(*s, ptr->string, sizeof buf - (s - buf)))
284**			break;
285**	it's faster...
286**
287**	XXX interface isn't completely clear (yet), hence this code is
288**	not available.
289**
290**
291**	Parameters:
292**		dst -- (pointer to) destination buffer
293**		src -- source string
294**		size -- size of destination buffer
295**
296**	Returns:
297**		true if strlen(src) < size
298**
299**	Side Effects:
300**		modifies dst if append succeeds (enough space).
301*/
302
303bool
304sm_strlapp(dst, src, size)
305	register char **dst;
306	register const char *src;
307	ssize_t size;
308{
309	register size_t i;
310
311	if (size-- <= 0)
312		return false;
313	for (i = 0; i < size && ((*dst)[i] = src[i]) != '\0'; i++)
314		continue;
315	(*dst)[i] = '\0';
316	if (src[i] == '\0')
317	{
318		*dst += i;
319		return true;
320	}
321
322	/* undo */
323	(*dst)[0] = '\0';
324	return false;
325}
326#endif /* 0 */
327