/src/opensips/ut.h

Source (jump to first uncovered line)
/*
 * - various general purpose functions
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * opensips is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 */


#ifndef ut_h
#define ut_h

#include <sys/types.h>
#include <sys/select.h>
#include <sys/time.h>
#include <limits.h>
#include <unistd.h>
#include <ctype.h>

#include "config.h"
#include "dprint.h"
#include "sr_module.h"
#include "action.h"
#include "str.h"
#include "evi/evi_modules.h"
#include "evi/evi_core.h"

#include "mem/mem.h"
#include "mem/shm_mem.h"

#include "lib/str2const.h"

typedef struct _int_str_t {
  union {
    int i;
    str s;
  };
  unsigned char is_str;
} int_str_t;

struct sip_msg;

/* the amount of decimals to be displayed for "float" and "double" values */
#define FLOATING_POINT_PRECISION 8

/* zero-string wrapper */
#define ZSW(_c) ((_c)?(_c):"")

/* returns string beginning and length without insignificant chars */
#define trim_len( _len, _begin, _mystr ) \
  do{   static char _c; \
    (_len)=(_mystr).len; \
    while ((_len) && ((_c=(_mystr).s[(_len)-1])==0 || is_ws(_c))) \
      (_len)--; \
    (_begin)=(_mystr).s; \
    while ((_len) && ((_c=*(_begin))==' ' || _c=='\t')) { \
      (_len)--;\
      (_begin)++; \
    } \
  }while(0)

#define trim_r( _mystr ) \
  do{ static char _c; \
    while( ((_mystr).len) && ( ((_c=(_mystr).s[(_mystr).len-1]))==0 ||\
                  _c=='\r' || _c=='\n' ) \
        ) \
      (_mystr).len--; \
  }while(0)

/* right and left space trimming */
#define trim_spaces_lr(_s_) \
  do{\
    for(;(_s_).s[(_s_).len-1]==' ';(_s_).s[--(_s_).len]=0);\
    for(;(_s_).s[0]==' ';(_s_).s=(_s_).s+1,(_s_).len--);\
  }while(0);

/* right and left space trimming without '0' padding */
#define str_trim_spaces_lr(_s_) \
  do{\
    for(;(_s_).s[(_s_).len-1]==' ';--(_s_).len);\
    for(;(_s_).s[0]==' ';(_s_).s=(_s_).s+1,(_s_).len--);\
  }while(0);


#define  translate_pointer( _new_buf , _org_buf , _p) \
  ( (_p)?(_new_buf + (_p-_org_buf)):(0) )

#define TIMEVAL_MS_DIFF(_tva, _tvb) \
  ((((_tvb).tv_sec * 1000000UL + (_tvb).tv_usec) - \
   ((_tva).tv_sec * 1000000UL + (_tva).tv_usec)) / 1000UL)

/**
 * _add_last() - Walk the @next_member field of any struct and append last.
 * @what: Pointer to the struct that is to be appended.
 * @where: Pointer to the list that is to be appended to.
 * @next_member: The name of the member used to link to the next ones.
 *
 * If the list @where is NULL, @what will be assigned to it.
 */
#define _add_last(what, where, next_member) \
  do { \
    if (!(where)) { \
      (where) = (what); \
    } else { \
      typeof(where) __wit = (where); \
      while (__wit->next_member) \
        __wit = __wit->next_member; \
      __wit->next_member = (what); \
    } \
  } while (0)

/**
 * add_last() - Walk the "->next" field of any struct and append last.
 * @what: Pointer to the struct that is to be appended.
 * @where: Pointer to the list that is to be appended to.
 *
 * If the list @where is NULL, @what will be assigned to it.
 */
#define add_last(what, where) \
  _add_last(what, where, next)

/**
 * pkg_free_all() - pkg_free() each element of the given (circular) list.
 * @things: Pointer to the list that is to be freed in succession.
 *
 * The list is walked using "->next".
 */
#define pkg_free_all(things) \
  do { \
    typeof(things) pos = NULL, head = (things); \
    while ((things) && ((things) != head || !pos)) \
      { pos = (things); (things) = (things)->next; pkg_free(pos); } \
  } while (0)

/**
 * shm_free_all() - shm_free() each element of the given (circular) list.
 * @things: Pointer to the list that is to be freed in succession.
 *
 * The list is walked using "->next".
 */
#define shm_free_all(things) \
  do { \
    typeof(things) pos = NULL, head = (things); \
    while ((things) && ((things) != head || !pos)) \
      { pos = (things); (things) = (things)->next; shm_free(pos); } \
  } while (0)

#define via_len(_via) \
  ((_via)->bsize-((_via)->name.s-\
    ((_via)->hdr.s+(_via)->hdr.len)))

#ifdef __GNUC__
#define ALLOW_UNUSED __attribute__ ((unused))
#else
#define ALLOW_UNUSED
#endif

#define PTR_STRING_SIZE  2+16+1
#define PTR_STR_SIZE     2+16

