static int
ac_packetfilter_simple(ac_sip_t *asip, void *data)
{
osip_message_t* sip = asip->req->evt->sip;
int code = osip_message_get_status_code(sip);
LOG_DEBUG("Performing simple ac on %s->%s, remote: %d\n", asip->from, asip->to, asip->req->remote_msg);
/* filter only inbound */
if (asip->req->remote_msg && !asip->req->internally_generated) {
/* todo: we should check that the sip from == the aor
associated with the connection (on remote calls) */
/* except that that would mess up the gateway things. */
//ASSERT_ZERO(sipp_get_sip_aors_simple(sip, &local_aor, &remote_aor, 1), end);
/*
if ((!MSG_IS_RESPONSE(asip->evt->sip) &&
(strcmp(asip->from, asip->remote) || strcmp(asip->to, asip->local))) ||
(MSG_IS_RESPONSE(asip->evt->sip) &&
(strcmp(asip->to, asip->remote) || strcmp(asip->from, asip->local))))
asip->verdict = AC_VERDICT_REJECT;
else
*/
if (MSG_IS_RESPONSE(sip)) {
/* reject 482 merges, as server loops aren't of any interest to us */
if (code == 482) {
LOG_WARN("Skipping %d response\n", code);
asip->verdict = AC_VERDICT_REJECT;
}
} else if (MSG_IS_ACK(sip) || MSG_IS_BYE(sip) || MSG_IS_CANCEL(sip) || MSG_IS_UPDATE(sip)) {
/* this we should let through pretty much undisturbed */
} else if (MSG_IS_SUBSCRIBE(sip) || MSG_IS_PUBLISH(sip)) {
/* if this is remotely got, just reject */
asip->verdict = AC_VERDICT_REJECT;
} else if (MSG_IS_INVITE(sip) || MSG_IS_MESSAGE(sip)) {
/* hm, nothing.. */
// } else if (MSG_IS_NOTIFY(sip)) {
} else {
/* todo: what about OPTIONS? */
LOG_WARN("Got unsupported request\n");
asip->verdict = AC_VERDICT_UNSUPP;
}
} else {
/* allow *all* outgoing! */
asip->verdict = AC_VERDICT_ALLOW;
}
return 1;
}
void
nict_snd_request (osip_transaction_t * nict, osip_event_t * evt)
{
int i;
osip_t *osip = (osip_t *) nict->config;
/* Here we have ict->orig_request == NULL */
nict->orig_request = evt->sip;
i = osip->cb_send_message (nict, evt->sip, nict->nict_context->destination,
nict->nict_context->port, nict->out_socket);
if (i == 0)
{
/* invoke the right callback! */
if (MSG_IS_REGISTER (evt->sip))
__osip_message_callback (OSIP_NICT_REGISTER_SENT, nict,
nict->orig_request);
else if (MSG_IS_BYE (evt->sip))
__osip_message_callback (OSIP_NICT_BYE_SENT, nict, nict->orig_request);
else if (MSG_IS_OPTIONS (evt->sip))
__osip_message_callback (OSIP_NICT_OPTIONS_SENT, nict, nict->orig_request);
else if (MSG_IS_INFO (evt->sip))
__osip_message_callback (OSIP_NICT_INFO_SENT, nict, nict->orig_request);
else if (MSG_IS_CANCEL (evt->sip))
__osip_message_callback (OSIP_NICT_CANCEL_SENT, nict, nict->orig_request);
else if (MSG_IS_NOTIFY (evt->sip))
__osip_message_callback (OSIP_NICT_NOTIFY_SENT, nict, nict->orig_request);
else if (MSG_IS_SUBSCRIBE (evt->sip))
__osip_message_callback (OSIP_NICT_SUBSCRIBE_SENT, nict,
nict->orig_request);
else
__osip_message_callback (OSIP_NICT_UNKNOWN_REQUEST_SENT, nict,
nict->orig_request);
__osip_transaction_set_state (nict, NICT_TRYING);
} else
{
nict_handle_transport_error (nict, i);
}
}
void
nist_rcv_request (osip_transaction_t * nist, osip_event_t * evt)
{
int i;
if (nist->state == NIST_PRE_TRYING) /* announce new REQUEST */
{
/* Here we have ist->orig_request == NULL */
nist->orig_request = evt->sip;
if (MSG_IS_REGISTER (evt->sip))
__osip_message_callback (OSIP_NIST_REGISTER_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_BYE (evt->sip))
__osip_message_callback (OSIP_NIST_BYE_RECEIVED, nist, nist->orig_request);
else if (MSG_IS_OPTIONS (evt->sip))
__osip_message_callback (OSIP_NIST_OPTIONS_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_INFO (evt->sip))
__osip_message_callback (OSIP_NIST_INFO_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_CANCEL (evt->sip))
__osip_message_callback (OSIP_NIST_CANCEL_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_NOTIFY (evt->sip))
__osip_message_callback (OSIP_NIST_NOTIFY_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_SUBSCRIBE (evt->sip))
__osip_message_callback (OSIP_NIST_SUBSCRIBE_RECEIVED, nist,
nist->orig_request);
else
__osip_message_callback (OSIP_NIST_UNKNOWN_REQUEST_RECEIVED, nist,
nist->orig_request);
} else /* NIST_PROCEEDING or NIST_COMPLETED */
{
/* delete retransmission */
osip_message_free (evt->sip);
__osip_message_callback (OSIP_NIST_REQUEST_RECEIVED_AGAIN, nist,
nist->orig_request);
if (nist->last_response != NULL) /* retransmit last response */
{
i = __osip_transaction_snd_xxx(nist, nist->last_response);
if (i != 0)
{
nist_handle_transport_error (nist, i);
return;
} else
{
if (MSG_IS_STATUS_1XX (nist->last_response))
__osip_message_callback (OSIP_NIST_STATUS_1XX_SENT, nist,
nist->last_response);
else if (MSG_IS_STATUS_2XX (nist->last_response))
__osip_message_callback (OSIP_NIST_STATUS_2XX_SENT_AGAIN,
nist, nist->last_response);
else
__osip_message_callback (OSIP_NIST_STATUS_3456XX_SENT_AGAIN,
nist, nist->last_response);
return;
}
}
/* we are already in the proper state */
return;
}
/* we come here only if it was the first REQUEST received */
__osip_transaction_set_state (nist, NIST_TRYING);
}
int
_eXosip_build_response_default (osip_message_t ** dest,
osip_dialog_t * dialog, int status,
osip_message_t * request)
{
osip_generic_param_t *tag;
osip_message_t *response;
int pos;
int i;
*dest = NULL;
if (request == NULL)
return -1;
i = osip_message_init (&response);
if (i != 0)
return -1;
/* initialise osip_message_t structure */
/* yet done... */
response->sip_version = (char *) osip_malloc (8 * sizeof (char));
sprintf (response->sip_version, "SIP/2.0");
osip_message_set_status_code (response, status);
/* handle some internal reason definitions. */
if (MSG_IS_NOTIFY (request) && status == 481)
{
response->reason_phrase = osip_strdup ("Subcription Does Not Exist");
} else if (MSG_IS_SUBSCRIBE (request) && status == 202)
{
response->reason_phrase = osip_strdup ("Accepted subscription");
} else
{
response->reason_phrase = osip_strdup (osip_message_get_reason (status));
if (response->reason_phrase == NULL)
{
if (response->status_code == 101)
response->reason_phrase = osip_strdup ("Dialog Establishement");
else
response->reason_phrase = osip_strdup ("Unknown code");
}
response->req_uri = NULL;
response->sip_method = NULL;
}
i = osip_to_clone (request->to, &(response->to));
if (i != 0)
goto grd_error_1;
i = osip_to_get_tag (response->to, &tag);
if (i != 0)
{ /* we only add a tag if it does not already contains one! */
if ((dialog != NULL) && (dialog->local_tag != NULL))
/* it should contain the local TAG we created */
{
osip_to_set_tag (response->to, osip_strdup (dialog->local_tag));
} else
{
if (status != 100)
osip_to_set_tag (response->to, osip_to_tag_new_random ());
}
}
i = osip_from_clone (request->from, &(response->from));
if (i != 0)
goto grd_error_1;
pos = 0;
while (!osip_list_eol (request->vias, pos))
{
osip_via_t *via;
osip_via_t *via2;
via = (osip_via_t *) osip_list_get (request->vias, pos);
i = osip_via_clone (via, &via2);
if (i != -0)
goto grd_error_1;
osip_list_add (response->vias, via2, -1);
pos++;
}
i = osip_call_id_clone (request->call_id, &(response->call_id));
if (i != 0)
goto grd_error_1;
i = osip_cseq_clone (request->cseq, &(response->cseq));
if (i != 0)
goto grd_error_1;
if (MSG_IS_SUBSCRIBE (request))
{
osip_header_t *exp;
osip_header_t *evt_hdr;
osip_message_header_get_byname (request, "event", 0, &evt_hdr);
if (evt_hdr != NULL && evt_hdr->hvalue != NULL)
osip_message_set_header (response, "Event", evt_hdr->hvalue);
else
osip_message_set_header (response, "Event", "presence");
i = osip_message_get_expires (request, 0, &exp);
if (exp == NULL)
{
osip_header_t *cp;
i = osip_header_clone (exp, &cp);
if (cp != NULL)
osip_list_add (response->headers, cp, 0);
}
}
osip_message_set_allow (response, "INVITE");
osip_message_set_allow (response, "ACK");
osip_message_set_allow (response, "OPTIONS");
osip_message_set_allow (response, "CANCEL");
osip_message_set_allow (response, "BYE");
osip_message_set_allow (response, "SUBSCRIBE");
osip_message_set_allow (response, "NOTIFY");
osip_message_set_allow (response, "MESSAGE");
osip_message_set_allow (response, "INFO");
osip_message_set_allow (response, "REFER");
osip_message_set_allow (response, "UPDATE");
*dest = response;
return 0;
grd_error_1:
osip_message_free (response);
return -1;
}
void
nict_snd_request (osip_transaction_t * nict, osip_event_t * evt)
{
int i;
osip_t *osip = (osip_t *) nict->config;
/* Here we have ict->orig_request == NULL */
nict->orig_request = evt->sip;
i = osip->cb_send_message (nict, evt->sip, nict->nict_context->destination, nict->nict_context->port, nict->out_socket);
if (i >= 0) {
/* invoke the right callback! */
if (MSG_IS_REGISTER (evt->sip))
__osip_message_callback (OSIP_NICT_REGISTER_SENT, nict, nict->orig_request);
else if (MSG_IS_BYE (evt->sip))
__osip_message_callback (OSIP_NICT_BYE_SENT, nict, nict->orig_request);
else if (MSG_IS_OPTIONS (evt->sip))
__osip_message_callback (OSIP_NICT_OPTIONS_SENT, nict, nict->orig_request);
else if (MSG_IS_INFO (evt->sip))
__osip_message_callback (OSIP_NICT_INFO_SENT, nict, nict->orig_request);
else if (MSG_IS_CANCEL (evt->sip))
__osip_message_callback (OSIP_NICT_CANCEL_SENT, nict, nict->orig_request);
else if (MSG_IS_NOTIFY (evt->sip))
__osip_message_callback (OSIP_NICT_NOTIFY_SENT, nict, nict->orig_request);
else if (MSG_IS_SUBSCRIBE (evt->sip))
__osip_message_callback (OSIP_NICT_SUBSCRIBE_SENT, nict, nict->orig_request);
else
__osip_message_callback (OSIP_NICT_UNKNOWN_REQUEST_SENT, nict, nict->orig_request);
#ifndef USE_BLOCKINGSOCKET
/*
stop timer E in reliable transport - non blocking socket:
the message was just sent
*/
{
osip_via_t *via;
char *proto;
int k;
k = osip_message_get_via (nict->orig_request, 0, &via); /* get top via */
if (k < 0) {
nict_handle_transport_error (nict, -1);
return;
}
proto = via_get_protocol (via);
if (proto == NULL) {
nict_handle_transport_error (nict, -1);
return;
}
if (i == 0) { /* but message was really sent */
if (osip_strcasecmp (proto, "TCP") != 0 && osip_strcasecmp (proto, "TLS") != 0 && osip_strcasecmp (proto, "SCTP") != 0) {
}
else { /* reliable protocol is used: */
nict->nict_context->timer_e_length = -1; /* E is not ACTIVE */
nict->nict_context->timer_e_start.tv_sec = -1;
}
} else {
if (osip_strcasecmp (proto, "TCP") != 0 && osip_strcasecmp (proto, "TLS") != 0 && osip_strcasecmp (proto, "SCTP") != 0) {
}
else { /* reliable protocol is used: */
nict->nict_context->timer_e_length = DEFAULT_T1_TCP_PROGRESS;
}
}
}
#endif
if (nict->nict_context->timer_e_length > 0) {
osip_gettimeofday (&nict->nict_context->timer_e_start, NULL);
add_gettimeofday (&nict->nict_context->timer_e_start, nict->nict_context->timer_e_length);
}
__osip_transaction_set_state (nict, NICT_TRYING);
}
else {
nict_handle_transport_error (nict, i);
}
}
void
nist_rcv_request (osip_transaction_t * nist, osip_event_t * evt)
{
int i;
osip_t *osip = (osip_t *) nist->config;
if (nist->state == NIST_PRE_TRYING) /* announce new REQUEST */
{
/* Here we have ist->orig_request == NULL */
nist->orig_request = evt->sip;
if (MSG_IS_REGISTER (evt->sip))
__osip_message_callback (OSIP_NIST_REGISTER_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_BYE (evt->sip))
__osip_message_callback (OSIP_NIST_BYE_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_OPTIONS (evt->sip))
__osip_message_callback (OSIP_NIST_OPTIONS_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_INFO (evt->sip))
__osip_message_callback (OSIP_NIST_INFO_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_CANCEL (evt->sip))
__osip_message_callback (OSIP_NIST_CANCEL_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_NOTIFY (evt->sip))
__osip_message_callback (OSIP_NIST_NOTIFY_RECEIVED, nist,
nist->orig_request);
else if (MSG_IS_SUBSCRIBE (evt->sip))
__osip_message_callback (OSIP_NIST_SUBSCRIBE_RECEIVED, nist,
nist->orig_request);
else
__osip_message_callback (OSIP_NIST_UNKNOWN_REQUEST_RECEIVED, nist,
nist->orig_request);
}
else /* NIST_PROCEEDING or NIST_COMPLETED */
{
/* delete retransmission */
osip_message_free (evt->sip);
__osip_message_callback (OSIP_NIST_REQUEST_RECEIVED_AGAIN, nist,
nist->orig_request);
if (nist->last_response != NULL) /* retransmit last response */
{
osip_via_t *via;
via = (osip_via_t *) osip_list_get (nist->last_response->vias, 0);
if (via)
{
char *host;
int port;
osip_generic_param_t *maddr;
osip_generic_param_t *received;
osip_generic_param_t *rport;
osip_via_param_get_byname (via, "maddr", &maddr);
osip_via_param_get_byname (via, "received", &received);
osip_via_param_get_byname (via, "rport", &rport);
/* 1: user should not use the provided information
(host and port) if they are using a reliable
transport. Instead, they should use the already
open socket attached to this transaction. */
/* 2: check maddr and multicast usage */
if (maddr != NULL)
host = maddr->gvalue;
/* we should check if this is a multicast address and use
set the "ttl" in this case. (this must be done in the
UDP message (not at the SIP layer) */
else if (received != NULL)
host = received->gvalue;
else
host = via->host;
if (rport == NULL || rport->gvalue == NULL)
{
if (via->port != NULL)
port = osip_atoi (via->port);
else
port = 5060;
}
else
port = osip_atoi (rport->gvalue);
i = osip->cb_send_message (nist, nist->last_response, host,
port, nist->out_socket);
}
else
i = -1;
if (i != 0)
{
nist_handle_transport_error (nist, i);
return;
}
else
{
if (MSG_IS_STATUS_1XX (nist->last_response))
__osip_message_callback (OSIP_NIST_STATUS_1XX_SENT, nist,
nist->last_response);
else if (MSG_IS_STATUS_2XX (nist->last_response))
__osip_message_callback (OSIP_NIST_STATUS_2XX_SENT_AGAIN, nist,
nist->last_response);
else
__osip_message_callback (OSIP_NIST_STATUS_3456XX_SENT_AGAIN, nist,
nist->last_response);
return;
}
}
/* we are already in the proper state */
return;
}
/* we come here only if it was the first REQUEST received */
__osip_transaction_set_state (nist, NIST_TRYING);
}
int main (int argc, char *argv[])
{
int port = 5060;
eXosip_event_t *event = NULL;
succeed_type flag;
#if !defined(__arc__)
struct servent *service = NULL;
#endif
struct regparam_t regparam = { 0, 3600, 0 };
int debug = 1;
port = 5060;
#if 0
if (debug > 0)
TRACE_INITIALIZE (6, NULL);
#endif
context_eXosip = eXosip_malloc ();
if (eXosip_init (context_eXosip)) {
printf("eXosip_init failed\r\n");
exit (1);
}
if (eXosip_listen_addr (context_eXosip, IPPROTO_UDP, "192.168.5.118", port, AF_INET, 0)) {
printf("eXosip_listen_addr failed\r\n");
exit (1);
}
/*start the notify thread */
#ifndef OSIP_MONOTHREAD
notify_thread = osip_thread_create(20000, notify_proc, ®param);
#endif
for(;;)
{
eXosip_event_t *event;
if (!(event = eXosip_event_wait (context_eXosip, 0, 1))) {
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
eXosip_automatic_action (context_eXosip);
#endif
// osip_usleep (10000);
continue;
}
eXosip_lock(context_eXosip);
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
#endif
// eXosip_automatic_action (context_eXosip);
eXosip_unlock(context_eXosip);
eXosip_automatic_action(context_eXosip);
switch (event->type) {
case EXOSIP_CALL_INVITE:
if(MSG_IS_INVITE(event->request))
{
flag = handle_request_invite(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle invite request failed\r\n");
}else{
printf("handle invite request succeed\r\n");
}
continue;
}
break;
case EXOSIP_CALL_REINVITE:
break;
case EXOSIP_CALL_NOANSWER:
break;
case EXOSIP_CALL_PROCEEDING:
break;
case EXOSIP_CALL_RINGING:
break;
case EXOSIP_CALL_ANSWERED:
break;
case EXOSIP_CALL_REDIRECTED:
break;
case EXOSIP_CALL_REQUESTFAILURE:
break;
case EXOSIP_CALL_SERVERFAILURE:
break;
case EXOSIP_CALL_GLOBALFAILURE:
break;
case EXOSIP_CALL_ACK:
break;
case EXOSIP_CALL_CANCELLED:
break;
case EXOSIP_CALL_MESSAGE_NEW:
break;
case EXOSIP_CALL_MESSAGE_PROCEEDING:
printf("EXOSIP_CALL_MESSAGE_PROCEEDING\r\n");
break;
case EXOSIP_CALL_MESSAGE_ANSWERED:
break;
case EXOSIP_CALL_MESSAGE_REDIRECTED:
break;
case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
break;
case EXOSIP_CALL_MESSAGE_SERVERFAILURE:
break;
case EXOSIP_CALL_MESSAGE_GLOBALFAILURE:
break;
case EXOSIP_CALL_CLOSED:
break;
case EXOSIP_CALL_RELEASED:
break;
case EXOSIP_MESSAGE_NEW:
printf("answer EXOSIP_MESSAGE_NEW\r\n");
if(MSG_IS_MESSAGE(event->request))
{
flag = handle_request_message(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle message request failed\r\n");
}else{
printf("handle message request succeed\r\n");
}
continue;
}
if(MSG_IS_REGISTER(event->request))
{
flag = handle_request_register(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle register request failed\r\n");
}else{
printf("handle register request succeed\r\n");
}
continue;
}
break;
case EXOSIP_MESSAGE_PROCEEDING:
break;
case EXOSIP_MESSAGE_ANSWERED:
break;
case EXOSIP_MESSAGE_REDIRECTED:
break;
case EXOSIP_MESSAGE_REQUESTFAILURE:
break;
case EXOSIP_MESSAGE_SERVERFAILURE:
break;
case EXOSIP_MESSAGE_GLOBALFAILURE:
break;
case EXOSIP_SUBSCRIPTION_NOANSWER:
break;
case EXOSIP_SUBSCRIPTION_PROCEEDING:
break;
case EXOSIP_SUBSCRIPTION_ANSWERED:
break;
case EXOSIP_SUBSCRIPTION_REDIRECTED:
break;
case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:
break;
case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
break;
case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
break;
case EXOSIP_SUBSCRIPTION_NOTIFY:
break;
case EXOSIP_IN_SUBSCRIPTION_NEW: //subscribe event
if(MSG_IS_SUBSCRIBE(event->request))
{
flag = handle_request_subscribe(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle subscribe request failed\r\n");
}else{
printf("handle subscribe request succeed\r\n");
}
continue;
}
break;
case EXOSIP_NOTIFICATION_NOANSWER:
break;
case EXOSIP_NOTIFICATION_PROCEEDING:
break;
case EXOSIP_NOTIFICATION_ANSWERED:
break;
case EXOSIP_NOTIFICATION_REDIRECTED:
break;
case EXOSIP_NOTIFICATION_REQUESTFAILURE:
break;
case EXOSIP_NOTIFICATION_SERVERFAILURE:
break;
case EXOSIP_NOTIFICATION_GLOBALFAILURE:
break;
case EXOSIP_EVENT_COUNT:
break;
default:
printf( "recieved unknown eXosip event (type, did, cid) = (%d, %d, %d)", event->type, event->did, event->cid);
}
eXosip_event_free (event);
}
}
static int
dtls_tl_send_message(osip_transaction_t * tr, osip_message_t * sip, char *host,
int port, int out_socket)
{
int len = 0;
size_t length = 0;
struct addrinfo *addrinfo;
struct __eXosip_sockaddr addr;
char *message;
char ipbuf[INET6_ADDRSTRLEN];
int i;
int pos;
struct socket_tab *socket_tab_used=NULL;
BIO *sbio=NULL;
if (dtls_socket <= 0)
return -1;
if (host == NULL)
{
host = sip->req_uri->host;
if (sip->req_uri->port != NULL)
port = osip_atoi (sip->req_uri->port);
else
port = 5061;
}
if (port == 5060)
port = 5061;
if (MSG_IS_REQUEST(sip))
{
if (MSG_IS_REGISTER(sip)
||MSG_IS_INVITE(sip)
||MSG_IS_SUBSCRIBE(sip)
|| MSG_IS_NOTIFY(sip))
eXtl_update_local_target(sip);
}
i=-1;
#ifndef MINISIZE
if (tr!=NULL && tr->record.name[0]!='\0' && tr->record.srventry[0].srv[0]!='\0')
{
/* always choose the first here.
if a network error occur, remove first entry and
replace with next entries.
*/
osip_srv_entry_t *srv;
int n=0;
for (srv = &tr->record.srventry[0];
n<10 && tr->record.srventry[0].srv[0];
srv = &tr->record.srventry[0])
{
i = eXosip_get_addrinfo (&addrinfo, srv->srv, srv->port, IPPROTO_UDP);
if (i == 0)
{
host = srv->srv;
port = srv->port;
break;
}
memmove(&tr->record.srventry[0], &tr->record.srventry[1], 9*sizeof(osip_srv_entry_t));
memset(&tr->record.srventry[9], 0, sizeof(osip_srv_entry_t));
i=-1;
/* copy next element */
n++;
}
}
#endif
/* if SRV was used, distination may be already found */
if (i != 0)
{
i = eXosip_get_addrinfo (&addrinfo, host, port, IPPROTO_UDP);
}
if (i != 0)
{
return -1;
}
memcpy (&addr, addrinfo->ai_addr, addrinfo->ai_addrlen);
len = addrinfo->ai_addrlen;
eXosip_freeaddrinfo (addrinfo);
/* remove preloaded route if there is no tag in the To header
*/
{
osip_route_t *route=NULL;
osip_generic_param_t *tag=NULL;
osip_message_get_route (sip, 0, &route);
osip_to_get_tag (sip->to, &tag);
if (tag==NULL && route != NULL && route->url != NULL)
{
osip_list_remove(&sip->routes, 0);
}
i = osip_message_to_str (sip, &message, &length);
if (tag==NULL && route != NULL && route->url != NULL)
{
osip_list_add(&sip->routes, route, 0);
}
}
if (i != 0 || length <= 0)
{
return -1;
}
switch ( ((struct sockaddr *)&addr)->sa_family )
{
case AF_INET:
inet_ntop (((struct sockaddr *)&addr)->sa_family, &(((struct sockaddr_in *) &addr)->sin_addr),
ipbuf, sizeof (ipbuf));
break;
case AF_INET6:
inet_ntop (((struct sockaddr *)&addr)->sa_family,
&(((struct sockaddr_in6 *) &addr)->sin6_addr), ipbuf,
sizeof (ipbuf));
break;
default:
strncpy (ipbuf, "(unknown)", sizeof (ipbuf));
break;
}
OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO1, NULL,
"Message sent: \n%s (to dest=%s:%i)\n",
message, ipbuf, port));
for (pos = 0; pos < EXOSIP_MAX_SOCKETS; pos++)
{
if (dtls_socket_tab[pos].ssl_conn != NULL
&& dtls_socket_tab[pos].ssl_type == EXOSIP_AS_A_SERVER)
{
if (dtls_socket_tab[pos].remote_port == port &&
(strcmp (dtls_socket_tab[pos].remote_ip, ipbuf) == 0))
{
BIO *rbio;
socket_tab_used = &dtls_socket_tab[pos];
rbio = BIO_new_dgram (dtls_socket, BIO_NOCLOSE);
BIO_dgram_set_peer (rbio, &addr);
dtls_socket_tab[pos].ssl_conn->rbio = rbio;
break;
}
}
}
if (socket_tab_used==NULL)
{
for (pos = 0; pos < EXOSIP_MAX_SOCKETS; pos++)
{
if (dtls_socket_tab[pos].ssl_conn != NULL
&& dtls_socket_tab[pos].ssl_type == EXOSIP_AS_A_CLIENT)
{
if (dtls_socket_tab[pos].remote_port == port &&
(strcmp (dtls_socket_tab[pos].remote_ip, ipbuf) == 0))
{
BIO *rbio;
socket_tab_used = &dtls_socket_tab[pos];
rbio = BIO_new_dgram (dtls_socket, BIO_NOCLOSE);
BIO_dgram_set_peer (rbio, &addr);
dtls_socket_tab[pos].ssl_conn->rbio = rbio;
break;
}
}
}
}
if (socket_tab_used==NULL)
{
/* delete an old one! */
pos=0;
if (dtls_socket_tab[pos].ssl_conn != NULL)
{
shutdown_free_client_dtls (pos);
shutdown_free_server_dtls (pos);
}
memset(&dtls_socket_tab[pos], 0, sizeof(struct socket_tab));
}
if (dtls_socket_tab[pos].ssl_conn == NULL)
{
/* create a new one */
SSL_CTX_set_read_ahead (client_ctx, 1);
dtls_socket_tab[pos].ssl_conn = SSL_new (client_ctx);
if (dtls_socket_tab[pos].ssl_conn == NULL)
{
OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
"DTLS SSL_new error\n"));
if (dtls_socket_tab[pos].ssl_conn != NULL)
{
shutdown_free_client_dtls (pos);
shutdown_free_server_dtls (pos);
}
memset(&dtls_socket_tab[pos], 0, sizeof(struct socket_tab));
osip_free (message);
return -1;
}
if (connect (dtls_socket, (struct sockaddr *) &addr, sizeof (addr)) == -1)
{
OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
"DTLS connect error\n"));
if (dtls_socket_tab[pos].ssl_conn != NULL)
{
shutdown_free_client_dtls (pos);
shutdown_free_server_dtls (pos);
}
memset(&dtls_socket_tab[pos], 0, sizeof(struct socket_tab));
osip_free (message);
return -1;
}
SSL_set_options (dtls_socket_tab[pos].ssl_conn, SSL_OP_NO_QUERY_MTU);
SSL_set_mtu (dtls_socket_tab[pos].ssl_conn, 2000);
SSL_set_connect_state (dtls_socket_tab[pos].ssl_conn);
sbio = BIO_new_dgram (dtls_socket, BIO_NOCLOSE);
BIO_ctrl_set_connected (sbio, 1, (struct sockaddr *) &addr);
SSL_set_bio (dtls_socket_tab[pos].ssl_conn, sbio, sbio);
dtls_socket_tab[pos].ssl_type = 2;
dtls_socket_tab[pos].ssl_state = 2;
osip_strncpy (dtls_socket_tab[pos].remote_ip, ipbuf,
sizeof (dtls_socket_tab[pos].remote_ip));
dtls_socket_tab[pos].remote_port = port;
}
i = SSL_write (dtls_socket_tab[pos].ssl_conn, message, length);
if (i<0)
{
i = SSL_get_error (dtls_socket_tab[pos].ssl_conn, i);
print_ssl_error (i);
if (i==SSL_ERROR_SSL
|| i==SSL_ERROR_SYSCALL)
{
OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
"DTLS SSL_write error\n"));
if (dtls_socket_tab[pos].ssl_conn != NULL)
{
shutdown_free_client_dtls (pos);
shutdown_free_server_dtls (pos);
}
memset(&dtls_socket_tab[pos], 0, sizeof(struct socket_tab));
}
#ifndef MINISIZE
/* delete first SRV entry that is not reachable */
if (tr->record.name[0]!='\0' && tr->record.srventry[0].srv[0]!='\0')
{
memmove(&tr->record.srventry[0], &tr->record.srventry[1], 9*sizeof(osip_srv_entry_t));
memset(&tr->record.srventry[9], 0, sizeof(osip_srv_entry_t));
osip_free (message);
return 0; /* retry for next retransmission! */
}
#endif
/* SIP_NETWORK_ERROR; */
osip_free (message);
return -1;
}
if (eXosip.keep_alive > 0)
{
if (MSG_IS_REGISTER (sip))
{
eXosip_reg_t *reg = NULL;
if (_eXosip_reg_find (®, tr) == 0)
{
memcpy (&(reg->addr), &addr, len);
reg->len = len;
}
}
}
osip_free (message);
return 0;
}
int
_eXosip_build_response_default (struct eXosip_t *excontext, osip_message_t ** dest, osip_dialog_t * dialog, int status, osip_message_t * request)
{
osip_generic_param_t *tag;
osip_message_t *response;
int i;
*dest = NULL;
if (request == NULL)
return OSIP_BADPARAMETER;
i = osip_message_init (&response);
if (i != 0)
return i;
/* initialise osip_message_t structure */
/* yet done... */
response->sip_version = (char *) osip_malloc (8 * sizeof (char));
if (response->sip_version == NULL) {
osip_message_free (response);
return OSIP_NOMEM;
}
sprintf (response->sip_version, "SIP/2.0");
osip_message_set_status_code (response, status);
#ifndef MINISIZE
/* handle some internal reason definitions. */
if (MSG_IS_NOTIFY (request) && status == 481) {
response->reason_phrase = osip_strdup ("Subscription Does Not Exist");
}
else if (MSG_IS_SUBSCRIBE (request) && status == 202) {
response->reason_phrase = osip_strdup ("Accepted subscription");
}
else {
response->reason_phrase = osip_strdup (osip_message_get_reason (status));
if (response->reason_phrase == NULL) {
if (response->status_code == 101)
response->reason_phrase = osip_strdup ("Dialog Establishement");
else
response->reason_phrase = osip_strdup ("Unknown code");
}
response->req_uri = NULL;
response->sip_method = NULL;
}
#else
response->reason_phrase = osip_strdup (osip_message_get_reason (status));
if (response->reason_phrase == NULL) {
if (response->status_code == 101)
response->reason_phrase = osip_strdup ("Dialog Establishement");
else
response->reason_phrase = osip_strdup ("Unknown code");
}
response->req_uri = NULL;
response->sip_method = NULL;
#endif
if (response->reason_phrase == NULL) {
osip_message_free (response);
return OSIP_NOMEM;
}
i = osip_to_clone (request->to, &(response->to));
if (i != 0) {
osip_message_free (response);
return i;
}
i = osip_to_get_tag (response->to, &tag);
if (i != 0) { /* we only add a tag if it does not already contains one! */
if ((dialog != NULL) && (dialog->local_tag != NULL))
/* it should contain the local TAG we created */
{
osip_to_set_tag (response->to, osip_strdup (dialog->local_tag));
}
else {
if (status != 100)
osip_to_set_tag (response->to, _eXosip_malloc_new_random ());
}
}
i = osip_from_clone (request->from, &(response->from));
if (i != 0) {
osip_message_free (response);
return i;
}
{
osip_list_iterator_t it;
osip_via_t *via = (osip_via_t*)osip_list_get_first(&request->vias, &it);
while (via != NULL) {
osip_via_t *via2;
i = osip_via_clone (via, &via2);
if (i != 0) {
osip_message_free (response);
return i;
}
osip_list_add (&response->vias, via2, -1);
via = (osip_via_t *)osip_list_get_next(&it);
}
}
i = osip_call_id_clone (request->call_id, &(response->call_id));
if (i != 0) {
osip_message_free (response);
return i;
}
i = osip_cseq_clone (request->cseq, &(response->cseq));
if (i != 0) {
osip_message_free (response);
return i;
}
#ifndef MINISIZE
if (MSG_IS_SUBSCRIBE (request)) {
osip_header_t *exp;
osip_header_t *evt_hdr;
osip_message_header_get_byname (request, "event", 0, &evt_hdr);
if (evt_hdr != NULL && evt_hdr->hvalue != NULL)
osip_message_set_header (response, "Event", evt_hdr->hvalue);
else
osip_message_set_header (response, "Event", "presence");
i = osip_message_get_expires (request, 0, &exp);
if (exp == NULL) {
osip_header_t *cp;
i = osip_header_clone (exp, &cp);
if (cp != NULL)
osip_list_add (&response->headers, cp, 0);
}
}
#endif
osip_message_set_user_agent (response, excontext->user_agent);
*dest = response;
return OSIP_SUCCESS;
}