static void linphone_proxy_config_register(LinphoneProxyConfig *obj){
osip_message_t *msg;
eXosip_lock();
eXosip_register_build_register(obj->rid,obj->expires,&msg);
eXosip_register_send_register(obj->rid,msg);
eXosip_unlock();
}
void linphone_proxy_config_register_again_with_updated_contact(LinphoneProxyConfig *obj, osip_message_t *orig_request, osip_message_t *last_answer){
osip_message_t *msg;
const char *rport,*received;
osip_via_t *via=NULL;
osip_generic_param_t *param=NULL;
osip_contact_t *ctt=NULL;
osip_message_get_via(last_answer,0,&via);
if (!via) return;
osip_via_param_get_byname(via,"rport",¶m);
if (param) rport=param->gvalue;
else return;
param=NULL;
osip_via_param_get_byname(via,"received",¶m);
if (param) received=param->gvalue;
else return;
osip_message_get_contact(orig_request,0,&ctt);
if (strcmp(ctt->url->host,received)==0 && (ctt->url->port!=0 && strcmp(ctt->url->port,rport)==0)){
ms_message("Register has up to date contact, doing nothing.");
return;
}
eXosip_lock();
eXosip_register_build_register(obj->rid,obj->expires,&msg);
osip_message_get_contact(msg,0,&ctt);
if (ctt->url->host!=NULL){
osip_free(ctt->url->host);
}
ctt->url->host=osip_strdup(received);
if (ctt->url->port!=NULL){
osip_free(ctt->url->port);
}
ctt->url->port=osip_strdup(rport);
eXosip_register_send_register(obj->rid,msg);
eXosip_unlock();
ms_message("Resending new register with updated contact %s:%i",received,rport);
}
static void *
register_proc (void *arg)
{
struct regparam_t *regparam = arg;
int reg;
for (;;) {
#ifdef _WIN32_WCE
Sleep ((regparam->expiry / 2) * 1000);
#else
sleep (regparam->expiry / 2);
#endif
eXosip_lock (context_eXosip);
reg = eXosip_register_send_register (context_eXosip, regparam->regid, NULL);
if (0 > reg) {
#ifdef _WIN32_WCE
fprintf (stdout, "eXosip_register: error while registring");
#else
perror ("eXosip_register");
#endif
exit (1);
}
regparam->auth = 0;
eXosip_unlock (context_eXosip);
}
return NULL;
}
void linphone_proxy_config_edit(LinphoneProxyConfig *obj){
obj->frozen=TRUE;
if (obj->reg_sendregister){
/* unregister */
if (obj->registered) {
osip_message_t *msg;
eXosip_lock();
eXosip_register_build_register(obj->rid,0,&msg);
eXosip_register_send_register(obj->rid,msg);
eXosip_unlock();
obj->registered=FALSE;
}
}
}
int linphone_proxy_config_done(LinphoneProxyConfig *obj)
{
const char *id_str;
if (!linphone_proxy_config_check(obj->lc,obj)) return -1;
if (obj->reg_identity!=NULL) id_str=obj->reg_identity;
else id_str=linphone_core_get_primary_contact(obj->lc);
obj->frozen=FALSE;
if (obj->reg_sendregister){
char *ct=NULL;
osip_message_t *msg=NULL;
obj->rid=eXosip_register_build_initial_register(id_str,obj->reg_proxy,NULL,obj->expires,&msg);
eXosip_register_send_register(obj->rid,msg);
if (ct!=NULL) osip_free(ct);
}
return 0;
}
static int
_eXosip_retry_register_with_auth (eXosip_event_t * je)
{
eXosip_reg_t *jr = NULL;
if (eXosip_reg_find_id (&jr, je->rid) < 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: registration not found\n"));
return -1;
}
if (jr->r_retry < 3)
{
jr->r_retry++;
return eXosip_register_send_register (jr->r_id, NULL);
}
return -1;
}
void
eXosip_automatic_action (void)
{
eXosip_call_t *jc;
eXosip_dialog_t *jd;
#ifndef MINISIZE
eXosip_subscribe_t *js;
eXosip_notify_t *jn;
#endif
eXosip_reg_t *jr;
time_t now;
now = time (NULL);
for (jc = eXosip.j_calls; jc != NULL; jc = jc->next)
{
if (jc->c_id < 1)
{
} else if (jc->c_dialogs == NULL || jc->c_dialogs->d_dialog == NULL)
{
/* an EARLY dialog may have failed with 401,407 or 3Xx */
osip_transaction_t *out_tr = NULL;
out_tr = jc->c_out_tr;
if (out_tr != NULL
&& (out_tr->state == ICT_TERMINATED
|| out_tr->state == NICT_TERMINATED
|| out_tr->state == ICT_COMPLETED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code == 401
|| out_tr->last_response->status_code == 407))
{
/* retry with credential */
if (jc->c_retry < 3)
{
int i;
i = _eXosip_call_retry_request (jc, NULL, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone msg for authentication\n"));
}
jc->c_retry++;
}
} else if (out_tr != NULL
&& (out_tr->state == ICT_TERMINATED
|| out_tr->state == NICT_TERMINATED
|| out_tr->state == ICT_COMPLETED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code >= 300
&& out_tr->last_response->status_code <= 399))
{
/* retry with credential */
int i;
i = _eXosip_call_retry_request (jc, NULL, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone msg for redirection\n"));
}
}
}
for (jd = jc->c_dialogs; jd != NULL; jd = jd->next)
{
if (jd->d_dialog == NULL) /* finished call */
{
} else
{
osip_transaction_t *out_tr = NULL;
out_tr = osip_list_get (jd->d_out_trs, 0);
if (out_tr == NULL)
out_tr = jc->c_out_tr;
if (out_tr != NULL
&& (out_tr->state == ICT_TERMINATED
|| out_tr->state == NICT_TERMINATED
|| out_tr->state == ICT_COMPLETED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code == 401
|| out_tr->last_response->status_code == 407))
{
/* retry with credential */
if (jd->d_retry < 3)
{
int i;
i =
_eXosip_call_retry_request (jc, jd, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone msg for authentication\n"));
}
jd->d_retry++;
}
} else if (out_tr != NULL
&& (out_tr->state == ICT_TERMINATED
|| out_tr->state == NICT_TERMINATED
|| out_tr->state == ICT_COMPLETED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code >= 300
&& out_tr->last_response->status_code <= 399))
{
/* retry with credential */
int i;
i = _eXosip_call_retry_request (jc, jd, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone msg for redirection\n"));
}
}
}
}
}
#ifndef MINISIZE
for (js = eXosip.j_subscribes; js != NULL; js = js->next)
{
if (js->s_id < 1)
{
} else if (js->s_dialogs == NULL)
{
osip_transaction_t *out_tr = NULL;
out_tr = js->s_out_tr;
if (out_tr != NULL
&& (out_tr->state == NICT_TERMINATED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code == 401
|| out_tr->last_response->status_code == 407))
{
/* retry with credential */
if (js->s_retry < 3)
{
int i;
i =
_eXosip_subscribe_send_request_with_credential (js, NULL,
out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone msg for authentication\n"));
}
js->s_retry++;
}
}
}
for (jd = js->s_dialogs; jd != NULL; jd = jd->next)
{
if (jd->d_dialog != NULL) /* finished call */
{
if (jd->d_id >= 1)
{
osip_transaction_t *out_tr = NULL;
out_tr = osip_list_get (jd->d_out_trs, 0);
if (out_tr == NULL)
out_tr = js->s_out_tr;
if (out_tr != NULL
&& (out_tr->state == NICT_TERMINATED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code == 401
|| out_tr->last_response->status_code == 407))
{
/* retry with credential */
if (jd->d_retry < 3)
{
int i;
i =
_eXosip_subscribe_send_request_with_credential (js, jd,
out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR,
NULL,
"eXosip: could not clone suscbribe for authentication\n"));
}
jd->d_retry++;
}
} else if (js->s_reg_period == 0 || out_tr == NULL)
{
} else if (now - out_tr->birth_time > js->s_reg_period - 60)
{ /* will expires in 60 sec: send refresh! */
int i;
i = _eXosip_subscribe_automatic_refresh(js, jd, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not clone subscribe for refresh\n"));
}
}
}
}
}
}
for (jn = eXosip.j_notifies; jn != NULL; jn = jn->next)
{
for (jd = jn->n_dialogs; jd != NULL; jd = jd->next)
{
if (jd->d_dialog != NULL) /* finished call */
{
if (jd->d_id >= 1)
{
osip_transaction_t *out_tr = NULL;
out_tr = osip_list_get (jd->d_out_trs, 0);
if (out_tr != NULL
&& (out_tr->state == NICT_TERMINATED
|| out_tr->state == NICT_COMPLETED) &&
now - out_tr->birth_time < 120 &&
out_tr->orig_request != NULL &&
out_tr->last_response != NULL &&
(out_tr->last_response->status_code == 401
|| out_tr->last_response->status_code == 407))
{
/* retry with credential */
if (jd->d_retry < 3)
{
int i;
i =
_eXosip_insubscription_send_request_with_credential
(jn, jd, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR,
NULL,
"eXosip: could not clone notify for authentication\n"));
}
jd->d_retry++;
}
}
}
}
}
}
#endif
for (jr = eXosip.j_reg; jr != NULL; jr = jr->next)
{
if (jr->r_id >= 1 && jr->r_last_tr != NULL)
{
if (jr->r_reg_period != 0 && now - jr->r_last_tr->birth_time > 900)
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
} else if (jr->r_reg_period != 0
&& now - jr->r_last_tr->birth_time > jr->r_reg_period - 60)
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
} else if (jr->r_reg_period != 0
&& now - jr->r_last_tr->birth_time > 120
&& (jr->r_last_tr->last_response == NULL
|| (!MSG_IS_STATUS_2XX (jr->r_last_tr->last_response))))
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
} else if (now - jr->r_last_tr->birth_time < 120 &&
jr->r_last_tr->orig_request != NULL &&
(jr->r_last_tr->last_response != NULL
&& (jr->r_last_tr->last_response->status_code == 401
|| jr->r_last_tr->last_response->status_code == 407)))
{
if (jr->r_retry < 3)
{
/* TODO: improve support for several retries when
several credentials are needed */
eXosip_register_send_register (jr->r_id, NULL);
jr->r_retry++;
}
}
}
}
}
void
eXosip_automatic_refresh (void)
{
eXosip_subscribe_t *js;
eXosip_dialog_t *jd;
eXosip_reg_t *jr;
time_t now;
now = time (NULL);
for (js = eXosip.j_subscribes; js != NULL; js = js->next)
{
for (jd = js->s_dialogs; jd != NULL; jd = jd->next)
{
if (jd->d_dialog != NULL && (jd->d_id >= 1)) /* finished call */
{
osip_transaction_t *out_tr = NULL;
out_tr = osip_list_get (jd->d_out_trs, 0);
if (out_tr == NULL)
out_tr = js->s_out_tr;
if (js->s_reg_period == 0 || out_tr == NULL)
{
} else if (now - out_tr->birth_time > js->s_reg_period - 60)
{ /* will expires in 60 sec: send refresh! */
int i;
i = _eXosip_subscribe_automatic_refresh(js, jd, out_tr);
if (i != 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"eXosip: could not send subscribe for refresh\n"));
}
}
}
}
}
for (jr = eXosip.j_reg; jr != NULL; jr = jr->next)
{
if (jr->r_id >= 1 && jr->r_last_tr != NULL)
{
if (jr->r_reg_period == 0)
{
/* skip refresh! */
} else if (now - jr->r_last_tr->birth_time > 900)
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
} else if (now - jr->r_last_tr->birth_time > jr->r_reg_period - 60)
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
} else if (now - jr->r_last_tr->birth_time > 120 &&
(jr->r_last_tr->last_response == NULL
|| (!MSG_IS_STATUS_2XX (jr->r_last_tr->last_response))))
{
/* automatic refresh */
eXosip_register_send_register (jr->r_id, NULL);
}
}
}
}
int uac_register()
{
int expires=3600; /* 注册存活时间 */
int ret = 0; /* 注册返回值 */
eXosip_event_t *je = NULL; /* 监听到的消息指针 */
osip_message_t *reg = NULL; /* 注册的消息体指针 */
char from[100];/*sip:主叫用户名@被叫IP地址*/
char proxy[100];/*sip:被叫IP地址:被叫IP端口*/
memset(from, 0, 100);
memset(proxy, 0, 100);
sprintf(from, "sip:%s@%s", device_info.ipc_id, device_info.server_ip);
sprintf(proxy, "sip:%s:%s", device_info.server_ip, device_info.server_port);
/*------step 1-----------发送不带认证信息的注册请求-----------------------*/
retry:
eXosip_lock();
g_register_id = eXosip_register_build_initial_register(from, proxy, NULL, expires, ®);
char mac[12];
memset(mac,0,12);
memcpy(mac,RegisterCon->self_MACaddr.macaddr,sizeof(RegisterCon->self_MACaddr.macaddr));
//mac[12]='\n';
//getNetInfo(NULL,mac);//printf("mac:%02x %02x %02x %02x %02x %02x",mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);
codeToChar(mac,sizeof(mac));
char mac_subject[20];
sprintf(mac_subject,"MAC:%s\r\n",mac);
osip_message_set_subject(reg,mac_subject);
osip_message_set_authorization(reg, "Capability algorithm=\"H:MD5\"");
if (0 > g_register_id)
{
eXosip_lock();
printf("eXosip_register_build_initial_register error!\r\n");
return -1;
}
printf("eXosip_register_build_initial_register success!\r\n");
ret = eXosip_register_send_register(g_register_id, reg);
eXosip_unlock();
if (0 != ret)
{
printf("eXosip_register_send_register no authorization error!\r\n");
return -1;
}
printf("eXosip_register_send_register no authorization success!\r\n");
printf("g_register_id=%d\r\n", g_register_id);
for (;;)
{
je = eXosip_event_wait(10, 500);/*侦听消息的到来*/
if (NULL == je)/*没有接收到消息*/
{
continue;
}
if (EXOSIP_REGISTRATION_FAILURE == je->type)/*注册失败*/
{
printf("<EXOSIP_REGISTRATION_FAILURE>\r\n");
printf("je->rid=%d\r\n", je->rid);
/*-------step 2---------收到服务器返回的注册失败/401未认证状态------------*/
if ((NULL != je->response)&&(401 == je->response->status_code))
{
AuthActive * auth_active_packet_data=NULL;
osip_body_t *body;
osip_header_t * subject;
osip_message_get_subject(je->response,0,&subject);
if(subject==NULL)
{
printf("no subject\n");
return 0;
}
//printf("subject->hvalue:%s\n",subject->hvalue);
char mac[12];
memset(mac, 0, 12);
memcpy(mac,subject->hvalue,4);
if(!strcmp(mac,"MAC:"))
{
memcpy(mac,subject->hvalue+4,12);
decodeFromChar(mac,12);
memcpy(RegisterCon->peer_MACaddr.macaddr,mac,6);
}
else
{
printf("subject not match\n");
return 0;
}
osip_message_get_body (je->response, 0, &body);
if(!auth_active_packet_data)
{
free(auth_active_packet_data);
auth_active_packet_data=NULL;
}
if((sizeof(AuthActive)*2)>(body->length))
{
printf("body->length is not enough");
return 0;
}
auth_active_packet_data=(AuthActive *)malloc (sizeof(AuthActive)*2);//;body->length*sizeof(char));
memset(auth_active_packet_data,0,sizeof(AuthActive)*2);
memcpy(auth_active_packet_data,body->body, sizeof(AuthActive)*2);
decodeFromChar((char*)auth_active_packet_data,sizeof(AuthActive)*2);
if(!HandleWAPIProtocolAuthActive(RegisterCon,auth_active_packet_data))
{
printf("HandleWAPIProtocolAuthActive error\n");
return 0;
}
/*
//printf("message:%s\n",message);
if(0/*when receive 401Unauthorized package，send ACK and Regester/)
{
osip_message_t *ack = NULL;
int call_id=atoi(reg->call_id->number);
printf("je->did:%d\n",je->did);
ret=eXosip_call_build_ack(je->rid,&ack);
ret=eXosip_call_send_ack(atoi(je->rid),ack);
}
*/
reg = NULL;
/*----------step 3-------------发送携带认证信息的注册请求----------------------*/
eXosip_lock();
int return_num;
return_num=eXosip_clear_authentication_info();/*清除认证信息*/
printf("return_num:%d\n",return_num);
return_num=eXosip_add_authentication_info(device_info.ipc_id, device_info.ipc_id, device_info.ipc_pwd, "MD5", NULL);/*添加主叫用户的认证信息*/
printf("return_num:%d\n",return_num);
printf("je->rid:%d expires:%d return num:%d\n",je->rid,expires,eXosip_register_build_register(je->rid, expires, ®));
//if(auth_request_packet_data!=NULL)
//{
//free(auth_request_packet_data);
//auth_request_packet_data=NULL;
//}
auth_request_packet_data=(AccessAuthRequ*)malloc(sizeof(AccessAuthRequ)*2);
memset(auth_request_packet_data,0, sizeof(AccessAuthRequ)*2);
if(ProcessWAPIProtocolAccessAuthRequest(RegisterCon,auth_active_packet_data,auth_request_packet_data)<1)
{
printf("ProcessWAPIProtocolAccessAuthRequest error\n");
return 0;
}
codeToChar((char*)auth_request_packet_data,sizeof(AccessAuthRequ)*2);
//printf("length:%d",(sizeof(AuthActive)*2));
//printf("length:%d",(sizeof(AccessAuthRequ)*2));
//printf("length:%d",(sizeof(CertificateAuthRequ)*2));
//printf("length:%d",sizeof(CertificateAuthResp)*2);
//printf("length:%d",sizeof(AccessAuthResp)*2);
printf("111\n");
if(reg==NULL)
{
printf("reg==NULL\n");
}
osip_message_set_body(reg,(char*)auth_request_packet_data,sizeof(AccessAuthRequ)*2);printf("222\n");
printf("333\n");
printf("je->rid:%d\n",je->rid);printf("444\n");
ret = eXosip_register_send_register(je->rid, reg);
eXosip_unlock();
decodeFromChar((char *)auth_request_packet_data,sizeof(AccessAuthRequ)*2);
if (0 != ret)
{
printf("eXosip_register_send_register authorization error!\r\n");
return -1;
}
printf("eXosip_register_send_register authorization success!\r\n");
eXosip_event_free (je);
//free(auth_active_packet_data);
printf("end\n");
}
else/*真正的注册失败*/
{
printf("EXOSIP_REGISTRATION_FAILURE error!\r\n");
eXosip_event_free (je);
return -1;
//goto retry;/*重新注册*/
}
}
else if (EXOSIP_REGISTRATION_SUCCESS == je->type)
{printf("recieve EXOSIP_REGISTRATION_SUCCESS\n");
/*---------step 6-------------收到服务器返回的注册成功--------------------------------*/
AccessAuthResp * access_auth_resp_data;
osip_body_t *body;
osip_message_get_body (je->response, 0, &body);
if(body==NULL)
{
printf("body==NULL\n");
return 0;
}
if( body->length<sizeof(AccessAuthResp)*2)
{
printf("message length is too short:%d\n",body->length);
return 0;
}
access_auth_resp_data=(AccessAuthResp *)malloc (body->length*sizeof(char));
memcpy(access_auth_resp_data,body->body, body->length);
decodeFromChar((char*)access_auth_resp_data,sizeof(AccessAuthResp)*2);
if(auth_request_packet_data==NULL)
{
printf("auth_request_packet_data = NULL\n");
}
if(HandleWAPIProtocolAccessAuthResp(RegisterCon,auth_request_packet_data,access_auth_resp_data)<1)
{
printf("HandleWAPIProtocolAccessAuthResp error\n");
return 0;
}
g_register_id = je->rid;/*保存注册成功的注册ID*/
printf("g_register_id=%d\r\n", g_register_id);
printf("<EXOSIP_REGISTRATION_SUCCESS>\r\n");
/*
//send key agreement package 发送密钥协商包
osip_message_t * inforequest;
ret=eXosip_message_build_request(&inforequest,"MESSAGE",proxy,from,NULL);
ret=osip_message_set_body(inforequest,"sssss",6);
ret=eXosip_message_send_request(inforequest);
*/
eXosip_event_free (je);
free(auth_request_packet_data);
free(access_auth_resp_data);
return 1;
break;
}
}
return 0;
}
int
main (int argc, char *argv[])
#endif
{
int c;
int port = 5060;
char *contact = NULL;
char *fromuser = NULL;
const char *localip = NULL;
const char *firewallip = NULL;
char *proxy = NULL;
#if !defined(__arc__)
struct servent *service;
#endif
char *username = NULL;
char *password = NULL;
struct regparam_t regparam = { 0, 3600, 0 };
#ifndef OSIP_MONOTHREAD
struct osip_thread *register_thread;
#endif
int debug = 0;
int nofork = 0;
#ifdef _WIN32_WCE
proxy = osip_strdup ("sip:sip.antisip.com");
fromuser = osip_strdup ("sip:[email protected]");
#else
for (;;) {
#define short_options "c:de:f:hl:p:r:u:U:P:"
#ifdef _GNU_SOURCE
int option_index = 0;
static struct option long_options[] = {
{"contact", required_argument, NULL, 'c'},
{"debug", no_argument, NULL, 'd'},
{"expiry", required_argument, NULL, 'e'},
{"firewallip", required_argument, NULL, 'f'},
{"from", required_argument, NULL, 'u'},
{"help", no_argument, NULL, 'h'},
{"localip", required_argument, NULL, 'l'},
{"port", required_argument, NULL, 'p'},
{"proxy", required_argument, NULL, 'r'},
{"username", required_argument, NULL, 'U'},
{"password", required_argument, NULL, 'P'},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, short_options, long_options, &option_index);
#else
c = getopt (argc, argv, short_options);
#endif
if (c == -1)
break;
switch (c) {
case 'c':
contact = optarg;
break;
case 'd':
nofork = 1;
#ifdef LOG_PERROR
debug = LOG_PERROR;
#endif
break;
case 'e':
regparam.expiry = atoi (optarg);
break;
case 'f':
firewallip = optarg;
break;
case 'h':
usage ();
exit (0);
case 'l':
localip = optarg;
break;
case 'p':
#if !defined(__arc__)
service = getservbyname (optarg, "udp");
if (service)
port = ntohs (service->s_port);
else
port = atoi (optarg);
#else
port = atoi (optarg);
#endif
break;
case 'r':
proxy = optarg;
break;
case 'u':
fromuser = optarg;
break;
case 'U':
username = optarg;
break;
case 'P':
password = optarg;
break;
default:
break;
}
}
#endif
if (!proxy || !fromuser) {
usage ();
exit (1);
}
#ifndef _WIN32_WCE
if (!nofork) {
daemon (1, 0);
}
#endif
#if 0
openlog (PROG_NAME, LOG_PID | debug, SYSLOG_FACILITY);
#endif
syslog_wrapper (LOG_INFO, UA_STRING " up and running");
syslog_wrapper (LOG_INFO, "proxy: %s", proxy);
syslog_wrapper (LOG_INFO, "fromuser: %s", fromuser);
syslog_wrapper (LOG_INFO, "contact: %s", contact);
syslog_wrapper (LOG_INFO, "expiry: %d", regparam.expiry);
syslog_wrapper (LOG_INFO, "local port: %d", port);
if (debug > 0)
TRACE_INITIALIZE (6, NULL);
context_eXosip = eXosip_malloc ();
if (eXosip_init (context_eXosip)) {
syslog_wrapper (LOG_ERR, "eXosip_init failed");
exit (1);
}
if (eXosip_listen_addr (context_eXosip, IPPROTO_UDP, NULL, port, AF_INET, 0)) {
syslog_wrapper (LOG_ERR, "eXosip_listen_addr failed");
exit (1);
}
if (localip) {
syslog_wrapper (LOG_INFO, "local address: %s", localip);
eXosip_masquerade_contact (context_eXosip, localip, port);
}
if (firewallip) {
syslog_wrapper (LOG_INFO, "firewall address: %s:%i", firewallip, port);
eXosip_masquerade_contact (context_eXosip, firewallip, port);
}
eXosip_set_user_agent (context_eXosip, UA_STRING);
if (username && password) {
syslog_wrapper (LOG_INFO, "username: %s", username);
syslog_wrapper (LOG_INFO, "password: [removed]");
if (eXosip_add_authentication_info (context_eXosip, username, username, password, NULL, NULL)) {
syslog_wrapper (LOG_ERR, "eXosip_add_authentication_info failed");
exit (1);
}
}
{
osip_message_t *reg = NULL;
int i;
regparam.regid = eXosip_register_build_initial_register (context_eXosip, fromuser, proxy, contact, regparam.expiry * 2, ®);
if (regparam.regid < 1) {
syslog_wrapper (LOG_ERR, "eXosip_register_build_initial_register failed");
exit (1);
}
i = eXosip_register_send_register (context_eXosip, regparam.regid, reg);
if (i != 0) {
syslog_wrapper (LOG_ERR, "eXosip_register_send_register failed");
exit (1);
}
}
#ifndef OSIP_MONOTHREAD
register_thread = osip_thread_create (20000, register_proc, ®param);
if (register_thread == NULL) {
syslog_wrapper (LOG_ERR, "pthread_create failed");
exit (1);
}
#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;
}
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
#endif
eXosip_automatic_action (context_eXosip);
switch (event->type) {
case EXOSIP_REGISTRATION_SUCCESS:
syslog_wrapper (LOG_INFO, "registrered successfully");
break;
case EXOSIP_REGISTRATION_FAILURE:
regparam.auth = 1;
break;
default:
syslog_wrapper (LOG_DEBUG, "recieved unknown eXosip event (type, did, cid) = (%d, %d, %d)", event->type, event->did, event->cid);
}
eXosip_event_free (event);
}
}
