1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 /*
17 * Copyright (c) 1990, 1993
18 * The Regents of the University of California. All rights reserved.
19 *
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions
22 * are met:
23 * 1. Redistributions of source code must retain the above copyright
24 * notice, this list of conditions and the following disclaimer.
25 * 2. Redistributions in binary form must reproduce the above copyright
26 * notice, this list of conditions and the following disclaimer in the
27 * documentation and/or other materials provided with the distribution.
28 * 3. All advertising materials mentioning features or use of this software
29 * must display the following acknowledgement:
30 * This product includes software developed by the University of
31 * California, Berkeley and its contributors.
32 * 4. Neither the name of the University nor the names of its contributors
33 * may be used to endorse or promote products derived from this software
34 * without specific prior written permission.
35 *
36 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
37 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
40 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
42 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
44 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
45 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46 * SUCH DAMAGE.
47 */
48
49 #include "apr.h"
50 #include "apr_strings.h"
51 #include "apr_general.h"
52 #include "apr_private.h"
53 #include "apr_lib.h"
54 #define APR_WANT_STDIO
55 #define APR_WANT_STRFUNC
56 #include "apr_want.h"
57
58 #ifdef HAVE_STDDEF_H
59 #include <stddef.h> /* NULL */
60 #endif
61
62 #ifdef HAVE_STDLIB_H
63 #include <stdlib.h> /* strtol and strtoll */
64 #endif
65
66 /** this is used to cache lengths in apr_pstrcat */
67 #define MAX_SAVED_LENGTHS 6
68
apr_pstrdup(apr_pool_t * a,const char * s)69 APR_DECLARE(char *) apr_pstrdup(apr_pool_t *a, const char *s)
70 {
71 char *res;
72 apr_size_t len;
73
74 if (s == NULL) {
75 return NULL;
76 }
77 len = strlen(s) + 1;
78 res = apr_pmemdup(a, s, len);
79 return res;
80 }
81
apr_pstrndup(apr_pool_t * a,const char * s,apr_size_t n)82 APR_DECLARE(char *) apr_pstrndup(apr_pool_t *a, const char *s, apr_size_t n)
83 {
84 char *res;
85 const char *end;
86
87 if (s == NULL) {
88 return NULL;
89 }
90 end = memchr(s, '\0', n);
91 if (end != NULL)
92 n = end - s;
93 res = apr_palloc(a, n + 1);
94 memcpy(res, s, n);
95 res[n] = '\0';
96 return res;
97 }
98
apr_pstrmemdup(apr_pool_t * a,const char * s,apr_size_t n)99 APR_DECLARE(char *) apr_pstrmemdup(apr_pool_t *a, const char *s, apr_size_t n)
100 {
101 char *res;
102
103 if (s == NULL) {
104 return NULL;
105 }
106 res = apr_palloc(a, n + 1);
107 memcpy(res, s, n);
108 res[n] = '\0';
109 return res;
110 }
111
apr_pmemdup(apr_pool_t * a,const void * m,apr_size_t n)112 APR_DECLARE(void *) apr_pmemdup(apr_pool_t *a, const void *m, apr_size_t n)
113 {
114 void *res;
115
116 if (m == NULL)
117 return NULL;
118 res = apr_palloc(a, n);
119 memcpy(res, m, n);
120 return res;
121 }
122
apr_pstrcat(apr_pool_t * a,...)123 APR_DECLARE_NONSTD(char *) apr_pstrcat(apr_pool_t *a, ...)
124 {
125 char *cp, *argp, *res;
126 apr_size_t saved_lengths[MAX_SAVED_LENGTHS];
127 int nargs = 0;
128
129 /* Pass one --- find length of required string */
130
131 apr_size_t len = 0;
132 va_list adummy;
133
134 va_start(adummy, a);
135
136 while ((cp = va_arg(adummy, char *)) != NULL) {
137 apr_size_t cplen = strlen(cp);
138 if (nargs < MAX_SAVED_LENGTHS) {
139 saved_lengths[nargs++] = cplen;
140 }
141 len += cplen;
142 }
143
144 va_end(adummy);
145
146 /* Allocate the required string */
147
148 res = (char *) apr_palloc(a, len + 1);
149 cp = res;
150
151 /* Pass two --- copy the argument strings into the result space */
152
153 va_start(adummy, a);
154
155 nargs = 0;
156 while ((argp = va_arg(adummy, char *)) != NULL) {
157 if (nargs < MAX_SAVED_LENGTHS) {
158 len = saved_lengths[nargs++];
159 }
160 else {
161 len = strlen(argp);
162 }
163
164 memcpy(cp, argp, len);
165 cp += len;
166 }
167
168 va_end(adummy);
169
170 /* Return the result string */
171
172 *cp = '\0';
173
174 return res;
175 }
176
apr_pstrcatv(apr_pool_t * a,const struct iovec * vec,apr_size_t nvec,apr_size_t * nbytes)177 APR_DECLARE(char *) apr_pstrcatv(apr_pool_t *a, const struct iovec *vec,
178 apr_size_t nvec, apr_size_t *nbytes)
179 {
180 apr_size_t i;
181 apr_size_t len;
182 const struct iovec *src;
183 char *res;
184 char *dst;
185
186 /* Pass one --- find length of required string */
187 len = 0;
188 src = vec;
189 for (i = nvec; i; i--) {
190 len += src->iov_len;
191 src++;
192 }
193 if (nbytes) {
194 *nbytes = len;
195 }
196
197 /* Allocate the required string */
198 res = (char *) apr_palloc(a, len + 1);
199
200 /* Pass two --- copy the argument strings into the result space */
201 src = vec;
202 dst = res;
203 for (i = nvec; i; i--) {
204 memcpy(dst, src->iov_base, src->iov_len);
205 dst += src->iov_len;
206 src++;
207 }
208
209 /* Return the result string */
210 *dst = '\0';
211
212 return res;
213 }
214
215 #if (!APR_HAVE_MEMCHR)
memchr(const void * s,int c,size_t n)216 void *memchr(const void *s, int c, size_t n)
217 {
218 const char *cp;
219
220 for (cp = s; n > 0; n--, cp++) {
221 if (*cp == c)
222 return (char *) cp; /* Casting away the const here */
223 }
224
225 return NULL;
226 }
227 #endif
228
229 #ifndef INT64_MAX
230 #define INT64_MAX APR_INT64_C(0x7fffffffffffffff)
231 #endif
232 #ifndef INT64_MIN
233 #define INT64_MIN (-APR_INT64_C(0x7fffffffffffffff) - APR_INT64_C(1))
234 #endif
235
apr_strtoff(apr_off_t * offset,const char * nptr,char ** endptr,int base)236 APR_DECLARE(apr_status_t) apr_strtoff(apr_off_t *offset, const char *nptr,
237 char **endptr, int base)
238 {
239 errno = 0;
240 *offset = APR_OFF_T_STRFN(nptr, endptr, base);
241 return APR_FROM_OS_ERROR(errno);
242 }
243
apr_strtoi64(const char * nptr,char ** endptr,int base)244 APR_DECLARE(apr_int64_t) apr_strtoi64(const char *nptr, char **endptr, int base)
245 {
246 #ifdef APR_INT64_STRFN
247 errno = 0;
248 return APR_INT64_STRFN(nptr, endptr, base);
249 #else
250 const char *s;
251 apr_int64_t acc;
252 apr_int64_t val;
253 int neg, any;
254 char c;
255
256 errno = 0;
257 /*
258 * Skip white space and pick up leading +/- sign if any.
259 * If base is 0, allow 0x for hex and 0 for octal, else
260 * assume decimal; if base is already 16, allow 0x.
261 */
262 s = nptr;
263 do {
264 c = *s++;
265 } while (apr_isspace(c));
266 if (c == '-') {
267 neg = 1;
268 c = *s++;
269 } else {
270 neg = 0;
271 if (c == '+')
272 c = *s++;
273 }
274 if ((base == 0 || base == 16) &&
275 c == '0' && (*s == 'x' || *s == 'X')) {
276 c = s[1];
277 s += 2;
278 base = 16;
279 }
280 if (base == 0)
281 base = c == '0' ? 8 : 10;
282 acc = any = 0;
283 if (base < 2 || base > 36) {
284 errno = EINVAL;
285 if (endptr != NULL)
286 *endptr = (char *)(any ? s - 1 : nptr);
287 return acc;
288 }
289
290 /* The classic bsd implementation requires div/mod operators
291 * to compute a cutoff. Benchmarking proves that is very, very
292 * evil to some 32 bit processors. Instead, look for underflow
293 * in both the mult and add/sub operation. Unlike the bsd impl,
294 * we also work strictly in a signed int64 word as we haven't
295 * implemented the unsigned type in win32.
296 *
297 * Set 'any' if any `digits' consumed; make it negative to indicate
298 * overflow.
299 */
300 val = 0;
301 for ( ; ; c = *s++) {
302 if (c >= '0' && c <= '9')
303 c -= '0';
304 #if (('Z' - 'A') == 25)
305 else if (c >= 'A' && c <= 'Z')
306 c -= 'A' - 10;
307 else if (c >= 'a' && c <= 'z')
308 c -= 'a' - 10;
309 #elif APR_CHARSET_EBCDIC
310 else if (c >= 'A' && c <= 'I')
311 c -= 'A' - 10;
312 else if (c >= 'J' && c <= 'R')
313 c -= 'J' - 19;
314 else if (c >= 'S' && c <= 'Z')
315 c -= 'S' - 28;
316 else if (c >= 'a' && c <= 'i')
317 c -= 'a' - 10;
318 else if (c >= 'j' && c <= 'r')
319 c -= 'j' - 19;
320 else if (c >= 's' && c <= 'z')
321 c -= 'z' - 28;
322 #else
323 #error "CANNOT COMPILE apr_strtoi64(), only ASCII and EBCDIC supported"
324 #endif
325 else
326 break;
327 if (c >= base)
328 break;
329 val *= base;
330 if ( (any < 0) /* already noted an over/under flow - short circuit */
331 || (neg && (val > acc || (val -= c) > acc)) /* underflow */
332 || (!neg && (val < acc || (val += c) < acc))) { /* overflow */
333 any = -1; /* once noted, over/underflows never go away */
334 #ifdef APR_STRTOI64_OVERFLOW_IS_BAD_CHAR
335 break;
336 #endif
337 } else {
338 acc = val;
339 any = 1;
340 }
341 }
342
343 if (any < 0) {
344 acc = neg ? INT64_MIN : INT64_MAX;
345 errno = ERANGE;
346 } else if (!any) {
347 errno = EINVAL;
348 }
349 if (endptr != NULL)
350 *endptr = (char *)(any ? s - 1 : nptr);
351 return (acc);
352 #endif
353 }
354
apr_atoi64(const char * buf)355 APR_DECLARE(apr_int64_t) apr_atoi64(const char *buf)
356 {
357 return apr_strtoi64(buf, NULL, 10);
358 }
359
apr_itoa(apr_pool_t * p,int n)360 APR_DECLARE(char *) apr_itoa(apr_pool_t *p, int n)
361 {
362 const int BUFFER_SIZE = sizeof(int) * 3 + 2;
363 char *buf = apr_palloc(p, BUFFER_SIZE);
364 char *start = buf + BUFFER_SIZE - 1;
365 int negative;
366 if (n < 0) {
367 negative = 1;
368 n = -n;
369 }
370 else {
371 negative = 0;
372 }
373 *start = 0;
374 do {
375 *--start = '0' + (n % 10);
376 n /= 10;
377 } while (n);
378 if (negative) {
379 *--start = '-';
380 }
381 return start;
382 }
383
apr_ltoa(apr_pool_t * p,long n)384 APR_DECLARE(char *) apr_ltoa(apr_pool_t *p, long n)
385 {
386 const int BUFFER_SIZE = sizeof(long) * 3 + 2;
387 char *buf = apr_palloc(p, BUFFER_SIZE);
388 char *start = buf + BUFFER_SIZE - 1;
389 int negative;
390 if (n < 0) {
391 negative = 1;
392 n = -n;
393 }
394 else {
395 negative = 0;
396 }
397 *start = 0;
398 do {
399 *--start = (char)('0' + (n % 10));
400 n /= 10;
401 } while (n);
402 if (negative) {
403 *--start = '-';
404 }
405 return start;
406 }
407
apr_off_t_toa(apr_pool_t * p,apr_off_t n)408 APR_DECLARE(char *) apr_off_t_toa(apr_pool_t *p, apr_off_t n)
409 {
410 const int BUFFER_SIZE = sizeof(apr_off_t) * 3 + 2;
411 char *buf = apr_palloc(p, BUFFER_SIZE);
412 char *start = buf + BUFFER_SIZE - 1;
413 int negative;
414 if (n < 0) {
415 negative = 1;
416 n = -n;
417 }
418 else {
419 negative = 0;
420 }
421 *start = 0;
422 do {
423 *--start = '0' + (char)(n % 10);
424 n /= 10;
425 } while (n);
426 if (negative) {
427 *--start = '-';
428 }
429 return start;
430 }
431
apr_strfsize(apr_off_t size,char * buf)432 APR_DECLARE(char *) apr_strfsize(apr_off_t size, char *buf)
433 {
434 const char ord[] = "KMGTPE";
435 const char *o = ord;
436 int remain;
437
438 if (size < 0) {
439 return strcpy(buf, " - ");
440 }
441 if (size < 973) {
442 if (apr_snprintf(buf, 5, "%3d ", (int) size) < 0)
443 return strcpy(buf, "****");
444 return buf;
445 }
446 do {
447 remain = (int)(size & 1023);
448 size >>= 10;
449 if (size >= 973) {
450 ++o;
451 continue;
452 }
453 if (size < 9 || (size == 9 && remain < 973)) {
454 if ((remain = ((remain * 5) + 256) / 512) >= 10)
455 ++size, remain = 0;
456 if (apr_snprintf(buf, 5, "%d.%d%c", (int) size, remain, *o) < 0)
457 return strcpy(buf, "****");
458 return buf;
459 }
460 if (remain >= 512)
461 ++size;
462 if (apr_snprintf(buf, 5, "%3d%c", (int) size, *o) < 0)
463 return strcpy(buf, "****");
464 return buf;
465 } while (1);
466 }
467
468