utils.h File Reference

dst

do { \
               ((p)->flags &= ~(flag)); \
               } while(0)

do { \
               (dest)->flags &= ~(flagz); \
               (dest)->flags |= ((src)->flags & (flagz)); \
               } while (0)

ast_pthread_create_stack(a, b, c, d,         \
                             0,           \
                             __FILE__, __FUNCTION__,     \
                             __LINE__, #c)

ast_pthread_create_stack(a, b, c, d,         \
                              AST_BACKGROUND_STACKSIZE,  \
                              __FILE__, __FUNCTION__, \
                              __LINE__, #c)

do { \
               ((p)->flags |= (flag)); \
               } while(0)

00327 {
00328    int cnt = 0;
00329    unsigned int byte = 0;
00330    unsigned int bits = 0;
00331    int incnt = 0;
00332    while (*src && (cnt < max)) {
00333       /* Shift in 6 bits of input */
00334       byte <<= 6;
00335       byte |= (b2a[(int)(*src)]) & 0x3f;
00336       bits += 6;
00337       src++;
00338       incnt++;
00339       /* If we have at least 8 bits left over, take that character 
00340          off the top */
00341       if (bits >= 8)  {
00342          bits -= 8;
00343          *dst = (byte >> bits) & 0xff;
00344          dst++;
00345          cnt++;
00346       }
00347    }
00348    /* Dont worry about left over bits, they're extra anyway */
00349    return cnt;
00350 }

00405 {
00406    return ast_base64encode_full(dst, src, srclen, max, 0);
00407 }

00354 {
00355    int cnt = 0;
00356    int col = 0;
00357    unsigned int byte = 0;
00358    int bits = 0;
00359    int cntin = 0;
00360    /* Reserve space for null byte at end of string */
00361    max--;
00362    while ((cntin < srclen) && (cnt < max)) {
00363       byte <<= 8;
00364       byte |= *(src++);
00365       bits += 8;
00366       cntin++;
00367       if ((bits == 24) && (cnt + 4 <= max)) {
00368          *dst++ = base64[(byte >> 18) & 0x3f];
00369          *dst++ = base64[(byte >> 12) & 0x3f];
00370          *dst++ = base64[(byte >> 6) & 0x3f];
00371          *dst++ = base64[byte & 0x3f];
00372          cnt += 4;
00373          col += 4;
00374          bits = 0;
00375          byte = 0;
00376       }
00377       if (linebreaks && (cnt < max) && (col == 64)) {
00378          *dst++ = '\n';
00379          cnt++;
00380          col = 0;
00381       }
00382    }
00383    if (bits && (cnt + 4 <= max)) {
00384       /* Add one last character for the remaining bits, 
00385          padding the rest with 0 */
00386       byte <<= 24 - bits;
00387       *dst++ = base64[(byte >> 18) & 0x3f];
00388       *dst++ = base64[(byte >> 12) & 0x3f];
00389       if (bits == 16)
00390          *dst++ = base64[(byte >> 6) & 0x3f];
00391       else
00392          *dst++ = '=';
00393       *dst++ = '=';
00394       cnt += 4;
00395    }
00396    if (linebreaks && (cnt < max)) {
00397       *dst++ = '\n';
00398       cnt++;
00399    }
00400    *dst = '\0';
00401    return cnt;
00402 }

00623 {
00624    /* Try to write string, but wait no more than ms milliseconds
00625       before timing out */
00626    int res = 0;
00627    struct pollfd fds[1];
00628    while (len) {
00629       res = write(fd, s, len);
00630       if ((res < 0) && (errno != EAGAIN)) {
00631          return -1;
00632       }
00633       if (res < 0)
00634          res = 0;
00635       len -= res;
00636       s += res;
00637       res = 0;
00638       if (len) {
00639          fds[0].fd = fd;
00640          fds[0].events = POLLOUT;
00641          /* Wait until writable again */
00642          res = poll(fds, 1, timeoutms);
00643          if (res < 1)
00644             return -1;
00645       }
00646    }
00647    return res;
00648 }

00183 {
00184    int res;
00185    int herrno;
00186    int dots=0;
00187    const char *s;
00188    struct hostent *result = NULL;
00189    /* Although it is perfectly legitimate to lookup a pure integer, for
00190       the sake of the sanity of people who like to name their peers as
00191       integers, we break with tradition and refuse to look up a
00192       pure integer */
00193    s = host;
00194    res = 0;
00195    while (s && *s) {
00196       if (*s == '.')
00197          dots++;
00198       else if (!isdigit(*s))
00199          break;
00200       s++;
00201    }
00202    if (!s || !*s) {
00203       /* Forge a reply for IP's to avoid octal IP's being interpreted as octal */
00204       if (dots != 3)
00205          return NULL;
00206       memset(hp, 0, sizeof(struct ast_hostent));
00207       hp->hp.h_addrtype = AF_INET;
00208       hp->hp.h_addr_list = (void *) hp->buf;
00209       hp->hp.h_addr = hp->buf + sizeof(void *);
00210       if (inet_pton(AF_INET, host, hp->hp.h_addr) > 0)
00211          return &hp->hp;
00212       return NULL;
00213       
00214    }
00215 #ifdef SOLARIS
00216    result = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &herrno);
00217 
00218    if (!result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
00219       return NULL;
00220 #else
00221    res = gethostbyname_r(host, &hp->hp, hp->buf, sizeof(hp->buf), &result, &herrno);
00222 
00223    if (res || !result || !hp->hp.h_addr_list || !hp->hp.h_addr_list[0])
00224       return NULL;
00225 #endif
00226    return &hp->hp;
00227 }

00494 {
00495    char *buf;
00496 
00497    if (!(buf = ast_threadstorage_get(&inet_ntoa_buf, INET_ADDRSTRLEN)))
00498       return "";
00499 
00500    return inet_ntop(AF_INET, &ia, buf, INET_ADDRSTRLEN);
00501 }

00293 {
00294    struct MD5Context md5;
00295    unsigned char digest[16];
00296    char *ptr;
00297    int x;
00298 
00299    MD5Init(&md5);
00300    MD5Update(&md5, (unsigned char *)input, strlen(input));
00301    MD5Final(digest, &md5);
00302    ptr = output;
00303    for (x = 0; x < 16; x++)
00304       ptr += sprintf(ptr, "%2.2x", digest[x]);
00305 }

00798 {
00799    char *dataPut = start;
00800    int inEscape = 0;
00801    int inQuotes = 0;
00802 
00803    for (; *start; start++) {
00804       if (inEscape) {
00805          *dataPut++ = *start;       /* Always goes verbatim */
00806          inEscape = 0;
00807       } else {
00808          if (*start == '\\') {
00809             inEscape = 1;      /* Do not copy \ into the data */
00810          } else if (*start == '\'') {
00811             inQuotes = 1 - inQuotes;   /* Do not copy ' into the data */
00812          } else {
00813             /* Replace , with |, unless in quotes */
00814             *dataPut++ = inQuotes ? *start : ((*start == find) ? replace_with : *start);
00815          }
00816       }
00817    }
00818    if (start != dataPut)
00819       *dataPut = 0;
00820    return dataPut;
00821 }

00556 {
00557 #if !defined(LOW_MEMORY)
00558    struct thr_arg *a;
00559 #endif
00560 
00561    if (!attr) {
00562       attr = alloca(sizeof(*attr));
00563       pthread_attr_init(attr);
00564    }
00565 
00566 #ifdef __linux__
00567    /* On Linux, pthread_attr_init() defaults to PTHREAD_EXPLICIT_SCHED,
00568       which is kind of useless. Change this here to
00569       PTHREAD_INHERIT_SCHED; that way the -p option to set realtime
00570       priority will propagate down to new threads by default.
00571       This does mean that callers cannot set a different priority using
00572       PTHREAD_EXPLICIT_SCHED in the attr argument; instead they must set
00573       the priority afterwards with pthread_setschedparam(). */
00574    if ((errno = pthread_attr_setinheritsched(attr, PTHREAD_INHERIT_SCHED)))
00575       ast_log(LOG_WARNING, "pthread_attr_setinheritsched: %s\n", strerror(errno));
00576 #endif
00577 
00578    if (!stacksize)
00579       stacksize = AST_STACKSIZE;
00580 
00581    if ((errno = pthread_attr_setstacksize(attr, stacksize ? stacksize : AST_STACKSIZE)))
00582       ast_log(LOG_WARNING, "pthread_attr_setstacksize: %s\n", strerror(errno));
00583 
00584 #if !defined(LOW_MEMORY)
00585    if ((a = ast_malloc(sizeof(*a)))) {
00586       a->start_routine = start_routine;
00587       a->data = data;
00588       start_routine = dummy_start;
00589       asprintf(&a->name, "%-20s started at [%5d] %s %s()",
00590           start_fn, line, file, caller);
00591       data = a;
00592    }
00593 #endif /* !LOW_MEMORY */
00594 
00595    return pthread_create(thread, attr, start_routine, data); /* We're in ast_pthread_create, so it's okay */
00596 }

00788 {
00789    long int res;
00790    ast_mutex_lock(&randomlock);
00791    res = random();
00792    ast_mutex_unlock(&randomlock);
00793    return res;
00794 }

00299 { 
00300    struct thread_list_t *new = ast_calloc(1, sizeof(*new));
00301 
00302    if (!new)
00303       return;
00304    new->id = pthread_self();
00305    new->name = name; /* steal the allocated memory for the thread name */
00306    AST_LIST_LOCK(&thread_list);
00307    AST_LIST_INSERT_HEAD(&thread_list, new, list);
00308    AST_LIST_UNLOCK(&thread_list);
00309 }

00309 {
00310    struct SHA1Context sha;
00311    char *ptr;
00312    int x;
00313    uint8_t Message_Digest[20];
00314 
00315    SHA1Reset(&sha);
00316    
00317    SHA1Input(&sha, (const unsigned char *) input, strlen(input));
00318 
00319    SHA1Result(&sha, Message_Digest);
00320    ptr = output;
00321    for (x = 0; x < 20; x++)
00322       ptr += sprintf(ptr, "%2.2x", Message_Digest[x]);
00323 }

00189 {
00190    int res;
00191 
00192    res = (int) *input + *value;
00193    if (res > 32767)
00194       *input = 32767;
00195    else if (res < -32767)
00196       *input = -32767;
00197    else
00198       *input = (short) res;
00199 }

00215 {
00216    *input /= *value;
00217 }

00202 {
00203    int res;
00204 
00205    res = (int) *input * *value;
00206    if (res > 32767)
00207       *input = 32767;
00208    else if (res < -32767)
00209       *input = -32767;
00210    else
00211       *input = (short) res;
00212 }

00312 {
00313    struct thread_list_t *x;
00314 
00315    AST_LIST_LOCK(&thread_list);
00316    AST_LIST_TRAVERSE_SAFE_BEGIN(&thread_list, x, list) {
00317       if ((void *) x->id == id) {
00318          AST_LIST_REMOVE_CURRENT(&thread_list, list);
00319          break;
00320       }
00321    }
00322    AST_LIST_TRAVERSE_SAFE_END;
00323    AST_LIST_UNLOCK(&thread_list);
00324    if (x) {
00325       free(x->name);
00326       free(x);
00327    }
00328 }

00477 {
00478    char *o;
00479    unsigned int tmp;
00480 
00481    for (o = s; *s; s++, o++) {
00482       if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
00483          /* have '%', two chars and correct parsing */
00484          *o = tmp;
00485          s += 2;  /* Will be incremented once more when we break out */
00486       } else /* all other cases, just copy */
00487          *o = *s;
00488    }
00489    *o = '\0';
00490 }

00446 {
00447    char *reserved = ";/?:@&=+$, ";  /* Reserved chars */
00448 
00449    const char *ptr  = string; /* Start with the string */
00450    char *out = NULL;
00451    char *buf = NULL;
00452 
00453    ast_copy_string(outbuf, string, buflen);
00454 
00455    /* If there's no characters to convert, just go through and don't do anything */
00456    while (*ptr) {
00457       if (((unsigned char) *ptr) > 127 || (doreserved && strchr(reserved, *ptr)) ) {
00458          /* Oops, we need to start working here */
00459          if (!buf) {
00460             buf = outbuf;
00461             out = buf + (ptr - string) ;  /* Set output ptr */
00462          }
00463          out += sprintf(out, "%%%02x", (unsigned char) *ptr);
00464       } else if (buf) {
00465          *out = *ptr;   /* Continue copying the string */
00466          out++;
00467       } 
00468       ptr++;
00469    }
00470    if (buf)
00471       *out = '\0';
00472    return outbuf;
00473 }

00504 {
00505    base64_init();
00506    return 0;
00507 }

00599 {
00600    struct pollfd pfd[1];
00601    memset(pfd, 0, sizeof(pfd));
00602    pfd[0].fd = fd;
00603    pfd[0].events = POLLIN|POLLPRI;
00604    return poll(pfd, 1, ms);
00605 }

00254 {
00255    return ((sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) 
00256       || (sin1->sin_port != sin2->sin_port));
00257 }

00264 { 
00265    ast_mutex_lock(&test_lock2);
00266    ast_mutex_lock(&test_lock);
00267    lock_count += 1;
00268    ast_mutex_lock(&test_lock);
00269    lock_count += 1;
00270    ast_pthread_create(&test_thread, NULL, test_thread_body, NULL); 
00271    usleep(100);
00272    if (lock_count != 2) 
00273       test_errors++;
00274    ast_mutex_unlock(&test_lock);
00275    lock_count -= 1;
00276    usleep(100); 
00277    if (lock_count != 1) 
00278       test_errors++;
00279    ast_mutex_unlock(&test_lock);
00280    lock_count -= 1;
00281    if (lock_count != 0) 
00282       test_errors++;
00283    ast_mutex_unlock(&test_lock2);
00284    usleep(100);
00285    if (lock_count != 0) 
00286       test_errors++;
00287    pthread_join(test_thread, NULL);
00288    return(test_errors);          /* return 0 on success. */
00289 }

   Note:
   It is very important to use only unsigned variables to hold
   bit flags, as otherwise you can fall prey to the compiler's
   sign-extension antics if you try to use the top two bits in
   your variable.

   The flag macros below use a set of compiler tricks to verify
   that the caller is using an "unsigned int" variable to hold
   the flags, and nothing else. If the caller uses any other
   type of variable, a warning message similar to this:

   warning: comparison of distinct pointer types lacks cast
   will be generated.

   The "dummy" variable below is used to make these comparisons.

   Also note that at -O2 or above, this type-safety checking
   does _not_ produce any additional object code at all.


Data Structures
struct	ast_flags
struct	ast_hostent
Defines
#define	ast_asprintf(ret, fmt,) _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
#define	AST_BACKGROUND_STACKSIZE 240 * 1024
#define	ast_calloc(num, len) _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_calloc_cache(num, len) _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_clear_flag(p, flag)
#define	ast_clear_flag_nonstd(p, flag)
#define	ast_copy_flags(dest, src, flagz)
#define	ast_copy_flags_nonstd(dest, src, flagz)
#define	AST_FLAGS_ALL UINT_MAX
#define	ast_free free
	free() wrapper
#define	ast_malloc(len) _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
	A wrapper for malloc().
#define	ast_pthread_create(a, b, c, d)
#define	ast_pthread_create_background(a, b, c, d)
#define	ast_realloc(p, len) _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_set2_flag(p, value, flag)
#define	ast_set2_flag_nonstd(p, value, flag)
#define	ast_set_flag(p, flag)
#define	ast_set_flag_nonstd(p, flag)
#define	ast_set_flags_to(p, flag, value)
#define	AST_STACKSIZE 240 * 1024
#define	ast_strdup(str) _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_strdupa(s)
#define	ast_strndup(str, len) _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_test_flag(p, flag)
#define	ast_test_flag_nonstd(p, flag) ((p)->flags & (flag))
#define	ast_vasprintf(ret, fmt, ap) _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
#define	inet_ntoa __dont__use__inet_ntoa__use__ast_inet_ntoa__instead__
#define	MALLOC_FAILURE_MSG ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
Functions
int	ast_base64decode (unsigned char dst, const char src, int max)
	decode BASE64 encoded text
int	ast_base64encode (char dst, const unsigned char src, int srclen, int max)
int	ast_base64encode_full (char dst, const unsigned char src, int srclen, int max, int linebreaks)
	encode text to BASE64 coding
int	ast_carefulwrite (int fd, char *s, int len, int timeoutms)
	Try to write string, but wait no more than ms milliseconds before timing out.
hostent *	ast_gethostbyname (const char host, struct ast_hostent hp)
	Re-entrant (thread safe) version of gethostbyname that replaces the standard gethostbyname (which is not thread safe).
const char *	ast_inet_ntoa (struct in_addr ia)
	thread-safe replacement for inet_ntoa().
	AST_INLINE_API (void attribute_malloc _ast_malloc(size_t len, const char file, int lineno, const char func),{void p;if(!(p=malloc(len))) MALLOC_FAILURE_MSG;return p;}) AST_INLINE_API(void *attribute_malloc _ast_calloc(size_t num
	A wrapper for calloc().
void	ast_md5_hash (char output, char input)
	Produce 32 char MD5 hash of value.
char *	ast_process_quotes_and_slashes (char *start, char find, char replace_with)
	Process a string to find and replace characters.
int	ast_pthread_create_stack (pthread_t thread, pthread_attr_t attr, void (start_routine)(void ), void data, size_t stacksize, const char file, const char caller, int line, const char *start_fn)
long int	ast_random (void)
void	ast_register_thread (char *name)
void	ast_sha1_hash (char output, char input)
	Produce 40 char SHA1 hash of value.
static force_inline void	ast_slinear_saturated_add (short input, short value)
static force_inline void	ast_slinear_saturated_divide (short input, short value)
static force_inline void	ast_slinear_saturated_multiply (short input, short value)
void	ast_unregister_thread (void *id)
void	ast_uri_decode (char *s)
	Decode URI, URN, URL (overwrite string).
char *	ast_uri_encode (const char string, char outbuf, int buflen, int doreserved)
	Turn text string to URI-encoded XX version At this point, we're converting from ISO-8859-x (8-bit), not UTF8 as in the SIP protocol spec If doreserved == 1 we will convert reserved characters also. RFC 2396, section 2.4 outbuf needs to have more memory allocated than the instring to have room for the expansion. Every char that is converted is replaced by three ASCII characters.
int	ast_utils_init (void)
int	ast_wait_for_input (int fd, int ms)
static force_inline int	inaddrcmp (const struct sockaddr_in sin1, const struct sockaddr_in sin2)
int	test_for_thread_safety (void)
Variables
unsigned int	__unsigned_int_flags_dummy
size_t const char *	file
size_t const char int const char *	func
size_t	len
size_t const char int	lineno

Asterisk developer's documentation :: Codename Pineapple

utils.h File Reference

Detailed Description

Data Structures

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation