00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "asterisk.h"
00023
00024 #include <sys/types.h>
00025 #include <ctype.h>
00026 #include <stdio.h>
00027 #include <stdlib.h>
00028 #include <string.h>
00029 #include <stdarg.h>
00030
00031 #ifdef HAVE_ALLOCA_H
00032 #include <alloca.h>
00033 #endif
00034
00035 #ifndef HAVE_STRSEP
00036 char *strsep(char **str, const char *delims)
00037 {
00038 char *token;
00039
00040 if (!*str) {
00041
00042 return NULL;
00043 }
00044
00045 token = *str;
00046 while (**str != '\0') {
00047 if (strchr(delims, **str)) {
00048 **str = '\0';
00049 (*str)++;
00050 return token;
00051 }
00052 (*str)++;
00053 }
00054
00055
00056 *str = NULL;
00057
00058 return token;
00059 }
00060 #endif
00061
00062 #ifndef HAVE_SETENV
00063 int setenv(const char *name, const char *value, int overwrite)
00064 {
00065 unsigned char *buf;
00066 int buflen;
00067
00068 buflen = strlen(name) + strlen(value) + 2;
00069 buf = alloca(buflen);
00070
00071 if (!overwrite && getenv(name))
00072 return 0;
00073
00074 snprintf(buf, buflen, "%s=%s", name, value);
00075
00076 return putenv(buf);
00077 }
00078 #endif
00079
00080 #ifndef HAVE_UNSETENV
00081 int unsetenv(const char *name)
00082 {
00083 return setenv(name, "", 0);
00084 }
00085 #endif
00086
00087 #ifndef HAVE_STRCASESTR
00088 static char *upper(const char *orig, char *buf, int bufsize)
00089 {
00090 int i = 0;
00091
00092 while (i < (bufsize - 1) && orig[i]) {
00093 buf[i] = toupper(orig[i]);
00094 i++;
00095 }
00096
00097 buf[i] = '\0';
00098
00099 return buf;
00100 }
00101
00102 char *strcasestr(const char *haystack, const char *needle)
00103 {
00104 char *u1, *u2;
00105 int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
00106
00107 u1 = alloca(u1len);
00108 u2 = alloca(u2len);
00109 if (u1 && u2) {
00110 char *offset;
00111 if (u2len > u1len) {
00112
00113 return NULL;
00114 }
00115 offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
00116 if (offset) {
00117
00118 return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
00119 } else {
00120 return NULL;
00121 }
00122 } else {
00123 return NULL;
00124 }
00125 }
00126 #endif
00127
00128 #ifndef HAVE_STRNLEN
00129 size_t strnlen(const char *s, size_t n)
00130 {
00131 size_t len;
00132
00133 for (len = 0; len < n; len++)
00134 if (s[len] == '\0')
00135 break;
00136
00137 return len;
00138 }
00139 #endif
00140
00141 #if !defined(HAVE_STRNDUP) && !defined(__AST_DEBUG_MALLOC)
00142 char *strndup(const char *s, size_t n)
00143 {
00144 size_t len = strnlen(s, n);
00145 char *new = malloc(len + 1);
00146
00147 if (!new)
00148 return NULL;
00149
00150 new[len] = '\0';
00151 return memcpy(new, s, len);
00152 }
00153 #endif
00154
00155 #if !defined(HAVE_VASPRINTF) && !defined(__AST_DEBUG_MALLOC)
00156 int vasprintf(char **strp, const char *fmt, va_list ap)
00157 {
00158 int size;
00159 va_list ap2;
00160 char s;
00161
00162 *strp = NULL;
00163 va_copy(ap2, ap);
00164 size = vsnprintf(&s, 1, fmt, ap2);
00165 va_end(ap2);
00166 *strp = malloc(size + 1);
00167 if (!*strp)
00168 return -1;
00169 vsnprintf(*strp, size + 1, fmt, ap);
00170
00171 return size;
00172 }
00173 #endif
00174
00175 #ifndef HAVE_TIMERSUB
00176 void timersub(struct timeval *tvend, struct timeval *tvstart, struct timeval *tvdiff)
00177 {
00178 tvdiff->tv_sec = tvend->tv_sec - tvstart->tv_sec;
00179 tvdiff->tv_usec = tvend->tv_usec - tvstart->tv_usec;
00180 if (tvdiff->tv_usec < 0) {
00181 tvdiff->tv_sec --;
00182 tvdiff->tv_usec += 1000000;
00183 }
00184
00185 }
00186 #endif
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207 #if !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC)
00208 int asprintf(char **str, const char *fmt, ...)
00209 {
00210 va_list ap;
00211 int ret;
00212
00213 *str = NULL;
00214 va_start(ap, fmt);
00215 ret = vasprintf(str, fmt, ap);
00216 va_end(ap);
00217
00218 return ret;
00219 }
00220 #endif
00221
00222 #ifndef HAVE_STRTOQ
00223 #ifndef LONG_MIN
00224 #define LONG_MIN (-9223372036854775807L-1L)
00225
00226 #endif
00227 #ifndef LONG_MAX
00228 #define LONG_MAX 9223372036854775807L
00229
00230 #endif
00231
00232
00233
00234
00235
00236
00237
00238 uint64_t strtoq(const char *nptr, char **endptr, int base)
00239 {
00240 const char *s;
00241 uint64_t acc;
00242 unsigned char c;
00243 uint64_t qbase, cutoff;
00244 int neg, any, cutlim;
00245
00246
00247
00248
00249
00250
00251 s = nptr;
00252 do {
00253 c = *s++;
00254 } while (isspace(c));
00255 if (c == '-') {
00256 neg = 1;
00257 c = *s++;
00258 } else {
00259 neg = 0;
00260 if (c == '+')
00261 c = *s++;
00262 }
00263 if ((base == 0 || base == 16) &&
00264 c == '\0' && (*s == 'x' || *s == 'X')) {
00265 c = s[1];
00266 s += 2;
00267 base = 16;
00268 }
00269 if (base == 0)
00270 base = c == '\0' ? 8 : 10;
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290 qbase = (unsigned)base;
00291 cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
00292 cutlim = cutoff % qbase;
00293 cutoff /= qbase;
00294 for (acc = 0, any = 0;; c = *s++) {
00295 if (!isascii(c))
00296 break;
00297 if (isdigit(c))
00298 c -= '\0';
00299 else if (isalpha(c))
00300 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
00301 else
00302 break;
00303 if (c >= base)
00304 break;
00305 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
00306 any = -1;
00307 else {
00308 any = 1;
00309 acc *= qbase;
00310 acc += c;
00311 }
00312 }
00313 if (any < 0) {
00314 acc = neg ? LONG_MIN : LONG_MAX;
00315 } else if (neg)
00316 acc = -acc;
00317 if (endptr != 0)
00318 *((const char **)endptr) = any ? s - 1 : nptr;
00319 return acc;
00320 }
00321 #endif
00322
00323 #ifndef HAVE_GETLOADAVG
00324 #ifdef linux
00325
00326 int getloadavg(double *list, int nelem)
00327 {
00328 FILE *LOADAVG;
00329 double avg[3] = { 0.0, 0.0, 0.0 };
00330 int i, res = -1;
00331
00332 if ((LOADAVG = fopen("/proc/loadavg", "r"))) {
00333 fscanf(LOADAVG, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]);
00334 res = 0;
00335 fclose(LOADAVG);
00336 }
00337
00338 for (i = 0; (i < nelem) && (i < 3); i++) {
00339 list[i] = avg[i];
00340 }
00341
00342 return res;
00343 }
00344 #else
00345
00346
00347 int getloadavg(double *list, int nelem)
00348 {
00349 int i;
00350
00351 for (i = 0; i < nelem; i++) {
00352 list[i] = 0.1;
00353 }
00354 return -1;
00355 }
00356 #endif
00357 #endif
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396 #ifndef HAVE_STRLCAT
00397 size_t strlcat(char *dst, const char *src, size_t siz)
00398 {
00399 register char *d = dst;
00400 register const char *s = src;
00401 register size_t n = siz;
00402 size_t dlen;
00403
00404
00405 while (n-- != 0 && *d != '\0')
00406 d++;
00407 dlen = d - dst;
00408 n = siz - dlen;
00409
00410 if (n == 0)
00411 return dlen + strlen(s);
00412
00413 while (*s != '\0') {
00414 if (n != 1) {
00415 *d++ = *s;
00416 n--;
00417 }
00418 s++;
00419 }
00420 *d = '\0';
00421
00422 return dlen + (s - src);
00423 }
00424 #endif
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460 #ifndef HAVE_STRLCPY
00461 size_t strlcpy(char *dst, const char *src, size_t siz)
00462 {
00463 register char *d = dst;
00464 register const char *s = src;
00465 register size_t n = siz;
00466
00467
00468 if (n != 0 && --n != 0) {
00469 do {
00470 if ((*d++ = *s++) == 0)
00471 break;
00472 } while (--n != 0);
00473 }
00474
00475
00476 if (n == 0) {
00477 if (siz != 0)
00478 *d = '\0';
00479 while (*s++)
00480 ;
00481 }
00482
00483 return s - src - 1;
00484 }
00485 #endif