/* char to hex conversion table */
static char fourbits2char[16] = { '0', '1', '2', '3', '4', '5',
  '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };


/* converts a str to an u. short, returns the u. short and sets *err on
 * error and if err!=null
  */
static inline unsigned short str2s(const char* s, unsigned int len,
                  int *err)
{
  unsigned short ret;
  int i;
  unsigned char *limit;
  unsigned char *str;

  /*init*/
  str=(unsigned char*)s;
  ret=i=0;
  limit=str+len;

  for(;str<limit ;str++){
    if ( (*str <= '9' ) && (*str >= '0') ){
        ret=ret*10+*str-'0';
        i++;
        if (i>5) goto error_digits;
    }else{
        //error unknown char
        goto error_char;
    }
  }
  if (err) *err=0;
  return ret;

error_digits:
  LM_DBG("too many letters in [%.*s]\n", (int)len, s);
  if (err) *err=1;
  return 0;
error_char:
  LM_DBG("unexpected char %c in %.*s\n", *str, (int)len, s);
  if (err) *err=1;
  return 0;
}


static inline int btostr( char *p,  unsigned char val)
{
  unsigned int a,b,i =0;

  if ( (a=val/100)!=0 )
    *(p+(i++)) = a+'0';         /*first digit*/
  if ( (b=val%100/10)!=0 || a)
    *(p+(i++)) = b+'0';        /*second digit*/
  *(p+(i++)) = '0'+val%10;              /*third digit*/

  return i;
}

static inline int rctostr( char *p,  unsigned int val)
{
  unsigned int a,b,i =0;

  if ( (a=val/100)!=0 )
    *(p+(i++)) = a+'0';         /*first digit*/
  if ( (b=val%100/10)!=0 || a)
    *(p+(i++)) = b+'0';        /*second digit*/
  *(p+(i++)) = '0'+val%10;              /*third digit*/

  return i;
}

/* 2^64~= 16*10^18 => 19+1+1 sign + digits + \0 */
#define INT2STR_MAX_LEN  (1+19+1+1)

/* INTeger-TO-Buffer-STRing : converts a 64-bit integer to a string
 * IMPORTANT: the provided buffer must be at least INT2STR_MAX_LEN size !! */
static inline char* int2bstr(uint64_t l, char *s, int* len)
{
  int i;

  i=INT2STR_MAX_LEN-2;
  s[INT2STR_MAX_LEN-1]=0; /* null terminate */
  do{
    s[i]=l%10+'0';
    i--;
    l/=10;
  }while(l && (i>=0));
  if (l && (i<0)){
    LM_CRIT("overflow error\n");
  }
  if (len) *len=(INT2STR_MAX_LEN-2)-i;
  return &s[i+1];
}


/* INTeger-TO-STRing : convers a 64-bit integer to a string
 * returns a pointer to a static buffer containing l in asciiz & sets len */
#define INT2STR_BUF_NO    7
extern unsigned int int2str_buf_index;
extern char int2str_buf[INT2STR_BUF_NO][INT2STR_MAX_LEN];
static inline unsigned int getstrbufindex(void) {
  return ((int2str_buf_index++) % INT2STR_BUF_NO);
}

static inline char* int2str(uint64_t l, int* len)
{
  return int2bstr( l, int2str_buf[getstrbufindex()], len);
}


/* Signed INTeger-TO-STRing: convers a long to a string
 * returns a pointer to a static buffer containing l in asciiz & sets len */
static inline char* sint2str(long l, int* len)
{
  int sign;
  char *p;

  sign = 0;
  if(l<0) {
    sign = 1;
    l = -l;
  }
  p = int2str((unsigned long)l, len);
  if(sign) {
    *(--p) = '-';
    if (len) (*len)++;
  }
  return p;
}

#define DOUBLE2STR_MAX_LEN  INT2STR_MAX_LEN
static inline char* double2str(double d, int* len)
{
  unsigned int buf;

  buf = getstrbufindex();
  *len = snprintf(int2str_buf[buf], INT2STR_MAX_LEN - 1, "%0.*lf",
                  FLOATING_POINT_PRECISION, d);
  int2str_buf[buf][*len] = '\0';

  return int2str_buf[buf];
}

#define BIGINT2STR_MAX_LEN  INT2STR_MAX_LEN
static inline char* bigint2str(long long l, int* len)
{
  unsigned int buf;

  buf = getstrbufindex();
  *len = snprintf(int2str_buf[buf], INT2STR_MAX_LEN - 1, "%lld", l);
  int2str_buf[buf][*len] = '\0';

  return int2str_buf[buf];
}

/* faster memchr version */
static inline char* q_memchr(char* p, int c, unsigned int size)
{
  char* end;

  end=p+size;
  for(;p<end;p++){
    if (*p==(unsigned char)c) return p;
  }
  return NULL;
}


/* faster memrchr version */
static inline char* q_memrchr(char* p, int c, unsigned int size)
{
  char* cursor;

  cursor=p+size-1;
  for(;cursor>=p;cursor--){
    if (*cursor==(unsigned char)c) return cursor;
  }
  return NULL;
}


inline static int reverse_hex2int( char *c, int len, unsigned int *r)
{
  char *pc;
  char mychar;

  *r=0;
  for (pc=c+len-1; len>0; pc--, len--) {
    (*r) <<= 4 ;
    mychar=*pc;
    if ( mychar >='0' && mychar <='9') (*r)+=mychar -'0';
    else if (mychar >='a' && mychar <='f') (*r)+=mychar -'a'+10;
    else if (mychar  >='A' && mychar <='F') (*r)+=mychar -'A'+10;
    else return -1;
  }
  return 0;
}

inline static int int2reverse_hex( char **c, int *size, unsigned int nr )
{
  unsigned short digit;

  if (*size && nr==0) {
    **c = '0';
    (*c)++;
    (*size)--;
    return 1;
  }

  while (*size && nr ) {
    digit = nr & 0xf ;
    **c= digit >= 10 ? digit + 'a' - 10 : digit + '0';
    nr >>= 4;
    (*c)++;
    (*size)--;
  }
  return nr ? -1 /* number not processed; too little space */ : 1;
}

/* same functions, higher representation 64 bit*/
/* if unsafe requested when first non numerical character shall be
 * met the number shall be returned; avoid giving the
 * exact len of the number */
inline static int reverse_hex2int64( char *c, int len, int unsafe, uint64_t *r)
{
  char *pc;
  char mychar;

  *r=0;
  for (pc=c+len-1; len>0; pc--, len--) {
    (*r) <<= 4 ;
    mychar=*pc;
    if ( mychar >='0' && mychar <='9') (*r)+=mychar -'0';
    else if (mychar >='a' && mychar <='f') (*r)+=mychar -'a'+10;
    else if (mychar  >='A' && mychar <='F') (*r)+=mychar -'A'+10;
    else if (unsafe)
      return 0;
    else return -1;
  }
  return 0;
}

inline static int64_t int64_2reverse_hex( char **c, int *size, uint64_t nr )
{
  unsigned short digit;

  if (*size && nr==0) {
    **c = '0';
    (*c)++;
    (*size)--;
    return 1;
  }

  while (*size && nr ) {
    digit = nr & 0xf ;
    **c= digit >= 10 ? digit + 'a' - 10 : digit + '0';
    nr >>= 4;
    (*c)++;
    (*size)--;
  }
  return nr ? -1 /* number not processed; too little space */ : 1;
}


inline static int hexstr2int(char *c, int len, unsigned int *val)
{
  char *pc;
  int r;
  char mychar;

  r=0;
  for (pc=c; pc<c+len; pc++) {
    r <<= 4 ;
    mychar=*pc;
    if ( mychar >='0' && mychar <='9') r+=mychar -'0';
    else if (mychar >='a' && mychar <='f') r+=mychar -'a'+10;
    else if (mychar  >='A' && mychar <='F') r+=mychar -'A'+10;
    else return -1;
  }
  *val = r;
  return 0;
}


/* double output length assumed ; does NOT zero-terminate */
inline static int string2hex(
  /* input */ const char *str, int len,
  /* output */ char *hex )
{
  int orig_len;

  if (len==0) {
    *hex='0';
    return 1;
  }

  orig_len=len;
  while ( len ) {

    *hex=fourbits2char[((*str) >> 4) & 0x0f];
    hex++;
    *hex=fourbits2char[(*str) & 0x0f];
    hex++;
    len--;
    str++;

  }
  return orig_len * 2;
}

inline static int hex2string(
  /* input */ const char *str, int len,
  /* output */ char *hex )
{
  int i;
  for (i = 0; i < len / 2; i++) {
    if(str[2*i]>='0' && str[2*i]<='9')
      hex[i] = (str[2*i]-'0') << 4;
    else if(str[2*i]>='a' && str[2*i]<='f')
      hex[i] = (str[2*i]-'a'+10) << 4;
    else if(str[2*i]>='A' && str[2*i]<='F')
      hex[i] = (str[2*i]-'A'+10) << 4;
    else goto error;

    if(str[2*i+1]>='0' && str[2*i+1]<='9')
      hex[i] += str[2*i+1]-'0';
    else if(str[2*i+1]>='a' && str[2*i+1]<='f')
      hex[i] += str[2*i+1]-'a'+10;
    else if(str[2*i+1]>='A' && str[2*i+1]<='F')
      hex[i] += str[2*i+1]-'A'+10;
    else goto error;
  }
  return i;
error:
  return -1;
}

/* portable sleep in microseconds (no interrupt handling now) */

inline static void sleep_us( unsigned int nusecs )
{
  struct timeval tval;
  tval.tv_sec=nusecs/1000000;
  tval.tv_usec=nusecs%1000000;
  select(0, NULL, NULL, NULL, &tval );
}


/* portable determination of max_path */
inline static int pathmax(void)
{
#ifdef PATH_MAX
  static int pathmax=PATH_MAX;
#else
  static int pathmax=0;
#endif
  if (pathmax==0) { /* init */
    pathmax=pathconf("/", _PC_PATH_MAX);
    pathmax=(pathmax<=0)?PATH_MAX_GUESS:pathmax+1;
  }
  return pathmax;
}

/* faster than glibc equivalents */
#define _isdigit(c) ((c) >= '0' && (c) <= '9')
#define _isalpha(c) \
  (((c) >= 'a' && (c) <= 'z') || \
   ((c) >= 'A' && (c) <= 'Z'))
#define _isxdigit(c) \
  (((c) >= '0' && (c) <= '9') || \
   ((c) >= 'a' && (c) <= 'f') || \
   ((c) >= 'A' && (c) <= 'F'))
#define _isalnum(c) (_isalpha(c) || _isdigit(c))

inline static int hex2int(char hex_digit)
{
  if (hex_digit>='0' && hex_digit<='9')
    return hex_digit-'0';
  if (hex_digit>='a' && hex_digit<='f')
    return hex_digit-'a'+10;
  if (hex_digit>='A' && hex_digit<='F')
    return hex_digit-'A'+10;
  /* no valid hex digit ... */
  LM_ERR("'%c' is no hex char\n", hex_digit );
  return -1;
}

/* Un-escape URI user  -- it takes a pointer to original user
   str, as well as the new, unescaped one, which MUST have
   an allocated buffer linked to the 'str' structure ;
   (the buffer can be allocated with the same length as
   the original string -- the output string is always
   shorter (if escaped characters occur) or same-long
   as the original one).

   only printable characters are permitted

  <0 is returned on an unescaping error, length of the
  unescaped string otherwise
*/
inline static int un_escape(str *user, str *new_user )
{
  int i, j, value;
  int hi, lo;

  if( new_user==0 || new_user->s==0) {
    LM_CRIT("called with invalid param\n");
    return -1;
  }

  new_user->len = 0;
  j = 0;

  for (i = 0; i < user->len; i++) {
    if (user->s[i] == '%') {
      if (i + 2 >= user->len) {
        LM_ERR("escape sequence too short in"
          " '%.*s' @ %d\n",
          user->len, user->s, i );
        goto error;
      }
      hi=hex2int(user->s[i + 1]);
      if (hi<0) {
        LM_ERR(" non-hex high digit in an escape"
          " sequence in '%.*s' @ %d\n",
          user->len, user->s, i+1 );
        goto error;
      }
      lo=hex2int(user->s[i + 2]);
      if (lo<0) {
        LM_ERR("non-hex low digit in an escape sequence in "
          "'%.*s' @ %d\n",
          user->len, user->s, i+2 );
        goto error;
      }
      value=(hi<<4)+lo;
      if (value < 32 || value > 126) {
        LM_ERR("non-ASCII escaped character in '%.*s' @ %d\n",
          user->len, user->s, i );
        goto error;
      }
      new_user->s[j] = value;
      i+=2; /* consume the two hex digits, for cycle will move to the next char */
    } else {
      new_user->s[j] = user->s[i];
    }
        j++; /* good -- we translated another character */
  }
  new_user->len = j;
  return j;

error:
  new_user->len = j;
  return -1;
}

static inline void unescape_crlf(str *in_out)
{
  char *p, *lim = in_out->s + in_out->len;

  if (ZSTR(*in_out))
    return;

  for (p = in_out->s; p < lim; p++) {
    if (*p == '\\' && p + 1 < lim) {
      if (*(p + 1) == 'r') {
        *p = '\r';
        memmove(p + 1, p + 2, lim - (p + 2));
        in_out->len--;
      } else if (*(p + 1) == 'n') {
        *p = '\n';
        memmove(p + 1, p + 2, lim - (p + 2));
        in_out->len--;
      }
    }
  }
}

/* @max_digits should be just 15, but there are exceptions to this rule! */
static inline int _is_e164(const str* _user, int require_plus, int max_digits)
{
  char *d, *start, *end;

  if (_user->len < 1)
    return -1;

  if (_user->s[0] == '+') {
    start = _user->s + 1;
  } else {
    if (require_plus)
      return -1;
    start = _user->s;
  }

  end = _user->s + _user->len;
  if (end - start < 2 || end - start > max_digits)
    return -1;

  for (d = start; d < end; d++)
    if (!_isdigit(*d))
      return -1;

  return 1;
}
#define is_e164(_user) _is_e164(_user, 1, 15)

/*
 * Convert a string to lower case
 */
static inline void strlower(str* _s)
{
  int i;

  for(i = 0; i < _s->len; i++) {
    _s->s[i] = tolower(_s->s[i]);
  }
}

/*
 * Convert a str into a short integer
 */
static inline int str2short(str* _s, unsigned short *_r)
{
  int i;

  if (_s==0 || _s->s == 0 || _s->len == 0 || _r == 0)
    return -1;

  *_r = 0;
  for(i = 0; i < _s->len; i++) {
    if ((_s->s[i] >= '0') && (_s->s[i] <= '9')) {
      *_r *= 10;
      *_r += _s->s[i] - '0';
    } else {
      return -1;
    }
  }

  return 0;
}

/*
 * Convert a str into integer
 */
static inline int str2int(const str* _s, unsigned int* _r)
{
  int i;

  if (_s==0 || _s->s == 0 || _s->len == 0 || _r == 0)
    return -1;

  *_r = 0;
  for(i = 0; i < _s->len; i++) {
    if ((_s->s[i] >= '0') && (_s->s[i] <= '9')) {
      *_r *= 10;
      *_r += _s->s[i] - '0';
    } else {
      return -1;
    }
  }

  return 0;
}

/*
 * Convert a str into a big integer
 */
static inline int str2int64(const str* _s, uint64_t *_r)
{
  int i;

  if (_s==0 || _s->s == 0 || _s->len == 0 || _r == 0)
    return -1;

  *_r = 0;
  for(i = 0; i < _s->len; i++) {
    if ((_s->s[i] >= '0') && (_s->s[i] <= '9')) {
      *_r *= 10;
      *_r += _s->s[i] - '0';
    } else {
      return -1;
    }
  }

  return 0;
}


/*
 * Convert a str into signed integer
 */
static inline int str2sint(const str* _s, int* _r)
{
  int i;
  int s;

  if (_s==0 || _s->s == 0 || _s->len == 0 || _r == 0)
    return -1;

  *_r = 0;
  s = 1;
  i=0;
  if(_s->s[i]=='-') {
    s=-1;
    i++;
  } else if (_s->s[i]=='+') {
    i++;
  }
  for(; i < _s->len; i++) {
    if ((_s->s[i] >= '0') && (_s->s[i] <= '9')) {
      *_r *= 10;
      *_r += _s->s[i] - '0';
    } else {
      //Preserve sign for partially converted strings
      *_r *= s;
      return -1;
    }
  }
  *_r *= s;
  return 0;
}


/*
 * Convert a str (base 10 or 16) into integer
 */
static inline int strno2int(const str *val, unsigned int *mask )
{
  /* hexa or decimal*/
  if (val->len>2 && val->s[0]=='0' && val->s[1]=='x') {
    return hexstr2int( val->s+2, val->len-2, mask);
  } else {
    return str2int( val, mask);
  }
}


/*
 * Make a copy of a str structure using shm_malloc
 *
 * Return: 0 on success, -1 on failure
 */
#define shm_str_dup(/* str* */_dst_, /* str* */_src_) \
  ({ \
    int __ret__; \
    (_dst_)->s = shm_malloc((_src_)->len); \
    if (!(_dst_)->s) { \
      LM_ERR("no shared memory left\n"); \
      (_dst_)->len = 0; \
      __ret__ = -1; \
    } else { \
      memcpy((_dst_)->s, (_src_)->s, (_src_)->len); \
      (_dst_)->len = (_src_)->len; \
      __ret__ = 0; \
    } \
   __ret__; \
   })


/*
 * Make a copy of an str structure using shm_malloc
 *    + an additional '\0' byte, so you can make use of dst->s
 *
 * dst == src is allowed!
 */
static inline int shm_nt_str_dup(str* dst, const str* src)
{
  const str _src = *src;

  if (!_src.s) {
    memset(dst, 0, sizeof *dst);
    return 0;
  }

  dst->s = shm_malloc(_src.len + 1);
  if (!dst->s) {
    LM_ERR("no shared memory left\n");
    dst->len = 0;
    if (dst == src)
      *dst = _src;
    return -1;
  }

  memcpy(dst->s, _src.s, _src.len);
  dst->len = _src.len;
  dst->s[_src.len] = '\0';
  return 0;
}

/*
 * Make a copy of an str structure using pkg_malloc
 *    + an additional '\0' byte, so you can make use of dst->s
 *
 * dst == src is allowed!
 */
static inline int pkg_nt_str_dup(str* dst, const str* src)
{
  const str _src = *src;

  if (!_src.s) {
    memset(dst, 0, sizeof *dst);
    return 0;
  }

  dst->s = pkg_malloc(_src.len + 1);
  if (!dst->s) {
    LM_ERR("no private memory left\n");
    dst->len = 0;
    if (dst == src)
      *dst = _src;
    return -1;
  }

  memcpy(dst->s, _src.s, _src.len);
  dst->len = _src.len;
  dst->s[_src.len] = '\0';
  return 0;
}

static inline char *shm_strdup(const char *str)
{
  char *rval;
  int len;

  if (!str)
    return NULL;

  len = strlen(str) + 1;
  rval = shm_malloc(len);
  if (!rval)
    return NULL;
  memcpy(rval, str, len);
  return rval;
}

/*
 * Ensure the given (str *) points to an SHM buffer of at least "size" bytes
 *
 * Return: 0 on success, -1 on failure
 */
#define shm_str_extend(/* str* */_in_, /* int */_size_) \
  ({ \
    int __ret__ = 0; \
    /* do not check for !in->s here, as it's better \
     * to crash sooner on a corrupt @in string (e.g. {NULL, 172}) */ \
    if ((_in_)->len < (_size_)) { \
      char *_p_ = shm_realloc((_in_)->s, _size_); \
      if (!_p_) { \
        LM_ERR("oom\n"); \
        __ret__ = -1; \
      } else { \
        (_in_)->s = _p_; \
        (_in_)->len = _size_; \
      } \
    } \
    __ret__; \
   })


/*
 * Ensure "dst" matches the content of "src" without leaking memory
 *
 * Note: if you just want to dup a string, use "shm_str_dup()" instead
 * Return: 0 on success, -1 on failure
 */
#define shm_str_sync(/* str* */_dst_, /* str* */_src_) \
  ({ \
    int __ret__; \
    if ((str *)(_src_) == (str *)NULL || !(_src_)->s || (_src_)->len == 0) { \
      if ((_dst_)->s) \
        shm_free((_dst_)->s); \
      memset((_dst_), 0, sizeof *(_dst_)); \
      __ret__ = 0; \
    } else if (shm_str_extend(_dst_, (_src_)->len) != 0) { \
      LM_ERR("oom\n"); \
      __ret__ = -1; \
    } else { \
      memcpy((_dst_)->s, (_src_)->s, (_src_)->len); \
      (_dst_)->len = (_src_)->len; \
      __ret__ = 0; \
    } \
  __ret__; \
  })


static inline void shm_str_clean(str* dst)
{
  if (dst->s)
    shm_free(dst->s);
  memset(dst, 0, sizeof *dst);
}

/*
 * Make a copy of a str structure using pkg_malloc
 */
static inline int pkg_str_dup(str* dst, const str* src)
{
  dst->s = pkg_malloc(src->len);
  if (!dst->s) {
    LM_ERR("no private memory left\n");
    dst->len = 0;
    return -1;
  }

  memcpy(dst->s, src->s, src->len);
  dst->len = src->len;
  return 0;
}

static inline char *pkg_strdup(const char *str)
{
  char *rval;
  int len;

  if (!str)
    return NULL;

  len = strlen(str) + 1;
  rval = pkg_malloc(len);
  if (!rval)
    return NULL;
  memcpy(rval, str, len);
  return rval;
}

/* Extend the given buffer only if needed */
static inline int pkg_str_extend(str *in, int size)
{
  char *p;

  /* do not check for !in->s here, as it's better
   * to crash sooner on a corrupt @in string (e.g. {NULL, 172}) */
  if (in->len < size) {
    p = pkg_realloc(in->s, size);
    if (!p) {
      LM_ERR("oom\n");
      return -1;
    }

    in->s = p;
    in->len = size;
  }

  return 0;
}

/*
 * Ensure "dst" matches the content of "src" without leaking memory
 *
 * Note: if you just want to dup a string, use "pkg_str_dup()" instead
 */
static inline int pkg_str_sync(str* dst, const str* src)
{
  if (ZSTRP(src)) {
    if (dst->s)
      pkg_free(dst->s);
    memset(dst, 0, sizeof *dst);
    return 0;
  }

  if (pkg_str_extend(dst, src->len) != 0) {
    LM_ERR("oom\n");
    return -1;
  }

  memcpy(dst->s, src->s, src->len);
  dst->len = src->len;
  return 0;
}




/*
 * test if two str's are equal
 */
static inline int _str_matchCC(const str_const *a, const str_const *b)
{
  return a->len == b->len && !memcmp(a->s, b->s, a->len);
}
static inline int _str_matchSS(const str *a, const str *b)
{
        return _str_matchCC(str2const(a), str2const(b));
}
static inline int _str_matchSC(const str *a, const str_const *b)
{
        return _str_matchCC(str2const(a), b);
}
static inline int _str_matchCS(const str_const *a, const str *b)
{
        return _str_matchCC(a, str2const(b));
}

/*
 * test if two str's are equal, case-insensitive
 */
static inline int _str_casematchCC(const str_const *a, const str_const *b)
{
  const char *p, *q, *end;

  if (a->len != b->len)
    return 0;

  p = a->s;
  q = b->s;

  if (p == q || a->len == 0)
    return 1;

  end = p + a->len;

  do {
    if (tolower(*p) != tolower(*q++))
      return 0;
  } while (++p < end);

  return 1;
}
static inline int _str_casematchSS(const str *a, const str *b)
{
        return _str_casematchCC(str2const(a), str2const(b));
}
static inline int _str_casematchSC(const str *a, const str_const *b)
{
        return _str_casematchCC(str2const(a), b);
}
static inline int _str_casematchCS(const str_const *a, const str *b)
{
        return _str_casematchCC(a, str2const(b));
}

/*
 * compare two str's
 */
static inline int _str_strcmpCC(const str_const *stra, const str_const *strb)
{
  int i;
  int alen;
  int blen;
  int minlen;

  if(stra==NULL || strb==NULL || stra->s ==NULL || strb->s==NULL
  || stra->len<0 || strb->len<0)
  {
#ifdef EXTRA_DEBUG
    LM_DBG("bad parameters\n");
#endif
    return -2;
  }

  alen = stra->len;
  blen = strb->len;
  minlen = (alen < blen ? alen : blen);

  for (i = 0; i < minlen; i++) {
    const char a = stra->s[i];
    const char b = strb->s[i];
    if (a < b)
      return -1;
    if (a > b)
      return 1;
  }

  if (alen < blen)
    return -1;
  else if (alen > blen)
    return 1;
  else
    return 0;
}
static inline int _str_strcmpSS(const str *a, const str *b)
{
  return _str_strcmpCC(str2const(a), str2const(b));
}
static inline int _str_strcmpSC(const str *a, const str_const *b)
{
  return _str_strcmpCC(str2const(a), b);
}
static inline int _str_strcmpCS(const str_const *a, const str *b)
{
  return _str_strcmpCC(a, str2const(b));
}

/*
 * compares a str with a const null terminated string
 */
static inline int str_match_nt(const str *a, const char *b)
{
  return a->len == strlen(b) && !memcmp(a->s, b, a->len);
}

/*
 * compares a str with a const null terminated string, case-insensitive
 */
static inline int str_casematch_nt(const str *a, const char *b)
{
  return a->len == strlen(b) && !strncasecmp(a->s, b, a->len);
}


/*
 * search @strb in @stra, return pointer to 1st occurrence
 */
static inline char* str_strstr(const str *stra, const str *strb)
{
  int i;
  int len;

  if (stra==NULL || strb==NULL || stra->s==NULL || strb->s==NULL
      || stra->len<=0 || strb->len<=0) {
#ifdef EXTRA_DEBUG
    LM_DBG("bad parameters\n");
#endif
    return NULL;
  }

  if (strb->len > stra->len)
    return NULL;

  len=0;
  while (stra->len-len >= strb->len){
    if (stra->s[len] != strb->s[0]) {
      len++;
      continue;
    }

    for (i=1; i<strb->len; i++)
      if (stra->s[len+i]!=strb->s[i]) {
        len++;
        break;
      }

    if (i != strb->len)
      continue;

    return stra->s+len;
  }


  return NULL;
}

/*
 * search @strb in @stra ignoring case of both, return pointer to 1st occurrence
 */
static inline char* str_strcasestr(const str *stra, const str *strb)
{
  int i;
  int len;

  if (stra==NULL || strb==NULL || stra->s==NULL || strb->s==NULL
      || stra->len<=0 || strb->len<=0) {
#ifdef EXTRA_DEBUG
    LM_DBG("bad parameters\n");
#endif
    return NULL;
  }

  if (strb->len > stra->len)
    return NULL;

  len=0;
  while (stra->len-len >= strb->len){
    if (tolower(stra->s[len]) != tolower(strb->s[0])) {
      len++;
      continue;
    }

    for (i=1; i<strb->len; i++)
      if (tolower(stra->s[len+i])!=tolower(strb->s[i])) {
        len++;
        break;
      }

    if (i != strb->len)
      continue;

    return stra->s+len;
  }


  return NULL;
}

/*
 * case-insensitive compare n chars of two str's
 */
static inline int str_strncasecmp(const str *stra, const str *strb, int n)
{
  int i;

  if(stra==NULL || strb==NULL || stra->s ==NULL || strb->s==NULL
  || stra->len<0 || strb->len<0)
  {
#ifdef EXTRA_DEBUG
    LM_DBG("bad parameters\n");
#endif
    return -2;
  }

  if (stra->len<n || strb->len<n) {
    LM_ERR("input strings don't have at least [n=%d] characters\n", n);
    return -2;
  }

  for (i = 0; i < n; i++) {
    const char a = tolower(stra->s[i]);
    const char b = tolower(strb->s[i]);
    if (a < b)
      return -1;
    if (a > b)
      return 1;
  }

  return 0;

}

/*
 * case-insensitive compare two str's
 */
static inline int str_strcasecmp(const str *stra, const str *strb)
{
  int i;
  int alen;
  int blen;
  int minlen;

  if(stra==NULL || strb==NULL || stra->s ==NULL || strb->s==NULL
  || stra->len<0 || strb->len<0)
  {
#ifdef EXTRA_DEBUG
    LM_DBG("bad parameters\n");
#endif
    return -2;
  }
  alen = stra->len;
  blen = strb->len;
  minlen = (alen < blen ? alen : blen);

  for (i = 0; i < minlen; i++) {
    const char a = tolower(stra->s[i]);
    const char b = tolower(strb->s[i]);
    if (a < b)
      return -1;
    if (a > b)
      return 1;
  }
  if (alen < blen)
    return -1;
  else if (alen > blen)
    return 1;
  else
    return 0;
}

#define start_expire_timer(begin,threshold) \
  do { \
    if (threshold) \
      gettimeofday(&(begin), NULL); \
  } while(0) \

#define __stop_expire_timer(begin,threshold,func_info, \
                           extra_s,extra_len,tcp,_slow_stat) \
  do { \
    if (threshold) { \
      int __usdiff__ = get_time_diff(&(begin)); \
      if (__usdiff__ > (threshold)) { \
        log_expiry(__usdiff__,(threshold),(func_info), \
                   (extra_s),(extra_len),tcp); \
        if (_slow_stat) \
          inc_stat(_slow_stat); \
      } \
    } \
  } while(0)

