/**

* $Id: items.c 2715 2007-09-05 15:31:50Z miconda $

*

* Copyright (C) 2001-2003 FhG Fokus

* Copyright (C) 2005 Voice Sistem SRL

*

* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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)

*/

#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 "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"

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

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 };

static str str_null = { "<null>", 6 };

static str str_empty = { "", 0 };

static str str_udp = { "UDP", 3 };

static str str_5060 = { "5060", 4 };

unsigned int _pv_msg_id = 0;

time_t _pv_msg_tm = 0;

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];

/********** 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 = int2str(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)

*/

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)

*/

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_udp(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)

{

return pv_get_strintval(msg, param, res, &str_udp, (int)PROTO_UDP);

}

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

{

return pv_get_strintval(msg, param, res, &str_5060, 5060);

}

int pv_update_time(struct sip_msg *msg, time_t *t)

{

if(_pv_msg_id != msg->id || _pv_msg_tm==0)

{

_pv_msg_tm = time(NULL);

_pv_msg_id = msg->id;

if(t!=NULL)

*t=_pv_msg_tm;

return 1;

}

if(t!=NULL)

*t=_pv_msg_tm;

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_times(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

if(msg==NULL)

return -1;

pv_update_time(msg, NULL);

return pv_get_uintval(msg, param, res, (unsigned int)_pv_msg_tm);

}

static int pv_get_timef(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

str s;

if(msg==NULL)

return -1;

pv_update_time(msg, NULL);

s.s = ctime(&_pv_msg_tm);

s.len = strlen(s.s)-1;

return pv_get_strintval(msg, param, res, &s, (int)_pv_msg_tm);

}

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 doesnt 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_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 doesnt 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)

{

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_5060(msg, param, res);

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)

return pv_get_udp(msg, param, res);

return pv_get_strintval(msg, param, res, &parsed_uri->transport,

(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 doesnt 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 doesnt 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_contact(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

if(msg==NULL)

return -1;

if(msg->contact==NULL && parse_headers(msg, HDR_CONTACT_F, 0)==-1)

{

LM_DBG("no contact header\n");

return pv_get_null(msg, param, res);

}

if(!msg->contact || !msg->contact->body.s || msg->contact->body.len<=0)

{

LM_DBG("no contact header!\n");

return pv_get_null(msg, param, res);

}

// res->s = ((struct to_body*)msg->contact->parsed)->uri.s;

// res->len = ((struct to_body*)msg->contact->parsed)->uri.len;

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

}

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);

}

return 0;

}

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)

{

if(msg==NULL)

return -1;

return pv_get_uintval(msg, param, res, msg->flags);

}

static inline char* int_to_8hex(int val)

{

unsigned short digit;

int i;

static char outbuf[9];

outbuf[8] = '\0';

for(i=0; i<8; i++)

{

if(val!=0)

{

digit = val & 0x0f;

outbuf[7-i] = digit >= 10 ? digit + 'a' - 10 : digit + '0';

val >>= 4;

}

else

outbuf[7-i] = '0';

}

return outbuf;

}

static int pv_get_hexflags(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

str s;

if(msg==NULL || res==NULL)

return -1;

s.s = int_to_8hex(msg->flags);

s.len = 8;

return pv_get_strintval(msg, param, res, &s, (int)msg->flags);

}

static int pv_get_bflags(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

return pv_get_uintval(msg, param, res, getb0flags());

}

static int pv_get_hexbflags(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

str s;

if(res==NULL)

return -1;

s.s = int_to_8hex((int)getb0flags());

s.len = 8;

return pv_get_strintval(msg, param, res, &s, (int)getb0flags());

}

static int pv_get_sflags(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

return pv_get_uintval(msg, param, res, getsflags());

}

static int pv_get_hexsflags(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

str s;

if(res==NULL)

return -1;

s.s = int_to_8hex((int)getsflags());

s.len = 8;

return pv_get_strintval(msg, param, res, &s, (int)getsflags());

}

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;

s.s = ip_addr2a(&msg->rcv.src_ip);

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_rcvip(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

if(msg==NULL)

return -1;

if(msg->rcv.bind_address==NULL

|| msg->rcv.bind_address->address_str.s==NULL)

return pv_get_null(msg, param, res);

return pv_get_strval(msg, param, res, &msg->rcv.bind_address->address_str);

}

static int pv_get_rcvport(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

if(msg==NULL)

return -1;

if(msg->rcv.bind_address==NULL

|| msg->rcv.bind_address->port_no_str.s==NULL)

return pv_get_null(msg, param, res);

return pv_get_intstrval(msg, param, res,

(int)msg->rcv.bind_address->port_no,

&msg->rcv.bind_address->port_no_str);

}

static int pv_get_force_sock(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

if(msg==NULL)

return -1;

if (msg->force_send_socket==0)

return pv_get_null(msg, param, res);

return pv_get_strval(msg, param, res, &msg->force_send_socket->sock_str);

}

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));

}

/* proto of received message: $pr or $proto*/

static int pv_get_proto(struct sip_msg *msg, pv_param_t *param,

pv_value_t *res)

{

str s;

if(msg==NULL)

return -1;

switch(msg->rcv.proto)

{

case PROTO_UDP:

s.s = "udp";

s.len = 3;

break;

case PROTO_TCP:

s.s = "tcp";

s.len = 3;

break;

case PROTO_TLS:

s.s = "tls";

s.len = 3;

break;

case PROTO_SCTP:

s.s = "sctp";

s.len = 4;

break;

default:

s.s = "NONE";

s.len = 4;

}

return pv_get_strintval(msg, param, res, &s, (int)msg->rcv.proto);

}

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;