select_core.c
a0fb4e8b
 /*
  * $Id$
  *
  * Copyright (C) 2005-2006 iptelorg GmbH
  *
  * This file is part of ser, a free SIP server.
  *
  * ser 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
  *
  * For a license to use the ser software under conditions
  * other than those described here, or to purchase support for this
  * software, please contact iptel.org by e-mail at the following addresses:
  *    info@iptel.org
  *
  * ser 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:
  * --------
  *  2005-12-19  select framework, basic core functions (mma)
43f88e4f
  *  2006-01-19  multiple nested calls, IS_ALIAS -> NESTED flag renamed (mma)
b9e4bf3f
  *  2006-02-17  fixup call for select_anyhdr (mma)
e7317b87
  *  2007-01-26  date, identity, identity_info support added (gergo)
a0fb4e8b
  */
 
1d0661db
 /*!
  * \file
  * \brief SIP-router core :: 
  * \ingroup core
  * Module: \ref core
  */
 
7e381ae0
 #include <stdlib.h> 
3fb428ed
 #include "select.h"
 #include "select_core.h"
8c5e4afe
 #include "select_buf.h"
d6f89ee4
 #include "dprint.h"
 #include "trim.h"
3917797b
 #include "ut.h"
4bb044d3
 #include "globals.h"
84b87bd3
 #include "parser/parser_f.h"
d6f89ee4
 #include "parser/hf.h"
 #include "parser/parse_from.h"
 #include "parser/parse_to.h"
 #include "parser/contact/parse_contact.h"
 #include "parser/contact/contact.h"
 #include "parser/parse_via.h"
 #include "parser/parse_uri.h"
750057b9
 #include "parser/parse_event.h"
 #include "parser/parse_rr.h"
3917797b
 #include "parser/digest/digest.h"
b9e4bf3f
 #include "mem/mem.h"
 #include "parser/parse_hname2.h"
c51c5eb6
 #include "ip_addr.h"
7e381ae0
 #include "parser/parse_expires.h"
 #include "parser/parse_refer_to.h"
 #include "parser/parse_rpid.h"
6f2858cb
 #include "parser/parse_content.h"
 #include "parser/parse_body.h"
7e381ae0
 #include "dset.h"
ebf528da
 #include "sr_module.h"
3d55e464
 #include "resolve.h"
 #include "forward.h"
d6f89ee4
 
7e381ae0
 #define RETURN0_res(x) {*res=(x);return 0;}
 #define TRIM_RET0_res(x) {*res=(x);trim(res);return 0;} 
 #define TEST_RET_res_body(x) if (x){*res=(x)->body;return 0;}else return 1;
 #define TEST_RET_res_value(x) if (x){*res=(x)->value;return 0;}else return 1;
ec26bb71
 
04023b50
 int select_ruri(str* res, select_t* s, struct sip_msg* msg)
 {
3e004cca
 	/* Parse the RURI even if it is not needed right now
 	 * because the nested select calls can access the
 	 * parsed URI in this case.
 	 * Go ahead even if the parsing fails, so the
 	 * value of the broken RURI can be accessed at least.
 	 * Subsequent select calls will fail when they try to parse
 	 * the URI anyway. (Miklos)
 	 */
 	parse_sip_msg_uri(msg);
 
8321667b
 	if (msg->parsed_uri_ok)
 		select_uri_p = &msg->parsed_uri;
 
04023b50
 	if (msg->first_line.type==SIP_REQUEST) {
db0e6aa3
 		if(msg->new_uri.s) {
 			RETURN0_res(msg->new_uri);
 		}
 		else {
 			RETURN0_res(msg->first_line.u.request.uri);
eea15f43
 		}
 	}
 	return -1;
 }
 
 int select_dst_uri(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (msg->first_line.type!=SIP_REQUEST)
 		return -1;
 	RETURN0_res(msg->dst_uri);
 }
 
 int select_next_hop(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (msg->first_line.type==SIP_REQUEST) {
 		if(msg->dst_uri.s) {
 			RETURN0_res(msg->dst_uri);
 		}
 		else if(msg->new_uri.s) {
8321667b
 			if (msg->parsed_uri_ok)
 				select_uri_p = &msg->parsed_uri;
eea15f43
 			RETURN0_res(msg->new_uri);
 		}
 		else {
8321667b
 			if (msg->parsed_uri_ok)
 				select_uri_p = &msg->parsed_uri;
 			else if (msg->parsed_orig_ruri_ok)
 				select_uri_p = &msg->parsed_orig_ruri;
eea15f43
 			RETURN0_res(msg->first_line.u.request.uri);
db0e6aa3
 		}
04023b50
 	}
ec26bb71
 	return -1;
04023b50
 }
 
3d55e464
 int select_next_hop_src_ip(str* res, select_t* s, struct sip_msg* msg) {
 	struct socket_info* socket_info;
 	union sockaddr_union to;
 	char proto;
 	struct sip_uri *u, next_hop;
 	str *dst_host;
 
 	if (msg->first_line.type!=SIP_REQUEST) 
 		return -1;
 
 	if (msg->force_send_socket) {
 		*res = msg->force_send_socket->address_str;
 		return 0;
 	}
 
 	if (msg->dst_uri.len) {
 		if (parse_uri(msg->dst_uri.s, msg->dst_uri.len, &next_hop) < 0)
 			return -1;
 		u = &next_hop;
 	}
 	else {
 		if (parse_sip_msg_uri(msg) < 0)
 			return -1;
 		u = &msg->parsed_uri;
 	}
 #ifdef USE_TLS
 	if (u->type==SIPS_URI_T)
 		proto = PROTO_TLS;
 	else
 #endif
 		proto = u->proto;
 
 #ifdef HONOR_MADDR
 	if (u->maddr_val.s && u->maddr_val.len)
 		dst_host = &u->maddr_val;
 	else
 #endif
 		dst_host = &u->host;
 
 	if (sip_hostport2su(&to, dst_host, u->port_no, &proto) < 0)
 		return -1;
 	socket_info = get_send_socket(msg, &to, proto);
 	if (!socket_info)
 		return -1;
 
 	*res = socket_info->address_str;
 	return 0;
 }
 
7e381ae0
 #define SELECT_uri_header(_name_) \
 int select_##_name_(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	if (parse_##_name_##_header(msg)<0) \
 		return -1; \
 	RETURN0_res(msg->_name_->body); \
 } \
 \
 int select_##_name_##_uri(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	if (parse_##_name_##_header(msg)<0) \
 		return -1; \
 	RETURN0_res(get_##_name_(msg)->uri); \
 } \
 \
 int select_##_name_##_tag(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	if (parse_##_name_##_header(msg)<0) \
 		return -1; \
 	RETURN0_res(get_##_name_(msg)->tag_value); \
 } \
 \
 int select_##_name_##_name(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	if (parse_##_name_##_header(msg)<0) \
 		return -1; \
 	RETURN0_res(get_##_name_(msg)->display); \
 } \
 \
 int select_##_name_##_params(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	struct to_param* p; \
 	if (parse_##_name_##_header(msg)<0) \
 		return -1; \
 	\
 	p = get_##_name_(msg)->param_lst; \
 	while (p) { \
 		if ((p->name.len==s->params[s->n-1].v.s.len) \
 		    && !strncasecmp(p->name.s, s->params[s->n-1].v.s.s,p->name.len)) { \
 			RETURN0_res(p->value); \
 		} \
 		p = p->next; \
 	} \
 	return 1; \
 } 