#define stop_expire_timer(begin,threshold,func_info,extra_s,extra_len,tcp) \
  __stop_expire_timer(begin,threshold,func_info, \
                     extra_s,extra_len,tcp,(stat_var *)NULL)

#define _stop_expire_timer(begin,threshold,func_info,extra_s,extra_len,tcp, \
              slow, total) \
  do { \
    __stop_expire_timer(begin,threshold,func_info, \
              extra_s,extra_len,tcp,slow); \
    if (total) \
      inc_stat(total); \
  } while (0)

extern int tcp_timeout_con_get;
extern int tcp_timeout_receive_fd;
extern int tcp_timeout_send;

#define reset_tcp_vars(threshold) \
  do { \
    if (threshold) \
    { \
      tcp_timeout_con_get=0; \
      tcp_timeout_receive_fd=0; \
      tcp_timeout_send=0; \
    } \
  } while(0)

#define get_time_difference(begin,threshold,tcp_dbg) \
  do { \
    if ((threshold)) \
      tcp_dbg = get_time_diff(&(begin)); \
  } while(0)

/* Note: limited to a max time diff of 2147 * 10^6 useconds! */
static inline int get_time_diff(struct timeval *begin)
{
  struct timeval end;

  gettimeofday(&end, NULL);

  /* difference is returned in microseconds */
  return (long long)(end.tv_sec*1000000 + end.tv_usec)
           - (long long)(begin->tv_sec*1000000 + begin->tv_usec);
}

