* $Id$
 * Copyright (C) 2001-2003 FhG Fokus
 * 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
 * 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:
 * -------
 *  2001-??-??  created by andrei
 *  ????-??-??  lots of changes by a lot of people
 *  2003-01-23  support for determination of outbound interface added :
 *               get_out_socket (jiri)
 *  2003-01-24  reply to rport support added, contributed by
 *               Maxim Sobolev <sobomax@FreeBSD.org> and modified by andrei
 *  2003-02-11  removed calls to upd_send & tcp_send & replaced them with
 *               calls to msg_send (andrei)
 *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
 *  2003-04-02  fixed get_send_socket for tcp fwd to udp (andrei)
 *  2003-04-03  added su_setport (andrei)
 *  2003-04-04  update_sock_struct_from_via now differentiates between
 *               local replies  & "normal" replies (andrei)
 *  2003-04-12  update_sock_struct_from via uses also FL_FORCE_RPORT for
 *               local replies (andrei)
 *  2003-08-21  check_self properly handles ipv6 addresses & refs   (andrei)
 *  2003-10-21  check_self updated to handle proto (andrei)
 *  2003-10-24  converted to the new socket_info lists (andrei)
 *  2004-10-10  modified check_self to use grep_sock_info (andrei)
 *  2004-11-08  added force_send_socket support in get_send_socket (andrei)
 *  2005-12-11  onsend_router support; forward_request to no longer
 *              pkg_malloc'ed (andrei)
 *  2006-04-12  forward_{request,reply} use now struct dest_info (andrei)
 *  2006-04-21  basic comp via param support (andrei)

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "forward.h"
#include "hash_func.h"
#include "config.h"
#include "parser/msg_parser.h"
#include "route.h"
#include "dprint.h"
#include "globals.h"
#include "data_lump.h"
#include "ut.h"
#include "mem/mem.h"
#include "msg_translator.h"
#include "sr_module.h"
#include "ip_addr.h"
#include "resolve.h"
#include "name_alias.h"
#include "socket_info.h"
#include "onsend.h"

#include <dmalloc.h>

