/src/opensips/pvar.c

Source
/**
 * Copyright (C) 2010-2020 OpenSIPS Solutions
 * Copyright (C) 2005-2009 Voice Sistem SRL
 * 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
 *
 * History:
 * --------
 * 2004-10-20 - added header name specifier (ramona)
 * 2005-06-14 - added avp name specifier (ramona)
 * 2005-06-18 - added color printing support via escape sequesnces
 *              contributed by Ingo Flaschberger (daniel)
 * 2005-06-22 - created this file from modules/xlog/pv_lib.c (daniel)
 * 2009-04-28 - $ct and $ct.fields() PVs added (bogdan)
 * 2009-05-02 - $branch() added, $br, $bR, $bf, $bF removed (bogdan)
 */

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

#include "dprint.h"
#include "mem/mem.h"
#include "mem/shm_mem.h"
#include "ut.h"
#include "trim.h"
#include "dset.h"
#include "action.h"
#include "socket_info.h"
#include "route_struct.h"
#include "usr_avp.h"
#include "errinfo.h"
#include "transformations.h"
#include "script_var.h"
#include "pvar.h"
#include "sdp_ops.h"
#include "flags.h"
#include "xlog.h"

#include "parser/parse_from.h"
#include "parser/parse_uri.h"
#include "parser/parse_hname2.h"
#include "parser/parse_content.h"
#include "parser/parse_refer_to.h"
#include "parser/parse_rpid.h"
#include "parser/parse_diversion.h"
#include "parser/parse_ppi.h"
#include "parser/parse_pai.h"
#include "parser/digest/digest.h"
#include "parser/contact/parse_contact.h"
#include "parser/parse_authenticate.h"
#include "lib/digest_auth/digest_auth.h"

#define is_in_str(p, in) (p<in->s+in->len && *p)

extern int curr_action_line;
extern char *curr_action_file;

typedef struct _pv_extra
{
  pv_export_t pve;
  struct _pv_extra *next;
} pv_extra_t, *pv_extra_p;

pv_extra_p  *_pv_extra_list=0;

static str str_marker = { PV_MARKER_STR, 1 };

/* IMPORTANT : the "const" strings returned by the var functions must
   be read-write (as they may be changed by the script interpreter), so
   we need to allocated as array and not as pointing to RO data segment
   */
static char _str_null_hlp[] = "<null>";
static str str_null         = str_init(_str_null_hlp);

static char _str_empty_hlp[] = "";
static str str_empty         = str_init(_str_empty_hlp);

int _pv_pid = 0;

#define PV_FIELD_DELIM ", "
#define PV_FIELD_DELIM_LEN (sizeof(PV_FIELD_DELIM) - 1)

#define PV_LOCAL_BUF_SIZE 511
static char pv_local_buf[PV_LOCAL_BUF_SIZE+1];

/* pv context list */
pv_context_t* pv_context_lst = NULL;

static pv_context_t* pv_get_context(const str* name);
static pv_context_t* add_pv_context(const str* name, pv_contextf_t get_context);

static int pv_parse_argv_name(pv_spec_p sp, const str *in);
static int pv_get_argv(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res);
static int pv_contextlist_check(void);
/* always obtain a printable version of the given (pv_value_t *) */
static str pv_value_print(const pv_value_t *val);

static int pvc_before_check = 1;

int pv_print_buf_size = 20000;
#define PV_PRINT_BUF_NO   7
str *pv_print_buf;

#define is_pv_print_buf(p) (p >= (char *)pv_print_buf && \
      p <= (char *)pv_print_buf + \
        PV_PRINT_BUF_NO * (sizeof(*pv_print_buf) + pv_print_buf_size))

int init_pvar_support(void)
{
  int i;

  /* check pv context list */
  if (pv_contextlist_check() != 0) {
    LM_ERR("used pv context that was not defined\n");
    return -1;
  }

  pv_print_buf = pkg_malloc(PV_PRINT_BUF_NO * (sizeof(str)
                                 + pv_print_buf_size));
  if (!pv_print_buf) {
    LM_ERR("oom\n");
    return -1;
  }

  for (i = 0; i < PV_PRINT_BUF_NO; i++) {
    pv_print_buf[i].s = (char *)(pv_print_buf + PV_PRINT_BUF_NO)
                                  + i * pv_print_buf_size;
    pv_print_buf[i].len = pv_print_buf_size;
  }

  return 0;
}

/* route param variable */
static int pv_get_param(struct sip_msg *msg,  pv_param_t *ip, pv_value_t *res);
static int pv_parse_param_name(pv_spec_p sp, const str *in);
static int pv_parse_return_value(pv_spec_p sp, const str *in);

/********** helper functions ********/
/**
 * convert unsigned int to pv_value_t
 */
int pv_get_uintval(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, unsigned int uival)
{
  int l = 0;
  char *ch = NULL;

  if(res==NULL)
    return -1;

  ch = int2str(uival, &l);
  res->rs.s = ch;
  res->rs.len = l;

  res->ri = (int)uival;
  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
  return 0;
}

/**
 * convert signed int to pv_value_t
 */
int pv_get_sintval(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, int sival)
{
  int l = 0;
  char *ch = NULL;

  if(res==NULL)
    return -1;

  ch = sint2str(sival, &l);
  res->rs.s = ch;
  res->rs.len = l;

  res->ri = sival;
  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
  return 0;
}

/**
 * convert str to pv_value_t
 */
int pv_get_strval(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, str *sval)
{
  if(res==NULL)
    return -1;

  res->rs = *sval;
  res->flags = PV_VAL_STR;
  return 0;
}

/**
 * convert str-int to pv_value_t (type is str)
 */
static int pv_get_strintval(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, str *sval, int ival)
{
  if(res==NULL)
    return -1;

  res->rs = *sval;
  res->ri = ival;
  res->flags = PV_VAL_STR|PV_VAL_INT;
  return 0;
}

/**
 * convert int-str to pv_value_t (type is int)
 */
static int pv_get_intstrval(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, int ival, str *sval)
{
  if(res==NULL)
    return -1;

  res->rs = *sval;
  res->ri = ival;
  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
  return 0;
}

/************************************************************/
static int pv_get_marker(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  return pv_get_strintval(msg, param, res, &str_marker, (int)str_marker.s[0]);
}

int pv_get_null(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
{
  if(res==NULL)
    return -1;

  res->rs = str_empty;
  res->ri = 0;
  res->flags = PV_VAL_NULL;
  return 0;
}

/************************************************************/
static int pv_get_pid(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(_pv_pid == 0)
    _pv_pid = (int)getpid();
  return pv_get_sintval(msg, param, res, _pv_pid);
}


extern int return_code;
static int pv_get_return_code(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  return pv_get_sintval(msg, param, res, return_code);
}

static int pv_get_route(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  static str rn_buf;

  str s;
  int i, idx, idx_flags, len, rlen, has_name, route_stack_size_ctx;

  if (pv_get_spec_index(msg, param, &idx, &idx_flags) != 0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idx_flags == PV_IDX_ALL) {
    get_top_route_type(&s, &has_name);
    if (!has_name)
      goto unnamed_route;

    len = strlen(route_stack[route_stack_start]);
    if (pkg_str_extend(&rn_buf, s.len + 2 + len + 1) != 0) {
      LM_ERR("oom\n");
      return pv_get_null(msg, param, res);
    }

    len = sprintf(rn_buf.s, "%.*s[%s]", s.len, s.s, route_stack[route_stack_start]);
    goto print_remaining;

  unnamed_route:
    if (pkg_str_extend(&rn_buf, s.len + 1) != 0) {
      LM_ERR("oom\n");
      return pv_get_null(msg, param, res);
    }

    len = sprintf(rn_buf.s, "%.*s", s.len, s.s);

  print_remaining:
    s = str_route;

    for (i = route_stack_start+1; i < route_stack_size; i++) {
      if (!route_stack[i]) {
        if (pkg_str_extend(&rn_buf, len + 3 + s.len + 1) != 0) {
          LM_ERR("oom\n");
          return pv_get_null(msg, param, res);
        }

        len += sprintf(rn_buf.s + len, " > %.*s", s.len, s.s);
      } else if (route_stack[i][0] != '!') {
        rlen = strlen(route_stack[i]);

        if (pkg_str_extend(&rn_buf, len + s.len + 5 + rlen + 1) != 0) {
          LM_ERR("oom\n");
          return pv_get_null(msg, param, res);
        }

        len += sprintf(rn_buf.s + len, " > %.*s[%s]",
                  s.len, s.s, route_stack[i]);
      } else {
        rlen = strlen(route_stack[i]);

        /* the "!" marker tells us to print that route name as-is */
        if (pkg_str_extend(&rn_buf, len + rlen + 3) != 0) {
          LM_ERR("oom\n");
          return pv_get_null(msg, param, res);
        }

        len += sprintf(rn_buf.s + len, " > %s", route_stack[i] + 1);
      }
    }

    s.s = rn_buf.s;
    s.len = len;
    return pv_get_strval(msg, param, res, &s);
  }

  route_stack_size_ctx = route_stack_size - route_stack_start;

  if (idx < 0)
    idx += route_stack_size_ctx;

  /* index out of bounds -- play nice and return NULL */
  if (idx > route_stack_size_ctx - 1 || idx < 0)
    return pv_get_null(msg, param, res);

  /* reverse the index, since we index the route stack backwards */
  idx = route_stack_size_ctx - idx - 1;

  if (idx == 0) {
    get_top_route_type(&s, &has_name);
    if (!has_name)
      goto out_ok;

  } else {
    s = str_route;
    if (!route_stack[route_stack_start + idx])
      goto out_ok;
  }

  len = strlen(route_stack[route_stack_start + idx]);

  if (route_stack[route_stack_start + idx][0] != '!') {
    if (pkg_str_extend(&rn_buf, s.len + 2 + len + 1) != 0) {
      LM_ERR("oom\n");
      return pv_get_null(msg, param, res);
    }

    s.len = sprintf(rn_buf.s, "%.*s[%s]", s.len, s.s, route_stack[route_stack_start + idx]);
    s.s = rn_buf.s;
  } else {
    /* the "!" marker tells us to print that route name as-is */
    if (pkg_str_extend(&rn_buf, len) != 0) {
      LM_ERR("oom\n");
      return pv_get_null(msg, param, res);
    }

    s.len = sprintf(rn_buf.s, "%s", route_stack[route_stack_start + idx] + 1);
    s.s = rn_buf.s;
  }

out_ok:
  return pv_get_strval(msg, param, res, &s);
}


static int pv_get_route_name(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str rn;
  int idx, idx_flags, route_stack_size_ctx;

  if (pv_get_spec_index(msg, param, &idx, &idx_flags) != 0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idx_flags == PV_IDX_ALL) {
    LM_ERR("unsupported index: [*]\n");
    return -1;
  }

  route_stack_size_ctx = route_stack_size - route_stack_start;

  if (idx < 0)
    idx += route_stack_size_ctx;

  /* index out of bounds -- play nice and return NULL */
  if (idx > route_stack_size_ctx - 1 || idx < 0)
    return pv_get_null(msg, param, res);

  /* reverse the index, since we index the route stack backwards */
  idx = route_stack_size_ctx - idx - 1;

  get_route_name(idx, &rn);
  return pv_get_strval(msg, param, res, &rn);
}


static int pv_get_route_type(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str rt;
  int idx, idx_flags, route_stack_size_ctx;

  if (pv_get_spec_index(msg, param, &idx, &idx_flags) != 0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idx_flags == PV_IDX_ALL) {
    LM_ERR("unsupported index: [*]\n");
    return -1;
  }

  route_stack_size_ctx = route_stack_size - route_stack_start;

  if (idx < 0)
    idx += route_stack_size_ctx;

  /* index out of bounds -- play nice and return NULL */
  if (idx > route_stack_size_ctx - 1 || idx < 0)
    return pv_get_null(msg, param, res);

  /* reverse the index, since we index the route stack backwards */
  idx = route_stack_size_ctx - idx - 1;

  get_route_type(idx, &rt);
  return pv_get_strval(msg, param, res, &rt);
}


static int pv_get_times(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  return pv_get_uintval(msg, param, res, (unsigned int)time(NULL));
}

static int pv_get_timem(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  struct timeval TP;

  if(msg==NULL)
    return -1;

  gettimeofday(&TP, NULL);
  return pv_get_uintval(msg, param, res, (unsigned int)TP.tv_usec);
}

static int pv_get_start_times(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  return pv_get_uintval(msg, param, res, (unsigned int)startup_time);
}

static int pv_parse_time_name(pv_spec_p sp, const str *in)
{
  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = AVP_NAME_STR;
  sp->pvp.pvn.u.isname.name.s.s = pkg_malloc(in->len + 1);
  if (sp->pvp.pvn.u.isname.name.s.s==NULL) {
    LM_ERR("failed to allocated private mem\n");
    return -1;
  }
  memcpy(sp->pvp.pvn.u.isname.name.s.s, in->s, in->len);
  sp->pvp.pvn.u.isname.name.s.s[in->len] = 0;
  sp->pvp.pvn.u.isname.name.s.len = in->len;
  return 0;
}

static int pv_get_formated_time(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  static char buf[128];
  struct tm ltime;
  time_t t;

  if(msg==NULL)
    return -1;

  time( &t );
  localtime_r(&t, &ltime);
  res->rs.len = strftime( buf, 127, param->pvn.u.isname.name.s.s, &ltime);

  if (res->rs.len<=0)
    return pv_get_null(msg, param, res);

  res->rs.s = buf;
  res->flags = PV_VAL_STR;
  return 0;
}

#define CTIME_BUFFER_NO 5
#define CTIME_BUFFER_SIZE 26

static int pv_get_timef(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  static char ctime_bufs[CTIME_BUFFER_NO][CTIME_BUFFER_SIZE];
  static char *buf;
  static int ctime_buf_no = 0;
  time_t t;
  str s;

  if(msg==NULL)
    return -1;

  t = time(NULL);
  buf = ctime_bufs[ctime_buf_no];
  ctime_buf_no = (ctime_buf_no + 1) % CTIME_BUFFER_NO;
  s.s = ctime_r(&t, buf);
  s.len = strlen(s.s)-1;
  return pv_get_strintval(msg, param, res, &s, (int)t);
}

static int pv_get_msgid(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;
  return pv_get_uintval(msg, param, res, msg->id);
}

static int pv_get_method(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->first_line.type == SIP_REQUEST)
  {
    return pv_get_strintval(msg, param, res,
        &msg->first_line.u.request.method,
        (int)msg->first_line.u.request.method_value);
  }

  if(msg->cseq==NULL && ((parse_headers(msg, HDR_CSEQ_F, 0)==-1) ||
        (msg->cseq==NULL)))
  {
    LM_ERR("no CSEQ header\n");
    return pv_get_null(msg, param, res);
  }

  return pv_get_strintval(msg, param, res,
      &get_cseq(msg)->method,
      get_cseq(msg)->method_id);
}

static int pv_get_status(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->first_line.type != SIP_REPLY)
    return pv_get_null(msg, param, res);

  return pv_get_intstrval(msg, param, res,
      (int)msg->first_line.u.reply.statuscode,
      &msg->first_line.u.reply.status);
}

static int pv_get_reason(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->first_line.type != SIP_REPLY)
    return pv_get_null(msg, param, res);

  return pv_get_strval(msg, param, res, &msg->first_line.u.reply.reason);
}

static int pv_get_ruri(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL || res==NULL)
    return -1;

  if(msg->first_line.type == SIP_REPLY) /* REPLY doesn't have a ruri */
    return pv_get_null(msg, param, res);

  if(msg->parsed_uri_ok==0 /* R-URI not parsed*/ && parse_sip_msg_uri(msg)<0)
  {
    LM_ERR("failed to parse the R-URI\n");
    return pv_get_null(msg, param, res);
  }

  if (msg->new_uri.s!=NULL)
    return pv_get_strval(msg, param, res, &msg->new_uri);
  return pv_get_strval(msg, param, res, &msg->first_line.u.request.uri);
}

static int pv_get_ru_q(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL || res==NULL)
    return -1;

  if(msg->first_line.type == SIP_REPLY)
    return pv_get_null(msg, param, res);

  return pv_get_sintval(msg, param, res, get_ruri_q(msg));
}