static inline unsigned long long get_clock_diff(struct timespec *begin)
{
    struct timespec end;

    clock_gettime(CLOCK_REALTIME, &end);

    return (end.tv_sec - begin->tv_sec) * 1000000000ULL
             + (end.tv_nsec - begin->tv_nsec);
}

#define __clock_check_diff(__loglv__, start_tmspec, maxdf, fmt, ...) \
  do { \
    unsigned long long _diff_ns = get_clock_diff(start_tmspec); \
    if (_diff_ns > (maxdf)) \
      LM_GEN(__loglv__, "time spent: %0.*lfs " fmt "\n", 3, \
             (_diff_ns)/1e9, __VA_ARGS__); \
  } while (0)
#define _clock_check_diff(start_tmspec, maxdf, fmt, ...) \
  __clock_check_diff(L_NOTICE, start_tmspec, maxdf, fmt, __VA_ARGS__)

/**
 * clock_check_diff() - measure code execution time relative to the @begin
 *       timespec; print notice msg if the difference was exceeded
 * @maxdf (unsigned long long) - the maximum accepted execution time
 * @fmt (char *) - extra format string + variable # of arguments
 */
#define clock_check_diff(maxdf, fmt, ...) \
  _clock_check_diff(&begin, maxdf, fmt, __VA_ARGS__)