/* return a socket_info_pointer to the sending socket; as opposed to
 * get_send_socket, which returns process's default socket, get_out_socket
 * attempts to determine the outbound interface which will be used;
 * it creates a temporary connected socket to determine it; it will
 * be very likely noticeably slower, but it can deal better with
 * multihomed hosts
struct socket_info* get_out_socket(union sockaddr_union* to, int proto)
	int temp_sock;
	socklen_t len;
	union sockaddr_union from; 
	struct socket_info* si;
	struct ip_addr ip;

	if (proto!=PROTO_UDP) {
		LOG(L_CRIT, "BUG: get_out_socket can only be called for UDP\n");
		return 0;
	temp_sock=socket(to->s.sa_family, SOCK_DGRAM, 0 );
	if (temp_sock==-1) {
		LOG(L_ERR, "ERROR: get_out_socket: socket() failed: %s\n",
		return 0;
	if (connect(temp_sock, &to->s, sockaddru_len(*to))==-1) {
		LOG(L_ERR, "ERROR: get_out_socket: connect failed: %s\n",
		goto error;
	if (getsockname(temp_sock, &from.s, &len)==-1) {
		LOG(L_ERR, "ERROR: get_out_socket: getsockname failed: %s\n",
		goto error;
	su2ip_addr(&ip, &from);
	si=find_si(&ip, 0, proto);
	if (si==0) goto error;
	DBG("DEBUG: get_out_socket: socket determined: %p\n", si );
	return si;
	LOG(L_ERR, "ERROR: get_out_socket: no socket found\n");
	return 0;

/* returns a socket_info pointer to the sending socket or 0 on error
 * params: sip msg (can be null), destination socket_union pointer, protocol
 * if msg!=null and msg->force_send_socket, the force_send_socket will be
 * used
struct socket_info* get_send_socket(struct sip_msg *msg, 
										union sockaddr_union* to, int proto)
	struct socket_info* send_sock;
	/* check if send interface is not forced */
	if (msg && msg->force_send_socket){
		if (msg->force_send_socket->proto!=proto){
			DBG("get_send_socket: force_send_socket of different proto"
					" (%d)!\n", proto);
		if (msg->force_send_socket && (msg->force_send_socket->socket!=-1)) 
			return msg->force_send_socket;
			if (msg->force_send_socket->socket==-1)
				LOG(L_WARN, "WARNING: get_send_socket: not listening"
						 " on the requested socket, no fork mode?\n");
				LOG(L_WARN, "WARNING: get_send_socket: "
						"protocol/port mismatch\n");

	if (mhomed && proto==PROTO_UDP){
		send_sock=get_out_socket(to, proto);
		if ((send_sock==0) || (send_sock->socket!=-1))
			return send_sock; /* found or error*/
		else if (send_sock->socket==-1){
			LOG(L_WARN, "WARNING: get_send_socket: not listening on the"
					" requested socket, no fork mode?\n");
			/* continue: try to use some socket */

	/* check if we need to change the socket (different address families -
	 * eg: ipv4 -> ipv6 or ipv6 -> ipv4) */
#ifdef USE_TCP
		case PROTO_TCP:
		/* on tcp just use the "main address", we don't really now the
		 * sending address (we can find it out, but we'll need also to see
		 * if we listen on it, and if yes on which port -> too complicated*/
				/* FIXME */
				case AF_INET:	send_sock=sendipv4_tcp;
#ifdef USE_IPV6
				case AF_INET6:	send_sock=sendipv6_tcp;
				default:	LOG(L_ERR, "get_send_socket: BUG: don't know how"
									" to forward to af %d\n", to->s.sa_family);
#ifdef USE_TLS
		case PROTO_TLS:
				/* FIXME */
				case AF_INET:	send_sock=sendipv4_tls;
#ifdef USE_IPV6
				case AF_INET6:	send_sock=sendipv6_tls;
				default:	LOG(L_ERR, "get_send_socket: BUG: don't know how"
									" to forward to af %d\n", to->s.sa_family);
#endif /* USE_TLS */
		case PROTO_UDP:
			if ((bind_address==0)||(to->s.sa_family!=bind_address->address.af)||
					case AF_INET:	send_sock=sendipv4;
#ifdef USE_IPV6
					case AF_INET6:	send_sock=sendipv6;
					default:	LOG(L_ERR, "get_send_socket: BUG: don't know"
										" how to forward to af %d\n",
			}else send_sock=bind_address;
			LOG(L_CRIT, "BUG: get_send_socket: unknown proto %d\n", proto);
	return send_sock;

/* checks if the proto: host:port is one of the address we listen on;
 * if port==0, the  port number is ignored
 * if proto==0 (PROTO_NONE) the protocol is ignored
 * returns 1 if true, 0 if false, -1 on error
 * WARNING: uses str2ip6 so it will overwrite any previous
 *  unsaved result of this function (static buffer)
int check_self(str* host, unsigned short port, unsigned short proto)
	if (grep_sock_info(host, port, proto)) goto found;
	/* try to look into the aliases*/
	if (grep_aliases(host->s, host->len, port, proto)==0){
		DBG("check_self: host != me\n");
		return 0;
	return 1;

/* forwards a request to dst
 * parameters:
 *   msg       - sip msg
 *   send_info - filled dest_info structure:
 *               if the send_socket memeber is null, a send_socket will be 
 *               choosen automatically
 * WARNING: don' forget to zero-fill all the  unused members (a non-zero 
 * random id along with proto==PROTO_TCP can have bad consequences, same for
 *   a bogus send_socket vaule)
int forward_request(struct sip_msg* msg, struct dest_info* send_info)
	unsigned int len;
	char* buf;
	char md5[MD5_LEN];
	if (send_info->send_sock==0)
		send_info->send_sock=get_send_socket(msg, &send_info->to,
	if (send_info->send_sock==0){
		LOG(L_ERR, "forward_req: ERROR: cannot forward to af %d, proto %d "
				"no corresponding listening socket\n",
				send_info->to.s.sa_family, send_info->proto);
		goto error;

	/* calculate branch for outbound request;  if syn_branch is turned off,
	   calculate is from transaction key, i.e., as an md5 of From/To/CallID/
	   CSeq exactly the same way as TM does; good for reboot -- than messages
	   belonging to transaction lost due to reboot will still be forwarded
	   with the same branch parameter and will be match-able downstream

       if it is turned on, we don't care about reboot; we simply put a simple
	   value in there; better for performance
	if (syn_branch ) {
	} else {
		if (!char_msg_val( msg, md5 )) 	{ /* parses transaction key */
			LOG(L_ERR, "ERROR: forward_request: char_msg_val failed\n");
			goto error;
		msg->hash_index=hash( msg->callid->body, get_cseq(msg)->number);
		if (!branch_builder( msg->hash_index, 0, md5, 0 /* 0-th branch */,
					msg->add_to_branch_s, &msg->add_to_branch_len )) {
			LOG(L_ERR, "ERROR: forward_request: branch_builder failed\n");
			goto error;

	buf = build_req_buf_from_sip_req(msg, &len, send_info);
	if (!buf){
		LOG(L_ERR, "ERROR: forward_request: building failed\n");
		goto error;
	 /* send it! */
	DBG("Sending:\n%.*s.\n", (int)len, buf);
	DBG("orig. len=%d, new_len=%d, proto=%d\n",
			msg->len, len, send_info->proto );
	if (run_onsend(msg, send_info, buf, len)==0){
		LOG(L_INFO, "forward_request: request dropped (onsend_route)\n");
		ser_error=E_OK; /* no error */
		goto error; /* error ? */
	if (msg_send(send_info, buf, len)<0){
		goto error;
	/* sent requests stats */
	STATS_TX_REQUEST(  msg->first_line.u.request.method_value );
	/* received_buf & line_buf will be freed in receive_msg by free_lump_list*/
	return 0;

	if (buf) pkg_free(buf);
	return -1;

int update_sock_struct_from_via( union sockaddr_union* to,
								 struct sip_msg* msg,
								 struct via_body* via )
	struct hostent* he;
	str* name;
	int err;
	unsigned short port;

		/* _local_ reply, we ignore any rport or received value
		 * (but we will send back to the original port if rport is
		 *  present) */
		if ((msg->msg_flags&FL_FORCE_RPORT)||(via->rport))
		else port=via->port;
		name=&(via->host); /* received=ip in 1st via is ignored (it's
							  not added by us so it's bad) */
		/* "normal" reply, we use rport's & received value if present */
		if (via->rport && via->rport->value.s){
			DBG("update_sock_struct_from_via: using 'rport'\n");
			port=str2s(via->rport->value.s, via->rport->value.len, &err);
			if (err){
				LOG(L_NOTICE, "ERROR: forward_reply: bad rport value(%.*s)\n",
						via->rport->value.len, via->rport->value.s);
		if (via->received){
			DBG("update_sock_struct_from_via: using 'received'\n");
			/* making sure that we won't do SRV lookup on "received"
			 * (possible if no DNS_IP_HACK is used)*/
			if (port==0) port=via->port?via->port:SIP_PORT; 
			DBG("update_sock_struct_from_via: using via host\n");
			if (port==0) port=via->port;
	/* we do now a malloc/memcpy because gethostbyname loves \0-terminated 
	   strings; -jiri 
	   but only if host is not null terminated
	   (host.s[len] will always be ok for a via)
	    BTW: when is via->host.s non null terminated? tm copy? - andrei 
	    Yes -- it happened on generating a 408 by TM; -jiri
	    sip_resolvehost now accepts str -janakj
	DBG("update_sock_struct_from_via: trying SRV lookup\n");
	he=sip_resolvehost(name, &port, via->proto);
	if (he==0){
		LOG(L_NOTICE, "ERROR:forward_reply:resolve_host(%.*s) failure\n",
				name->len, name->s);
		return -1;
	hostent2su(to, he, 0, port);
	return 1;

/* removes first via & sends msg to the second */
int forward_reply(struct sip_msg* msg)
	char* new_buf;
	struct dest_info dst;
	unsigned int new_len;
	struct sr_module *mod;
#ifdef USE_TCP
	char* s;
	int len;
	/*check if first via host = us */
	if (check_via){
		if (check_self(&msg->via1->host,
			LOG(L_NOTICE, "ERROR: forward_reply: host in first via!=me :"
					" %.*s:%d\n", msg->via1->host.len, msg->via1->host.s,
			/* send error msg back? */
			goto error;
	/* quick hack, slower for multiple modules*/
	for (mod=modules;mod;mod=mod->next){
		if ((mod->exports) && (mod->exports->response_f)){
			DBG("forward_reply: found module %s, passing reply to it\n",
			if (mod->exports->response_f(msg)==0) goto skip;

	/* we have to forward the reply stateless, so we need second via -bogdan*/
	if (parse_headers( msg, HDR_VIA2_F, 0 )==-1 
		|| (msg->via2==0) || (msg->via2->error!=PARSE_OK))
		/* no second via => error */
		LOG(L_ERR, "ERROR: forward_reply: no 2nd via found in reply\n");
		goto error;

	new_buf = build_res_buf_from_sip_res( msg, &new_len);
	if (!new_buf){
		LOG(L_ERR, "ERROR: forward_reply: building failed\n");
		goto error;

	if (update_sock_struct_from_via( &dst.to, msg, msg->via2 )==-1) goto error;
#ifdef USE_COMP

#ifdef USE_TCP
	if (dst.proto==PROTO_TCP
#ifdef USE_TLS
			|| dst.proto==PROTO_TLS
		/* find id in i param if it exists */
		if (msg->via1->i && msg->via1->i->value.s){
			DBG("forward_reply: i=%.*s\n",len, ZSW(s));
			if (reverse_hex2int(s, len, (unsigned int*)&dst.id)<0){
				LOG(L_ERR, "ERROR: forward_reply: bad via i param \"%.*s\"\n",
						len, ZSW(s));
	if (msg_send(&dst, new_buf, new_len)<0) goto error;
#ifdef STATS
	STATS_TX_RESPONSE(  (msg->first_line.u.reply.statuscode/100) );

	DBG(" reply forwarded to %.*s:%d\n", 
			msg->via2->host.len, msg->via2->host.s,
			(unsigned short) msg->via2->port);

	return 0;
	if (new_buf) pkg_free(new_buf);
	return -1;