d6f89ee4
 
7e381ae0
 SELECT_uri_header(to)
 SELECT_uri_header(from)
 SELECT_uri_header(refer_to)
 SELECT_uri_header(rpid)
d6f89ee4
 
 int parse_contact_header( struct sip_msg *msg)
 {
         if ( !msg->contact && ( parse_headers(msg,HDR_CONTACT_F,0)==-1 || !msg->contact)) {
bed413b7
                 DBG("bad msg or missing CONTACT header\n");
d6f89ee4
                 return -1;
         }
 
         if (msg->contact->parsed)
                 return 0;
 
 	return parse_contact(msg->contact);
 }
 
 #define get_contact(msg) ((contact_body_t*)(msg->contact->parsed))
 
 int select_contact(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (parse_contact_header(msg)<0)
 		return -1;
 	RETURN0_res(msg->contact->body);
 }
 
 int select_contact_uri(str* res, select_t* s, struct sip_msg* msg)
 {
 	contact_t* c;
 	if (parse_contact_header(msg)<0)
 		return -1;
 	
 	c = get_contact(msg)->contacts;
 	if (!c)
 		return 1;
 	RETURN0_res(c->uri);
 }
 
 int select_contact_name(str* res, select_t* s, struct sip_msg* msg)
 {
 	contact_t* c;
 	if (parse_contact_header(msg)<0)
 		return -1;
 	
 	c = get_contact(msg)->contacts;
 	if (!c)
 		return 1;
 	RETURN0_res(c->name);
 }
 
 int select_contact_params_spec(str* res, select_t* s, struct sip_msg* msg)
 {
 	contact_t* c;
 	
ec2b7f55
 	if (s->params[s->n-1].type != SEL_PARAM_DIV) {
d6f89ee4
 		BUG("Last parameter should have type DIV (converted)\n");
 		return -1;
 	}
 	
 	if (parse_contact_header(msg)<0)
 		return -1;
 	
 	c = get_contact(msg)->contacts;
 	if (!c)
 		return 1;
 	
 	switch (s->params[s->n-1].v.i) {
 	case SEL_PARAM_Q:
 		TEST_RET_res_body(c->q);
 	case SEL_PARAM_EXPIRES:
 		TEST_RET_res_body(c->expires);
b4fb73d0
 	case SEL_PARAM_METHODS:
 		TEST_RET_res_body(c->methods);
d6f89ee4
 	case SEL_PARAM_RECEIVED:
 		TEST_RET_res_body(c->received);
 	case SEL_PARAM_INSTANCE:
 		TEST_RET_res_body(c->instance);
 	default:
 		BUG("Unexpected parameter value \"%d\"\n", s->params[s->n-1].v.i);
 		return -1;
 	}
 	return -1;
 }
 
 int select_contact_params(str* res, select_t* s, struct sip_msg* msg)
 {
 	contact_t* c;
 	param_t* p;
 	if (parse_contact_header(msg)<0)
 		return -1;
 	
 	c = get_contact(msg)->contacts;
 	if (!c)
 		return 1;
 	p = c->params;
 	while (p) {
 		if ((p->name.len==s->params[s->n-1].v.s.len)
 		    && !strncasecmp(p->name.s, s->params[s->n-1].v.s.s,p->name.len)) {
 			RETURN0_res(p->body)
 		}
 		p = p->next;
 	}
 	return 1;
 }
 
 int select_via(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
511841b7
 	if ((s->n == 1) || (s->params[1].type == SEL_PARAM_STR)) {
 		if (parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	res->s=p->name.s;
 	res->len=p->bsize;
 	trim(res);
 	return 0;
 }
 
 int select_via_name(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if(parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->name);
 }
 
 int select_via_version(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if (parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->version);
 }
 
 int select_via_transport(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if(parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->transport);
 }
 
 int select_via_host(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if (parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->host);
 }
 
 int select_via_port(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if (parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->port_str);
 }
 
 int select_via_comment(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if(parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	RETURN0_res(p->comment);
 }
 
 int select_via_params(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 	struct via_param *q;
 
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type == SEL_PARAM_STR) {
 		if (parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	
 	for (q = p->param_lst;q;q=q->next) {
 		if ((q->name.len==s->params[s->n-1].v.s.len)
 		    && !strncasecmp(q->name.s, s->params[s->n-1].v.s.s,q->name.len)) {
 			RETURN0_res(q->value);
 		}
 	}
 	return 1;
 }
 
 int select_via_params_spec(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct via_body *p = NULL;
 
ec2b7f55
 	if (s->params[s->n-1].type != SEL_PARAM_DIV) {
d6f89ee4
 		BUG("Last parameter should have type DIV (converted)\n");
 		return -1;
 	}
 	
 	// it's not neccessary to test if (s->n > 1)
511841b7
 	if (s->params[1].type != SEL_PARAM_INT) {
 		if(parse_via_header(msg, 1, &p)<0) return -1;
 	} else if (parse_via_header(msg, s->params[1].v.i, &p)<0) return -1;
d6f89ee4
 	if (!p) return -1;
 	
 	switch (s->params[s->n-1].v.i) {
 	case SEL_PARAM_BRANCH:
 		TEST_RET_res_value(p->branch);
 	case SEL_PARAM_RECEIVED:
 		TEST_RET_res_value(p->received);
 	case SEL_PARAM_RPORT:
 		TEST_RET_res_value(p->rport);
 	case SEL_PARAM_I:
 		TEST_RET_res_value(p->i);
 	case SEL_PARAM_ALIAS:
 		TEST_RET_res_value(p->alias);
 	default:
 		BUG("Unexpected parameter value \"%d\"\n", s->params[s->n-1].v.i);
 		return -1;
 	}
 	return -1;
 }
 
7e381ae0
 int select_msg(str* res, select_t* s, struct sip_msg* msg)
d6f89ee4
 {
7e381ae0
 	res->s = msg->buf;
 	res->len = msg->len;
 	return 0;
 }
 
 int select_msg_first_line(str* res, select_t* s, struct sip_msg* msg) 
 {
2c99a29d
 	res->s=SIP_MSG_START(msg);
 	res->len=msg->first_line.len;
 	trim_trailing(res);
 	return 0;
7e381ae0
 }
 
 int select_msg_type(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, msg->first_line.type);
 } 
 
 int select_msg_len(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, msg->len);
 }
 
 int select_msg_id(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, msg->id);
 }
 
 int select_msg_id_hex(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer_ex(res, msg->id, 16, 8);
 }
 
 int select_msg_flags(str* res, select_t* s, struct sip_msg* msg) { 
 	return uint_to_static_buffer(res, msg->flags);
 } 
 
 int select_msg_body(str* res, select_t* s, struct sip_msg* msg)
 {
 	res->s = get_body(msg);
 	res->len = msg->buf+msg->len - res->s;
 	return 0;	
 }
 
14b41ee3
 /* returns the sdp part of the message body */
6f2858cb
 int select_msg_body_sdp(str* res, select_t* sel, struct sip_msg* msg)
 {
 	/* try to get the body part with application/sdp */
 	if ((res->s = get_body_part(msg,
 				TYPE_APPLICATION, SUBTYPE_SDP,
 				&res->len))
 	)
 		return 0;
 	else
 		return -1;
 }
 
14b41ee3
 /* returns the value of the requested SDP line */
54b827f3
 int select_sdp_line(str* res, select_t* sel, struct sip_msg* msg)
 {
 	int	len;
 	char	*buf;
 	char	*buf_end, *line_end;
 	char	line;
 
 	if (msg == NULL) {
 		if (res!=NULL) return -1;
 		if (sel->n < 5) return -1;
 
 		if (sel->params[4].type != SEL_PARAM_STR) {
 			ERR("wrong parameter type");
 			return -1;
 		}
 		if ((sel->params[4].v.s.len < 1) ||
 			(sel->params[4].v.s.len > 2) ||
 			((sel->params[4].v.s.len == 2) && (sel->params[4].v.s.s[1] != '='))
 		) {
 			ERR("wrong sdp line format: %.*s\n",
 				sel->params[4].v.s.len, sel->params[4].v.s.s);
 			return -1;
 		}
 		return 0;
 	}
 
 	/* try to get the body part with application/sdp */
 	if (!(buf = get_body_part(msg,
 				TYPE_APPLICATION, SUBTYPE_SDP,
 				&len))
 	)
 		return -1;
 
 	buf_end = buf + len;
 	line = *(sel->params[4].v.s.s);
 
 	while (buf < buf_end) {
 		if (*buf == line) {
 			/* the requested SDP line is found, return its value */
14b41ee3
 			buf++;
 			if ((buf >= buf_end) || (*buf != '=')) {
 				ERR("wrong SDP line format\n");
 				return -1;
 			}
 			buf++;
 
54b827f3
 			line_end = buf;
 			while ((line_end < buf_end) && (*line_end != '\n'))
 				line_end++;
 
 			if (line_end >= buf_end) {
 				ERR("wrong SDP line format\n");
 				return -1;
 			}
 			line_end--;
 			if (*line_end == '\r') line_end--;
 
 			if (line_end < buf) {
 				ERR("wrong SDP line format\n");
 				return -1;
 			}
 
 			res->s = buf;
 			res->len = line_end - buf + 1;
 			return 0;
 		}
 		while ((buf < buf_end) && (*buf != '\n'))
 			buf++;
 		buf++;
 	}
 
 	return -1;
 }
 
7e381ae0
 int select_msg_header(str* res, select_t* s, struct sip_msg* msg)
 {
 	/* get all headers */
 	char *c;
2c99a29d
 	res->s = SIP_MSG_START(msg) + msg->first_line.len; 
7e381ae0
 	c = get_body(msg);
 	res->len = c - res->s;
 	return 0;
d6f89ee4
 }
 
 int select_anyheader(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct hdr_field *hf, *hf0;
 	int hi;
b9e4bf3f
 	char c;
 	struct hdr_field hdr;
d6f89ee4
 	
b9e4bf3f
 	if(msg==NULL) {
 		if (res!=NULL) return -1;
 
 		/* "fixup" call, res & msg are NULL */
7e381ae0
 		if (s->n <3) return -1;
b9e4bf3f
 
7e381ae0
 		if (s->params[2].type==SEL_PARAM_STR) {
b9e4bf3f
 				/* replace _ with - (for P-xxx headers) */
7e381ae0
 			for (hi=s->params[2].v.s.len-1; hi>0; hi--)
 				if (s->params[2].v.s.s[hi]=='_')
 					s->params[2].v.s.s[hi]='-';
b9e4bf3f
 				/* if header name is parseable, parse it and set SEL_PARAM_DIV */
7e381ae0
 			c=s->params[2].v.s.s[s->params[2].v.s.len];
 			s->params[2].v.s.s[s->params[2].v.s.len]=':';
 			if (parse_hname2(s->params[2].v.s.s,s->params[2].v.s.s+(s->params[2].v.s.len<3?4:s->params[2].v.s.len+1),
b9e4bf3f
 						&hdr)==0) {
 				ERR("select_anyhdr:fixup_call:parse error\n");
 				return -1;
 			}
7e381ae0
 			s->params[2].v.s.s[s->params[2].v.s.len]=c;
b9e4bf3f
 			
 			if (hdr.type!=HDR_OTHER_T && hdr.type!=HDR_ERROR_T) {
5823b2f7
 				/* pkg_free(s->params[1].v.s.s); */
 				/* don't free it (the mem can leak only once at startup)
 				 * the parsed string can live inside larger string block
 				 * e.g. when xlog's select is parsed
 				 */
7e381ae0
 				s->params[2].type = SEL_PARAM_DIV;
 				s->params[2].v.i = hdr.type;
b9e4bf3f
 			}
 		}
 		return 1;
 	}
d6f89ee4
 
 	hf0 = NULL;
 
 	/* extract header index if present */
559cb457
 	if (s->param_offset[select_level+1] == 4) {
7e381ae0
 		if (s->params[3].type == SEL_PARAM_INT) {
 			hi = s->params[3].v.i;
d6f89ee4
 		} else {
 			hi = -1;
 		}
 	} else {
 		hi = 1;
 	}
 
 	/* we need to be sure we have parsed all headers */
 	if (!msg->eoh && (parse_headers(msg,HDR_EOH_F,0)==-1 || !msg->eoh)) {
 		ERR("bad msg while parsing to EOH \n");
 		return -1;
 	}
 	for (hf=msg->headers; hf; hf=hf->next) {
7e381ae0
 		if(s->params[2].type==SEL_PARAM_DIV) {
 			if (s->params[2].v.i!=hf->type)	continue;
 		} else if(s->params[2].type==SEL_PARAM_STR) {
 			if (s->params[2].v.s.len!=hf->name.len)	continue;
 			if (strncasecmp(s->params[2].v.s.s, hf->name.s, hf->name.len)!=0) continue;
d6f89ee4
 		}
 		hf0 = hf;
 		hi--;
 		if (!hi) break;
 	}
 	if(hf0==NULL || hi>0)
 		return 1;
 	res->s = hf0->body.s;
 	res->len = hf0->body.len;
 	trim(res);
 	return 0;
 }
 
7e381ae0
 //ABSTRACT_F(select_anyheader_params)
 // Instead of ABSTRACT_F(select_anyheader_params)
 // use function which uses select_core_table
 // to avoid gcc warning about not used
  
 int select_anyheader_params(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (select_core_table.next)
 		return -1;
 	else
 		return -1;
 }
 
d6f89ee4
 ABSTRACT_F(select_any_uri)
 
04023b50
 static struct sip_uri uri;
 
d6f89ee4
 int select_uri_type(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		trim(res);
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
d6f89ee4
 
8321667b
 	if (select_uri_p->type==ERROR_URI_T)
d6f89ee4
 		return -1;
9b1ad373
 
8321667b
 	uri_type_to_str(select_uri_p->type, res);
d6f89ee4
 	return 0;
 }
 
 int select_uri_user(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
d6f89ee4
 
8321667b
 	if (select_uri_p->flags & URI_USER_NORMALIZE) {
 		if (!(res->s=get_static_buffer(select_uri_p->user.len)))
9b1ad373
 			return -1;
8321667b
 		if ((res->len=normalize_tel_user(res->s, (&select_uri_p->user)))==0)
9b1ad373
 			return 1;
 		return 0;
 	}
8321667b
 	RETURN0_res(select_uri_p->user);
d6f89ee4
 }
 
c98100c7
 /* search for a parameter with "name"
  * Return value:
  *	0: not found
  *	1: found
  *	-1: error
  *
  * val is set to the value of the parameter.
  */
21ba29a1
 static inline int search_param(str params, char *name, int name_len,
c98100c7
 				str *val)
 {
 	param_hooks_t h;
 	param_t *p, *list;
 
21ba29a1
 	if (params.s == NULL)
c98100c7
 		return 0;
 
21ba29a1
 	if (parse_params(&params, CLASS_ANY, &h, &list) < 0)
c98100c7
 		return -1;
 	for (p = list; p; p=p->next) {
 		if ((p->name.len == name_len)
 			&& (strncasecmp(p->name.s, name, name_len) == 0)
 		) {
 			*val=p->body;
 			free_params(list);
 			return 1;
 		}
 	}
 	free_params(list);
 	return 0;
 }
 
 /* Return the value of the "rn" parameter if exists, otherwise the user name.
  * The user name is normalized if needed, i.e. visual separators are removed,
  * the "rn" param is always normalized. */
 int select_uri_rn_user(str* res, select_t* s, struct sip_msg* msg)
 {
 	int	ret;
 	str	val;
 
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
c98100c7
 
 	/* search for the "rn" parameter */
21ba29a1
 	if ((ret = search_param(select_uri_p->params, "rn", 2, &val)) != 0)
c98100c7
 		goto done;
 
8321667b
 	if (select_uri_p->sip_params.s != select_uri_p->params.s) {
c98100c7
 		/* check also the original sip: URI parameters */
21ba29a1
 		if ((ret = search_param(select_uri_p->sip_params, "rn", 2, &val)) != 0)
c98100c7
 			goto done;
 	}
 
8321667b
 	if ((select_uri_p->flags & URI_USER_NORMALIZE) == 0)
 		RETURN0_res(select_uri_p->user);
c98100c7
 	/* else normalize the user name */
8321667b
 	val = select_uri_p->user;
c98100c7
 done:
 	if (ret < 0)
 		return -1; /* error */
 
 	if (!(res->s=get_static_buffer(val.len)))
 		return -1;
 	if ((res->len=normalize_tel_user(res->s, &val))==0)
 		return 1;
 	return 0;
 }
 
d6f89ee4
 int select_uri_pwd(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
d6f89ee4
 
8321667b
 	RETURN0_res(select_uri_p->passwd);
d6f89ee4
 }
 
 int select_uri_host(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
d6f89ee4
 
8321667b
 	RETURN0_res(select_uri_p->host);
d6f89ee4
 }
 
 int select_uri_port(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
d6f89ee4
 
8321667b
 	RETURN0_res(select_uri_p->port);
d6f89ee4
 }
 
8c5e4afe
 int select_uri_hostport(str* res, select_t* s, struct sip_msg* msg)
 {
 	char* p;
 	int size;
 	
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
8c5e4afe
 
8321667b
 	if (!select_uri_p->host.len)
8c5e4afe
 		return -1;
 	
8321667b
 	if (select_uri_p->port.len) {
 		res->s=select_uri_p->host.s;
 		res->len=select_uri_p->host.len+select_uri_p->port.len+1;
8c5e4afe
 		return 0;
 	}
 	
8321667b
 	size=select_uri_p->host.len+5;
8c5e4afe
 	if (!(p = get_static_buffer(size)))
 		return -1;
 			
8321667b
 	strncpy(p, select_uri_p->host.s, select_uri_p->host.len);
 	switch (select_uri_p->type) {
8c5e4afe
 		case SIPS_URI_T:
 		case TELS_URI_T:
8321667b
 			strncpy(p+select_uri_p->host.len, ":5061", 5); 
8c5e4afe
 			break;
 		case SIP_URI_T:
 		case TEL_URI_T:
9c9e5a33
 		case URN_URI_T:
8321667b
 			strncpy(p+select_uri_p->host.len, ":5060", 5);
8c5e4afe
 			break;
 		case ERROR_URI_T:
 			return -1;
 	}
 	res->s = p;
 	res->len = size;
 	return 0;
 }
 
f90ef683
 int select_uri_proto(str* res, select_t* s, struct sip_msg* msg)
 {
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
f90ef683
 
8321667b
 	if (select_uri_p->proto != PROTO_NONE) {
 		proto_type_to_str(select_uri_p->proto, res);
f90ef683
 	} else {
8321667b
 		switch (select_uri_p->type) {
f90ef683
 			case SIPS_URI_T:
 			case TELS_URI_T:
 				proto_type_to_str(PROTO_TLS, res);
 				break;
 			case SIP_URI_T:
 			case TEL_URI_T:
9c9e5a33
 			case URN_URI_T:
f90ef683
 				proto_type_to_str(PROTO_UDP, res);
 				break;
 			case ERROR_URI_T:
 				return -1;
 		}
 	}
 	return 0;
 }
 
d6f89ee4
 int select_uri_params(str* res, select_t* s, struct sip_msg* msg)
 {
948e083f
 	int	ret;
60c006fa
 	if (!msg || !res) {
 		return select_any_params(res, s, msg);
 	}
 
8321667b
 	if (select_uri_p == NULL) {
 		if (parse_uri(res->s, res->len, &uri)<0)
 			return -1;
 		select_uri_p = &uri;
 	}
60c006fa
 	
559cb457
 	if (s->param_offset[select_level+1]-s->param_offset[select_level]==1)
8321667b
 		RETURN0_res(select_uri_p->params);
60c006fa
 
8321667b
 	*res=select_uri_p->params;
948e083f
 	ret = select_any_params(res, s, msg);
 	if ((ret < 0)
8321667b
 		&& (select_uri_p->sip_params.s != NULL)
 		&& (select_uri_p->sip_params.s != select_uri_p->params.s)
948e083f
 	) {
 		/* Search also in the original sip: uri parameters. */
8321667b
 		*res = select_uri_p->sip_params;
948e083f
 		ret = select_any_params(res, s, msg);
 	}
 	return ret;
60c006fa
 }
 
 int select_any_params(str* res, select_t* s, struct sip_msg* msg)
 {
d0cf3d0b
 	str* wanted;
1ee35cdc
 	int i;
 
 	if (!msg || !res) {
559cb457
 		if (s->param_offset[select_level+1]-s->param_offset[select_level]==1) return 0;
 		if (s->params[s->param_offset[select_level]+1].type!=SEL_PARAM_STR) return -1;
 		wanted=&s->params[s->param_offset[select_level]+1].v.s;
1ee35cdc
 		for (i=0; i<wanted->len; i++) 
 			if (wanted->s[i]=='_') 
 				wanted->s[i]='-';
 		return 0;
 	}
d0cf3d0b
 	
559cb457
 	if (s->params[s->param_offset[select_level]+1].type!=SEL_PARAM_STR) return -1;
 	wanted=&s->params[s->param_offset[select_level]+1].v.s;
d0cf3d0b
 	
60c006fa
 	if (!res->len) return -1;
d0cf3d0b
 
21ba29a1
 	if (search_param(*res, wanted->s, wanted->len, res) <= 0) {
c98100c7
 		DBG("SELECT ...uri.params.%s NOT FOUND !\n", wanted->s);
 		return -1;
 	} else {
 		return (res->len) ? 0 : 1;
 	}
d6f89ee4
 }
3fb428ed
 
750057b9
 int select_event(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (!msg->event && parse_headers(msg, HDR_EVENT_F, 0) == -1) {
 		ERR("Error while searching Event header field\n");
 		return -1;
 	}
 
 	if (!msg->event) {
 		DBG("Event header field not found\n");
 		return -1;
 	}
 
 	if (parse_event(msg->event) < 0) {
 		ERR("Error while parsing Event header field\n");
 		return -1;
 	}
 
bf7bb14b
 	*res = ((event_t*)msg->event->parsed)->name;
750057b9
 	return 0;
 }
 
 
 
 static int parse_rr_header(struct sip_msg *msg)
 {
         if ( !msg->record_route && ( parse_headers(msg,HDR_RECORDROUTE_F,0) == -1)) {
                 ERR("bad msg or missing Record-Route header\n");
                 return -1;
         }
 
 	if (!msg->record_route) {
 		DBG("No Record-Route header field found\n");
 		return -1;
 	}
 
 	return parse_rr(msg->record_route);
 }
 
 #define get_rr(msg) ((rr_t*)(msg->record_route->parsed))
 
 
 int select_rr(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (parse_rr_header(msg)<0)
 		return -1;
 	RETURN0_res(msg->record_route->body);
 }
 
 int select_rr_uri(str* res, select_t* s, struct sip_msg* msg)
 {
 	rr_t* r;
 	if (parse_rr_header(msg)<0)
 		return -1;
 	
 	r = get_rr(msg);
 	if (!r)
 		return 1;
 	RETURN0_res(r->nameaddr.uri);
 }
 
 int select_rr_name(str* res, select_t* s, struct sip_msg* msg)
 {
 	rr_t* r;
 	if (parse_rr_header(msg)<0)
 		return -1;
 	
 	r = get_rr(msg);
 	if (!r)
 		return 1;
 	RETURN0_res(r->nameaddr.name);
 }
 
 int select_rr_params(str* res, select_t* s, struct sip_msg* msg)
 {
 	rr_t* r;
 	param_t* p;
 	if (parse_rr_header(msg)<0)
 		return -1;
 	
 	r = get_rr(msg);
 	if (!r)
 		return 1;
 	p = r->params;
 	while (p) {
 		if ((p->name.len==s->params[s->n-1].v.s.len)
 		    && !strncasecmp(p->name.s, s->params[s->n-1].v.s.s,p->name.len)) {
 			RETURN0_res(p->body)
 		}
 		p = p->next;
 	}
 	return 0;
 }
 
 
 static inline struct cseq_body* sel_parse_cseq(struct sip_msg* msg)
 {
         if (!msg->cseq && (parse_headers(msg, HDR_CSEQ_F, 0) == -1)) {
                 ERR("Unable to parse CSeq header\n");
                 return 0;
         }
 
 	if (!msg->cseq) {
 		DBG("No CSeqheader field found\n");
 		return 0;
 	}
 
 	return get_cseq(msg);
 }
 
 
 
 int select_cseq(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct cseq_body* cs;
 
 	cs = sel_parse_cseq(msg);
 	if (!cs) return -1;
 	*res = msg->cseq->body;
 	return 0;
 }
 
 int select_cseq_num(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct cseq_body* cs;
 
 	cs = sel_parse_cseq(msg);
 	if (!cs) return -1;
 	*res = cs->number;
 	return 0;
 }
 
 int select_cseq_method(str* res, select_t* s, struct sip_msg* msg)
 {
 	struct cseq_body* cs;
 
 	cs = sel_parse_cseq(msg);
 	if (!cs) return -1;
 	*res = cs->method;
 	return 0;
 }
84b87bd3
 
8aa67e4d
 int get_credentials(struct sip_msg* msg, select_t* s, struct hdr_field** hdr)
3917797b
 {
 	int ret;
 	str realm;
 	hdr_types_t hdr_type;
 
8aa67e4d
 	*hdr = NULL;
 
ebf528da
 	if (!msg) {
 		/* fix-up call check domain for fparam conversion */
 		void * ptr;
 		char chr;
 		ptr=(void *)(s->params[1].v.s.s);
 		chr=s->params[1].v.s.s[s->params[1].v.s.len];
 		s->params[1].v.s.s[s->params[1].v.s.len]=0;
 		ret=fixup_var_str_12(&ptr,0);
8aa67e4d
 		if (ret>=0) {
 			s->params[1].v.s.s[s->params[1].v.s.len]=chr;
 			s->params[1].v.p=ptr;
 			s->params[1].type=SEL_PARAM_PTR;
 		}
 		return ret;
ebf528da
 	}
 	
 
8aa67e4d
 	/* Try to find credentials with corresponding realm
 	 * in the message, parse them and return pointer to
 	 * parsed structure
 	 */
ebf528da
 	if (s->params[1].type==SEL_PARAM_PTR) {
 		if (get_str_fparam(&realm, msg, s->params[1].v.p)<0)
8aa67e4d
 			return -1;
ebf528da
 	} else {
 		realm = s->params[1].v.s;
 	}
3917797b
 
 	switch (s->params[0].v.i) {
 	case SEL_AUTH_WWW:
 		hdr_type = HDR_AUTHORIZATION_T;
 		break;
 
 	case SEL_AUTH_PROXY:
 		hdr_type = HDR_PROXYAUTH_T;
 		break;
 
 	default:
 		BUG("Unexpected parameter value \"%d\"\n", s->params[0].v.i);
8aa67e4d
 		return -1;
3917797b
 	}
 
8aa67e4d
 	ret = find_credentials(msg, &realm, hdr_type, hdr);
 	return ret;
3917797b
 }
 
 
 int select_auth(str* res, select_t* s, struct sip_msg* msg)
 {
8aa67e4d
 	int ret;
3917797b
 	struct hdr_field* hdr;
 
ebf528da
 	if (s->n != 2 && s->params[1].type != SEL_PARAM_STR
 	              && s->params[1].type != SEL_PARAM_PTR) return -1;
3917797b
 
 	if (s->params[0].type != SEL_PARAM_DIV) {
 		BUG("Last parameter should have type DIV (converted)\n");
 		return -1;
 	}
 
8aa67e4d
 	ret = get_credentials(msg, s, &hdr);
 	if (!hdr) return ret;
3917797b
 	RETURN0_res(hdr->body);
 }
 
 int select_auth_param(str* res, select_t* s, struct sip_msg* msg)
 {
8aa67e4d
 	int ret;
3917797b
 	struct hdr_field* hdr;
 	dig_cred_t* cred;
 
d0cf3d0b
 	if ((s->n != 3 && s->n != 4) || (s->params[s->n - 1].type != SEL_PARAM_DIV)) return -1;
3917797b
 
8aa67e4d
 	ret = get_credentials(msg, s, &hdr);
 	if (!hdr) return ret;
3917797b
 	cred = &((auth_body_t*)hdr->parsed)->digest;
 
 	switch(s->params[s->n - 1].v.i) {
 	case SEL_AUTH_USER:     RETURN0_res(cred->username.user);
 	case SEL_AUTH_DOMAIN:   RETURN0_res(cred->username.domain);
 	case SEL_AUTH_USERNAME: RETURN0_res(cred->username.whole);
 	case SEL_AUTH_REALM:    RETURN0_res(cred->realm);
 	case SEL_AUTH_NONCE:    RETURN0_res(cred->nonce);
 	case SEL_AUTH_URI:      RETURN0_res(cred->uri);
 	case SEL_AUTH_CNONCE:   RETURN0_res(cred->cnonce);
 	case SEL_AUTH_NC:       RETURN0_res(cred->nc);
 	case SEL_AUTH_RESPONSE: RETURN0_res(cred->response);
 	case SEL_AUTH_OPAQUE:   RETURN0_res(cred->opaque);
 	case SEL_AUTH_ALG:      RETURN0_res(cred->alg.alg_str);
 	case SEL_AUTH_QOP:      RETURN0_res(cred->qop.qop_str);
 	default:
 		BUG("Unsupported digest credentials parameter in select\n");
 		return -1;
 	}
 }
 
 int select_auth_username(str* res, select_t* s, struct sip_msg* msg)
 {
 	return select_auth_param(res, s, msg);
 }
 
 int select_auth_username_comp(str* res, select_t* s, struct sip_msg* msg)
 {
 	return select_auth_param(res, s, msg);
 }
 
84b87bd3
 ABSTRACT_F(select_any_nameaddr)
 
 int select_nameaddr_name(str* res, select_t* s, struct sip_msg* msg)
 {
 	char *p;
 	
 	p=find_not_quoted(res, '<');
 	if (!p) {
 		DBG("select_nameaddr_name: no < found, whole string is uri\n");
 		res->len=0;
 		return 1;
 	}
 
 	res->len=p-res->s;
 	while (res->len && SP(res->s[res->len-1])) res->len--;
 	return 0;
 }
 
 int select_nameaddr_uri(str* res, select_t* s, struct sip_msg* msg)
 {
 	char *p;
 	
 	p=find_not_quoted(res, '<');
 	if (!p) {
ca807b0b
 		DBG("select_nameaddr_uri: no < found, string up to first semicolon is uri\n");
 		p = q_memchr(res->s, ';', res->len);
 		if (p)
 			res->len = p-res->s;
84b87bd3
 		return 0;
 	}
 
 	res->len=res->len - (p-res->s) -1;
 	res->s=p +1;
 	
 	p=find_not_quoted(res, '>');
 	if (!p) {
 		ERR("select_nameaddr_uri: no > found, invalid nameaddr value\n");
 		return -1;
 	}
 
 	res->len=p-res->s;
 	return 0;
 }
60c006fa
 
 int select_nameaddr_params(str* res, select_t* s, struct sip_msg* msg)
 {
 	char *p;
 	
 	p=find_not_quoted(res, '<');
 	if (!p) {
 		p=find_not_quoted(res, ';');
 	} else {
 		res->len=res->len - (p-res->s) -1;
 		res->s=p +1;
 		p=find_not_quoted(res, '>');
 		if (!p) {
 			ERR("select_nameaddr_params: no > found, invalid nameaddr value\n");
 			return -1;
 		}
 		res->len=res->len - (p-res->s) -1;
 		res->s=p +1;
 		
 		p=find_not_quoted(res, ';');
 	}
 	if (!p) return 1;
 	
 	res->len=res->len - (p-res->s) -1;
 	res->s=p +1;
 	
559cb457
 	if (s->param_offset[select_level+1]-s->param_offset[select_level]==1)
60c006fa
 		return (res->len ? 0 : 1);
 
 	return select_any_params(res, s, msg);
 }
 
c51c5eb6
 ABSTRACT_F(select_src)
 ABSTRACT_F(select_dst)
 ABSTRACT_F(select_rcv)
 int select_ip_port(str* res, select_t* s, struct sip_msg* msg)
 {
 	str ip_str=STR_NULL, port_str=STR_NULL, proto_str=STR_NULL;
 	int param, pos;
 	
 
 	if ((s->n != 2) || (s->params[1].type != SEL_PARAM_DIV)) return -1;
 	param=s->params[1].v.i;
 
 	if (param & SEL_SRC) {
 		if (param & SEL_IP) {
 			ip_str.s = ip_addr2a(&msg->rcv.src_ip);
 			ip_str.len = strlen(ip_str.s);
 		}
 		if (param & SEL_PORT) {
 			port_str.s = int2str(msg->rcv.src_port, &port_str.len);
 		}
 	} else if (param & SEL_DST) {
 		if (param & SEL_IP) {
 			ip_str.s = ip_addr2a(&msg->rcv.dst_ip);
 			ip_str.len = strlen(ip_str.s);
 		}
 		if (param & SEL_PORT) {
 			port_str.s = int2str(msg->rcv.dst_port, &port_str.len);
 		}
 	} else if (param & SEL_RCV) {
 		if (param & SEL_IP) {
 			ip_str = msg->rcv.bind_address->address_str;
 		}
 		if (param & SEL_PORT) {
 			port_str = msg->rcv.bind_address->port_no_str;
 		}
 		if (param & SEL_PROTO) {
 			switch (msg->rcv.proto) {
 			case PROTO_NONE:
 				proto_str.s = 0;
 				proto_str.len = 0;
 				break;
 
 			case PROTO_UDP:
 				proto_str.s = "udp";
 				proto_str.len = 3;
 				break;
 
 			case PROTO_TCP:
 				proto_str.s = "tcp";
 				proto_str.len = 3;
 				break;
 
 			case PROTO_TLS:
 				proto_str.s = "tls";
 				proto_str.len = 3;
 				break;
 
 			case PROTO_SCTP:
 				proto_str.s = "sctp";
 				proto_str.len = 4;
 				break;
 
 			default:
 				ERR("BUG: select_ip_port: Unknown transport protocol\n");
 				return -1;
 			}
 		}
 	} else {
 		return -1;
 	}
 
 	res->s = get_static_buffer(ip_str.len+port_str.len+proto_str.len+3);
 	if (!res->s) return -1;
 
 	pos=0;
 	if (param & SEL_PROTO) {
 		memcpy(res->s, proto_str.s, proto_str.len);
 		pos += proto_str.len;
 	}
 	if (param & SEL_IP) {
 		if (pos) res->s[pos++] = ':';
 		memcpy(res->s+pos, ip_str.s, ip_str.len);
 		pos += ip_str.len;
 	}
 	if (param & SEL_PORT) {
 		if (pos) res->s[pos++] = ':';
 		memcpy(res->s+pos, port_str.s, port_str.len);
 		pos += port_str.len;
 	}
 	res->s[pos] = 0;
 	res->len = pos;
 	return (pos==0 ? 1 : 0);
 
 }
 
7e381ae0
 
 int select_expires(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (!msg->expires && (parse_headers(msg, HDR_EXPIRES_F, 0) == -1)) {
 		return -1; /* error */
 	}
 
 	if (!msg->expires) {
 		return 1;  /* null */
 	}
 
 	if (msg->expires->parsed == NULL && parse_expires(msg->expires) < 0) {
 		return -1;
 	}
 
 	RETURN0_res(((struct exp_body*)msg->expires->parsed)->text);
 }
 
 #define SELECT_plain_header(_sel_name_,_fld_name_,_hdr_f_) \
 int select_##_sel_name_(str* res, select_t* s, struct sip_msg* msg) \
 { \
 	if (!msg->_fld_name_ && (parse_headers(msg, _hdr_f_, 0) == -1)) { \
 		return -1; \
 	} \
 	if (!msg->_fld_name_) { \
 		return 1; \
 	} \
 	RETURN0_res(msg->_fld_name_->body); \
 }
 
 SELECT_plain_header(call_id, callid, HDR_CALLID_F)
 SELECT_plain_header(max_forwards, maxforwards, HDR_MAXFORWARDS_F)
 SELECT_plain_header(content_type, content_type, HDR_CONTENTTYPE_F)
 SELECT_plain_header(content_length, content_length, HDR_CONTENTLENGTH_F)
 SELECT_plain_header(user_agent, user_agent, HDR_USERAGENT_F)
 SELECT_plain_header(subject, subject, HDR_SUBJECT_F)
 SELECT_plain_header(organization, organization, HDR_ORGANIZATION_F)
 SELECT_plain_header(priority, priority, HDR_PRIORITY_F)
 SELECT_plain_header(session_expires, session_expires, HDR_SESSIONEXPIRES_F)
 SELECT_plain_header(min_se, min_se, HDR_MIN_SE_F)
 SELECT_plain_header(sip_if_match, sipifmatch, HDR_SIPIFMATCH_F)
e7317b87
 SELECT_plain_header(date, date, HDR_DATE_F)
 SELECT_plain_header(identity, identity, HDR_IDENTITY_F)
 SELECT_plain_header(identity_info, identity_info, HDR_IDENTITY_INFO_F)
7e381ae0
 
 int select_msg_request(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (msg->first_line.type==SIP_REQUEST) { 
 		return select_msg(res, s, msg); 
 	}
 	else
 		return -1;	
 }
 
 int select_msg_response(str* res, select_t* s, struct sip_msg* msg)
 {
 	if (msg->first_line.type==SIP_REPLY) {
 		return select_msg(res, s, msg); 
 	}
 	else
 		return -1;	
 }
 
 #define SELECT_first_line(_sel_name_,_type_,_fld_) \
 int select_msg_##_sel_name_(str* res, select_t* s, struct sip_msg* msg) {\
 	if (msg->first_line.type==_type_) { \
 		RETURN0_res(msg->first_line._fld_); \
 	} else return -1; \
 }
 
 SELECT_first_line(request_method,SIP_REQUEST,u.request.method)
 SELECT_first_line(request_uri,SIP_REQUEST,u.request.uri)
 SELECT_first_line(request_version,SIP_REQUEST,u.request.version)
 SELECT_first_line(response_version,SIP_REPLY,u.reply.version)
 SELECT_first_line(response_status,SIP_REPLY,u.reply.status)
 SELECT_first_line(response_reason,SIP_REPLY,u.reply.reason)
 
 
 int select_version(str* res, select_t* s, struct sip_msg* msg)
 {
 	switch (msg->first_line.type) { 
 		case SIP_REQUEST:
 			RETURN0_res(msg->first_line.u.request.version)
 			break;
 		case SIP_REPLY:
 			RETURN0_res(msg->first_line.u.reply.version)
 			break;
 		default:
 			return -1;
 	}
 }
 
 ABSTRACT_F(select_sys)
 
 int select_sys_pid(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, getpid());
 }
 