#define reset_longest_action_list(threshold) \
  do { \
    if ((threshold)) { \
      min_action_time=0; \
      memset(longest_action,0,LONGEST_ACTION_SIZE*sizeof(action_time)); \
    } \
  } while (0)

static inline void log_expiry(int time_diff,int expire,
          const char *func_info,char *extra_dbg,int dbg_len,int tcp)
{
  str param;
  evi_params_p list;
  static str func_str = str_init("source");
  static str time_str = str_init("time");
  static str extra_str = str_init("extra");
  int i;

  if (time_diff > expire)
  {
    if (tcp) {
      LM_WARN("threshold exceeded : tcp took too long : "
        "con_get=%d, rcv_fd=%d, send=%d. Source : %.*s\n",
        tcp_timeout_con_get,tcp_timeout_receive_fd,
        tcp_timeout_send,dbg_len,extra_dbg);
      time_diff = tcp_timeout_send + tcp_timeout_receive_fd +
        tcp_timeout_con_get;
    } else
      LM_WARN("threshold exceeded : %s took too long - %d us."
          "Source : %.*s\n",func_info,time_diff,dbg_len,extra_dbg);

    if (memcmp(func_info,"msg",3) == 0) {
      for (i=0;i<LONGEST_ACTION_SIZE;i++) {
        if (longest_action[i].a) {
          if ((unsigned char)longest_action[i].a->type == CMD_T)
          LM_WARN("#%i is a module action : %s - %dus - line %d\n",i+1,
              ((cmd_export_t*)(longest_action[i].a->elem[0].u.data))->name,
              longest_action[i].a_time,longest_action[i].a->line);
          else
          LM_WARN("#%i is a core action : %d - %dus - line %d\n",i+1,
              longest_action[i].a->type,
              longest_action[i].a_time,longest_action[i].a->line);
        }
      }
    }
    if (evi_probe_event(EVI_THRESHOLD_ID)) {

      param.s = (char *)func_info;
      param.len = strlen(func_info);
      if (!(list = evi_get_params()))
        return;
      if (evi_param_add_str(list, &func_str, &param)) {
        LM_ERR("unable to add func parameter\n");
        goto error;
      }
      if (evi_param_add_int(list, &time_str, &time_diff)) {
        LM_ERR("unable to add time parameter\n");
        goto error;
      }
      param.s = extra_dbg;
      param.len = dbg_len;
      if (evi_param_add_str(list, &extra_str, &param)) {
        LM_ERR("unable to add extra parameter\n");
        goto error;
      }
      if (evi_raise_event(EVI_THRESHOLD_ID, list)) {
        LM_ERR("unable to send event\n");
      }

    } else {
      LM_DBG("no event raised\n");
    }
  }
  return;
error:
  evi_free_params(list);
}

