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