4bb044d3
 int select_sys_server_id(str* res, select_t* s, struct sip_msg* msg) {
 	return int_to_static_buffer(res, server_id);
 }
 
7e381ae0
 int select_sys_unique(str* res, select_t* s, struct sip_msg* msg) {
 	#define UNIQUE_ID_PID_LEN 4
 	#define UNIQUE_ID_TIME_LEN 8
 	#define UNIQUE_ID_FIX_LEN (UNIQUE_ID_PID_LEN+1+UNIQUE_ID_TIME_LEN+1)
 	#define UNIQUE_ID_RAND_LEN 8
 	static char uniq_id[UNIQUE_ID_FIX_LEN+UNIQUE_ID_RAND_LEN];
 	static int uniq_for_pid = -1;
 	int i;
 
 	if (uniq_for_pid != getpid()) {
 		/* first call for this process */
 		int cb, rb, x, l;
 		char *c;
 		/* init gloabally uniq part */
 		c = int2str_base_0pad(getpid(), &l, 16, UNIQUE_ID_PID_LEN);
 		memcpy(uniq_id, c, UNIQUE_ID_PID_LEN);
 		uniq_id[UNIQUE_ID_PID_LEN] = '-';
 		c = int2str_base_0pad(time(NULL), &l, 16, UNIQUE_ID_TIME_LEN);
 		memcpy(uniq_id+UNIQUE_ID_PID_LEN+1, c, UNIQUE_ID_TIME_LEN);
 		uniq_id[UNIQUE_ID_PID_LEN+1+UNIQUE_ID_TIME_LEN] = '-';
 
 		/* init random part */
 		for (i = RAND_MAX, rb=0; i; rb++, i>>=1);
 		for (i = UNIQUE_ID_FIX_LEN, cb = 0, x = 0; i < UNIQUE_ID_FIX_LEN+UNIQUE_ID_RAND_LEN; i++) {
 			if (!cb) {
 				cb = rb;
 				x = rand();
 			}
 			uniq_id[i] = fourbits2char[x & 0x0F];
 			x >>= rb;
 			cb -= rb;
 		}
 		uniq_for_pid = getpid();
 	}
         for (i = UNIQUE_ID_FIX_LEN + UNIQUE_ID_RAND_LEN - 1; i >= UNIQUE_ID_FIX_LEN; i--) {
 		switch (uniq_id[i]) {
 			case '9':
 				uniq_id[i]='a';
 				i = 0;
 				break;
 			case 'f':
 				uniq_id[i]='0';
 				/* go on */
 				break;
 			default:
 				uniq_id[i]++;
 				i = 0;
 				break;
 		}
 	}
 	res->s = uniq_id;   /* I think it's not worth copying at static buffer, I hope there is no real meaning of @sys.unique==@sys.unique */
 	res->len = UNIQUE_ID_FIX_LEN+UNIQUE_ID_RAND_LEN;
 	return 0;
 }
 
 
 int select_sys_now(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, time(NULL));
 }
 
 int select_sys_now_fmt(str* res, select_t* s, struct sip_msg* msg)
 {
 #define SEL_POS 2
 	time_t t;
 	struct tm *tm;
 	
 	t = time(NULL);
 	switch (s->params[SEL_POS].v.i) {
 		case SEL_NOW_GMT:
 			tm = gmtime(&t);
 			break;
 	
 		case SEL_NOW_LOCAL:
 			tm = localtime(&t);
 			break;
 		default:
 			BUG("Unexpected parameter value 'now' \"%d\"\n", s->params[SEL_POS].v.i);
 			return -1;
 	}
 	if (s->n <= SEL_POS+1) {
 		char *c;
 		c = asctime(tm);
 		res->len = strlen(c);
 		while (res->len && c[res->len-1] < ' ') res->len--; /* rtrim */
 		res->s = get_static_buffer(res->len);
 		if (!res->s) return -1;
 		memcpy(res->s, c, res->len);
 	}
 	else {
 		char c, buff[80];
 		c = s->params[SEL_POS+1].v.s.s[s->params[SEL_POS+1].v.s.len];
 		s->params[SEL_POS+1].v.s.s[s->params[SEL_POS+1].v.s.len] = '\0';
 		res->len = strftime(buff, sizeof(buff)-1, s->params[SEL_POS+1].v.s.s, tm);
 		s->params[SEL_POS+1].v.s.s[s->params[SEL_POS+1].v.s.len] = c;
 		res->s = get_static_buffer(res->len);
 		if (!res->s) return -1;
 		memcpy(res->s, buff, res->len);
 	}
 	return 0;
 #undef SEL_POS
 }
 
 ABSTRACT_F(select_branch)
 
 int select_branch_count(str* res, select_t* s, struct sip_msg* msg) {
 	return uint_to_static_buffer(res, nr_branches);
 }
 
 int select_branch_uri(str* res, select_t* s, struct sip_msg* msg) {
 #define SEL_POS 1 
 #define Q_PARAM ">;q="
 #define Q_PARAM_LEN (sizeof(Q_PARAM) - 1)
 
 	qvalue_t q;
 	int l, n;
 	str dst_uri;
 	if (s->n <= SEL_POS+1 && nr_branches > 1) { /* get all branches, if nr_branches==1 then use faster algorithm */
 		int len;
 		unsigned l2;
 		char *c;
 		init_branch_iterator();
 		len = 0;
8ca114df
 		while ((c = next_branch(&l, &q, &dst_uri, 0, 0, 0, 0, 0, 0))) {
7e381ae0
 
 			if (s->params[SEL_POS].v.i & SEL_BRANCH_DST_URI) {
 				l = dst_uri.len;
 				c = dst_uri.s;
 			}
 			if (s->params[SEL_POS].v.i & (SEL_BRANCH_URI|SEL_BRANCH_DST_URI) ) {
 				len += l;
 			}
 	                if (q != Q_UNSPECIFIED && (s->params[SEL_POS].v.i & SEL_BRANCH_Q)) {
 				len += len_q(q);
 				if (s->params[SEL_POS].v.i & SEL_BRANCH_URI) {
 					len += 1 + Q_PARAM_LEN;
 				}
 			}
  			len += 1;
 		}
 		if (!len) return 1;
 		res->s = get_static_buffer(len);
 		if (!res->s) return -1;
 		
 		init_branch_iterator();
 		res->len = 0;
 		n = 0;
8ca114df
 		while ((c = next_branch(&l, &q, &dst_uri, 0, 0, 0, 0, 0, 0))) {
7e381ae0
 			if (s->params[SEL_POS].v.i & SEL_BRANCH_DST_URI) {
 				l = dst_uri.len;
 				c = dst_uri.s;
 			}
 			if (n) {
 				res->s[res->len] = ',';
 				res->len++;
 			}
 			if ((s->params[SEL_POS].v.i & SEL_BRANCH_Q) == 0) {
 				q = Q_UNSPECIFIED;
 			}
 			if ((s->params[SEL_POS].v.i & (SEL_BRANCH_URI|SEL_BRANCH_DST_URI)) && q != Q_UNSPECIFIED) {
 				res->s[res->len] = '<';
 				res->len++;
 				memcpy(res->s+res->len, c, l);
 				res->len += l; 
 				memcpy(res->s+res->len, Q_PARAM, Q_PARAM_LEN);
 				res->len += Q_PARAM_LEN;
 				c = q2str(q, &l2); l = l2;
 				memcpy(res->s+res->len, c, l);
 				res->len += l; 
 			}
 			else if (s->params[SEL_POS].v.i & (SEL_BRANCH_URI|SEL_BRANCH_DST_URI)) {
 				memcpy(res->s+res->len, c, l);
 				res->len += l; 
 			}
 			else if (q != Q_UNSPECIFIED) {
 				c = q2str(q, &l2); l = l2;
 				memcpy(res->s+res->len, c, l);
 				res->len += l; 
 			}
 			n++;
 		}
 	}
 	else {
 		unsigned l2;
 		char *c;
 		n = s->params[SEL_POS+1].v.i;
 		if (n < 0 || n >= nr_branches) 
 			return -1;
 		init_branch_iterator();
8ca114df
 		for (; (c = next_branch(&l, &q, &dst_uri, 0, 0, 0, 0, 0, 0)) && n; n--);
7e381ae0
 		if (!c) return 1;
 		
 		if (s->params[SEL_POS].v.i & SEL_BRANCH_DST_URI) {
 			l = dst_uri.len;
 			c = dst_uri.s;
 		}
 		if ((s->params[SEL_POS].v.i & SEL_BRANCH_Q) == 0) {
 			q = Q_UNSPECIFIED;
 		}
 		if ((s->params[SEL_POS].v.i & (SEL_BRANCH_URI|SEL_BRANCH_DST_URI)) && q != Q_UNSPECIFIED) {
 
 			res->s = get_static_buffer(l + 1 + Q_PARAM_LEN + len_q(q));
 			if (!res->s) return -1;
 			res->len = 1;
 			res->s[0] = '<';
 			memcpy(res->s+res->len, c, l);
 			res->len += l; 
 			memcpy(res->s+res->len, Q_PARAM, Q_PARAM_LEN);
 			res->len += Q_PARAM_LEN;
 			c = q2str(q, &l2); l = l2;
 			memcpy(res->s+res->len, c, l);
 			res->len += l; 
 		}
 		else if (s->params[SEL_POS].v.i & (SEL_BRANCH_URI|SEL_BRANCH_DST_URI)) {
 			res->s = c;  /* not necessary to copy to static buffer */
 			res->len = l;
 		} 
 		else if (q != Q_UNSPECIFIED) {
 			c = q2str(q, &l2);
 			res->len = l2;
 			res->s = get_static_buffer(res->len);
 			if (!res->s) return -1;
 			memcpy(res->s, c, res->len);
 		}
 		else {
 			res->len = 0;
 		}
 	}
 	return 0;
 #undef SEL_POS
 }
 
 int select_branch_uriq(str* res, select_t* s, struct sip_msg* msg) {
 	return select_branch_uri(res, s, msg);
 }
 
 int select_branch_q(str* res, select_t* s, struct sip_msg* msg) {
 	return select_branch_uri(res, s, msg);
 }
 
 int select_branch_dst_uri(str* res, select_t* s, struct sip_msg* msg) {
 	return select_branch_uri(res, s, msg);
 }