static inline int get_timestamp(int *sec,int *usec)
{
  struct timeval t;

  if (gettimeofday(&t,NULL) != 0)
  {
    LM_ERR("failed to get time of day\n");
    return -1;
  }

  *sec = t.tv_sec;
  *usec = t.tv_usec;

  return 0;
}

/*
 * checks if the string is a token as defined in rfc3261
 * returns:
 *  -1 - if the string is invalid
 *  1 - if the string is a token
 *  0 - not a token
 */
static inline int str_check_token( str * in)
{
  char *p;

  if (!in || !in->s || !in->len)
    return -1;

  p = in->s + in->len;
  while (p > in->s) {
    p--;
    if (!(
        /* alphanum */
        (*p >= 'a' && *p <= 'z') ||
        (*p >= 'A' && *p <= 'Z') ||
        (*p >= '0' && *p <= '9') ||
        /* other */
        *p == '-' || *p == '.' ||
        *p == '!' || *p == '%' ||
        *p == '*' || *p == '_' ||
        *p == '+' || *p == '`' ||
        *p == '\'' || *p == '~'
        ))
      return 0;
  }
  return 1;
}


/*
 * l_memmem() returns the location of the first occurrence of data
 * pattern b2 of size len2 in memory block b1 of size len1 or
 * NULL if none is found. Obtained from NetBSD.
 */