static int pv_get_ouri(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL || res==NULL)
    return -1;

  if(msg->first_line.type == SIP_REPLY) /* REPLY doesn't have a ruri */
    return pv_get_null(msg, param, res);

  if(msg->parsed_orig_ruri_ok==0
      /* orig R-URI not parsed*/ && parse_orig_ruri(msg)<0)
  {
    LM_ERR("failed to parse the R-URI\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_strval(msg, param, res, &msg->first_line.u.request.uri);
}

static int pv_get_xuri_attr(struct sip_msg *msg, struct sip_uri *parsed_uri,
    pv_param_t *param, pv_value_t *res)
{
  unsigned short proto;
  str proto_s;

  if(param->pvn.u.isname.name.n==1) /* username */
  {
    if(parsed_uri->user.s==NULL || parsed_uri->user.len<=0)
      return pv_get_null(msg, param, res);
    return pv_get_strval(msg, param, res, &parsed_uri->user);
  } else if(param->pvn.u.isname.name.n==2) /* domain */ {
    if(parsed_uri->host.s==NULL || parsed_uri->host.len<=0)
      return pv_get_null(msg, param, res);
    return pv_get_strval(msg, param, res, &parsed_uri->host);
  } else if(param->pvn.u.isname.name.n==3) /* port */ {
    if(parsed_uri->port.s==NULL)
      return pv_get_uintval(msg, param, res,
        get_uri_port( parsed_uri, &proto));
    return pv_get_strintval(msg, param, res, &parsed_uri->port,
        (int)parsed_uri->port_no);
  } else if(param->pvn.u.isname.name.n==4) /* protocol */ {
    if(parsed_uri->transport_val.s==NULL) {
      get_uri_port(parsed_uri, &proto);
      proto_s.s = protos[proto].name;
      proto_s.len = proto_s.s ? strlen(proto_s.s) : 0;
      return pv_get_strintval(msg, param, res, &proto_s, (int)proto);
    }
    return pv_get_strintval(msg, param, res, &parsed_uri->transport_val,
        (int)parsed_uri->proto);
  }
  LM_ERR("unknown specifier\n");
  return pv_get_null(msg, param, res);
}

static int pv_get_ruri_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->first_line.type == SIP_REPLY) /* REPLY doesn't have a ruri */
    return pv_get_null(msg, param, res);

  if(msg->parsed_uri_ok==0 /* R-URI not parsed*/ && parse_sip_msg_uri(msg)<0)
  {
    LM_ERR("failed to parse the R-URI\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_xuri_attr(msg, &(msg->parsed_uri), param, res);
}

static int pv_get_ouri_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->first_line.type == SIP_REPLY) /* REPLY doesn't have a ruri */
    return pv_get_null(msg, param, res);

  if(msg->parsed_orig_ruri_ok==0
      /* orig R-URI not parsed*/ && parse_orig_ruri(msg)<0)
  {
    LM_ERR("failed to parse the R-URI\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_xuri_attr(msg, &(msg->parsed_orig_ruri), param, res);
}

static int pv_get_path(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(!msg->path_vec.s)
  {
    return pv_get_null(msg, param, res);
  }
  return pv_get_strval(msg, param, res, &msg->path_vec);
}

#define CT_NAME_S        "name"
#define CT_NAME_LEN      (sizeof(CT_NAME_S)-1)
#define CT_NAME_ID       1
#define CT_URI_S         "uri"
#define CT_URI_LEN       (sizeof(CT_URI_S)-1)
#define CT_URI_ID        2
#define CT_Q_S           "q"
#define CT_Q_LEN         (sizeof(CT_Q_S)-1)
#define CT_Q_ID          3
#define CT_EXPIRES_S     "expires"
#define CT_EXPIRES_LEN   (sizeof(CT_EXPIRES_S)-1)
#define CT_EXPIRES_ID     4
#define CT_METHODS_S     "methods"
#define CT_METHODS_LEN   (sizeof(CT_METHODS_S)-1)
#define CT_METHODS_ID    5
#define CT_RECEIVED_S    "received"
#define CT_RECEIVED_LEN  (sizeof(CT_RECEIVED_S)-1)
#define CT_RECEIVED_ID   6
#define CT_PARAMS_S      "params"
#define CT_PARAMS_LEN    (sizeof(CT_PARAMS_S)-1)
#define CT_PARAMS_ID     7

static int pv_parse_ct_name(pv_spec_p sp, const str *in)
{
  if (sp==NULL)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  if (in==NULL || in->s==NULL || in->len==0) {
    sp->pvp.pvn.u.isname.name.n = 0;
  } else
  if (in->len==CT_NAME_LEN &&
  strncasecmp(in->s, CT_NAME_S, CT_NAME_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_NAME_ID;
  } else
  if (in->len==CT_URI_LEN &&
  strncasecmp(in->s, CT_URI_S, CT_URI_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_URI_ID;
  } else
  if (in->len==CT_Q_LEN &&
  strncasecmp(in->s, CT_Q_S, CT_Q_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_Q_ID;
  } else
  if (in->len==CT_EXPIRES_LEN &&
  strncasecmp(in->s, CT_EXPIRES_S, CT_EXPIRES_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_EXPIRES_ID;
  } else
  if (in->len==CT_METHODS_LEN &&
  strncasecmp(in->s, CT_METHODS_S, CT_METHODS_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_METHODS_ID;
  } else
  if (in->len==CT_RECEIVED_LEN &&
  strncasecmp(in->s, CT_RECEIVED_S, CT_RECEIVED_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_RECEIVED_ID;
  } else
  if (in->len==CT_PARAMS_LEN &&
  strncasecmp(in->s, CT_PARAMS_S, CT_PARAMS_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = CT_PARAMS_ID;
  } else {
    LM_ERR("unsupported CT field <%.*s>\n",in->len,in->s);
    return -1;
  }

  return 0;
}


static inline int get_contact_body_field(pv_value_t *res,struct hdr_field *cth,
                    contact_t *ct, pv_name_t *pvn)
{
  param_t *p;

  if (ct==NULL) {
    /* star contact hdr */
    if (pvn->u.isname.name.n==0) {
      res->rs = cth->body;
      res->flags = PV_VAL_STR;
      return 0;
    }
    return pv_get_null(NULL, NULL, res);
  }

  switch (pvn->u.isname.name.n) {
    case 0: /* all body */
      res->rs.s = ct->name.s?ct->name.s:ct->uri.s;
      res->rs.len = ct->len;
      break;
    case CT_NAME_ID: /* name only */
      if (ct->name.s==NULL || ct->name.len==0)
        return pv_get_null(NULL, NULL, res);
      res->rs = ct->name;
      break;
    case CT_URI_ID: /* uri only */
      res->rs = ct->uri;
      break;
    case CT_Q_ID: /* Q param only */
      if ( !ct->q || !ct->q->body.s || !ct->q->body.len)
        return pv_get_null(NULL, NULL, res);
      res->rs = ct->q->body;
      break;
    case CT_EXPIRES_ID: /* EXPIRES param only */
      if (!ct->expires||!ct->expires->body.s||!ct->expires->body.len)
        return pv_get_null(NULL, NULL, res);
      res->rs = ct->expires->body;
      break;
    case CT_METHODS_ID: /* METHODS param only */
      if (!ct->methods||!ct->methods->body.s||!ct->methods->body.len)
        return pv_get_null(NULL, NULL, res);
      res->rs = ct->methods->body;
      break;
    case CT_RECEIVED_ID: /* RECEIVED param only */
      if(!ct->received||!ct->received->body.s||!ct->received->body.len)
        return pv_get_null(NULL, NULL, res);
      res->rs = ct->received->body;
      break;
    case CT_PARAMS_ID: /* all param */
      if (!ct->params)
        return pv_get_null(NULL, NULL, res);
      res->rs.s = ct->params->name.s;
      for( p=ct->params ; p->next ; p=p->next);
      res->rs.len = p->name.s + p->len - res->rs.s;
      break;
    default:
      LM_CRIT("BUG - unsupported ID %d\n",pvn->u.isname.type);
      return pv_get_null(NULL, NULL, res);
  }

  res->flags = PV_VAL_STR;
  return 0;
}


static int pv_get_contact_body(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  struct hdr_field *ct_h;
  contact_body_t *ct_b;
  contact_t *ct;
  int idx;
  int idxf;
  char *p;

  if(msg==NULL)
    return -1;

  /* get all CONTACT headers */
  if(parse_headers(msg, HDR_EOH_F, 0)==-1 || msg->contact==NULL ||
  !msg->contact->body.s || msg->contact->body.len<=0)
  {
    LM_DBG("no contact header!\n");
    return pv_get_null(msg, param, res);
  }

  ct_h = msg->contact;
  if (parse_contact( ct_h )!=0) {
    LM_ERR("failed to parse contact hdr\n");
    return -1;
  }
  ct_b = (contact_body_t*)ct_h->parsed;
  if (ct_b==NULL)
    return pv_get_null(msg, param, res);
  ct = ct_b->contacts;

  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if( idxf!=PV_IDX_ALL && idx==0) {
    /* no index specified -> return the first contact body */
    return get_contact_body_field( res , ct_h, ct, &param->pvn);
  }

  if(idxf==PV_IDX_ALL) {
    /* return all contact bodies */
    p = pv_local_buf;
    do {
      if(p!=pv_local_buf) {
        if (p-pv_local_buf+PV_FIELD_DELIM_LEN+1>PV_LOCAL_BUF_SIZE){
          LM_ERR("local buffer length exceeded\n");
          return pv_get_null(msg, param, res);
        }
        memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
        p += PV_FIELD_DELIM_LEN;
      }

      get_contact_body_field( res , ct_h, ct, &param->pvn);
      if (p-pv_local_buf+res->rs.len+1>PV_LOCAL_BUF_SIZE) {
        LM_ERR("local buffer length exceeded!\n");
        return pv_get_null(msg, param, res);
      }
      memcpy(p, res->rs.s, res->rs.len);
      p += res->rs.len;

      ct = ct?ct->next:NULL;
      while (ct==NULL && ct_h!=NULL) {
        ct_h = ct_h->sibling;
        if (ct_h) {
          if (parse_contact( ct_h )!=0) {
            LM_ERR("failed to parse contact hdr\n");
            return -1;
          }
          ct_b = (contact_body_t*)ct_h->parsed;
          ct = ct_b->contacts;
        }
      }
    } while (ct_h);

    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    res->flags = PV_VAL_STR;
    return 0;
  }

  /* numerical index */
  if (idx<0) {
    /* index from the end */
    idxf=0;
    while(ct_h) {
      idxf++;
      ct = ct?ct->next:NULL;
      while (ct==NULL && ct_h!=NULL) {
        ct_h = ct_h->sibling;
        if (ct_h) {
          if (parse_contact( ct_h)!=0) {
            LM_ERR("failed to parse contact hdr\n");
            return -1;
          }
          ct_b = (contact_body_t*)ct_h->parsed;
          ct = ct_b->contacts;
        }
      }
    }
    if (-idx>idxf)
      return pv_get_null(msg, param, res);

    idx = idxf +idx;
    ct_h = msg->contact;
    ct_b = (contact_body_t*)ct_h->parsed;
    ct = ct_b->contacts;
  }

  while (idx!=0 && ct_h) {
    /* get to the next contact body */
    idx--;
    ct = ct?ct->next:NULL;
    while (ct==NULL && ct_h!=NULL) {
      ct_h = ct_h->sibling;
      if (ct_h) {
        if (parse_contact( ct_h )!=0) {
          LM_ERR("failed to parse contact hdr\n");
          return -1;
        }
        ct_b = (contact_body_t*)ct_h->parsed;
        ct = ct_b->contacts;
      }
    }
  }

  /* nothing found ?*/
  if (ct==NULL)
    return pv_get_null(msg, param, res);

  /* take the current body */
  return get_contact_body_field( res , ct_h, ct, &param->pvn);
}

extern err_info_t _oser_err_info;
static int pv_get_errinfo_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(param->pvn.u.isname.name.n==0) /* class */ {
    return pv_get_sintval(msg, param, res, _oser_err_info.eclass);
  } else if(param->pvn.u.isname.name.n==1) /* level */ {
    return pv_get_sintval(msg, param, res, _oser_err_info.level);
  } else if(param->pvn.u.isname.name.n==2) /* info */ {
    if(_oser_err_info.info.s==NULL)
      pv_get_null(msg, param, res);
    return pv_get_strval(msg, param, res, &_oser_err_info.info);
  } else if(param->pvn.u.isname.name.n==3) /* rcode */ {
    return pv_get_sintval(msg, param, res, _oser_err_info.rcode);
  } else if(param->pvn.u.isname.name.n==4) /* rreason */ {
    if(_oser_err_info.rreason.s==NULL)
      pv_get_null(msg, param, res);
    return pv_get_strval(msg, param, res, &_oser_err_info.rreason);
  } else {
    LM_DBG("invalid attribute!\n");
    return pv_get_null(msg, param, res);
  }
}

static int pv_get_xto_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, struct to_body *xto, int type)
{
  struct sip_uri *uri;
  if(xto==NULL)
    return -1;

  if(param->pvn.u.isname.name.n==1) /* uri */
    return pv_get_strval(msg, param, res, &xto->uri);

  if(param->pvn.u.isname.name.n==4) /* tag */
  {
    if (xto->tag_value.s==NULL || xto->tag_value.len<=0)
    {
            LM_DBG("no Tag parameter\n");
            return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &xto->tag_value);
  }

  if(param->pvn.u.isname.name.n==5) /* display name */
  {
    if(xto->display.s==NULL || xto->display.len<=0)
    {
      LM_DBG("no Display name\n");
      return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &xto->display);
  }

  if(type==0)
  {
    if((uri=parse_to_uri(msg))==NULL)
    {
      LM_ERR("cannot parse To URI\n");
      return pv_get_null(msg, param, res);
    }
  } else {
    if((uri=parse_from_uri(msg))==NULL)
    {
      LM_ERR("cannot parse From URI\n");
      return pv_get_null(msg, param, res);
    }
  }

  if(param->pvn.u.isname.name.n==2) /* username */
  {
      if(uri->user.s==NULL || uri->user.len<=0)
    {
        LM_DBG("no username\n");
      return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &uri->user);
  } else if(param->pvn.u.isname.name.n==3) /* domain */ {
      if(uri->host.s==NULL || uri->host.len<=0)
    {
        LM_DBG("no domain\n");
      return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &uri->host);
  }

  LM_ERR("unknown specifier\n");
  return pv_get_null(msg, param, res);
}

static int pv_get_to_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->to==NULL && parse_headers(msg, HDR_TO_F, 0)==-1)
  {
    LM_ERR("cannot parse To header\n");
    return pv_get_null(msg, param, res);
  }
  if(msg->to==NULL || get_to(msg)==NULL) {
    LM_DBG("no To header\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_xto_attr(msg, param, res, get_to(msg), 0);
}

static int pv_get_from_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(parse_from_header(msg)<0)
  {
    LM_ERR("cannot parse From header\n");
    return pv_get_null(msg, param, res);
  }

  if(msg->from==NULL || get_from(msg)==NULL) {
    LM_DBG("no From header\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_xto_attr(msg, param, res, get_from(msg), 1);
}

static int pv_get_cseq(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->cseq==NULL && ((parse_headers(msg, HDR_CSEQ_F, 0)==-1)
        || (msg->cseq==NULL)) )
  {
    LM_ERR("cannot parse CSEQ header\n");
    return pv_get_null(msg, param, res);
  }
  return pv_get_strval(msg, param, res, &(get_cseq(msg)->number));
}

static int pv_get_msg_buf(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str s;
  if(msg==NULL)
    return -1;

  s.s = msg->buf;
  s.len = msg->len;
  return pv_get_strval(msg, param, res, &s);
}

static int pv_get_msg_len(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  return pv_get_uintval(msg, param, res, msg->len);
}

static int pv_get_flags(struct sip_msg *msg, pv_param_t *param,
                         pv_value_t *res)
{
  str buf;

  if (!msg)
    return -1;

  buf = bitmask_to_flag_list(FLAG_TYPE_MSG, msg->flags);

  return pv_get_strval(msg, param, res, &buf);
}

static int pv_get_bflags(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str buf;

  if (!msg)
    return -1;

  buf = bitmask_to_flag_list(FLAG_TYPE_BRANCH, getb0flags(msg));

  return pv_get_strval(msg, param, res, &buf);
}

static int pv_get_callid(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(msg->callid==NULL && ((parse_headers(msg, HDR_CALLID_F, 0)==-1) ||
        (msg->callid==NULL)) )
  {
    LM_ERR("cannot parse Call-Id header\n");
    return pv_get_null(msg, param, res);
  }

  return pv_get_strval(msg, param, res, &msg->callid->body);
}

static int pv_get_srcip(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str s;
  if(msg==NULL)
    return -1;

  if ( (s.s=ip_addr2a(&msg->rcv.src_ip))==NULL)
    return pv_get_null(msg, param, res);
  s.len = strlen(s.s);
  return pv_get_strval(msg, param, res, &s);
}

static int pv_get_srcport(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;
  return pv_get_uintval(msg, param, res, msg->rcv.src_port);
}

static int pv_get_useragent(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;
  if(msg->user_agent==NULL && ((parse_headers(msg, HDR_USERAGENT_F, 0)==-1)
       || (msg->user_agent==NULL)))
  {
    LM_DBG("no User-Agent header\n");
    return pv_get_null(msg, param, res);
  }

  return pv_get_strval(msg, param, res, &msg->user_agent->body);
}

static int pv_get_refer_to(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(parse_refer_to_header(msg)==-1)
  {
    LM_DBG("no Refer-To header\n");
    return pv_get_null(msg, param, res);
  }

  if(msg->refer_to==NULL || get_refer_to(msg)==NULL)
    return pv_get_null(msg, param, res);

  return pv_get_strval(msg, param, res, &(get_refer_to(msg)->uri));
}

static int pv_get_diversion(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str *val;
  str name;

  if(msg == NULL)
    return -1;

  if(parse_diversion_header(msg) == -1)
  {
    LM_DBG("no Diversion header\n");
    return pv_get_null(msg, param, res);
  }

  if(msg->diversion == NULL || get_diversion(msg) == NULL)
  {
    LM_DBG("no Diversion header\n");
    return pv_get_null(msg, param, res);
  }

  if(param->pvn.u.isname.name.n == 1)  { /* uri */
    return pv_get_strval(msg, param, res, &(get_diversion(msg)->uri));
  }

  if(param->pvn.u.isname.name.n == 2)  { /* reason param */
      name.s = "reason";
      name.len = 6;
      val = diversion_param(msg, name);
      if (val) {
      return pv_get_strval(msg, param, res, val);
      } else {
      return pv_get_null(msg, param, res);
      }
  }

  if(param->pvn.u.isname.name.n == 3)  { /* privacy param */
      name.s = "privacy";
      name.len = 7;
      val = diversion_param(msg, name);
      if (val) {
      return pv_get_strval(msg, param, res, val);
      } else {
      return pv_get_null(msg, param, res);
      }
  }

  LM_ERR("unknown diversion specifier\n");
  return pv_get_null(msg, param, res);
}

static int pv_get_rpid(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if(parse_rpid_header(msg)==-1)
  {
    LM_DBG("no RPID header\n");
    return pv_get_null(msg, param, res);
  }

  if(msg->rpid==NULL || get_rpid(msg)==NULL)
    return pv_get_null(msg, param, res);

  return pv_get_strval(msg, param, res, &(get_rpid(msg)->uri));
}

static int pv_get_ppi_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
    struct sip_uri *uri;

    if(msg==NULL)
  return -1;

    if(parse_ppi_header(msg) < 0) {
  LM_DBG("no P-Preferred-Identity header\n");
  return pv_get_null(msg, param, res);
    }

    if(msg->ppi == NULL || get_ppi(msg) == NULL) {
         LM_DBG("no P-Preferred-Identity header\n");
    return pv_get_null(msg, param, res);
    }

    if(param->pvn.u.isname.name.n == 1) { /* uri */
    return pv_get_strval(msg, param, res, &(get_ppi(msg)->uri));
    }

    if(param->pvn.u.isname.name.n==4) { /* display name */
    if(get_ppi(msg)->display.s == NULL ||
        get_ppi(msg)->display.len <= 0) {
        LM_DBG("no P-Preferred-Identity display name\n");
      return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &(get_ppi(msg)->display));
    }

    if((uri=parse_ppi_uri(msg))==NULL) {
    LM_ERR("cannot parse P-Preferred-Identity URI\n");
    return pv_get_null(msg, param, res);
    }

    if(param->pvn.u.isname.name.n==2) { /* username */
    if(uri->user.s==NULL || uri->user.len<=0) {
        LM_DBG("no P-Preferred-Identity username\n");
        return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &uri->user);
    } else if(param->pvn.u.isname.name.n==3) { /* domain */
    if(uri->host.s==NULL || uri->host.len<=0) {
      LM_DBG("no P-Preferred-Identity domain\n");
      return pv_get_null(msg, param, res);
    }
    return pv_get_strval(msg, param, res, &uri->host);
    }

  LM_ERR("unknown specifier\n");
  return pv_get_null(msg, param, res);
}

static int pv_get_pai(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
    if(msg==NULL)
    return -1;

    if(parse_pai_header(msg)==-1)
    {
    LM_DBG("no P-Asserted-Identity header\n");
    return pv_get_null(msg, param, res);
    }

    if(msg->pai==NULL || get_pai(msg)==NULL) {
    LM_DBG("no P-Asserted-Identity header\n");
    return pv_get_null(msg, param, res);
    }

  return pv_get_strval(msg, param, res, &(get_pai(msg)->uri));
}

static int pv_get_dset(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str s;

  if(msg==NULL)
    return -1;

  s.s = print_dset(msg, &s.len);
  if (s.s == NULL)
    return pv_get_null(msg, param, res);
  s.len -= CRLF_LEN;

  return pv_get_strval(msg, param, res, &s);
}


static int pv_get_dsturi(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;

  if (msg->dst_uri.s == NULL) {
    LM_DBG("no destination URI\n");
    return pv_get_null(msg, param, res);
  }

  return pv_get_strval(msg, param, res, &msg->dst_uri);
}

static int pv_get_dsturi_attr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  struct sip_uri uri;
  unsigned short proto;
  str proto_s;

  if(msg==NULL)
    return -1;

  if (msg->dst_uri.s == NULL) {
    LM_DBG("no destination URI\n");
    return pv_get_null(msg, param, res);
  }

  if(parse_uri(msg->dst_uri.s, msg->dst_uri.len, &uri)!=0)
  {
    LM_ERR("failed to parse dst uri\n");
    return pv_get_null(msg, param, res);
  }

  if(param->pvn.u.isname.name.n==1) /* domain */
  {
    if(uri.host.s==NULL || uri.host.len<=0)
      return pv_get_null(msg, param, res);
    return pv_get_strval(msg, param, res, &uri.host);
  } else if(param->pvn.u.isname.name.n==2) /* port */ {
    if(uri.port.s==NULL)
      return pv_get_uintval(msg, param, res, get_uri_port(&uri, &proto));
    return pv_get_strintval(msg, param, res, &uri.port, (int)uri.port_no);
  } else if(param->pvn.u.isname.name.n==3) /* proto */ {
    if(uri.transport_val.s==NULL) {
      get_uri_port(&uri, &proto);
      proto_s.s = protos[proto].name;
      proto_s.len = proto_s.s ? strlen(proto_s.s) : 0;
      return pv_get_strintval(msg, param, res, &proto_s, (int)proto);
    }
    return pv_get_strintval(msg, param, res, &uri.transport_val,
        (int)uri.proto);
  }

  LM_ERR("invalid specifier\n");
  return pv_get_null(msg, param, res);
}

static int pv_get_content_type(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
#define BUFLEN 1024

  str s;
  int idx=-1;
  int idxf=-1;
  int distance=0;
  char buf[BUFLEN];
  struct sip_msg_body* sbody;
  struct body_part* body_part;
  struct body_part* neg_index[2];

  if(msg==NULL)
    return -1;

  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  /* no index or all contenttypes */
  if (param->pvi.type==0 || idxf == PV_IDX_ALL) {
    if(msg->content_type==NULL
        && ((parse_headers(msg, HDR_CONTENTTYPE_F, 0)==-1)
         || (msg->content_type==NULL)))
    {
      LM_DBG("no Content-Type header\n");
      return pv_get_null(msg, param, res);
    }

    /* only the main contenttype requested*/
    if (param->pvi.type==0)
      return pv_get_strval(msg, param, res, &msg->content_type->body);
  }

  if ( parse_sip_body(msg)<0 || (sbody=msg->body)==NULL ) {
    LM_DBG("no body found\n");
    return pv_get_null(msg, param, res);
  }

  /* one contenttype request */
  if (idxf != PV_IDX_ALL) {
    if (idx< 0) {
      neg_index[0] = neg_index[1] = &sbody->first;
      /*distance=last_body_postition-searched_body_position*/
      distance -= idx+1;
      while (neg_index[1]->next) {
        if (distance == 0) {
          neg_index[0] = neg_index[0]->next;
        } else {
          distance--;
        }
        neg_index[1] = neg_index[1]->next;
      }

      if (distance>0) {
        LM_ERR("Index too low [%d]\n", idx);
        return pv_get_null(msg, param, res);
      }

      s.s = convert_mime2string_CT(neg_index[0]->mime);
      s.len = strlen(s.s);
    } else {
      body_part = &sbody->first;
      distance = idx;
      while (distance && body_part->next) {
        distance--;
        body_part=body_part->next;
      }

      if (distance > 0) {
        LM_ERR("Index too big [%d]\n", idx);
        return pv_get_null(msg, param, res);
      }

      s.s = convert_mime2string_CT(body_part->mime);
      s.len = strlen(s.s);
    }
  } else {
    /* copy main content type */
    memcpy(buf, msg->content_type->body.s, msg->content_type->body.len);
    buf[msg->content_type->body.len] = ',';
    s.len = msg->content_type->body.len+1;

    /* copy all the other contenttypes */
    body_part = &sbody->first;
    while (body_part) {
      s.s = convert_mime2string_CT(body_part->mime);
      if (s.len + strlen(s.s) >= BUFLEN) {
        LM_CRIT("buffer overflow! Too many contenttypes!\n");
        return pv_get_null(msg, param, res);
      }

      memcpy( buf+s.len, s.s, strlen(s.s));
      s.len += strlen(s.s);

      /* delimiter only if something follows */
      if(body_part->next)
        buf[s.len++] = ',';

      body_part = body_part->next;
    }
    s.s = buf;
  }

  return pv_get_strval(msg, param, res, &s);

#undef BUFLEN
}

static int pv_get_content_length(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  if(msg==NULL)
    return -1;
  if(msg->content_length==NULL
      && ((parse_headers(msg, HDR_CONTENTLENGTH_F, 0)==-1)
       || (msg->content_length==NULL)))
  {
    LM_DBG("no Content-Length header\n");
    return pv_get_null(msg, param, res);
  }

  return pv_get_intstrval(msg, param, res,
      (int)(long)msg->content_length->parsed,
      &msg->content_length->body);
}

static int pv_parse_rb_name(pv_spec_p sp, const str *in)
{
  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;

  if (decode_mime_type( in->s, in->s+in->len ,
  (unsigned int *)&sp->pvp.pvn.u.isname.name.n , NULL) == 0) {
    LM_ERR("unsupported mime <%.*s>\n",in->len,in->s);
    return -1;
  }

  sp->pvp.pvn.type = PV_NAME_INTSTR;  /* INT/STR for var name type */
  sp->pvp.pvn.u.isname.type = 0;      /* name is INT */

  return 0;
}

static int pv_get_msg_body(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  str s;
  int idx=-1;
  int idxf=-1;
  int distance=0;
  struct sip_msg_body* sbody;
  struct body_part* body_part;
  struct body_part* neg_index[2];
  unsigned int mime;

  if(msg==NULL)
    return -1;

  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  /* any index specified */
  if (param->pvi.type==0 || idxf==PV_IDX_ALL) {
    if (param->pvn.u.isname.name.n==0) {
      /* no name/mime -> requests all bodies */
      if (get_body( msg, &s)!=0 || s.len==0 ) {
        LM_DBG("no message body\n");
        return pv_get_null(msg, param, res);
      }
      goto end;
    } else {
      /* return first part with the requested mime */
      idx = 0;
    }
  }

  if ( parse_sip_body(msg)<0 || (sbody=msg->body)==NULL ) {
    LM_DBG("no body found\n");
    return pv_get_null(msg, param, res);
  }

  mime = param->pvn.u.isname.name.n;
  LM_DBG("--------mime is <%d>, idx=%d\n",mime, idx);

#define first_part_by_mime( _part_start, _part_end, _mime) \
  do {\
    _part_end = _part_start;\
    while( (_part_end) && \
    !(is_body_part_received(_part_end) && ((_mime)==0 || \
    (_mime)==(_part_end)->mime )) ) { \
      _part_end = (_part_end)->next; \
    } \
  }while(0)

  if (idx<0) {
    first_part_by_mime( &sbody->first, neg_index[1], mime );
    neg_index[0] = neg_index[1];

    if (neg_index[0]==NULL) {
      LM_DBG("Body part not found for <%d>\n", mime);
      return pv_get_null(msg, param, res);
    }

    /*distance=last_body_postition-searched_body_position*/
    distance -= idx+1;
    first_part_by_mime(neg_index[1]->next, neg_index[1], mime);
    while (neg_index[1]) {
      if (distance == 0) {
        first_part_by_mime( neg_index[0]->next, neg_index[0], mime );
      } else {
        distance--;
      }
      first_part_by_mime( neg_index[1]->next, neg_index[1], mime );
    }

    if (distance>0) {
      LM_DBG("Index too low [%d]\n", idx);
      return pv_get_null(msg, param, res);
    }

    s.s = neg_index[0]->body.s;
    s.len = neg_index[0]->body.len;
  } else {
    first_part_by_mime( &sbody->first, body_part, mime );
    distance = idx;
    while (distance && body_part ) {
      distance--;
      first_part_by_mime( body_part->next, body_part, mime );
    }

    if (distance>0 || body_part==NULL) {
      LM_DBG("Index too big [%d], body_part=%p\n", idx,body_part);
      return pv_get_null(msg, param, res);
    }

    s.s = body_part->body.s;
    s.len = body_part->body.len;
  }

end:
  return pv_get_strval(msg, param, res, &s);
}


static int pv_get_sdp(struct sip_msg *msg, pv_param_t *_, pv_value_t *res)
{
  pv_param_t param;

  memset(&param, 0, sizeof param);
  param.pvn.u.isname.name.n = ((TYPE_APPLICATION<<16)+SUBTYPE_SDP);

  return pv_get_msg_body(msg, &param, res);
}


static int pv_get_authattr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  struct hdr_field *hdr;
  str *s;

  if(msg==NULL)
    return -1;

  if ((msg->REQ_METHOD==METHOD_ACK) || (msg->REQ_METHOD==METHOD_CANCEL)) {
    LM_DBG("no [Proxy-]Authorization header\n");
    return pv_get_null(msg, param, res);
  }

  if ((parse_headers(msg, HDR_PROXYAUTH_F|HDR_AUTHORIZATION_F, 0)==-1)
      || (msg->proxy_auth==0 && msg->authorization==0))
  {
    LM_DBG("no [Proxy-]Authorization header\n");
    return pv_get_null(msg, param, res);
  }

  hdr = (msg->proxy_auth==0)?msg->authorization:msg->proxy_auth;
  if(parse_credentials(hdr)!=0) {
    LM_ERR("failed to parse credentials\n");
    return pv_get_null(msg, param, res);
  }

  switch(param->pvn.u.isname.name.n)
  {
    case 11:
      s = &((auth_body_t*)(hdr->parsed))->digest.nc;
      break;
    case 10:
      s = &((auth_body_t*)(hdr->parsed))->digest.qop.qop_str;
      break;
    case 9:
      s = &((auth_body_t*)(hdr->parsed))->digest.alg.alg_str;
      break;
    case 8:
      s = &((auth_body_t*)(hdr->parsed))->digest.opaque;
      break;
    case 7:
      s = &((auth_body_t*)(hdr->parsed))->digest.cnonce;
      break;
    case 6:
      s = &((auth_body_t*)(hdr->parsed))->digest.response;
      break;
    case 5:
      s = &((auth_body_t*)(hdr->parsed))->digest.nonce;
      break;
    case 4:
      s = &((auth_body_t*)(hdr->parsed))->digest.username.domain;
      break;
    case 3:
      s = &((auth_body_t*)(hdr->parsed))->digest.uri;
      break;
    case 2:
      s = &((auth_body_t*)(hdr->parsed))->digest.realm;
      break;
    case 1:
      s = &((auth_body_t*)(hdr->parsed))->digest.username.user;
      break;
    default:
      s = &((auth_body_t*)(hdr->parsed))->digest.username.whole;
  }

  if (s->len==0)
    return pv_get_null(msg, param, res);
  return pv_get_strval(msg, param, res, s);
}


static int pv_get_cauthattr(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  struct authenticate_body *auth = NULL;
  str *s;

  if(msg==NULL)
    return -1;

  if (msg->first_line.type!=SIP_REPLY) {
    LM_DBG("{Proxy,WWW}-Authenticate header should be only in replies\n");
    return pv_get_null(msg, param, res);
  }
  switch (msg->REPLY_STATUS) {
    case 401:
      parse_www_authenticate_header(msg, NULL, &auth);
      break;
    case 407:
      parse_proxy_authenticate_header(msg, NULL, &auth);
      break;
    default:
      LM_DBG("bad reply code for a challenge!\n");
      break;
  }
  if (!auth) {
    LM_DBG("no {Proxy,WWW}-Authenticate header\n");
    return pv_get_null(msg, param, res);
  }

  switch (param->pvn.u.isname.name.n) {
    case 1:
      s = (str *)print_digest_algorithm(auth->algorithm);
      break;
    case 2:
      s = &auth->realm;
      break;
    case 3:
      s = &auth->nonce;
      break;
    case 4:
      s = &auth->opaque;
      break;
    case 5:
      s = &auth->qop;
      break;
    case 6:
      s = &auth->ik;
      break;
    case 7:
      s = &auth->ck;
      break;
    default:
      LM_BUG("unhandled mode %d\n", param->pvn.u.isname.name.n);
      return pv_get_null(msg, param, res);
  }

  return pv_get_strval(msg, param, res, s);
}


static inline str *cred_user(struct sip_msg *rq)
{
  struct hdr_field* h;
  auth_body_t* cred;

  get_authorized_cred(rq->proxy_auth, &h);
  if (!h) get_authorized_cred(rq->authorization, &h);
  if (!h) return 0;
  cred=(auth_body_t*)(h->parsed);
  if (!cred || !cred->digest.username.user.len)
      return 0;
  return &cred->digest.username.user;
}


static inline str *cred_realm(struct sip_msg *rq)
{
  str* realm;
  struct hdr_field* h;
  auth_body_t* cred;

  get_authorized_cred(rq->proxy_auth, &h);
  if (!h) get_authorized_cred(rq->authorization, &h);
  if (!h) return 0;
  cred=(auth_body_t*)(h->parsed);
  if (!cred) return 0;
  realm = GET_REALM(&cred->digest);
  if (!realm->len || !realm->s) {
    return 0;
  }
  return realm;
}

static int pv_get_acc_username(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  static char buf[MAX_URI_SIZE];
  str* user;
  str* realm;
  struct sip_uri puri;
  struct to_body* from;
  str s;

  /* try to take it from credentials */
  user = cred_user(msg);
  if (user) {
    realm = cred_realm(msg);
    if (realm) {
      s.len = user->len+1+realm->len;
      if (s.len > MAX_URI_SIZE) {
        LM_ERR("uri too long\n");
        return pv_get_null(msg, param, res);
      }
      s.s = buf;
      memcpy(s.s, user->s, user->len);
      (s.s)[user->len] = '@';
      memcpy(s.s+user->len+1, realm->s, realm->len);
      return pv_get_strval(msg, param, res, &s);
    }
    return pv_get_strval(msg, param, res, user);
  }

  /* from from uri */
  if(parse_from_header(msg)<0)
  {
    LM_ERR("cannot parse FROM header\n");
    return pv_get_null(msg, param, res);
  }
  if (msg->from && (from=get_from(msg)) && from->uri.len) {
    if (parse_uri(from->uri.s, from->uri.len, &puri) < 0 ) {
      LM_ERR("bad From URI\n");
      return pv_get_null(msg, param, res);
    }
    s.len = puri.user.len + 1 + puri.host.len;
    if (s.len > MAX_URI_SIZE) {
      LM_ERR("from URI too long\n");
      return pv_get_null(msg, param, res);
    }
    s.s = buf;
    memcpy(s.s, puri.user.s, puri.user.len);
    (s.s)[puri.user.len] = '@';
    memcpy(s.s + puri.user.len + 1, puri.host.s, puri.host.len);
  } else {
    s.len = 0;
    s.s = 0;
  }
  return pv_get_strval(msg, param, res, &s);
}


#define BR_URI_S         "uri"
#define BR_URI_LEN       (sizeof(BR_URI_S)-1)
#define BR_URI_ID        1
#define BR_DURI_S        "duri"
#define BR_DURI_LEN      (sizeof(BR_DURI_S)-1)
#define BR_DURI_ID       2
#define BR_Q_S           "q"
#define BR_Q_LEN         (sizeof(BR_Q_S)-1)
#define BR_Q_ID          3
#define BR_PATH_S        "path"
#define BR_PATH_LEN      (sizeof(BR_PATH_S)-1)
#define BR_PATH_ID       4
#define BR_FLAGS_S       "flags"
#define BR_FLAGS_LEN     (sizeof(BR_FLAGS_S)-1)
#define BR_FLAGS_ID       5
#define BR_SOCKET_S       "socket"
#define BR_SOCKET_LEN     (sizeof(BR_SOCKET_S)-1)
#define BR_SOCKET_ID      6

static int pv_parse_branch_name(pv_spec_p sp, const str *in)
{
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  if (in->len==BR_URI_LEN &&
  strncasecmp(in->s, BR_URI_S, BR_URI_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_URI_ID;
  } else
  if (in->len==BR_DURI_LEN &&
  strncasecmp(in->s, BR_DURI_S, BR_DURI_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_DURI_ID;
  } else
  if (in->len==BR_Q_LEN &&
  strncasecmp(in->s, BR_Q_S, BR_Q_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_Q_ID;
  } else
  if (in->len==BR_PATH_LEN &&
  strncasecmp(in->s, BR_PATH_S, BR_PATH_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_PATH_ID;
  } else
  if (in->len==BR_FLAGS_LEN &&
  strncasecmp(in->s, BR_FLAGS_S, BR_FLAGS_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_FLAGS_ID;
  } else
  if (in->len==BR_SOCKET_LEN &&
  strncasecmp(in->s, BR_SOCKET_S, BR_SOCKET_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = BR_SOCKET_ID;
  } else {
    LM_ERR("unsupported MSG BRANCH field <%.*s>\n",in->len,in->s);
    return -1;
  }

  return 0;
}

static inline int get_branch_field( int idx, int field_id, pv_value_t *res)
{
  struct msg_branch *branch;

  branch = get_msg_branch(idx);
  if (branch==NULL)
    return pv_get_null( NULL, NULL, res);

  /* got a valid branch, return the field */
  switch (field_id) {
    case 0:
    case BR_URI_ID: /* return URI */
      res->rs = branch->uri;
      res->flags = PV_VAL_STR;
      break;
    case BR_Q_ID: /* return Q */
      res->rs.s = q2str(branch->q, (unsigned int*)&res->rs.len);
      res->flags = PV_VAL_STR;
      break;
    case BR_DURI_ID: /* return DURI */
      if ( ZSTR(branch->dst_uri) )
        return pv_get_null(NULL, NULL, res);
      res->rs = branch->dst_uri;
      res->flags = PV_VAL_STR;
      break;
    case BR_PATH_ID: /* return PATH */
      if ( ZSTR(branch->path) )
        return pv_get_null(NULL, NULL, res);
      res->rs = branch->path;
      res->flags = PV_VAL_STR;
      break;
    case BR_FLAGS_ID: /* return FLAGS */
      res->rs = bitmask_to_flag_list(FLAG_TYPE_BRANCH, branch->bflags);
      res->flags = PV_VAL_STR;
      break;
    case BR_SOCKET_ID: /* return SOCKET */
      if ( branch->force_send_socket==NULL )
        return pv_get_null(NULL, NULL, res);
      res->rs = branch->force_send_socket->sock_str;
      res->flags = PV_VAL_STR;
      break;
    default:
      LM_CRIT("BUG - unsupported ID %d\n",field_id);
      return pv_get_null(NULL, NULL, res);
  }
  return 0;
}


static int pv_get_branch_fields(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res)
{
  int size;
  int idx;
  int idxf;
  char *p;

  if(msg==NULL || res==NULL)
    return -1;

  if ( (size=get_dset_size()) == 0)
    return pv_get_null(msg, param, res);

  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idxf!=PV_IDX_ALL && idx==0) {
    /* no index specified -> return the first branch */
    return get_branch_field( 0, param->pvn.u.isname.name.n, res);
  }

  if(idxf==PV_IDX_ALL) {
    /* return all branches */
    p = pv_local_buf;
    idx = 0;

    while ( idx<size ) {

      get_branch_field( idx, param->pvn.u.isname.name.n, res);

      if ( pv_local_buf + PV_LOCAL_BUF_SIZE <=
      p + res->rs.len + PV_FIELD_DELIM_LEN ) {
        LM_ERR("local buffer length exceeded\n");
        return pv_get_null(msg, param, res);
      }

      if (idx) {
        memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
        p += PV_FIELD_DELIM_LEN;
      }

      memcpy(p, res->rs.s, res->rs.len);
      p += res->rs.len;
      idx++;
    }

    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    res->flags = PV_VAL_STR;
    return 0;
  }

  /* numerical index */
  if (idx<0) {
    /* index from the end */
    if (-idx > size)
      return pv_get_null(msg, param, res);
    idx = size + idx;
  }

  /* return the request branch info */
  return get_branch_field( idx, param->pvn.u.isname.name.n, res);
}


/******* MSG Branch stuff *******/

static inline int get_msg_branch_field( struct sip_msg *msg, int idx,
                        int field_id, pv_value_t *res)
{
  if (idx==0) {
    /* this is the RURI branch */
    switch (field_id) {
      case 0:
      case BR_URI_ID: /* return URI */
        res->rs = *GET_RURI(msg);
        res->flags = PV_VAL_STR;
        break;
      case BR_Q_ID: /* return Q */
        res->rs.s = q2str(msg->ruri_q, (unsigned int*)&res->rs.len);
        res->flags = PV_VAL_STR;
        break;
      case BR_DURI_ID: /* return DURI */
        if ( ZSTR(msg->dst_uri) )
          return pv_get_null(NULL, NULL, res);
        res->rs = msg->dst_uri;
        res->flags = PV_VAL_STR;
        break;
      case BR_PATH_ID: /* return PATH */
        if ( ZSTR(msg->path_vec) )
          return pv_get_null(NULL, NULL, res);
        res->rs = msg->path_vec;
        res->flags = PV_VAL_STR;
        break;
      case BR_FLAGS_ID: /* return FLAGS */
        res->rs = bitmask_to_flag_list(FLAG_TYPE_BRANCH,
          msg->ruri_bflags);
        res->flags = PV_VAL_STR;
        break;
      case BR_SOCKET_ID: /* return SOCKET */
        if ( msg->force_send_socket==NULL )
          return pv_get_null(NULL, NULL, res);
        res->rs = msg->force_send_socket->sock_str;
        res->flags = PV_VAL_STR;
        break;
      default:
        LM_CRIT("BUG - unsupported ID %d\n",field_id);
        return pv_get_null(NULL, NULL, res);
    }
    return 0;
  } else {
    /* translate this to idx into the additional msg branches */
    return get_branch_field( idx-1, field_id, res);
  }
}

static int pv_get_msg_branch_fields(struct sip_msg *msg, pv_param_t *param,
    pv_value_t *res, int field)
{
  int size;
  int idx;
  int idxf;
  char *p;

  if(msg==NULL || res==NULL)
    return -1;

  size = get_dset_size() + 1;

  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idxf==0 && idx==0) {
    /* no index specified -> operate with the last branch */
    return get_msg_branch_field( msg, size-1 , field, res);
  }

  if(idxf==PV_IDX_ALL) {
    /* return all branches */
    p = pv_local_buf;
    idx = 0;

    while ( idx<size ) {

      get_msg_branch_field( msg, idx, field, res);

      if ( pv_local_buf + PV_LOCAL_BUF_SIZE <=
      p + res->rs.len + PV_FIELD_DELIM_LEN ) {
        LM_ERR("local buffer length exceeded\n");
        return pv_get_null(msg, param, res);
      }

      if (idx) {
        memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
        p += PV_FIELD_DELIM_LEN;
      }

      memcpy(p, res->rs.s, res->rs.len);
      p += res->rs.len;
      idx++;
    }

    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    res->flags = PV_VAL_STR;
    return 0;
  }

  /* numerical index */
  if (idx<0) {
    /* index from the end */
    if (-idx > size)
      return pv_get_null(msg, param, res);
    idx = size + idx;
  }

  /* return the request branch info */
  return get_msg_branch_field( msg, idx, field, res);
}

static int pv_get_msg_branch_uri(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_URI_ID);
}

static int pv_get_msg_branch_duri(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_DURI_ID);
}

static int pv_get_msg_branch_q(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_Q_ID);
}

static int pv_get_msg_branch_path(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_PATH_ID);
}

static int pv_get_msg_branch_flags(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_FLAGS_ID);
}

static int pv_get_msg_branch_sock(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  return pv_get_msg_branch_fields( msg, param, res, BR_SOCKET_ID);
}

static int pv_get_msg_branch_attr(struct sip_msg *msg,  pv_param_t *param,
                              pv_value_t *res)
{
  int idx, idxf;
  int size, n, attr_name;
  unsigned short attr_flags;
  int_str val;

  if(msg==NULL || res==NULL || param==NULL)
    return -1;

  if (pv_get_avp_name(msg, param, &attr_name, &attr_flags)!=0) {
    LM_ALERT("BUG in getting dst AVP name\n");
    return -1;
  }

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idxf==PV_IDX_ALL) {
    /* ALL - not supported */
    LM_ERR("ALL index not supported for attrs\n");
    return -1;
  }

  size = get_dset_size() + 1 /* ruri branch*/;
  /* if no branch set, consider the last one */
  if (idxf==0 && idx==0)
    idx = size - 1;

  /* numerical index */
  if (idx<0) {
    /* index from the end */
    if (-idx > size)
      return -1;
    idx = size + idx;
  }

  n = get_msg_branch_attr( idx, attr_name, &attr_flags, &val);
  if ( n<0 || attr_flags&AVP_VAL_NULL)
    return pv_get_null(msg, param, res);

  res->flags = PV_VAL_STR;

  if (attr_flags & AVP_VAL_STR) {
    res->rs = val.s;
  } else {
    res->rs.s = sint2str(val.n, &res->rs.len);
    res->ri = val.n;
    res->flags |= PV_VAL_INT|PV_TYPE_INT;
  }

  return 0;
}

static int pv_get_msg_branch_lastidx(struct sip_msg *msg,  pv_param_t *param,
                              pv_value_t *res)
{
  int idx;

  /* the last index is the size -1, counting all branches, as RURI as 
   * branch 0 followed by the added branches in dset */
  idx = get_dset_size();
  res->flags = PV_VAL_STR;
  res->rs.s = sint2str( idx, &res->rs.len);
  res->ri = idx;
  res->flags |= PV_VAL_INT|PV_TYPE_INT;
  return 0;
}


/******** LISTENING SOCKETS related vars & functions **********/

#define SOCK_IP_S             "ip"
#define SOCK_IP_LEN           (sizeof(SOCK_IP_S)-1)
#define SOCK_IP_ID            1
#define SOCK_PORT_S           "port"
#define SOCK_PORT_LEN         (sizeof(SOCK_PORT_S)-1)
#define SOCK_PORT_ID          2
#define SOCK_PROTO_S          "proto"
#define SOCK_PROTO_LEN        (sizeof(SOCK_PROTO_S)-1)
#define SOCK_PROTO_ID         3
#define SOCK_ADV_IP_S         "advertised_ip"
#define SOCK_ADV_IP_LEN       (sizeof(SOCK_ADV_IP_S)-1)
#define SOCK_ADV_IP_ID        4
#define SOCK_ADV_PORT_S       "advertised_port"
#define SOCK_ADV_PORT_LEN     (sizeof(SOCK_ADV_PORT_S)-1)
#define SOCK_ADV_PORT_ID      5
#define SOCK_TAG_S            "tag"
#define SOCK_TAG_LEN          (sizeof(SOCK_TAG_S)-1)
#define SOCK_TAG_ID           6
#define SOCK_ANYCAST_S        "anycast"
#define SOCK_ANYCAST_LEN      (sizeof(SOCK_ANYCAST_S)-1)
#define SOCK_ANYCAST_ID       7
#define SOCK_AF_S             "af"
#define SOCK_AF_LEN           (sizeof(SOCK_AF_S)-1)
#define SOCK_AF_ID            8
#define SOCK_FORCED_S         "forced"
#define SOCK_FORCED_LEN       (sizeof(SOCK_FORCED_S)-1)
#define SOCK_FORCED_ID        9

static int pv_parse_socket_name(pv_spec_p sp, const str *in)
{
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  if (in->len==SOCK_IP_LEN &&
  strncasecmp(in->s, SOCK_IP_S, SOCK_IP_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_IP_ID;
  } else
  if (in->len==SOCK_PORT_LEN &&
  strncasecmp(in->s, SOCK_PORT_S, SOCK_PORT_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_PORT_ID;
  } else
  if (in->len==SOCK_PROTO_LEN &&
  strncasecmp(in->s, SOCK_PROTO_S, SOCK_PROTO_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_PROTO_ID;
  } else
  if (in->len==SOCK_ADV_IP_LEN &&
  strncasecmp(in->s, SOCK_ADV_IP_S, SOCK_ADV_IP_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_ADV_IP_ID;
  } else
  if (in->len==SOCK_ADV_PORT_LEN &&
  strncasecmp(in->s, SOCK_ADV_PORT_S, SOCK_ADV_PORT_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_ADV_PORT_ID;
  } else
  if (in->len==SOCK_TAG_LEN &&
  strncasecmp(in->s, SOCK_TAG_S, SOCK_TAG_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_TAG_ID;
  } else
  if (in->len==SOCK_ANYCAST_LEN &&
  strncasecmp(in->s, SOCK_ANYCAST_S, SOCK_ANYCAST_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_ANYCAST_ID;
  } else
  if (in->len==SOCK_AF_LEN &&
  strncasecmp(in->s, SOCK_AF_S, SOCK_AF_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_AF_ID;
  } else {
    LM_ERR("unsupported SOCKET_IN/OUT field <%.*s>\n",in->len,in->s);
    return -1;
  }

  return 0;
}

#define PROXY_PROTOCOL_SRC_IP_S         "src_ip"
#define PROXY_PROTOCOL_SRC_IP_LEN       (sizeof(PROXY_PROTOCOL_SRC_IP_S)-1)
#define PROXY_PROTOCOL_SRC_IP_ID        0
#define PROXY_PROTOCOL_SRC_PORT_S       "src_port"
#define PROXY_PROTOCOL_SRC_PORT_LEN     (sizeof(PROXY_PROTOCOL_SRC_PORT_S)-1)
#define PROXY_PROTOCOL_SRC_PORT_ID      1
#define PROXY_PROTOCOL_DST_IP_S         "dst_ip"
#define PROXY_PROTOCOL_DST_IP_LEN       (sizeof(PROXY_PROTOCOL_DST_IP_S)-1)
#define PROXY_PROTOCOL_DST_IP_ID        2
#define PROXY_PROTOCOL_DST_PORT_S       "dst_port"
#define PROXY_PROTOCOL_DST_PORT_LEN     (sizeof(PROXY_PROTOCOL_DST_PORT_S)-1)
#define PROXY_PROTOCOL_DST_PORT_ID      3
#define PROXY_PROTOCOL_AF_S             "af"
#define PROXY_PROTOCOL_AF_LEN           (sizeof(PROXY_PROTOCOL_AF_S)-1)
#define PROXY_PROTOCOL_AF_ID            4

static int pv_parse_proxy_protocol(pv_spec_p sp, const str *in)
{
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  if (in->len==PROXY_PROTOCOL_SRC_IP_LEN &&
  strncasecmp(in->s, PROXY_PROTOCOL_SRC_IP_S, PROXY_PROTOCOL_SRC_IP_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = PROXY_PROTOCOL_SRC_IP_ID;
  } else
  if (in->len==PROXY_PROTOCOL_SRC_PORT_LEN &&
  strncasecmp(in->s, PROXY_PROTOCOL_SRC_PORT_S, PROXY_PROTOCOL_SRC_PORT_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = PROXY_PROTOCOL_SRC_PORT_ID;
  } else
  if (in->len==PROXY_PROTOCOL_DST_IP_LEN &&
  strncasecmp(in->s, PROXY_PROTOCOL_DST_IP_S, PROXY_PROTOCOL_DST_IP_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = PROXY_PROTOCOL_DST_IP_ID;
  } else
  if (in->len==PROXY_PROTOCOL_DST_PORT_LEN &&
  strncasecmp(in->s, PROXY_PROTOCOL_DST_PORT_S, PROXY_PROTOCOL_DST_PORT_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = PROXY_PROTOCOL_DST_PORT_ID;
  } else
  if (in->len==PROXY_PROTOCOL_AF_LEN &&
  strncasecmp(in->s, PROXY_PROTOCOL_AF_S, PROXY_PROTOCOL_AF_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = PROXY_PROTOCOL_AF_ID;
  } else {
    LM_ERR("unsupported $proxy_protocol field <%.*s>\n",in->len,in->s);
    return -1;
  }

  return 0;
}

static int pv_parse_socket_out_name(pv_spec_p sp, const str *in)
{
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  if (in->len==SOCK_FORCED_LEN &&
  strncasecmp(in->s, SOCK_FORCED_S, SOCK_FORCED_LEN)==0 ) {
    sp->pvp.pvn.u.isname.name.n = SOCK_FORCED_ID;
    return 0;
  } else {
    return pv_parse_socket_name(sp, in);
  }
}


static inline int get_socket_field( const struct socket_info *si,
                      pv_name_t *pvn, pv_value_t *res)
{
  if (si==NULL)
    return pv_get_null( NULL, NULL, res);

  /* return the field */
  switch (pvn->u.isname.name.n) {
    case 0: /* return full socket description */
    case SOCK_FORCED_ID: /* return forced socket description */
      res->rs = si->sock_str;
      res->flags = PV_VAL_STR;
      break;
    case SOCK_IP_ID: /* return IP address */
      res->rs = si->address_str;
      res->flags = PV_VAL_STR;
      break;
    case SOCK_PORT_ID: /* return PORT */
      res->rs = si->port_no_str;
      res->ri = si->port_no;
      res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
      break;
    case SOCK_PROTO_ID: /* return PROTOCOL */
      if ( si->proto>=PROTO_FIRST && si->proto<PROTO_LAST &&
      protos[si->proto].id ) {
        res->rs.s = protos[si->proto].name;
        res->rs.len = strlen(res->rs.s);
        res->flags = PV_VAL_STR;
      } else {
        return pv_get_null( NULL, NULL, res);
      }
      break;
    case SOCK_ADV_IP_ID: /* return advertised IP address */
      if (si->adv_name_str.s) {
        res->rs = si->adv_name_str;
        res->flags = PV_VAL_STR;
      } else {
        return pv_get_null( NULL, NULL, res);
      }
      break;
    case SOCK_ADV_PORT_ID: /* return advertised PORT */
      if (si->adv_port_str.s) {
        res->rs = si->adv_port_str;
        res->ri = si->adv_port;
        res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
      } else {
        return pv_get_null( NULL, NULL, res);
      }
      break;
    case SOCK_TAG_ID: /* return internal TAG */
      if (si->tag.s) {
        res->rs = si->tag;
        res->flags = PV_VAL_STR;
      } else {
        return pv_get_null( NULL, NULL, res);
      }
      break;
    case SOCK_ANYCAST_ID: /* return ANYCAST */
      if (si->flags&SI_IS_ANYCAST)
        res->ri = 1;
      else
        res->ri = 0;
      res->flags = PV_VAL_INT|PV_TYPE_INT;
      break;
    case SOCK_AF_ID:  /* returns Address Family */
      if (si->address.af == AF_INET) {
        res->rs.s = "INET";
        res->rs.len = 4;
      } else if (si->address.af == AF_INET6) {
        res->rs.s = "INET6";
        res->rs.len = 5;
      } else
        return pv_get_null( NULL, NULL, res);
      res->flags = PV_VAL_STR;
      break;
    default:
      LM_CRIT("BUG - unsupported ID %d\n",pvn->u.isname.name.n);
      return pv_get_null(NULL, NULL, res);
  }
  return 0;
}


static int pv_get_socket_in_fields(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{

  if(msg==NULL || res==NULL)
    return -1;

  return get_socket_field( msg->rcv.bind_address, &param->pvn, res);
}


static int pv_get_socket_out_fields(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  const struct socket_info *si;

  if(msg==NULL || res==NULL)
    return -1;

  if (param->pvn.u.isname.name.n == SOCK_FORCED_ID && !msg->force_send_socket)
    return pv_get_null(msg, NULL, res);

  si = (msg->force_send_socket) ?
    msg->force_send_socket : msg->rcv.bind_address;

  return get_socket_field( si, &param->pvn, res);
}

static int pv_get_proxy_protocol(struct sip_msg *msg, pv_param_t *param,
                              pv_value_t *res)
{
  if(msg==NULL || res==NULL)
    return -1;

  if (msg->rcv.real_ep.flags != PP_OK)
    return pv_get_null(msg, NULL, res);

  switch (param->pvn.u.isname.name.n) {
    case PROXY_PROTOCOL_SRC_IP_ID:
      res->rs.s = ip_addr2a(&msg->rcv.real_ep.src_ip);
      res->rs.len = strlen(res->rs.s);
      res->flags = PV_VAL_STR;
      break;
    case PROXY_PROTOCOL_SRC_PORT_ID:
      res->ri = msg->rcv.real_ep.src_port;
      res->rs.s = int2str((uint64_t)msg->rcv.real_ep.src_port, &res->rs.len);
      res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
      break;
    case PROXY_PROTOCOL_DST_IP_ID:
      res->rs.s = ip_addr2a(&msg->rcv.real_ep.dst_ip);
      res->rs.len = strlen(res->rs.s);
      res->flags = PV_VAL_STR;
      break;
    case PROXY_PROTOCOL_DST_PORT_ID:
      res->ri = msg->rcv.real_ep.dst_port;
      res->rs.s = int2str((uint64_t)msg->rcv.real_ep.dst_port, &res->rs.len);
      res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
      break;
    case PROXY_PROTOCOL_AF_ID:
      if (msg->rcv.real_ep.src_ip.af == AF_INET) {
        res->rs.s = "INET";
        res->rs.len = 4;
      } else if (msg->rcv.real_ep.src_ip.af == AF_INET6) {
        res->rs.s = "INET6";
        res->rs.len = 5;
      } else {
        return pv_get_null(msg, NULL, res);
      }
      res->flags = PV_VAL_STR;
      break;
    default:
      LM_CRIT("BUG - unsupported proxy_protocol ID %d\n",
          param->pvn.u.isname.name.n);
      return pv_get_null(NULL, NULL, res);
  }
  return 0;
}



/************************************************************/

/**
 *
 */
static int pv_get_avp(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  unsigned short name_type;
  int avp_name;
  int_str avp_value;
  struct usr_avp *avp;
  int_str avp_value0;
  struct usr_avp *avp0;
  int idx;
  int idxf;
  char *p;
  int n=0;

  if(msg==NULL || res==NULL || param==NULL)
    return -1;

  /* get the name */
  if(pv_get_avp_name(msg, param, &avp_name, &name_type)!=0)
  {
    LM_ERR("invalid name\n");
    return -1;
  }
  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0)
  {
    LM_ERR("invalid index\n");
    return -1;
  }
  if (idxf==PV_IDX_APPEND)
    return pv_get_null(msg, param, res);

  if ((avp=search_first_avp(name_type, avp_name, &avp_value, 0))==0)
    return pv_get_null(msg, param, res);
  res->flags = PV_VAL_STR;

  if (idxf!=PV_IDX_ALL && idx==0)
  {
    if(avp->flags & AVP_VAL_STR) {
      res->rs = avp_value.s;
    } else if(avp->flags & AVP_VAL_NULL) {
      res->flags |= PV_VAL_NULL;
    } else {
      res->rs.s = sint2str(avp_value.n, &res->rs.len);
      res->ri = avp_value.n;
      res->flags |= PV_VAL_INT|PV_TYPE_INT;
    }
    return 0;
  }

  /* print the entire AVP array */
  if(idxf==PV_IDX_ALL)
  {
    p = pv_local_buf;

    /* separately handle the first AVP */
    if(avp->flags & AVP_VAL_STR) {
      res->rs = avp_value.s;
    } else if(avp->flags & AVP_VAL_NULL) {
      memset(&res->rs, 0, sizeof res->rs);
    } else {
      res->rs.s = sint2str(avp_value.n, &res->rs.len);
    }

    if(p-pv_local_buf+res->rs.len+1>PV_LOCAL_BUF_SIZE)
    {
      LM_ERR("local buffer length exceeded!\n");
      return pv_get_null(msg, param, res);
    }
    memcpy(p, res->rs.s, res->rs.len);
    p += res->rs.len;

    /* print subsequent AVPs as [DELIM AVP]* */
    while ((avp = search_first_avp(name_type, avp_name, &avp_value, avp)))
    {
      if(avp->flags & AVP_VAL_STR) {
        res->rs = avp_value.s;
      } else if(avp->flags & AVP_VAL_NULL) {
        memset(&res->rs, 0, sizeof res->rs);
      } else {
        res->rs.s = sint2str(avp_value.n, &res->rs.len);
      }

      if(p-pv_local_buf+PV_FIELD_DELIM_LEN+1>PV_LOCAL_BUF_SIZE)
      {
        LM_ERR("local buffer length exceeded\n");
        return pv_get_null(msg, param, res);
      }
      memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
      p += PV_FIELD_DELIM_LEN;

      if(p-pv_local_buf+res->rs.len+1>PV_LOCAL_BUF_SIZE)
      {
        LM_ERR("local buffer length exceeded!\n");
        return pv_get_null(msg, param, res);
      }
      memcpy(p, res->rs.s, res->rs.len);
      p += res->rs.len;
    }

    *p = 0;
    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    return 0;
  }

  /* we have a numeric index */
  if(idx<0)
  {
    n = 1;
    avp0 = avp;
    while ((avp0=search_first_avp(name_type, avp_name,
            &avp_value0, avp0))!=0) n++;
    idx = -idx;
    if(idx>n)
    {
      LM_DBG("index out of range\n");
      return pv_get_null(msg, param, res);
    }
    idx = n - idx;
    if(idx==0)
    {
      if(avp->flags & AVP_VAL_STR) {
        res->rs = avp_value.s;
      } else if(avp->flags & AVP_VAL_NULL) {
        res->flags |= PV_VAL_NULL;
      } else {
        res->rs.s = sint2str(avp_value.n, &res->rs.len);
        res->ri = avp_value.n;
        res->flags |= PV_VAL_INT|PV_TYPE_INT;
      }
      return 0;
    }
  }
  n=0;
  while(n<idx
      && (avp=search_first_avp(name_type, avp_name, &avp_value, avp))!=0)
    n++;

  if(avp!=0)
  {
    if(avp->flags & AVP_VAL_STR) {
      res->rs = avp_value.s;
    } else if(avp->flags & AVP_VAL_NULL) {
      res->flags |= PV_VAL_NULL;
    } else {
      res->rs.s = sint2str(avp_value.n, &res->rs.len);
      res->ri = avp_value.n;
      res->flags |= PV_VAL_INT|PV_TYPE_INT;
    }
    return 0;
  }

  LM_DBG("index out of range\n");
  return pv_get_null(msg, param, res);
}


static int pv_resolve_hdr_name(const str *in, pv_value_t *tv)
{
  struct hdr_field hdr;
  str s;
  if(in->len>=PV_LOCAL_BUF_SIZE-1)
  {
    LM_ERR("name too long\n");
    return -1;
  }
  memcpy(pv_local_buf, in->s, in->len);
  pv_local_buf[in->len] = ':';
  s.s = pv_local_buf;
  s.len = in->len+1;

  if (parse_hname2(s.s, s.s + ((s.len<4)?4:s.len), &hdr)==0)
  {
    LM_ERR("error parsing header name [%.*s]\n", s.len, s.s);
    return -1;
  }
  if (hdr.type!=HDR_OTHER_T && hdr.type!=HDR_ERROR_T)
  {
    LM_DBG("using hdr type (%d) instead of <%.*s>\n",
      hdr.type, in->len, in->s);
    tv->flags = 0;
    tv->ri = hdr.type;
  } else {
    tv->flags = PV_VAL_STR;
    tv->rs = *in;
  }
  return 0;
}

static int pv_get_hdr_prolog(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res, pv_value_t* tv)
{
  if(msg==NULL || res==NULL || param==NULL)
    return -1;

  /* get the name */
  if(param->pvn.type == PV_NAME_PVAR)
  {
    if(pv_get_spec_name(msg, param, tv)!=0 || (!(tv->flags&PV_VAL_STR)))
    {
      LM_ERR("invalid name\n");
      return -1;
    }
    if (pv_resolve_hdr_name(&tv->rs, tv) < 0)
      return -1;
  } else {
    if(param->pvn.u.isname.type == AVP_NAME_STR)
    {
      tv->flags = PV_VAL_STR;
      tv->rs = param->pvn.u.isname.name.s;
    } else {
      tv->flags = 0;
      tv->ri = param->pvn.u.isname.name.n;
    }
  }
  /* we need to be sure we have parsed all headers */
  if(parse_headers(msg, HDR_EOH_F, 0)<0)
  {
    LM_ERR("error parsing headers\n");
    return pv_get_null(msg, param, res);
  }
  return 1;
}

static int pv_get_hdrcnt(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  pv_value_t tv;
  struct hdr_field *hf;
  unsigned int n;
  int ret;

  if ( (ret=pv_get_hdr_prolog(msg,  param, res, &tv)) <= 0 )
        return ret;

  n = 0;
  if (tv.flags==0) {
    /* it is a known header -> use type to find it */
    for (hf=msg->headers; hf; hf=hf->next) {
      if (tv.ri==hf->type)
              ++n;
    }
  } else {
    /* it is an un-known header -> use name to find it */
    for (hf=msg->headers; hf; hf=hf->next) {
      if (hf->type==HDR_OTHER_T && hf->name.len==tv.rs.len
      && strncasecmp(hf->name.s, tv.rs.s, hf->name.len)==0)
        ++n;
    }
  }
  return pv_get_uintval(msg, param, res, n);
}

static int pv_get_hdr(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  int idx;
  int idxf;
  pv_value_t tv;
  struct hdr_field *hf;
  struct hdr_field *hf0;
  char *p;
  int n;
  int ret;

  if ( (ret=pv_get_hdr_prolog(msg,  param, res, &tv)) <= 0 )
        return ret;

  if (tv.flags==0) {
    /* it is a known header -> use type to find it */
    for (hf=msg->headers; hf; hf=hf->next) {
      if (tv.ri==hf->type)
        break;
    }
  } else {
    /* it is an un-known header -> use name to find it */
    for (hf=msg->headers; hf; hf=hf->next) {
      if (hf->type==HDR_OTHER_T && hf->name.len==tv.rs.len
      && strncasecmp(hf->name.s, tv.rs.s, hf->name.len)==0)
        break;
    }
  }

  if(hf==NULL)
    return pv_get_null(msg, param, res);
  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0)
  {
    LM_ERR("invalid index\n");
    return -1;
  }

  /* get the value */
  res->flags = PV_VAL_STR;
  if(idxf!=PV_IDX_ALL && idx==0)
  {
    res->rs  = hf->body;
    return 0;
  }
  if(idxf==PV_IDX_ALL)
  {
    p = pv_local_buf;
    do {
      if(p!=pv_local_buf)
      {
        if(p-pv_local_buf+PV_FIELD_DELIM_LEN+1>PV_LOCAL_BUF_SIZE)
        {
          LM_ERR("local buffer length exceeded\n");
          return pv_get_null(msg, param, res);
        }
        memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
        p += PV_FIELD_DELIM_LEN;
      }

      if(p-pv_local_buf+hf->body.len+1>PV_LOCAL_BUF_SIZE)
      {
        LM_ERR("local buffer length exceeded!\n");
        return pv_get_null(msg, param, res);
      }
      memcpy(p, hf->body.s, hf->body.len);
      p += hf->body.len;
      /* next hf */
      if (tv.flags==0) {
        /* it is a known header -> use type to find it */
        for (hf=hf->next ; hf; hf=hf->next) {
          if (tv.ri==hf->type)
            break;
        }
      } else {
        /* it is an un-known header -> use name to find it */
        for (hf=hf->next ; hf; hf=hf->next) {
          if (hf->type==HDR_OTHER_T && hf->name.len==tv.rs.len
          && strncasecmp(hf->name.s, tv.rs.s, hf->name.len)==0)
            break;
        }
      }
    } while (hf);
    *p = 0;
    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    return 0;
  }

  /* we have a numeric index */
  hf0 = 0;
  if(idx<0)
  {
    n = 1;
    /* count headers */
    if (tv.flags==0 ) {
      /* it is a known header -> use type to find it */
      for (hf0=hf->next; hf0; hf0=hf0->next) {
        if (tv.ri==hf0->type)
          n++;
      }
    } else {
      /* it is an un-known header -> use name to find it */
      for (hf0=hf->next; hf0; hf0=hf0->next) {
        if (hf0->type==HDR_OTHER_T && hf0->name.len==tv.rs.len
        && strncasecmp(hf0->name.s, tv.rs.s, hf0->name.len)==0)
          n++;
      }
    }

    idx = -idx;
    if(idx>n)
    {
      LM_DBG("index out of range\n");
      return pv_get_null(msg, param, res);
    }
    idx = n - idx;
    if(idx==0)
    {
      res->rs  = hf->body;
      return 0;
    }
  }
  n=0;
  while(n<idx)
  {
    if (tv.flags==0) {
      /* it is a known header -> use type to find it */
      for (hf0=hf->next; hf0; hf0=hf0->next) {
        if (tv.ri==hf0->type) {
          n++;
          if(n==idx) break;
        }
      }
    } else {
      /* it is an un-known header -> use name to find it */
      for (hf0=hf->next; hf0; hf0=hf0->next) {
        if (hf0->type==HDR_OTHER_T && hf0->name.len==tv.rs.len
        && strncasecmp(hf0->name.s, tv.rs.s, hf0->name.len)==0) {
          n++;
          if(n==idx) break;
        }
      }
    }
    if(hf0==NULL)
      break;
  }

  if(hf0!=0)
  {
    res->rs  = hf0->body;
    return 0;
  }

  LM_DBG("index out of range\n");
  return pv_get_null(msg, param, res);

}

static int pv_get_hdr_name(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  int idx, idx_f;
  struct hdr_field *hf;
  char *p;
  int n;

  if(msg==NULL || res==NULL || param==NULL)
    return -1;

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idx_f) != 0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  /* make sure we have parsed all the headers */
  if (parse_headers(msg, HDR_EOH_F, 0) <0 ) {
    LM_ERR("error parsing headers\n");
    return pv_get_null(msg, param, res);
  }

  res->flags = PV_VAL_STR;

  if (idx_f == PV_IDX_ALL) {
    /* return all header names, separated by ',' */

    p = pv_local_buf;
    hf = msg->headers;
    do {
      if (p != pv_local_buf) {
        if (p - pv_local_buf + PV_FIELD_DELIM_LEN + 1 > PV_LOCAL_BUF_SIZE) {
          LM_ERR("local buffer length exceeded\n");
          return pv_get_null(msg, param, res);
        }
        memcpy(p, PV_FIELD_DELIM, PV_FIELD_DELIM_LEN);
        p += PV_FIELD_DELIM_LEN;
      }

      if (p - pv_local_buf + hf->name.len + 1 > PV_LOCAL_BUF_SIZE) {
        LM_ERR("local buffer length exceeded!\n");
        return pv_get_null(msg, param, res);
      }
      memcpy(p, hf->name.s, hf->name.len);
      p += hf->name.len;

      hf = hf->next;
    } while (hf);

    *p = 0;
    res->rs.s = pv_local_buf;
    res->rs.len = p - pv_local_buf;
    return 0;
  }

  if (idx < 0) {
    /* negative index, translate it to a positive one */

    n = 0;
    for (hf = msg->headers; hf; hf = hf->next, n++) ;
    idx = -idx;
    if(idx > n) {
      LM_DBG("index [%d] out of range\n", -idx);
      return pv_get_null(msg, param, res);
    }
    idx = n - idx;
  }

  for (hf = msg->headers, n = 0; hf && n != idx; hf = hf->next, n++) ;

  if (!hf) {
    LM_DBG("index [%d] out of range\n", idx);
    return pv_get_null(msg, param, res);
  }

  res->rs = hf->name;
  return 0;
}

static int pv_get_scriptvar(struct sip_msg *msg,  pv_param_t *param,
    pv_value_t *res)
{
  int ival = 0;
  char *sval = NULL;
  script_var_t *sv=NULL;

  if(msg==NULL || res==NULL)
    return -1;

  if(param==NULL || param->pvn.u.dname==0)
    return pv_get_null(msg, param, res);

  sv= (script_var_t*)param->pvn.u.dname;

  if (sv->v.flags&VAR_VAL_NULL)
    return pv_get_null(msg, param, res);

  if(sv->v.flags&VAR_VAL_STR)
  {
    res->rs = sv->v.value.s;
    res->flags = PV_VAL_STR;
  } else {
    sval = sint2str(sv->v.value.n, &ival);

    res->rs.s = sval;
    res->rs.len = ival;

    res->ri = sv->v.value.n;
    res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;
  }
  return 0;
}

/********* end PV get functions *********/

/********* start PV set functions *********/
static int pv_set_avp(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  int avp_name;
  int_str avp_val;
  int flags;
  unsigned short name_type;
  int idx, idxf;

  if(param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(pv_get_avp_name(msg, param, &avp_name, &name_type)!=0)
  {
    LM_ALERT("BUG in getting dst AVP name\n");
    goto error;
  }

  /* get the index */
  if(pv_get_spec_index(msg, param, &idx, &idxf)!=0)
  {
    LM_ERR("invalid index\n");
    return -1;
  }

  if(val == NULL)
  {
    if(op == COLONEQ_T || idxf == PV_IDX_ALL)
      destroy_avps(name_type, avp_name, 1);
    else
    {
      destroy_index_avp(name_type, avp_name, idx);
    }
    return 0;
  }

  if(op == COLONEQ_T || idxf == PV_IDX_ALL)
    destroy_avps(name_type, avp_name, 1);

  flags = name_type;
  if(val->flags&PV_TYPE_INT)
  {
    avp_val.n = val->ri;
  } else {
    avp_val.s = val->rs;
    flags |= AVP_VAL_STR;
  }

  if(idxf == PV_IDX_INT || idxf == PV_IDX_PVAR) /* if the avp is indexed */
  {
    if(replace_avp(flags, avp_name, avp_val, idx)< 0)
    {
      LM_ERR("Failed to replace avp\n");
      goto error;
    }
  }
  else if (idxf == PV_IDX_APPEND) /* add AVP at the end */
  {
    if (add_avp_last(flags, avp_name, avp_val)<0)
    {
      LM_ERR("error - cannot add AVP\n");
      goto error;
    }
  }
  else {
    if (add_avp(flags, avp_name, avp_val)<0)
    {
      LM_ERR("error - cannot add AVP\n");
      goto error;
    }
  }

  return 0;
error:
  return -1;
}

static int pv_set_scriptvar(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  int_str avp_val;
  int flags;

  if(param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(param->pvn.u.dname==0)
  {
    LM_ERR("error - cannot find svar\n");
    goto error;
  }
  if(val == NULL)
  {
    set_var_value((script_var_t*)param->pvn.u.dname, NULL, VAR_VAL_NULL);
    return 0;
  }
  if(val->flags&PV_TYPE_INT)
  {
    avp_val.n = val->ri;
    flags = 0;
  } else {
    avp_val.s = val->rs;
    flags = VAR_VAL_STR;
  }
  if(set_var_value((script_var_t*)param->pvn.u.dname, &avp_val, flags)==NULL)
  {
    LM_ERR("error - cannot set svar [%.*s] \n",
        ((script_var_t*)param->pvn.u.dname)->name.len,
        ((script_var_t*)param->pvn.u.dname)->name.s);
    goto error;
  }
  return 0;
error:
  return -1;
}

static int pv_set_dsturi(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  if(msg==NULL || param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val == NULL)
  {
    reset_dst_uri(msg);

    return 1;
  }
  if(!(val->flags&PV_VAL_STR))
  {
    LM_ERR("error - str value required to set dst uri\n");
    goto error;
  }

  if(set_dst_uri(msg, &val->rs)!=0)
    goto error;

  return 0;
error:
  return -1;
}

static int pv_set_ruri(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  if(msg==NULL || param==NULL || val==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(!(val->flags&PV_VAL_STR))
  {
    LM_ERR("str value required to set R-URI\n");
    goto error;
  }

  if (set_ruri( msg, &val->rs)!=0) {
    LM_ERR("failed to set RURI\n");
    goto error;
  }

  return 0;
error:
  return -1;
}

static int pv_set_ru_q(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  if(msg==NULL || param==NULL || val==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(!(val->flags&PV_VAL_INT))
  {
    LM_ERR("int value required to set r-uri queue value\n");
    return -1;
  }

  if (val->ri > 1000) {
    LM_WARN("queue value too big %d - setting queue to "
        "maximum value (1000)\n", val->ri);
    set_ruri_q(msg, 1000);
  } else
    set_ruri_q(msg, val->ri);

  return 0;
}

static int pv_set_ruri_user(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  str sval;

  if(msg==NULL || param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val == NULL)
    sval = str_empty;
  else if(!(val->flags&PV_VAL_STR)) {
    LM_ERR("str value required to set R-URI user\n");
    return -1;
  } else
    sval = val->rs;

  if (rewrite_ruri(msg, &sval, 0, RW_RURI_USER) < 0) {
    LM_ERR("Failed to set R-URI user\n");
    return -1;
  }

  return 0;
}

static int pv_set_ruri_host(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  if(msg==NULL || param==NULL || val==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(!(val->flags&PV_VAL_STR))
  {
    LM_ERR("str value required to set R-URI hostname\n");
    return -1;
  }

  if (rewrite_ruri(msg, &val->rs, 0, RW_RURI_HOST) < 0) {
    LM_ERR("Failed to set R-URI hostname\n");
    return -1;
  }

  return 0;
}

static int pv_set_dsturi_host(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  if(msg==NULL || param==NULL || val==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(!(val->flags&PV_VAL_STR))
  {
    LM_ERR("str value required to set DST-URI hostname\n");
    return -1;
  }

  if (set_dst_host_port(msg, &val->rs, NULL) < 0) {
    LM_ERR("Failed to set DST-URI host\n");
    return -1;
  }

  return 0;
}

static int pv_set_dsturi_port(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  str sval;

  if(msg==NULL || param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val == NULL)
    sval = str_empty;
  else if(!(val->flags&PV_VAL_STR))
    sval.s = int2str(val->ri, &sval.len);
  else
    sval = val->rs;

  if (set_dst_host_port(msg, NULL, &sval) < 0) {
    LM_ERR("Failed to set DST-URI port\n");
    return -1;
  }

  return 0;
}




static int pv_set_ruri_port(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  str sval;

  if(msg==NULL || param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val == NULL)
    sval = str_empty;
  else if(!(val->flags&PV_VAL_STR))
    sval.s = int2str(val->ri, &sval.len);
  else
    sval = val->rs;

  if (rewrite_ruri(msg, &sval, 0, RW_RURI_PORT) < 0) {
    LM_ERR("Failed to set R-URI hostname\n");
    return -1;
  }

  return 0;
}


static int pv_set_msg_branch(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  struct msg_branch branch;

  if (msg==NULL || param==NULL) {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if (!val || !(val->flags&PV_VAL_STR) || val->flags&(PV_VAL_NULL) ||
  val->rs.len==0 ) {
    LM_ERR("str value required to create a new branch\n");
    return -1;
  }

  memset( &branch, 0, sizeof branch);
  branch.uri = val->rs;
  branch.q = Q_UNSPECIFIED;
  if (append_msg_branch( &branch )!=1){
    LM_ERR("failed to append new branch\n");
    return -1;
  }

  return 0;
}


static int _int_pv_set_branch_fields(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val, int field, int has_ruri_branch)
{
  int size, is_ruri_branch = 0;
  int idx;
  int idxf;
  str *s;
  qvalue_t q;
  unsigned int flags;
  const struct socket_info *si;

  if (msg==NULL || param==NULL) {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if (msg->first_line.type == SIP_REPLY)
    return -1;

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if (idxf==PV_IDX_ALL) {
    LM_ERR("SCRIPT BUG - * not allowed in branch assignment\n");
    return -1;
  }

  if (has_ruri_branch) {
    size = get_dset_size() + 1 ;
    /* no branch set, consider the last one */
    if (idxf==0 && idx==0)
      idx = size - 1;
    else
    /* if negative, count from the end */
    if (idx<0)
      idx = size + idx;
    /* now evaluate and ajust the idx to dset only */
    if (idx==0) {
      is_ruri_branch = 1;
    } else {
      /* offset with -1 */
      idx--;
    }
  } else {
    size = get_dset_size();
    /* if negative, count from the end */
    if (idx<0)
      idx = size + idx;
  }

  if (!is_ruri_branch) {
    /* if not RURI branch, it is a msg branch, so check the idx*/
    if (idx<0 || idx>=get_dset_size()) {
      LM_ERR("inexisting branch assignment [%d/%d]\n", size, idx);
      return -1;
    }
  }

  switch (field) {
    case BR_URI_ID: /* set URI */
      if (!val || !(val->flags&PV_VAL_STR) || val->flags&(PV_VAL_NULL) ||
      val->rs.len==0 ) {
        LM_ERR("str value required to set the branch URI\n");
        return -1;
      }
      s = &val->rs;
      return is_ruri_branch ?
        set_ruri( msg, s) :
        update_msg_branch_uri( idx, s);
    case BR_Q_ID: /* set Q */
      if ( val && !(val->flags&PV_VAL_INT) ) {
        LM_ERR("INT value required to set the branch Q\n");
        return -1;
      }
      q = (!val||val->flags&PV_VAL_NULL)? Q_UNSPECIFIED : val->ri;
      if (is_ruri_branch )
        set_ruri_q( msg, q);
      else
        update_msg_branch_q( idx, q);
      return 0;
    case BR_DURI_ID: /* set DURI */
      if ( val && !(val->flags&PV_VAL_STR) ) {
        LM_ERR("STR value required to set the branch DURI\n");
        return -1;
      }
      s = (!val||val->flags&PV_VAL_NULL)? NULL : &val->rs;
      return is_ruri_branch ?
        set_dst_uri( msg, s) :
        update_msg_branch_dst_uri( idx, s);
    case BR_PATH_ID: /* set PATH */
      if ( val && !(val->flags&PV_VAL_STR) ) {
        LM_ERR("STR value required to set the branch PATH\n");
        return -1;
      }
      s = (!val||val->flags&PV_VAL_NULL)? NULL : &val->rs;
      return is_ruri_branch ?
        set_path_vector( msg, s) :
        update_msg_branch_path( idx, s);
    case BR_FLAGS_ID: /* set FLAGS */
      if ( val && !(val->flags&PV_VAL_STR) ) {
        LM_ERR("string value required to set the branch FLAGS\n");
        return -1;
      }
      flags = (!val||val->flags&PV_VAL_NULL)?
        0 : flag_list_to_bitmask(str2const(&val->rs), FLAG_TYPE_BRANCH, FLAG_DELIM, 0);
      if ( is_ruri_branch )
        msg->ruri_bflags = flags;
      else
        update_msg_branch_bflags( idx, flags);
      return 0;
    case BR_SOCKET_ID: /* set SOCKET */
      if ( val && !(val->flags&PV_VAL_STR) ) {
        LM_ERR("STR value required to set the branch SOCKET\n");
        return -1;
      }
      if (!val || val->flags&PV_VAL_NULL) {
        si = NULL;
      } else {
        si = parse_sock_info(&val->rs);
        if (si==NULL)
          return -1;
      }
      if ( is_ruri_branch )
        msg->force_send_socket = si;
      else
        update_msg_branch_socket( idx, si);
      return 0;
    default:
      LM_CRIT("BUG - unsupported ID %d\n", field);
      return -1;
  }
}

static int pv_set_branch_fields(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  /* named branch fields,
   * so the type is in the name, no RURI branch support*/
  return _int_pv_set_branch_fields( msg, param, op, val,
    param->pvn.u.isname.name.n, 0);
}

static int pv_set_msg_branch_uri(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_URI_ID, 1);
}

static int pv_set_msg_branch_duri(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_DURI_ID, 1);
}

static int pv_set_msg_branch_q(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_Q_ID, 1);
}

static int pv_set_msg_branch_path(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_PATH_ID, 1);
}

static int pv_set_msg_branch_flags(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_FLAGS_ID, 1);
}

static int pv_set_msg_branch_sock(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  return _int_pv_set_branch_fields( msg, param, op, val, BR_SOCKET_ID, 1);
}

static int pv_set_msg_branch_attr(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  int idx, idxf;
  int size, n, attr_name;
  unsigned short attr_flags;
  int_str attr_val;

  if (msg==NULL || param==NULL) {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if (msg->first_line.type == SIP_REPLY)
    return -1;

  if(pv_get_avp_name(msg, param, &attr_name, &attr_flags)!=0) {
    LM_ALERT("BUG in getting dst AVP name\n");
    return -1;
  }

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if(idxf==PV_IDX_ALL) {
    LM_ERR("SCRIPT BUG - * not allowed in branch assignment\n");
    return -1;
  }

  size = get_dset_size() + 1 /* ruri branch*/;
  /* if no branch set, consider the last one */
  if (idxf==0 && idx==0)
    idx = size - 1;

  /* numerical index */
  if (idx<0) {
    /* index from the end */
    if (-idx > size)
      return -1;
    idx = size + idx;
  }

  if (!val || val->flags&PV_VAL_NULL) {
    attr_val.n = 0; //useless, makes compiler happy
    attr_flags |= AVP_VAL_NULL;
  } else
  if(val->flags&PV_TYPE_INT) {
    attr_val.n = val->ri;
  } else {
    attr_val.s = val->rs;
    attr_flags |= AVP_VAL_STR;
  }

  n = set_msg_branch_attr(idx, attr_name, attr_flags, attr_val);

  return (n>=0) ? 0 : -1 ;
}


static int pv_set_force_sock(struct sip_msg* msg, pv_param_t *param,
    int op, pv_value_t *val)
{
  const struct socket_info *si;

  if(msg==NULL || param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val==NULL)
  {
    msg->force_send_socket = NULL;
    return 0;
  }

  if(!(val->flags&PV_VAL_STR) || val->rs.len<=0)
  {
    LM_ERR("str value required to set the force send sock\n");
    goto error;
  }

  si = parse_sock_info(&val->rs);
  if (si!=NULL)
  {
    msg->force_send_socket = si;
  } else {
    LM_WARN("no socket found to match [%.*s]\n",
        val->rs.len, val->rs.s);
  }

  return 0;
error:
  return -1;
}


/********* end PV set functions *********/

static int pv_parse_scriptvar_name(pv_spec_p sp, const str *in)
{
  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;

  sp->pvp.pvn.type = PV_NAME_PVAR;
  sp->pvp.pvn.u.dname = (void*)add_var(in);
  if(sp->pvp.pvn.u.dname==NULL)
  {
    LM_ERR("cannot register var [%.*s]\n", in->len, in->s);
    return -1;
  }
  return 0;
}

static int pv_parse_hdr_name(pv_spec_p sp, const str *in)
{
  char *p;
  pv_spec_p nsp = 0;
  pv_value_t tv;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;

  p = in->s;
  if(*p==PV_MARKER)
  {
    nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
    if(nsp==NULL)
    {
      LM_ERR("no more memory\n");
      return -1;
    }
    p = pv_parse_spec(in, nsp);
    if(p==NULL)
    {
      LM_ERR("invalid name [%.*s]\n", in->len, in->s);
      pv_spec_free(nsp);
      return -1;
    }
    //LM_ERR("dynamic name [%.*s]\n", in->len, in->s);
    //pv_print_spec(nsp);
    sp->pvp.pvn.type = PV_NAME_PVAR;
    sp->pvp.pvn.u.dname = (void*)nsp;
    return 0;
  }

  if (pv_resolve_hdr_name(in, &tv) < 0)
    return -1;

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  if (!tv.flags)
  {
    LM_DBG("using hdr type (%d) instead of <%.*s>\n",
      tv.ri, in->len, in->s);
    sp->pvp.pvn.u.isname.type = 0;
    sp->pvp.pvn.u.isname.name.n = tv.ri;
  } else {
    sp->pvp.pvn.u.isname.type = AVP_NAME_STR;
    sp->pvp.pvn.u.isname.name.s = *in;
  }
  return 0;
}

int pv_parse_avp_name(pv_spec_p sp, const str *in)
{
  char *p;
  char *s;
  pv_spec_p nsp = 0;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;
  p = in->s;
  if(*p==PV_MARKER)
  {
    nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
    if(nsp==NULL)
    {
      LM_ERR("no more memory\n");
      return -1;
    }
    s = pv_parse_spec(in, nsp);
    if(s==NULL)
    {
      LM_ERR("invalid name [%.*s]\n", in->len, in->s);
      pv_spec_free(nsp);
      return -1;
    }
    //LM_ERR("dynamic name [%.*s]\n", in->len, in->s);
    //pv_print_spec(nsp);
    sp->pvp.pvn.type = PV_NAME_PVAR;
    sp->pvp.pvn.u.dname = (void*)nsp;
    return 0;
  }
  /*LM_DBG("static name [%.*s]\n", in->len, in->s);*/
  /* always an int type from now */
  sp->pvp.pvn.u.isname.type = 0;
  if(parse_avp_spec(in, &sp->pvp.pvn.u.isname.name.n)!=0)
  {
    LM_ERR("bad avp name [%.*s]\n", in->len, in->s);
    return -1;
  }
  sp->pvp.pvn.type = PV_NAME_INTSTR;
  return 0;
}

static int pv_parse_avp_index(pv_spec_p sp, const str *in)
{
  #define AVP_APPEND_IDX "append"

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;

  if ( (in->len==(sizeof(AVP_APPEND_IDX)-1)) &&
  strncasecmp(in->s,AVP_APPEND_IDX,in->len)==0) {
    sp->pvp.pvi.type = PV_IDX_APPEND;
    return 0;
  }
  return pv_parse_index(sp,in);
}

int pv_parse_index(pv_spec_p sp, const str *in)
{
  char *p;
  char *s;
  int sign;
  pv_spec_p nsp = 0;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;
  p = in->s;
  if(*p==PV_MARKER)
  {
    nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
    if(nsp==NULL)
    {
      LM_ERR("no more memory\n");
      return -1;
    }
    memset(nsp, 0, sizeof(pv_spec_t));
    s = pv_parse_spec(in, nsp);
    if(s==NULL)
    {
      LM_ERR("invalid index [%.*s]\n", in->len, in->s);
      pv_spec_free(nsp);
      return -1;
    }
    sp->pvp.pvi.type = PV_IDX_PVAR;
    sp->pvp.pvi.u.dval = (void*)nsp;
    return 0;
  }
  if(*p=='*' && in->len==1)
  {
    sp->pvp.pvi.type = PV_IDX_ALL;
    return 0;
  }
  sign = 1;
  if(*p=='-')
  {
    sign = -1;
    p++;
  }
  sp->pvp.pvi.u.ival = 0;
  while(p<in->s+in->len && *p>='0' && *p<='9')
  {
    sp->pvp.pvi.u.ival = sp->pvp.pvi.u.ival * 10 + *p - '0';
    p++;
  }
  if(p!=in->s+in->len)
  {
    LM_ERR("invalid index [%.*s]\n", in->len, in->s);
    return -1;
  }
  sp->pvp.pvi.u.ival *= sign;
  sp->pvp.pvi.type = PV_IDX_INT;

  return 0;
}

int pv_init_iname(pv_spec_p sp, int param)
{
  if(sp==NULL)
    return -1;
  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.name.n = param;
  return 0;
}

static int pv_get_line_number(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res){
  int l;
  char *ch;

  if (param==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if(res == NULL) {
    return -1;
  }

  res->ri = curr_action_line;
  ch = int2str( (unsigned long)res->ri, &l);

  res->rs.s = ch;
  res->rs.len = l;

  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;

  return 0;
}

static int pv_get_cfg_file_name(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res){

  if (param==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if(res == NULL) {
    return -1;
  }

  res->rs.s = curr_action_file;
  res->rs.len = (res->rs.s)?(strlen(res->rs.s)):(0);

  res->flags = PV_VAL_STR;

  return 0;
}


static int pv_set_log_level(struct sip_msg* msg, pv_param_t *param, int op,
                              pv_value_t *val)
{
  if(param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val==NULL || (val->flags&(PV_VAL_NULL|PV_VAL_NONE))!=0) {
    /* reset the value to default */
    reset_proc_log_level();
  } else {
    if ((val->flags&PV_TYPE_INT)==0) {
      LM_ERR("input for $log_level found not to be an integer\n");
      return -1;
    }
    set_proc_log_level(val->ri);
  }

  return 0;
}

static int pv_get_log_level(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  int l;

  if (param==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if(res == NULL) {
    return -1;
  }

  res->ri = *log_level;
  res->rs.s = sint2str( (long)res->ri, &l);
  res->rs.len = l;

  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;

  return 0;
}

static int pv_set_xlog_level(struct sip_msg* msg, pv_param_t *param, int op,
                              pv_value_t *val)
{
  if(param==NULL)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(val==NULL || (val->flags&(PV_VAL_NULL|PV_VAL_NONE))!=0) {
    /* reset the value to default */
    reset_xlog_level();
  } else {
    if ((val->flags&PV_TYPE_INT)==0) {
      LM_ERR("input for $xlog_level found not to be an integer\n");
      return -1;
    }
    set_local_xlog_level( val->ri );
  }

  return 0;
}

static int pv_get_xlog_level(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  int l;

  if (param==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if(res == NULL) {
    return -1;
  }

  res->ri = *xlog_level;
  res->rs.s = sint2str( (long)res->ri, &l);
  res->rs.len = l;

  res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT;

  return 0;
}

static int pv_get_return_value(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  int index;
  pv_value_t tv;

  if (param==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if(res == NULL)
    return -1;

  if (param->pvn.type == PV_NAME_INTSTR) {
    if (param->pvn.u.isname.type != 0) {
      LM_ERR("route $return variable accepts only integer indexes\n");
      return -1;
    }
    index = param->pvn.u.isname.name.n;
  } else {
    /* pvar -> it might be another $param variable! */
    if(pv_get_spec_value(msg, (pv_spec_p)(param->pvn.u.dname), &tv)!=0) {
      LM_ERR("cannot get spec value\n");
      return -1;
    }

    if(tv.flags&PV_VAL_NULL || tv.flags&PV_VAL_EMPTY) {
      LM_ERR("null or empty name\n");
      return -1;
    }
    if (!(tv.flags&PV_VAL_INT) || str2int(&tv.rs,(unsigned int*)&index) < 0) {
      LM_ERR("invalid index <%.*s>\n", tv.rs.len, tv.rs.s);
      return -1;
    }
  }

  if (script_return_get(res, index) < 0) {
    LM_ERR("could not get return %d\n", index);
    return -1;
  }

  /* "normalize" integer */
  if ((res->flags & PV_VAL_INT) && !(res->flags & PV_VAL_STR)) {
    res->rs.s = int2str(res->ri, &res->rs.len);
    res->flags |= PV_VAL_STR;
  }

  return 0;
}

/************** Boolean consts *****************/

const pv_value_t pv_true = {
  .ri = 1,
  .rs = str_init("true"),
  .flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT,
};


const pv_value_t pv_false = {
  .ri = 0,
  .rs = str_init("false"),
  .flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT,
};


/************** MSG FLAGS function *****************/

static int msg_flag_parse_name(pv_spec_p sp, const str *in)
{
  unsigned int idx;
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  if ( (idx=fixup_flag(FLAG_TYPE_MSG, in))==NAMED_FLAG_ERROR) {
    LM_ERR("failed to fix the flag <%.*s>\n",in->len,in->s);
    return -1;
  }

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  sp->pvp.pvn.u.isname.name.n = idx;

  return 0;
}


static int msg_flag_set(struct sip_msg* msg, pv_param_t *param, int op,
                              pv_value_t *val)
{
  if(param==NULL) {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if (val==NULL || (val->flags&(PV_VAL_NULL|PV_VAL_NONE))!=0 ||
  (val->flags&PV_TYPE_INT)==0 ) {
    LM_ERR("input for $msg.flag() found not to be an integer\n");
    return -1;
  }

  if (val->ri==0)
    resetflag (msg, (unsigned int)param->pvn.u.isname.name.n);
  else
    setflag( msg, (unsigned int)param->pvn.u.isname.name.n);

  return 0;
}


static int msg_flag_get(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  if (param==NULL||res==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if ( isflagset( msg, (unsigned int)param->pvn.u.isname.name.n)==1 ) {
    *res = pv_true;
  } else {
    *res = pv_false;
  }
  return 0;
}


/************** MSG TYPE function *****************/

static int msg_is_request_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
{
  if (param==NULL||res==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if ( msg->first_line.type==SIP_REQUEST ) {
    *res = pv_true;
  } else {
    *res = pv_false;
  }
  return 0;
}


static int msg_type_get(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
{
  if (param==NULL||res==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  if ( msg->first_line.type==SIP_REQUEST ) {
    res->rs.s = "request";
    res->rs.len = 7;
  } else {
    res->rs.s = "reply";
    res->rs.len = 5;
  }

  res->flags = PV_VAL_STR;

  return 0;
}



/************** BRANCH FLAGS function *****************/

static int msg_branch_flag_parse_name(pv_spec_p sp, const str *in)
{
  unsigned int idx;
  if (sp==NULL || in==NULL || in->s==NULL || in->len==0)
    return -1;

  if ( (idx=fixup_flag(FLAG_TYPE_BRANCH, in))==NAMED_FLAG_ERROR) {
    LM_ERR("failed to fix the flag <%.*s>\n",in->len,in->s);
    return -1;
  }

  sp->pvp.pvn.type = PV_NAME_INTSTR;
  sp->pvp.pvn.u.isname.type = 0;

  sp->pvp.pvn.u.isname.name.n = idx;

  return 0;
}


static int msg_branch_flag_set(struct sip_msg* msg, pv_param_t *param, int op,
                              pv_value_t *val)
{
  int size;
  int idx;
  int idxf;

  if(param==NULL) {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if (val==NULL || (val->flags&(PV_VAL_NULL|PV_VAL_NONE))!=0 ||
  (val->flags&PV_TYPE_INT)==0 ) {
    LM_ERR("input for $branch.flag() found not to be an integer\n");
    return -1;
  }

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if(idxf==PV_IDX_ALL) {
    LM_ERR("SCRIPT BUG - * not allowed in branch flag assignment\n");
    return -1;
  }

  size = get_dset_size() + 1;

  /* if no idx, work with the last branch */
  if (idxf==0 && idx==0)
    idx = size - 1;

  if (idx<0) {
    idx = size + idx;
  }

  if (idx<0 || idx>=size) {
    LM_DBG("inexisting branch flag assignment [%d/%d]\n", size, idx);
    return -1;
  }

  if (val->ri==0)
    resetbflag (msg, idx, param->pvn.u.isname.name.n);
  else
    setbflag( msg, idx, param->pvn.u.isname.name.n);

  return 0;
}


static int msg_branch_flag_get(struct sip_msg *msg,  pv_param_t *param,
                              pv_value_t *res)
{
  int size;
  int idx;
  int idxf;

  if (param==NULL||res==NULL) {
    LM_CRIT("BUG - bad parameters\n");
    return -1;
  }

  /* get the index */
  if (pv_get_spec_index(msg, param, &idx, &idxf)!=0) {
    LM_ERR("invalid index\n");
    return -1;
  }

  if(idxf==PV_IDX_ALL) {
    LM_ERR("SCRIPT BUG - * not allowed in branch flag reading\n");
    return -1;
  }

  size = get_dset_size();

  if (idx<0) {
    idx = size + idx;
  }

  if (idx<0 || idx>=size) {
    LM_DBG("inexisting branch flag reading [%d/%d]\n", size, idx);
    return -1;
  }

  if ( isbflagset( msg, idx, param->pvn.u.isname.name.n)==1 ) {
    *res = pv_true;
  } else {
    *res = pv_false;
  }
  return 0;
}


/********** generic helper functions ***************/

/**
 * the table with core pseudo-variables
 */
#ifndef FUZZ_BUILD
static
#endif
const pv_export_t _pv_names_table[] = {
  {str_const_init("avp"), PVT_AVP, pv_get_avp, pv_set_avp,
    pv_parse_avp_name, pv_parse_avp_index, 0, 0},
  {str_const_init("hdr"), PVT_HDR, pv_get_hdr, 0, pv_parse_hdr_name,
    pv_parse_index, 0, 0},
  {str_const_init("hdr_name"), PVT_HDR_NAME, pv_get_hdr_name, 0, 0,
    pv_parse_index, 0, 0},
  {str_const_init("hdrcnt"), PVT_HDRCNT, pv_get_hdrcnt, 0, pv_parse_hdr_name, 0, 0, 0},
  {str_const_init("var"), PVT_SCRIPTVAR, pv_get_scriptvar,
    pv_set_scriptvar, pv_parse_scriptvar_name, 0, 0, 0},
  {str_const_init("ai"), /* */
    PVT_PAI_URI, pv_get_pai, 0,
    0, 0, 0, 0},
  {str_const_init("au"), /* */
    PVT_AUTH_USERNAME, pv_get_authattr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("ar"), /* auth realm */
    PVT_AUTH_REALM, pv_get_authattr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("adu"), /* auth digest uri */
    PVT_AUTH_DURI, pv_get_authattr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("ad"), /* */
    PVT_AUTH_DOMAIN, pv_get_authattr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("an"), /* */
    PVT_AUTH_NONCE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 5},
  {str_const_init("auth.nonce"), /* */
    PVT_AUTH_NONCE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 5},
  {str_const_init("auth.resp"), /* */
    PVT_AUTH_RESPONSE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 6},
  {str_const_init("auth.cnonce"), /* */
    PVT_AUTH_CNONCE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 7},
  {str_const_init("auth.opaque"), /* */
    PVT_AUTH_OPAQUE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 8},
  {str_const_init("auth.alg"), /* */
    PVT_AUTH_ALGORITHM, pv_get_authattr, 0,
    0, 0, pv_init_iname, 9},
  {str_const_init("auth.qop"), /* */
    PVT_AUTH_QOP, pv_get_authattr, 0,
    0, 0, pv_init_iname, 10},
  {str_const_init("auth.nc"), /* */
    PVT_AUTH_NONCE_COUNT, pv_get_authattr, 0,
    0, 0, pv_init_iname, 11},
  {str_const_init("aU"), /* */
    PVT_AUTH_USERNAME_WHOLE, pv_get_authattr, 0,
    0, 0, pv_init_iname, 99},
  {str_const_init("challenge.algorithm"), /* */
    PVT_AUTH_USERNAME, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("challenge.realm"),
    PVT_AUTH_REALM, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("challenge.nonce"),
    PVT_AUTH_DURI, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("challenge.opaque"),
    PVT_AUTH_DOMAIN, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("challenge.qop"),
    PVT_AUTH_NONCE, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 5},
  {str_const_init("challenge.ik"), /* */
    PVT_AUTH_NONCE, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 6},
  {str_const_init("challenge.ck"), /* */
    PVT_AUTH_RESPONSE, pv_get_cauthattr, 0,
    0, 0, pv_init_iname, 7},
  {str_const_init("Au"), /* */
    PVT_ACC_USERNAME, pv_get_acc_username, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("bf"), /* */
    PVT_BFLAGS, pv_get_bflags, 0,
    0, 0, 0, 0},
  {str_const_init("branch"), /* to be obsolete */
    PVT_BRANCH, pv_get_branch_fields, pv_set_msg_branch,
    0, 0, 0, 0},
  {str_const_init("branch"), /* to be obsolete */
    PVT_BRANCH, pv_get_branch_fields, pv_set_branch_fields,
    pv_parse_branch_name, pv_parse_index, 0, 0},
  {str_const_init("branch.flag"), /* to be obsolete  */
    PVT_BRANCH_FLAG, msg_branch_flag_get, msg_branch_flag_set,
    msg_branch_flag_parse_name, pv_parse_index, 0, 0},
  {str_const_init("ci"), /* */
    PVT_CALLID, pv_get_callid, 0,
    0, 0, 0, 0},
  {str_const_init("cl"), /* */
    PVT_CONTENT_LENGTH, pv_get_content_length, 0,
    0, 0, 0, 0},
  {str_const_init("cs"), /* */
    PVT_CSEQ, pv_get_cseq, 0,
    0, 0, 0, 0},
  {str_const_init("ct"), /* */
    PVT_CONTACT, pv_get_contact_body, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("ct.fields"), /* */
    PVT_CONTACT, pv_get_contact_body, 0,
    pv_parse_ct_name, pv_parse_index, 0, 0},
  {str_const_init("cT"), /* */
    PVT_CONTENT_TYPE, pv_get_content_type, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("dd"), /* */
    PVT_DSTURI_DOMAIN, pv_get_dsturi_attr, pv_set_dsturi_host,
    0, 0, pv_init_iname, 1},
  {str_const_init("di"), /* */
    PVT_DIVERSION_URI, pv_get_diversion, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("dir"), /* */
    PVT_DIV_REASON, pv_get_diversion, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("dip"), /* */
    PVT_DIV_PRIVACY, pv_get_diversion, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("dp"), /* */
    PVT_DSTURI_PORT, pv_get_dsturi_attr, pv_set_dsturi_port,
    0, 0, pv_init_iname, 2},
  {str_const_init("dP"), /* */
    PVT_DSTURI_PROTOCOL, pv_get_dsturi_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("ds"), /* */
    PVT_DSET, pv_get_dset, 0,
    0, 0, 0, 0},
  {str_const_init("du"), /* */
    PVT_DSTURI, pv_get_dsturi, pv_set_dsturi,
    0, 0, 0, 0},
  {str_const_init("duri"), /* */
    PVT_DSTURI, pv_get_dsturi, pv_set_dsturi,
    0, 0, 0, 0},
  {str_const_init("err.class"), /* */
    PVT_ERR_CLASS, pv_get_errinfo_attr, 0,
    0, 0, 0, 0},
  {str_const_init("err.level"), /* */
    PVT_ERR_LEVEL, pv_get_errinfo_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("err.info"), /* */
    PVT_ERR_INFO, pv_get_errinfo_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("err.rcode"), /* */
    PVT_ERR_RCODE, pv_get_errinfo_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("err.rreason"), /* */
    PVT_ERR_RREASON, pv_get_errinfo_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("fd"), /* */
    PVT_FROM_DOMAIN, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("from.domain"), /* */
    PVT_FROM_DOMAIN, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("fn"), /* */
    PVT_FROM_DISPLAYNAME, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 5},
  {str_const_init("ft"), /* */
    PVT_FROM_TAG, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("fu"), /* */
    PVT_FROM, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("from"), /* */
    PVT_FROM, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("fU"), /* */
    PVT_FROM_USERNAME, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("from.user"), /* */
    PVT_FROM_USERNAME, pv_get_from_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("log_level"), /* per process log level*/
    PVT_LOG_LEVEL, pv_get_log_level, pv_set_log_level,
    0, 0, 0, 0},
  {str_const_init("mb"), /* */
    PVT_MSG_BUF, pv_get_msg_buf, 0,
    0, 0, 0, 0},
  {str_const_init("mf"), /* */
    PVT_FLAGS, pv_get_flags, 0,
    0, 0, 0, 0},
  {str_const_init("msg.flag"), /* */
    PVT_MSG_FLAG, msg_flag_get, msg_flag_set,
    msg_flag_parse_name, 0, 0, 0},
  {str_const_init("msg.is_request"), /* */
    PVT_MSG_FLAG, msg_is_request_get, 0,
    0, 0, 0, 0},
  {str_const_init("msg.type"), /* */
    PVT_MSG_FLAG, msg_type_get, 0,
    0, 0, 0, 0},

  {str_const_init("msg.branch"), /* */
    PVT_BRANCH, pv_get_branch_fields, pv_set_msg_branch,
    0, 0, 0, 0},
  {str_const_init("msg.branch.uri"), /* */
    PVT_BRANCH, pv_get_msg_branch_uri, pv_set_msg_branch_uri,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.duri"), /* */
    PVT_BRANCH, pv_get_msg_branch_duri, pv_set_msg_branch_duri,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.path"), /* */
    PVT_BRANCH, pv_get_msg_branch_path, pv_set_msg_branch_path,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.q"), /* */
    PVT_BRANCH, pv_get_msg_branch_q, pv_set_msg_branch_q,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.flags"), /* */
    PVT_BRANCH, pv_get_msg_branch_flags, pv_set_msg_branch_flags,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.socket"), /* */
    PVT_BRANCH, pv_get_msg_branch_sock, pv_set_msg_branch_sock,
    0, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.flag"), /* */
    PVT_BRANCH_FLAG, msg_branch_flag_get, msg_branch_flag_set,
    msg_branch_flag_parse_name, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.attr"), /* */
    PVT_BRANCH, pv_get_msg_branch_attr, pv_set_msg_branch_attr,
    pv_parse_avp_name, pv_parse_index, 0, 0},
  {str_const_init("msg.branch.last_idx"), /* */
    PVT_BRANCH, pv_get_msg_branch_lastidx, NULL,
    NULL, NULL, 0, 0},
  {str_const_init("mi"), /* */
    PVT_MSGID, pv_get_msgid, 0,
    0, 0, 0, 0},
  {str_const_init("ml"), /* */
    PVT_MSG_LEN, pv_get_msg_len, 0,
    0, 0, 0, 0},
  {str_const_init("od"), /* */
    PVT_OURI_DOMAIN, pv_get_ouri_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("op"), /* */
    PVT_OURI_PORT, pv_get_ouri_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("oP"), /* */
    PVT_OURI_PROTOCOL, pv_get_ouri_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("ou"), /* */
    PVT_OURI, pv_get_ouri, 0,
    0, 0, 0, 0},
  {str_const_init("ouri"), /* */
    PVT_OURI, pv_get_ouri, 0,
    0, 0, 0, 0},
  {str_const_init("oU"), /* */
    PVT_OURI_USERNAME, pv_get_ouri_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("path"), /* */
    PVT_PATH, pv_get_path, 0,
    0, 0, 0, 0},
  {str_const_init("pd"), /* */
    PVT_PPI_DOMAIN, pv_get_ppi_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("pn"), /* */
    PVT_PPI_DISPLAYNAME, pv_get_ppi_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("pp"), /* */
    PVT_PID, pv_get_pid, 0,
    0, 0, 0, 0},
  {str_const_init("pu"), /* */
    PVT_PPI, pv_get_ppi_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("pU"), /* */
    PVT_PPI_USERNAME, pv_get_ppi_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("proxy_protocol"),
    PVT_PROXY_PROTOCOL, pv_get_proxy_protocol, 0,
    pv_parse_proxy_protocol, 0, 0, 0},
  {str_const_init("rb"), /* */
    PVT_MSG_BODY, pv_get_msg_body, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("rb"), /* */
    PVT_MSG_BODY, pv_get_msg_body, 0,
    pv_parse_rb_name, pv_parse_index, 0, 0},
  {str_const_init("rc"), /* */
    PVT_RETURN_CODE, pv_get_return_code, 0,
    0, 0, 0, 0},
  {str_const_init("retcode"), /* */
    PVT_RETURN_CODE, pv_get_return_code, 0,
    0, 0, 0, 0},
  {str_const_init("rd"), /* */
    PVT_RURI_DOMAIN, pv_get_ruri_attr, pv_set_ruri_host,
    0, 0, pv_init_iname, 2},
  {str_const_init("ruri.domain"), /* */
    PVT_RURI_DOMAIN, pv_get_ruri_attr, pv_set_ruri_host,
    0, 0, pv_init_iname, 2},
  {str_const_init("re"), /* */
    PVT_RPID_URI, pv_get_rpid, 0,
    0, 0, 0, 0},
  {str_const_init("rm"), /* */
    PVT_METHOD, pv_get_method, 0,
    0, 0, 0, 0},
  {str_const_init("route"), /* */
    PVT_ROUTE, pv_get_route, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("route.name"), /* */
    PVT_ROUTE_NAME, pv_get_route_name, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("route.type"), /* */
    PVT_ROUTE_TYPE, pv_get_route_type, 0,
    0, pv_parse_index, 0, 0},
  {str_const_init("rp"), /* */
    PVT_RURI_PORT, pv_get_ruri_attr, pv_set_ruri_port,
    0, 0, pv_init_iname, 3},
  {str_const_init("rP"), /* */
    PVT_RURI_PROTOCOL, pv_get_ruri_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("rr"), /* */
    PVT_REASON, pv_get_reason, 0,
    0, 0, 0, 0},
  {str_const_init("rs"), /* */
    PVT_STATUS, pv_get_status, 0,
    0, 0, 0, 0},
  {str_const_init("rt"), /* */
    PVT_REFER_TO, pv_get_refer_to, 0,
    0, 0, 0, 0},
  {str_const_init("ru"), /* */
    PVT_RURI, pv_get_ruri, pv_set_ruri,
    0, 0, 0, 0},
  {str_const_init("ruri"), /* */
    PVT_RURI, pv_get_ruri, pv_set_ruri,
    0, 0, 0, 0},
  {str_const_init("ru_q"), /* */
    PVT_RU_Q, pv_get_ru_q, pv_set_ru_q,
    0, 0, 0, 0},
  {str_const_init("rU"), /* */
    PVT_RURI_USERNAME, pv_get_ruri_attr, pv_set_ruri_user,
    0, 0, pv_init_iname, 1},
  {str_const_init("ruri.user"), /* */
    PVT_RURI_USERNAME, pv_get_ruri_attr, pv_set_ruri_user,
    0, 0, pv_init_iname, 1},
  {str_const_init("sdp"), /* */
    PVT_SDP, pv_get_sdp, pv_set_sdp,
    0, 0, pv_init_iname, 1},
  {str_const_init("sdp"), /* */
    PVT_SDP, pv_get_sdp, pv_set_sdp,
    pv_parse_sdp_name, 0, pv_init_iname, 1},
  {str_const_init("sdp.line"), /* */
    PVT_SDP_LINE, pv_get_sdp_line, pv_set_sdp_line,
    pv_parse_sdp_line_name, pv_parse_sdp_line_index, 0, 0},
  {str_const_init("sdp.stream"), /* */
    PVT_SDP_STREAM, pv_get_sdp_stream, pv_set_sdp_stream,
    pv_parse_sdp_stream_name, pv_parse_sdp_line_index, 0, 0},
  {str_const_init("sdp.stream.idx"), /* */
    PVT_SDP_LINE, pv_get_sdp_stream_idx, 0,
    pv_parse_sdp_stream_name, 0, 0, 0},
  {str_const_init("sdp.session"), /* */
    PVT_SDP_SESSION, pv_get_sdp_session, pv_set_sdp_session,
    pv_parse_sdp_line_name, pv_parse_sdp_line_index, 0, 0},
  {str_const_init("src_ip"), /* */
    PVT_SRCIP, pv_get_srcip, 0,
    0, 0, 0, 0},
  {str_const_init("socket_in"), /* */
    PVT_SOCKET_IN, pv_get_socket_in_fields, NULL,
    0, 0, 0, 0},
  {str_const_init("socket_in"), /* */
    PVT_SOCKET_IN, pv_get_socket_in_fields, NULL,
    pv_parse_socket_name, 0, 0, 0},
  {str_const_init("socket_out"), /* */
    PVT_SOCKET_OUT, pv_get_socket_out_fields, pv_set_force_sock,
    0, 0, 0, 0},
  {str_const_init("socket_out"), /* */
    PVT_SOCKET_OUT, pv_get_socket_out_fields, NULL,
    pv_parse_socket_out_name, 0, 0, 0},
  {str_const_init("si"), /* */
    PVT_SRCIP, pv_get_srcip, 0,
    0, 0, 0, 0},
  {str_const_init("sp"), /* */
    PVT_SRCPORT, pv_get_srcport, 0,
    0, 0, 0, 0},
  {str_const_init("td"), /* */
    PVT_TO_DOMAIN, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("to.domain"), /* */
    PVT_TO_DOMAIN, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 3},
  {str_const_init("time"), /* */
    PVT_TIME, pv_get_formated_time, 0,
    pv_parse_time_name, 0, 0, 0},
  {str_const_init("tn"), /* */
    PVT_TO_DISPLAYNAME, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 5},
  {str_const_init("tt"), /* */
    PVT_TO_TAG, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 4},
  {str_const_init("tu"), /* */
    PVT_TO, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("to"), /* */
    PVT_TO, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 1},
  {str_const_init("tU"), /* */
    PVT_TO_USERNAME, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("to.user"), /* */
    PVT_TO_USERNAME, pv_get_to_attr, 0,
    0, 0, pv_init_iname, 2},
  {str_const_init("Tf"), /* */
    PVT_TIMEF, pv_get_timef, 0,
    0, 0, 0, 0},
  {str_const_init("Ts"), /* */
    PVT_TIMES, pv_get_times, 0,
    0, 0, 0, 0},
  {str_const_init("Tsm"), /* */
    PVT_TIMES, pv_get_timem, 0,
    0, 0, 0, 0},
  {str_const_init("TS"), /* */
    PVT_TIMES, pv_get_start_times, 0,
    0, 0, 0, 0},
  {str_const_init("ua"), /* */
    PVT_USERAGENT, pv_get_useragent, 0,
    0, 0, 0, 0},
  {str_const_init("C"), PVT_COLOR, pv_get_color, 0,
    pv_parse_color_name, 0, 0, 0 },
  {str_const_init("argv"), PVT_ARGV, pv_get_argv, 0,
    pv_parse_argv_name, 0, 0, 0 },
  {str_const_init("param"), PVT_ROUTE_PARAM, pv_get_param, 0,
    pv_parse_param_name, 0, 0, 0 },
  {str_const_init("cfg_line"), PVT_LINE_NUMBER, pv_get_line_number, 0,
    0, 0, 0, 0 },
  {str_const_init("cfg_file"), PVT_CFG_FILE_NAME, pv_get_cfg_file_name, 0,
  0, 0, 0, 0 },
  {str_const_init("xlog_level"), PVT_XLOG_LEVEL, pv_get_xlog_level,
    pv_set_xlog_level, 0, 0, 0, 0 },
  {str_const_init("return"), PVT_EXTRA, pv_get_return_value, 0,
    pv_parse_return_value, 0, 0, 0 },
  {{0,0}, 0, 0, 0, 0, 0, 0, 0}
};

static const pv_export_t* pv_lookup_spec_name(str *pvname, pv_spec_p e, int has_name)
{
  int i;
  pv_extra_p pvi;
  int found;

  if(pvname==0 || e==0)
  {
    LM_ERR("bad parameters\n");
    return NULL;
  }
  /* search in main table */
  for(i=0; _pv_names_table[i].name.s!=0; i++)
  {
    if(_pv_names_table[i].name.len==pvname->len
      && !((has_name?1:0) ^ (_pv_names_table[i].parse_name?1:0))
      && memcmp(_pv_names_table[i].name.s, pvname->s, pvname->len)==0)
    {
      /*LM_DBG("found [%.*s] [%d]\n", pvname->len, pvname->s,
          _pv_names_table[i].type);*/
      /* copy data from table to spec */
      e->type = _pv_names_table[i].type;
      e->getf = _pv_names_table[i].getf;
      e->setf = _pv_names_table[i].setf;
      return &_pv_names_table[i];
    }
  }
  /* search in extra list */
  if(_pv_extra_list==0)
  {
    LM_DBG("extra items list is empty\n");
    return NULL;
  }
  pvi = *_pv_extra_list;
  while(pvi)
  {
    if(pvi->pve.name.len>pvname->len)
      break;
    if(pvi->pve.name.len==pvname->len)
    {
      found = strncmp(pvi->pve.name.s, pvname->s, pvname->len);
      if(found>0)
        break;
      if(found==0)
      {
        LM_DBG("found in extra list [%.*s]\n", pvname->len, pvname->s);
        /* copy data from export to spec */
        e->type = pvi->pve.type;
        e->getf = pvi->pve.getf;
        e->setf = pvi->pve.setf;
        return &(pvi->pve);
      }
    }
    pvi = pvi->next;
  }

  return NULL;
}

static int is_pv_valid_char(char c)
{
  if((c>='0' && c<='9') || (c>='a' && c<='z') || (c>='A' && c<='Z')
      || (c=='_') || (c=='.'))
    return 1;
  return 0;
}

char* pv_parse_spec(const str *in, const pv_spec_p e)
{
  char *p;
  str s;
  str pvname;
  str pvcontext;
  int pvstate;
  int has_inner_name;
  trans_t *tr = NULL;
  const pv_export_t *pte = NULL;
  int n=0;

  if(in==NULL || in->s==NULL || e==NULL || *in->s!=PV_MARKER)
  {
    LM_ERR("bad parameters\n");
    return NULL;
  }

//  LM_DBG("***** input [%.*s] (%d)\n", in->len, in->s, in->len);
  tr = 0;
  pvstate = 0;
  memset(e, 0, sizeof(pv_spec_t));
  p = in->s;
  p++;
  if(*p==PV_LNBRACKET)
  {
    p++;
    pvstate = 1;
  }
  pvname.s = p;
  if(*p == PV_MARKER) {
    p++;
    if(pvstate==1)
    {
      if(*p!=PV_RNBRACKET)
        goto error;
      p++;
    }
    e->getf = pv_get_marker;
    e->type = PVT_MARKER;
    pvname.len = 1;
    goto done_all;
  }

  if (*p==PV_LCBRACKET)
  { /* context definition*/
    p++;
    pvcontext.s = p;

    while(is_in_str(p,in) && is_pv_valid_char(*p))
      p++;

    if(*p != PV_RCBRACKET)
    {
      LM_ERR("Expected to find the end of the context\n");
      return 0;
    }
    pvcontext.len = p - pvcontext.s;
    LM_DBG("Context name is %.*s\n", pvcontext.len, pvcontext.s);
    p++;
    e->pvc = pv_get_context(&pvcontext);
    if(e->pvc == NULL)
    {
      if(!pvc_before_check)
      {
        LM_ERR("Requested a non existing pv context\n");
        return 0;
      }
      LM_DBG("No context definition found for [%.*s]\n", pvcontext.len, pvcontext.s);
      /* create a dummy context strcuture to be filled by the register functions */
      e->pvc = add_pv_context(&pvcontext, 0);
      if(e->pvc == NULL )
      {
        LM_ERR("Failed to new context\n");
        return 0;
      }
    }
  }

  pvname.s = p;
  while(is_in_str(p,in) && is_pv_valid_char(*p))
    p++;
  pvname.len = p - pvname.s;

  if(pvstate==1)
  {
    if(*p==PV_RNBRACKET)
    { /* full pv name ended here*/
      goto done_inm;
    } else if(*p==PV_LNBRACKET) {
      p++;
      pvstate = 2;
    } else if(*p==PV_LIBRACKET) {
      p++;
      pvstate = 3;
    } else if(*p==TR_LBRACKET) {
      p++;
      pvstate = 4;
    }
    else {
      LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s,
          pvstate);
      goto error;
    }
  } else {
    if(!is_in_str(p, in)) {
      p--;
      goto done_inm;
    } else if(*p==PV_LNBRACKET) {
      p++;
      pvstate = 5;
    } else {
      /* still in input str, but end of PV */
      /* p is increased at the end, so decrement here */
      p--;
      goto done_inm;
    }
  }

done_inm:
  has_inner_name = (pvstate==2||pvstate==5)?1:0;
  if((pte = pv_lookup_spec_name(&pvname, e, has_inner_name))==NULL)
  {
    LM_ERR("unknown script var $%.*s%s, maybe a 'loadmodule' statement "
           "is missing?\n", pvname.len, pvname.s,has_inner_name ? "()":"");
    goto error;
  }
  if(pvstate==2 || pvstate==5)
  {
    s.s = p;
    n = 0;
    while(is_in_str(p, in))
    {
      if(*p==PV_RNBRACKET)
      {
        if(n==0)
          break;
        n--;
      }
      if(*p == PV_LNBRACKET)
        n++;
      p++;
    }

    if(!is_in_str(p, in))
      goto error;

    if(p==s.s)
    {
      LM_ERR("pvar \"%.*s\" does not get empty name param\n",
          pvname.len, pvname.s);
      goto error;
    }
    s.len = p - s.s;
    if(pte->parse_name == NULL || pte->parse_name(e, &s)!=0)
    {
      LM_ERR("pvar \"%.*s\" has an invalid name param [%.*s]\n",
          pvname.len, pvname.s, s.len, s.s);
      goto error;
    }
    if(pvstate==2)
    {
      p++;
      if(*p==PV_RNBRACKET)
      { /* full pv name ended here*/
        goto done_vnm;
      } else if(*p==PV_LIBRACKET) {
        p++;
        pvstate = 3;
      } else if(*p==TR_LBRACKET) {
        p++;
        pvstate = 4;
      } else {
        LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s,
          pvstate);
        goto error;
      }
    } else {
      if(*p==PV_RNBRACKET)
      { /* full pv name ended here*/
        p++;
        goto done_all;
      } else {
        LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s,
          pvstate);
        goto error;
      }
    }
  }
done_vnm:
  if(pvstate==3)
  {
    if(pte->parse_index==NULL)
    {
      LM_ERR("pvar \"%.*s\" does not get index param\n",
          pvname.len, pvname.s);
      goto error;
    }
    s.s = p;
    n = 0;
    while(is_in_str(p, in))
    {
      if(*p==PV_RIBRACKET)
      {
        if(n==0)
          break;
        n--;
      }
      if(*p == PV_LIBRACKET)
        n++;
      p++;
    }
    if(!is_in_str(p, in))
      goto error;

    if(p==s.s)
    {
      LM_ERR("pvar \"%.*s\" does not get empty index param\n",
          pvname.len, pvname.s);
      goto error;
    }
    s.len = p - s.s;
    if(pte->parse_index(e, &s)!=0)
    {
      LM_ERR("pvar \"%.*s\" has an invalid index param [%.*s]\n",
          pvname.len, pvname.s, s.len, s.s);
      goto error;
    }
    p++;
    if(*p==PV_RNBRACKET)
    { /* full pv name ended here*/
      goto done_idx;
    } else if(*p==TR_LBRACKET) {
      p++;
      pvstate = 4;
    } else {
      LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s,
          pvstate);
      goto error;
    }
  }
done_idx:
  if(pvstate==4)
  {
    s.s = p-1;
    n = 0;
    while(is_in_str(p, in))
    {
      if(*p==TR_RBRACKET)
      {
        if(n==0)
        {
          /* yet another transformation */
          p++;
          while(is_in_str(p, in) && (*p==' ' || *p=='\t')) p++;

          if(!is_in_str(p, in) || *p != TR_LBRACKET)
          {
            p--;
            break;
          }
        }
        n--;
      }
      if(*p == TR_LBRACKET)
        n++;
      p++;
    }
    if(!is_in_str(p, in))
      goto error;

    if(p==s.s)
    {
      LM_ERR("pvar \"%.*s\" does not get empty index param\n",
          pvname.len, pvname.s);
      goto error;
    }
    s.len = p - s.s + 1;

    p = parse_transformation(&s, &tr);
    if(p==NULL)
    {
      LM_ERR("ERROR:bad tr in pvar name \"%.*s\"\n",
          pvname.len, pvname.s);
      goto error;
    }
    if(*p!=PV_RNBRACKET)
    {
      LM_ERR("bad pvar name \"%.*s\" (%c)!\n", in->len, in->s, *p);
      goto error;
    }
    e->trans = (void*)tr;
  }
  p++;

done_all:
  if(pte!=NULL && pte->init_param)
    pte->init_param(e, pte->iparam);
  return p;

error:
  if(p!=NULL)
    LM_ERR("wrong char [%c/%d] in [%.*s] at [%d (%d)]\n", *p, (int)*p,
      in->len, in->s, (int)(p-in->s), pvstate);
  else
    LM_ERR("invalid parsing in [%.*s] at (%d)\n", in->len, in->s, pvstate);
  return NULL;

} /* end: pv_parse_spec */

/**
 *
 */
int pv_parse_format(const str *in, pv_elem_p *el)
{
  char *p, *p0;
  /*int n = 0;*/
  pv_elem_p e, e0;
  str s;

  if(in==NULL || in->s==NULL || el==NULL)
    return -1;

  /*LM_DBG("parsing [%.*s]\n", in->len, in->s);*/

  if(in->len == 0)
  {
    *el = pkg_malloc(sizeof(pv_elem_t));
    if(*el == NULL) {
      LM_ERR("not enough pkg memory for PV element (1)\n");
      goto error;
    }
    memset(*el, 0, sizeof(pv_elem_t));
    (*el)->text = *in;
    return 0;
  }

  p = in->s;
  *el = NULL;
  e = e0 = NULL;

  while(is_in_str(p,in))
  {
    e0 = e;
    e = pkg_malloc(sizeof(pv_elem_t));
    if(!e) {
      LM_ERR("not enough pkg memory for PV element (2)\n");
      goto error;
    }
    memset(e, 0, sizeof(pv_elem_t));
    /*n++;*/
    if(*el == NULL)
      *el = e;
    if(e0)
      e0->next = e;

    e->text.s = p;
    while(is_in_str(p,in) && *p!=PV_MARKER)
      p++;
    e->text.len = p - e->text.s;

    if(!is_in_str(p,in))
      break;
    s.s = p;
    s.len = in->s+in->len-p;
    p0 = pv_parse_spec(&s, &e->spec);

    if(p0==NULL) {
      LM_ERR("parsing PV spec failed\n");
      goto error;
    }
    if(!is_in_str(p0,in))
      break;
    p = p0;
  }
  /*LM_DBG("format parsed OK: [%d] items\n", n);*/

  if(*el == NULL)
    return -1;

  return 0;

error:
  pv_elem_free_all(*el);
  *el = NULL;
  return -1;
}

int pv_get_spec_name(struct sip_msg* msg, pv_param_p ip, pv_value_t *name)
{
  if(msg==NULL || ip==NULL || name==NULL)
    return -1;
  memset(name, 0, sizeof(pv_value_t));

  if(ip->pvn.type==PV_NAME_INTSTR)
  {
    if(ip->pvn.u.isname.type&AVP_NAME_STR)
    {
      name->rs = ip->pvn.u.isname.name.s;
      name->flags = PV_VAL_STR;
    } else {
      name->ri = ip->pvn.u.isname.name.n;
      name->flags = PV_VAL_INT|PV_TYPE_INT;
    }
    return 0;
  }
  /* pvar */
  if(pv_get_spec_value(msg, (const pv_spec_p)(ip->pvn.u.dname), name)!=0)
  {
    LM_ERR("cannot get name value\n");
    return -1;
  }
  if(name->flags&PV_VAL_NULL || name->flags&PV_VAL_EMPTY)
  {
    LM_ERR("null or empty name\n");
    return -1;
  }
  return 0;
}

int pv_get_avp_name(struct sip_msg* msg, pv_param_p ip, int *avp_name,
    unsigned short *name_type)
{
  pv_value_t tv;
  if(ip==NULL || avp_name==NULL || name_type==NULL)
    return -1;
  *avp_name = 0;
  *name_type = 0;

  if(ip->pvn.type==PV_NAME_INTSTR)
  {
    *name_type = ip->pvn.u.isname.type;
    *avp_name = ip->pvn.u.isname.name.n;
    *name_type &= AVP_SCRIPT_MASK;
    return 0;
  }
  /* pvar */
  if(pv_get_spec_value(msg, (const pv_spec_p)(ip->pvn.u.dname), &tv)!=0)
  {
    LM_ERR("cannot get avp value\n");
    return -1;
  }
  if(tv.flags&PV_VAL_NULL || tv.flags&PV_VAL_EMPTY)
  {
    LM_ERR("null or empty name\n");
    return -1;
  }

  if(!(tv.flags&PV_VAL_STR))
    tv.rs.s = int2str(tv.ri, &tv.rs.len);

  /* search the name here */
  *avp_name = get_avp_id(&tv.rs);
  if (*avp_name == 0) {
    LM_ERR("cannot find avp %.*s\n", tv.rs.len, tv.rs.s);
    return -1;
  }
  return 0;
}


int pv_get_spec_index(struct sip_msg* msg, pv_param_p ip, int *idx, int *flags)
{
  pv_value_t tv;
  if(ip==NULL || idx==NULL || flags==NULL)
    return -1;

  *idx = 0;
  *flags = ip->pvi.type;

  if(ip->pvi.type == 0)
    return 0;

  if(ip->pvi.type == PV_IDX_ALL || ip->pvi.type == PV_IDX_APPEND) {
    return 0;
  }

  if(ip->pvi.type == PV_IDX_INT)
  {
    *idx = ip->pvi.u.ival;
    return 0;
  }

  /* pvar */
  if(pv_get_spec_value(msg, (const pv_spec_p)ip->pvi.u.dval, &tv)!=0)
  {
    LM_ERR("cannot get index value\n");
    return -1;
  }
  if(!(tv.flags & PV_VAL_INT))
  {
    LM_ERR("invalid index value\n");
    return -1;
  }
  *idx = tv.ri;
  return 0;
}

/* function to set pv value */
int pv_set_value(struct sip_msg* msg, pv_spec_p sp,
    int op, pv_value_t *value)
{
  struct sip_msg* pv_msg;

  if(msg==NULL || sp==NULL || sp->setf==NULL || sp->type==PVT_NONE)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  if(sp->pvc && sp->pvc->contextf)
  {
    pv_msg = sp->pvc->contextf(msg);
    if(pv_msg == NULL || pv_msg==FAKED_REPLY)
    {
      LM_DBG("Invalid %p pv context message\n",pv_msg);
      return -1;
    }
  }
  else
    pv_msg = msg;

  return (*sp->setf)(pv_msg, &(sp->pvp), op, value);
}

int pv_get_spec_value(struct sip_msg* msg, const pv_spec_p sp, pv_value_t *value)
{
  struct sip_msg* pv_msg;

  if(msg==NULL || sp==NULL || sp->getf==NULL || value==NULL
      || sp->type==PVT_NONE)
  {
    LM_ERR("bad parameters\n");
    return -1;
  }

  memset(value, 0, sizeof(pv_value_t));

  if(sp->pvc && sp->pvc->contextf)
  {
    LM_DBG("Found context function %p\n", sp->pvc->contextf);
    pv_msg = sp->pvc->contextf(msg);
    if(pv_msg == NULL || pv_msg==FAKED_REPLY)
    {
      LM_DBG("Invalid %p pv context message\n",pv_msg);
      return pv_get_null( NULL, NULL, value);
    }
  } else {
    pv_msg = msg;
  }
  if((*sp->getf)(pv_msg, &(sp->pvp), value)!=0)
    return pv_get_null( NULL, NULL, value);
  if(sp->trans)
    if (run_transformations(pv_msg, (trans_t*)sp->trans, value)!=0)
      return pv_get_null( NULL, NULL, value);
  return 0;
}

int pv_print_spec(struct sip_msg* msg, const pv_spec_p sp, char *buf, int *len)
{
  pv_value_t tok;
  if(msg==NULL || sp==NULL || buf==NULL || len==NULL)
    return -1;

  if(*len <= 0)
    return -1;

  memset(&tok, 0, sizeof(pv_value_t));

  /* put the value of the specifier */
  if(pv_get_spec_value(msg, sp, &tok)==0)
  {
    if(tok.flags&PV_VAL_NULL)
      tok.rs = str_null;
    if(tok.rs.len < *len)
      memcpy(buf, tok.rs.s, tok.rs.len);
    else
      goto overflow;
  }

  *len = tok.rs.len;
  buf[tok.rs.len] = '\0';
  return 0;

overflow:
  LM_ERR("buffer overflow -- increase the buffer size...\n");
  return -1;
}


int pv_printf(struct sip_msg* msg, pv_elem_p list, char *buf, int *len)
{
  int n;
  pv_value_t tok;
  str print;
  pv_elem_p it;
  char *cur;

  if(msg==NULL || list==NULL || buf==NULL || len==NULL)
    return -1;

  if(*len <= 0)
    return -1;

  *buf = '\0';
  cur = buf;

  n = 0;
  for (it=list; it; it=it->next)
  {
    /* put the text */
    if(it->text.s && it->text.len>0)
    {
      if(n+it->text.len < *len)
      {
        memcpy(cur, it->text.s, it->text.len);
        n += it->text.len;
        cur += it->text.len;
      } else {
        LM_ERR("no more space for text [%d][%d]\n", n, it->text.len);
        goto overflow;
      }
    }
    /* put the value of the specifier */
    if(it->spec.type!=PVT_NONE
        && pv_get_spec_value(msg, &(it->spec), &tok)==0)
    {
      print = pv_value_print(&tok);
      if (n + print.len >= *len) {
        LM_ERR("no more space for spec value [%d][%d]\n",
               n, print.len);
        goto overflow;
      }

      memcpy(cur, print.s, print.len);
      n += print.len;
      cur += print.len;
    }
  }

  goto done;

overflow:
  if (is_pv_print_buf(buf))
    LM_ERR("buffer too small -- increase 'pv_print_buf_size' from [%d]\n",
        *len);
  else
    LM_ERR("buffer too small -- increase the buffer size "
        "from [%d]...\n", *len);
  return -1;

done:
#ifdef EXTRA_DEBUG
  LM_DBG("final buffer length %d\n", n);
#endif
  *cur = '\0';
  *len = n;
  return 0;
}



pvname_list_t* parse_pvname_list(str *in, unsigned int type)
{
  pvname_list_t* head = NULL;
  pvname_list_t* al = NULL;
  pvname_list_t* last = NULL;
  char *p;
  pv_spec_t spec;
  str s;

  if(in==NULL || in->s==NULL)
  {
    LM_ERR("bad parameters\n");
    return NULL;
  }

  p = in->s;
  while(is_in_str(p, in))
  {
    while(is_in_str(p, in) && (is_ws(*p)||*p==','||*p==';'))
      p++;
    if(!is_in_str(p, in))
    {
      if(head==NULL)
        LM_ERR("wrong item name list [%.*s]\n", in->len, in->s);
      return head;
    }
    s.s=p;
    s.len = in->s+in->len-p;
    p = pv_parse_spec(&s, &spec);
    if(p==NULL || (type && spec.type!=type))
    {
      LM_ERR("wrong item name list [%.*s]!\n", in->len, in->s);
      goto error;
    }
    al = (pvname_list_t*)pkg_malloc(sizeof(pvname_list_t));
    if(al==NULL)
    {
      LM_ERR("no more memory!\n");
      goto error;
    }
    memset(al, 0, sizeof(pvname_list_t));
    memcpy(&al->sname, &spec, sizeof(pv_spec_t));

    if(last==NULL)
    {
      head = al;
      last = al;
    } else {
      last->next = al;
      last = al;
    }
  }

  return head;

error:
  while(head)
  {
    al = head;
    head=head->next;
    pkg_free(al);
  }
  return NULL;
}

int pv_elem_free_all(pv_elem_p log)
{
  pv_elem_p t;
  while(log)
  {
    t = log;
    log = log->next;

    if (t->spec.trans)
      free_transformation((trans_t *)t->spec.trans);
    pkg_free(t);
  }
  return 0;
}

static str pv_value_print(const pv_value_t *val)
{
  str printed = str_init(NULL);

  if (val->flags & PV_VAL_NULL)
    return str_null;

  if (val->flags & PV_VAL_STR)
    return val->rs;

  if (val->flags & (PV_VAL_INT|PV_TYPE_INT)) {
    printed.s = int2str(val->ri, &printed.len);
    return printed;
  }

  LM_ERR("unknown type %x\n", val->flags);
  return str_empty;
}

void pv_value_destroy(pv_value_t *val)
{
  if(val==0) return;
  if(val->flags&PV_VAL_PKG) pkg_free(val->rs.s);
  if(val->flags&PV_VAL_SHM) shm_free(val->rs.s);
  memset(val, 0, sizeof(pv_value_t));
}

/* IMPORTANT NOTE - even if the function prints and returns a static buffer, it
 * has built-in support for PV_PRINTF_BUF_NO levels of nesting
 * (or concurrent usage).  If you think it's not enough for you, either use
 * pv_printf() directly, either increase PV_PRINT_BUF_NO   --bogdan */
int pv_printf_s(struct sip_msg* msg, pv_elem_p list, str *s)
{
  static int buf_itr = 0;

  if (list->next==0 && list->spec.getf==0) {
    *s = list->text;
    return 0;
  } else {
    *s = pv_print_buf[buf_itr];
    buf_itr = (buf_itr + 1) % PV_PRINT_BUF_NO;
    return pv_printf(msg, list, s->s, &s->len);
  }
}

void pv_spec_free(pv_spec_t *spec)
{
  if(spec==0) return;
  /* TODO: free name if it is PV */
  if(spec->trans)
    free_transformation((trans_t*)spec->trans);
  pkg_free(spec);
}

int pv_spec_dbg(const pv_spec_p sp)
{
  if(sp==NULL)
  {
    LM_DBG("spec: <<NULL>>\n");
    return 0;
  }
  LM_DBG("<spec>\n");
  LM_DBG("type: %d\n", sp->type);
  LM_DBG("getf: %p\n", sp->getf);
  LM_DBG("setf: %p\n", sp->setf);
  LM_DBG("tran: %p\n", sp->trans);
  LM_DBG("<param>\n");
  LM_DBG("<name>\n");
  LM_DBG("type: %d\n", sp->pvp.pvn.type);
  if(sp->pvp.pvn.type==PV_NAME_INTSTR)
  {
    LM_DBG("sub-type: %d\n", sp->pvp.pvn.u.isname.type);
    if (sp->pvp.pvn.u.isname.type&AVP_NAME_STR)
    {
      LM_DBG("name str: %.*s\n",
          sp->pvp.pvn.u.isname.name.s.len,
          sp->pvp.pvn.u.isname.name.s.s);
    } else {
      LM_DBG("name in: %d\n",
          sp->pvp.pvn.u.isname.name.n);
    }

  } else if(sp->pvp.pvn.type==PV_NAME_PVAR) {
    pv_spec_dbg((pv_spec_p)sp->pvp.pvn.u.dname);
  } else {
    LM_DBG("name: unknown\n");
  }
  LM_DBG("</name>\n");
  LM_DBG("<index>\n");
  LM_DBG("type: %d\n", sp->pvp.pvi.type);
  if(sp->pvp.pvi.type==PV_IDX_INT)
  {
    LM_DBG("index: %d\n", sp->pvp.pvi.u.ival);
  } else if(sp->pvp.pvi.type==PV_IDX_PVAR) {
    pv_spec_dbg((pv_spec_p)sp->pvp.pvi.u.dval);
  } else if(sp->pvp.pvi.type==PV_IDX_ALL){
    LM_DBG("index: *\n");
  } else {
    LM_DBG("index: unknown\n");
  }
  LM_DBG("</index>\n");
  LM_DBG("</param>\n");
  LM_DBG("</spec\n");
  return 0;
}


/**
 *
 */
static int pv_init_extra_list(void)
{
  _pv_extra_list = (pv_extra_p*)pkg_malloc(sizeof(pv_extra_p));
  if(_pv_extra_list==0)
  {
    LM_ERR("cannot alloc extra items list\n");
    return -1;
  }
  *_pv_extra_list=0;
  return 0;
}

static int pv_add_extra(const pv_export_t *e)
{
  const char *p;
  const str_const *in;
  pv_extra_t *pvi = NULL;
  pv_extra_t *pvj = NULL;
  pv_extra_t *pvn = NULL;
  int found;

  if(e==NULL || e->name.s==NULL || e->getf==NULL || e->type==PVT_NONE)
  {
    LM_ERR("invalid parameters\n");
    return -1;
  }

  if(_pv_extra_list==0)
  {
    LM_DBG("extra items list is not initialized\n");
    if(pv_init_extra_list()!=0)
    {
      LM_ERR("cannot intit extra list\n");
      return -1;
    }
  }
  in = &(e->name);
  p = in->s;
  while(is_in_str(p,in) && is_pv_valid_char(*p))
    p++;
  if(is_in_str(p,in))
  {
    LM_ERR("invalid char [%c] in [%.*s]\n", *p, in->len, in->s);
    return -1;
  }
  found = 0;
  pvi = *_pv_extra_list;
  while(pvi)
  {
    if(pvi->pve.name.len > in->len)
      break;
    if(pvi->pve.name.len==in->len)
    {
      found = strncmp(pvi->pve.name.s, in->s, in->len);
      if(found>0)
        break;
      if(found==0)
      {
        LM_ERR("pvar [%.*s] already exists\n", in->len, in->s);
        return -1;
      }
    }
    pvj = pvi;
    pvi = pvi->next;
  }

  pvn = (pv_extra_t*)pkg_malloc(sizeof(pv_extra_t));
  if(pvn==0)
  {
    LM_ERR("no more memory\n");
    return -1;
  }
  memcpy(&pvn->pve, e, sizeof(*e));
  pvn->pve.type += PVT_EXTRA;

  if(pvj==0)
  {
    pvn->next = *_pv_extra_list;
    *_pv_extra_list = pvn;
    goto done;
  }
  pvn->next = pvj->next;
  pvj->next = pvn;

done:
  return 0;
}

int register_pvars_mod(const char *mod_name, const pv_export_t *items)
{
  int ret;
  int i;

  if (items==0)
    return 0;

  for ( i=0 ; items[i].name.s ; i++ ) {
    ret = pv_add_extra(&items[i]);
    if (ret!=0) {
      LM_ERR("failed to register pseudo-variable <%.*s> for module %s\n",
          items[i].name.len, items[i].name.s, mod_name);
    }
  }
  return 0;
}

/**
 *
 */
int pv_free_extra_list(void)
{
  pv_extra_p xe;
  pv_extra_p xe1;
  if(_pv_extra_list!=0)
  {
    xe = *_pv_extra_list;
    while(xe!=0)
    {
      xe1 = xe;
      xe = xe->next;
      pkg_free(xe1);
    }
    pkg_free(_pv_extra_list);
    _pv_extra_list = 0;
  }

  return 0;
}

static pv_context_t* new_pv_context(const str* name, pv_contextf_t get_context)
{
  pv_context_t* pvc_new = NULL;
  int size;
/*
  if(get_context == NULL)
  {
    LM_ERR("NULL pointer to function\n");
    return 0;
  }
*/
  size = sizeof(pv_context_t) + name->len;
  pvc_new = (pv_context_t*)pkg_malloc(size);
  if(pvc_new == NULL)
  {
    LM_ERR("No more memory\n");
    return 0;
  }
  memset(pvc_new, 0, size);

  pvc_new->name.s = (char*)pvc_new + sizeof(pv_context_t);
  memcpy(pvc_new->name.s, name->s, name->len);
  pvc_new->name.len = name->len;

  pvc_new->contextf = get_context;

  return pvc_new;
}

int register_pv_context(char* cname, pv_contextf_t get_context)
{
  pv_context_t* pvc = pv_context_lst;
  str name;

  if(cname == NULL)
  {
    LM_DBG("NULL parameter\n");
    return -1;
  }

  name.s = cname;
  name.len = strlen(cname);

  LM_DBG("Registered new context: %.*s / %p\n", name.len, name.s, get_context);
  pvc = pv_get_context(&name);
  if(pvc == NULL)
  {
    LM_DBG("Context not found\n");
    if(add_pv_context(&name, get_context) == NULL)
    {
      LM_ERR("Failed to add context\n");
      return -1;
    }
    return 1;
  }

  if(pvc->contextf!=NULL)
  {
    LM_ERR("Context already registered [%s]\n", cname);
    return -1;
  }
  if(get_context == NULL)
  {
    LM_ERR("NULL context getter function\n");
    return -1;
  }
  pvc->contextf= get_context;
  return 1;
}


/* function to register a pv context getter */
static pv_context_t* add_pv_context(const str* name, pv_contextf_t get_context)
{
  pv_context_t* pvc = pv_context_lst;
  pv_context_t* pvc_new, *pvc_prev;

  if(pvc == NULL)
  {
    pvc_new = new_pv_context(name, get_context);
    if(pvc_new == NULL)
    {
      LM_ERR("Failed to allocate context\n");
      return 0;
    }
    pv_context_lst = pvc_new;
    return pvc_new;
  }

  while(pvc)
  {
    if(pvc->name.len == name->len && strncmp(pvc->name.s, name->s, name->len)==0)
    {
      LM_ERR("PV Context already registered [%.*s]\n", name->len, name->s);
      return 0;
    }
    pvc_prev = pvc;
    pvc = pvc->next;
  }

  pvc_new = new_pv_context(name, get_context);
  if(pvc_new == NULL)
  {
    LM_ERR("Failed to allocate context\n");
    return 0;
  }

  LM_DBG("Registered new context: %.*s\n", name->len, name->s);

  pvc_prev->next = pvc_new;

  return pvc_new;
}

static pv_context_t* pv_get_context(const str* name)
{
  pv_context_t* pvc = pv_context_lst;

  while(pvc)
  {
    if(pvc->name.len == name->len &&
        strncmp(pvc->name.s, name->s, name->len) == 0)
    {
      return pvc;
    }
    pvc = pvc->next;
  }
  return 0;
}

static int pv_contextlist_check(void)
{
  pv_context_t* pvc = pv_context_lst;

  while(pvc)
  {
    if(pvc->contextf == NULL)
      return -1;

    pvc = pvc->next;
  }
  pvc_before_check = 0;
  return 0;
}

/* argument options '-o' */
argv_p argv_vars = NULL;

static argv_p search_argv(const str *name)
{
  argv_p it;

  for (it = argv_vars; it; it = it->next) {
    if (it->name.len == name->len &&
        !strncmp(it->name.s, name->s, name->len))
      return it;
  }
  return 0;
}

int add_arg_var(char *opt)
{
  char *eq;
  str name;
  argv_p new = NULL;

  if (!opt) {
    LM_ERR("cannot receive null option\n");
    return -1;
  }

  eq = strchr(opt, '=');
  if (!eq) {
    LM_ERR("invalid option format - '=' char cannot be found\n");
    return -1;
  }
  if (eq <= opt) {
    LM_ERR("no option name specified\n");
    return -1;
  }

  name.s = opt;
  name.len = eq - name.s;

  /* check for duplicate option name */
  if (search_argv(&name)) {
    LM_ERR("duplicate option name <%.*s>\n", name.len, name.s);
    return -1;
  }

  new = (argv_p)pkg_malloc(sizeof(argv_t));
  if (!new) {
    LM_ERR("no more pkg memory\n");
    return -1;
  }
  memset(new, 0, sizeof(argv_t));

  new->name.s = name.s;
  new->name.len = name.len;

  new->value.s = eq+1;
  new->value.len = strlen(opt) + opt - new->value.s;

  if (!new->value.len)
    new->value.s = 0;

  new->next = argv_vars;
  argv_vars = new;

  LM_DBG("added argument name <%.*s> = <%.*s>\n",
      name.len, name.s, new->value.len, new->value.s);
  return 0;

}

static int pv_parse_argv_name(pv_spec_p sp, const str *in)
{
  argv_p v_arg;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;

  v_arg = search_argv(in);
  if (!v_arg) {
    LM_DBG("$argv(%.*s) not found\n", in->len, in->s);
    sp->pvp.pvv.len = 0;
    sp->pvp.pvv.s = 0;
  } else {
    sp->pvp.pvv = v_arg->value;
    sp->pvp.pvn.u.isname.name.s = v_arg->name;
  }

  sp->pvp.pvn.type = PV_NAME_PVAR;

  return 0;
}

static int pv_get_argv(struct sip_msg *msg,  pv_param_t *param, pv_value_t *res)
{
  if (!param) {
    LM_ERR("null parameter received\n");
    return -1;
  }

  if (param->pvv.len == 0 || !param->pvv.s)
    return pv_get_null(msg, param, res);

  return pv_get_strval(msg, param, res, &param->pvv);
}

static int pv_parse_param_name(pv_spec_p sp, const str *in)
{
  char *p;
  char *s;
  pv_spec_p nsp = 0;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;
  p = in->s;
  if(*p==PV_MARKER)
  {
    nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
    if(nsp==NULL)
    {
      LM_ERR("no more memory\n");
      return -1;
    }
    s = pv_parse_spec(in, nsp);
    if(s==NULL)
    {
      LM_ERR("invalid name [%.*s]\n", in->len, in->s);
      pv_spec_free(nsp);
      return -1;
    }
    sp->pvp.pvn.type = PV_NAME_PVAR;
    sp->pvp.pvn.u.dname = (void*)nsp;
    return 0;
  }
  /*LM_DBG("static name [%.*s]\n", in->len, in->s);*/
  /* always an int type from now */
  sp->pvp.pvn.u.isname.type = 0;
  sp->pvp.pvn.type = PV_NAME_INTSTR;
  /* do our best to convert it to an index */
  if (str2int(in, (unsigned int *)&sp->pvp.pvn.u.isname.name.n) < 0)
  {
    /* remember it was a string, so we can retrieve it later */
    sp->pvp.pvn.u.isname.name.s = *in;
    sp->pvp.pvn.u.isname.type = AVP_NAME_STR;
  }
  return 0;

}

static int pv_parse_return_value(pv_spec_p sp, const str *in)
{
  char *p;
  char *s;
  pv_spec_p nsp = 0;

  if(in==NULL || in->s==NULL || sp==NULL)
    return -1;
  p = in->s;
  if(*p==PV_MARKER)
  {
    nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
    if(nsp==NULL)
    {
      LM_ERR("no more memory\n");
      return -1;
    }
    s = pv_parse_spec(in, nsp);
    if(s==NULL)
    {
      LM_ERR("invalid name [%.*s]\n", in->len, in->s);
      pv_spec_free(nsp);
      return -1;
    }
    sp->pvp.pvn.type = PV_NAME_PVAR;
    sp->pvp.pvn.u.dname = (void*)nsp;
    return 0;
  }
  sp->pvp.pvn.u.isname.type = 0;
  sp->pvp.pvn.type = PV_NAME_INTSTR;
  /* do our best to convert it to an index */
  if (str2int(in, (unsigned int *)&sp->pvp.pvn.u.isname.name.n) < 0) {
    LM_ERR("could not convert index to int!\n");
    return -1;
  }
  return 0;

}

static int pv_get_param(struct sip_msg *msg,  pv_param_t *ip, pv_value_t *res)
{
  if (!ip)
  {
    LM_ERR("null parameter received\n");
    return -1;
  }
  return route_params_run(msg, ip, res);
}

void destroy_argv_list(void)
{
  argv_p arg;

  while (argv_vars) {
    arg = argv_vars;
    argv_vars = argv_vars->next;
    pkg_free(arg);
  }
}

Coverage Report

Created: 2026-04-12 06:51