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
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194 #if !defined(HAVE_ASPRINTF) && !defined(__AST_DEBUG_MALLOC)
00195 int asprintf(char **str, const char *fmt, ...)
00196 {
00197 va_list ap;
00198 int ret;
00199
00200 *str = NULL;
00201 va_start(ap, fmt);
00202 ret = vasprintf(str, fmt, ap);
00203 va_end(ap);
00204
00205 return ret;
00206 }
00207 #endif
00208
00209 #ifndef HAVE_STRTOQ
00210 #ifndef LONG_MIN
00211 #define LONG_MIN (-9223372036854775807L-1L)
00212
00213 #endif
00214 #ifndef LONG_MAX
00215 #define LONG_MAX 9223372036854775807L
00216
00217 #endif
00218
00219
00220
00221
00222
00223
00224
00225 uint64_t strtoq(const char *nptr, char **endptr, int base)
00226 {
00227 const char *s;
00228 uint64_t acc;
00229 unsigned char c;
00230 uint64_t qbase, cutoff;
00231 int neg, any, cutlim;
00232
00233
00234
00235
00236
00237
00238 s = nptr;
00239 do {
00240 c = *s++;
00241 } while (isspace(c));
00242 if (c == '-') {
00243 neg = 1;
00244 c = *s++;
00245 } else {
00246 neg = 0;
00247 if (c == '+')
00248 c = *s++;
00249 }
00250 if ((base == 0 || base == 16) &&
00251 c == '\0' && (*s == 'x' || *s == 'X')) {
00252 c = s[1];
00253 s += 2;
00254 base = 16;
00255 }
00256 if (base == 0)
00257 base = c == '\0' ? 8 : 10;
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277 qbase = (unsigned)base;
00278 cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
00279 cutlim = cutoff % qbase;
00280 cutoff /= qbase;
00281 for (acc = 0, any = 0;; c = *s++) {
00282 if (!isascii(c))
00283 break;
00284 if (isdigit(c))
00285 c -= '\0';
00286 else if (isalpha(c))
00287 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
00288 else
00289 break;
00290 if (c >= base)
00291 break;
00292 if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
00293 any = -1;
00294 else {
00295 any = 1;
00296 acc *= qbase;
00297 acc += c;
00298 }
00299 }
00300 if (any < 0) {
00301 acc = neg ? LONG_MIN : LONG_MAX;
00302 } else if (neg)
00303 acc = -acc;
00304 if (endptr != 0)
00305 *((const char **)endptr) = any ? s - 1 : nptr;
00306 return acc;
00307 }
00308 #endif
00309
00310 #ifndef HAVE_GETLOADAVG
00311 #ifdef linux
00312
00313 int getloadavg(double *list, int nelem)
00314 {
00315 FILE *LOADAVG;
00316 double avg[3] = { 0.0, 0.0, 0.0 };
00317 int i, res = -1;
00318
00319 if ((LOADAVG = fopen("/proc/loadavg", "r"))) {
00320 fscanf(LOADAVG, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]);
00321 res = 0;
00322 fclose(LOADAVG);
00323 }
00324
00325 for (i = 0; (i < nelem) && (i < 3); i++) {
00326 list[i] = avg[i];
00327 }
00328
00329 return res;
00330 }
00331 #else
00332
00333
00334 int getloadavg(double *list, int nelem)
00335 {
00336 int i;
00337
00338 for (i = 0; i < nelem; i++) {
00339 list[i] = 0.1;
00340 }
00341 return -1;
00342 }
00343 #endif
00344 #endif
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
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 #ifndef HAVE_STRLCAT
00384 size_t strlcat(char *dst, const char *src, size_t siz)
00385 {
00386 register char *d = dst;
00387 register const char *s = src;
00388 register size_t n = siz;
00389 size_t dlen;
00390
00391
00392 while (n-- != 0 && *d != '\0')
00393 d++;
00394 dlen = d - dst;
00395 n = siz - dlen;
00396
00397 if (n == 0)
00398 return dlen + strlen(s);
00399
00400 while (*s != '\0') {
00401 if (n != 1) {
00402 *d++ = *s;
00403 n--;
00404 }
00405 s++;
00406 }
00407 *d = '\0';
00408
00409 return dlen + (s - src);
00410 }
00411 #endif
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447 #ifndef HAVE_STRLCPY
00448 size_t strlcpy(char *dst, const char *src, size_t siz)
00449 {
00450 register char *d = dst;
00451 register const char *s = src;
00452 register size_t n = siz;
00453
00454
00455 if (n != 0 && --n != 0) {
00456 do {
00457 if ((*d++ = *s++) == 0)
00458 break;
00459 } while (--n != 0);
00460 }
00461
00462
00463 if (n == 0) {
00464 if (siz != 0)
00465 *d = '\0';
00466 while (*s++)
00467 ;
00468 }
00469
00470 return s - src - 1;
00471 }
00472 #endif