static inline void * l_memmem(const void *b1, const void *b2,
                          size_t len1, size_t len2)
{
  /* Initialize search pointer */
  char *sp = (char *) b1;

  /* Initialize pattern pointer */
  char *pp = (char *) b2;

  /* Initialize end of search address space pointer */
  char *eos = sp + len1 - len2;

  /* Sanity check */
  if(!(b1 && b2 && len1 && len2))
    return NULL;

  while (sp <= eos) {
    if (*sp == *pp)
      if (memcmp(sp, pp, len2) == 0)
        return sp;

    sp++;
  }

  return NULL;
}

/**
 * Make any database URL log-friendly by masking its password, if any
 * Note: makes use of a single, static buffer -- use accordingly!
 */
char *db_url_escape(const str *url);
static inline char *_db_url_escape(const char *url)
{
  return db_url_escape(_str(url));
}

int user2uid(int* uid, int* gid, char* user);

int group2gid(int* gid, char* group);

char * NTcopy_str( str *s );

/* utility function to give each children a unique seed */
void seed_child(unsigned int seed);


int parse_reply_codes( str *options_reply_codes_str,
    int **options_reply_codes, int *options_codes_no);

void base64encode(unsigned char *out, unsigned char *in, int inlen);
int base64decode(unsigned char *out,unsigned char *in,int len);

void base64urlencode(unsigned char *out, unsigned char *in, int inlen);
int base64urldecode(unsigned char *out,unsigned char *in,int len);

/*
 * "word64" is a combination between:
 *   - RFC 3261-compatible "word" token characters
 *   - modulo-64 encoding of base64
 */
void word64encode(unsigned char *out, unsigned char *in, int inlen);
int word64decode(unsigned char *out, unsigned char *in, int len);

void _base32encode(unsigned char *out, unsigned char *in, int inlen,
  unsigned char pad_char);
int _base32decode(unsigned char *out, unsigned char *in, int len,
  unsigned char pad_char);

#define base32encode(out, in, inlen) _base32encode(out, in, inlen, '=')

/* also accepts lowercase letters as equivalent encoding characters
 * of uppercase letters */
#define base32decode(out, in, len) _base32decode(out, in, len, '=')

/* same as base32 but uses '-' instead of '=' as pad character */
#define word32encode(out, in, inlen) _base32encode(out, in, inlen, '-')
#define word32decode(out, in, len) _base32decode(out, in, len, '-')

#define calc_base64_encode_len(_l) (((_l)/3 + ((_l)%3?1:0))*4)
#define calc_max_base64_decode_len(_l) ((_l)*3/4)

#define calc_word64_encode_len calc_base64_encode_len
#define calc_max_word64_decode_len calc_max_base64_decode_len

#define calc_base32_encode_len(_l) (((_l)/5 + ((_l)%5?1:0))*8)
#define calc_max_base32_decode_len(_l) ((_l)*5/8)

#define calc_word32_encode_len calc_base32_encode_len
#define calc_max_word32_decode_len calc_max_base32_decode_len

#ifdef howmany
#undef howmany
#endif
#define howmany(x, y) (sizeof(x) / sizeof(y))

/* waits for maximum _timeout microseconds for the _cond condition to be
 * satisfied, sleeping every _inc microseconds */
#define busy_wait_for(_cond, _timeout, _inc) \
  do { \
    unsigned _retries = (_timeout)/(_inc);\
    while (!(_cond) && --_retries > 0) \
      usleep(_inc); \
  } while (0)

#endif

Coverage Report

Created: 2025-07-09 06:29