static LinphoneFriendList * linphone_friend_list_new(void) {
LinphoneFriendList *list = belle_sip_object_new(LinphoneFriendList);
list->cbs = linphone_friend_list_cbs_new();
list->enable_subscriptions = TRUE;
belle_sip_object_ref(list);
return list;
}
static LinphoneNatPolicy * _linphone_nat_policy_new_with_ref(LinphoneCore *lc, const char *ref) {
LinphoneNatPolicy *policy = belle_sip_object_new(LinphoneNatPolicy);
belle_sip_object_ref(policy);
policy->lc = lc;
policy->ref = belle_sip_strdup(ref);
return policy;
}
belle_sip_uri_t* belle_sip_uri_new () {
belle_sip_uri_t* l_object = belle_sip_object_new(belle_sip_uri_t);
belle_sip_parameters_init((belle_sip_parameters_t*)l_object); /*super*/
l_object->header_list = belle_sip_parameters_new();
belle_sip_object_ref(l_object->header_list);
return l_object;
}
/*
* The http channel context stores pending requests so that they can be matched with response received.
* It is associated with the channel when the channel is created, and automatically destroyed when the channel is destroyed.
**/
belle_http_channel_context_t * belle_http_channel_context_new(belle_sip_channel_t *chan, belle_http_provider_t *prov){
belle_http_channel_context_t *obj=belle_sip_object_new(belle_http_channel_context_t);
obj->provider=prov;
belle_sip_channel_add_listener(chan,(belle_sip_channel_listener_t*)obj);
belle_sip_object_weak_ref(chan,(belle_sip_object_destroy_notify_t)on_channel_destroyed,obj);
return obj;
}
LinphoneCallParams * linphone_call_params_new(void) {
LinphoneCallParams *cp=belle_sip_object_new(LinphoneCallParams);
cp->audio_dir=LinphoneMediaDirectionSendRecv;
cp->video_dir=LinphoneMediaDirectionSendRecv;
cp->realtimetext_enabled=TRUE; /*fixme*/
return cp;
}
belle_sip_memory_body_handler_t *belle_sip_memory_body_handler_new_from_buffer(void *buffer, size_t bufsize, belle_sip_body_handler_progress_callback_t cb, void *user_data){
belle_sip_memory_body_handler_t *obj=belle_sip_object_new(belle_sip_memory_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,cb,user_data);
obj->buffer=(uint8_t*)buffer;
obj->base.expected_size=bufsize;
return obj;
}
belle_sip_refresher_t* belle_sip_refresher_new(belle_sip_client_transaction_t* transaction) {
belle_sip_refresher_t* refresher;
belle_sip_transaction_state_t state=belle_sip_transaction_get_state(BELLE_SIP_TRANSACTION(transaction));
belle_sip_request_t* request = belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(transaction));
int is_register=strcmp("REGISTER",belle_sip_request_get_method(request))==0;
refresher = (belle_sip_refresher_t*)belle_sip_object_new(belle_sip_refresher_t);
refresher->transaction=transaction;
refresher->state=stopped;
refresher->number_of_retry=0;
belle_sip_object_ref(transaction);
refresher->retry_after=DEFAULT_RETRY_AFTER;
if (belle_sip_transaction_get_dialog(BELLE_SIP_TRANSACTION(transaction))) {
set_or_update_dialog(refresher, belle_sip_transaction_get_dialog(BELLE_SIP_TRANSACTION(transaction)));
}
belle_sip_provider_add_internal_sip_listener(transaction->base.provider,BELLE_SIP_LISTENER(refresher), is_register);
if (set_expires_from_trans(refresher)==-1){
belle_sip_error("Unable to extract refresh value from transaction [%p]",transaction);
}
if (belle_sip_transaction_state_is_transient(state)) {
belle_sip_message("Refresher [%p] takes ownership of transaction [%p]",refresher,transaction);
transaction->base.is_internal=1;
refresher->state=started;
}else{
belle_sip_refresher_start(refresher);
}
return refresher;
}
belle_sip_hop_t* belle_sip_hop_new(const char* transport, const char *cname, const char* host,int port) {
belle_sip_hop_t* hop = belle_sip_object_new(belle_sip_hop_t);
if (transport) hop->transport=belle_sip_strdup(transport);
if (host) hop->host=belle_sip_strdup(host);
if (cname) hop->cname=belle_sip_strdup(cname);
hop->port=port;
return hop;
}
LinphoneAccountCreator * linphone_account_creator_new(LinphoneCore *core, const char *xmlrpc_url) {
LinphoneAccountCreator *creator;
creator = belle_sip_object_new(LinphoneAccountCreator);
creator->callbacks = linphone_account_creator_cbs_new();
creator->core = core;
creator->xmlrpc_session = linphone_xml_rpc_session_new(core, xmlrpc_url);
return creator;
}
static LinphoneXmlRpcRequest * _linphone_xml_rpc_request_new(const char *method, LinphoneXmlRpcArgType return_type) {
LinphoneXmlRpcRequest *request = belle_sip_object_new(LinphoneXmlRpcRequest);
request->callbacks = linphone_xml_rpc_request_cbs_new();
request->status = LinphoneXmlRpcStatusPending;
request->response.type = return_type;
request->method = belle_sip_strdup(method);
return request;
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_ict_t *belle_sip_ict_new(belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_ict_t *obj=belle_sip_object_new(belle_sip_ict_t);
belle_sip_client_transaction_init((belle_sip_client_transaction_t*)obj,prov,req);
return obj;
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_channel_t * belle_sip_channel_new_udp(belle_sip_stack_t *stack, int sock, const char *bindip, int localport, const char *dest, int port){
belle_sip_udp_channel_t *obj=belle_sip_object_new(belle_sip_udp_channel_t);
belle_sip_channel_init((belle_sip_channel_t*)obj,stack,bindip,localport,NULL,dest,port);
belle_sip_channel_set_socket((belle_sip_channel_t*)obj,sock,NULL);
return (belle_sip_channel_t*)obj;
}
belle_http_provider_t *belle_http_provider_new(belle_sip_stack_t *s, const char *bind_ip){
belle_http_provider_t *p=belle_sip_object_new(belle_http_provider_t);
p->stack=s;
p->bind_ip=belle_sip_strdup(bind_ip);
p->ai_family=strchr(p->bind_ip,':') ? AF_INET6 : AF_INET;
p->verify_ctx=belle_tls_verify_policy_new();
return p;
}
LinphoneFriend * linphone_friend_new(void){
LinphoneFriend *obj = belle_sip_object_new(LinphoneFriend);
obj->pol = LinphoneSPAccept;
obj->presence = NULL;
obj->subscribe = TRUE;
obj->vcard = NULL;
obj->storage_id = 0;
return obj;
}
belle_sip_memory_body_handler_t *belle_sip_memory_body_handler_new_copy_from_buffer(const void *buffer, size_t bufsize, belle_sip_body_handler_progress_callback_t cb, void *user_data){
belle_sip_memory_body_handler_t *obj=belle_sip_object_new(belle_sip_memory_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,cb,user_data);
obj->buffer=(uint8_t*)belle_sip_malloc(bufsize+1);
obj->buffer[bufsize]='\0';
obj->base.expected_size=bufsize;
memcpy(obj->buffer,buffer,bufsize);
return obj;
}
belle_sip_listening_point_t * belle_sip_udp_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port){
belle_sip_udp_listening_point_t *lp=belle_sip_object_new(belle_sip_udp_listening_point_t);
belle_sip_udp_listening_point_init(lp,s,ipaddress, port);
if (lp->sock==(belle_sip_socket_t)-1){
belle_sip_object_unref(lp);
return NULL;
}
return (belle_sip_listening_point_t*)lp;
}
static LinphoneEvent * linphone_event_new_base(LinphoneCore *lc, LinphoneSubscriptionDir dir, const char *name, SalOp *op){
LinphoneEvent *lev=belle_sip_object_new(LinphoneEvent);
lev->lc=lc;
lev->dir=dir;
lev->op=op;
lev->name=ms_strdup(name);
sal_op_set_user_pointer(lev->op,lev);
return lev;
}
belle_sip_channel_t * belle_sip_channel_new_udp_with_addr(belle_sip_stack_t *stack, int sock, const char *bindip, int localport, const struct addrinfo *peer){
belle_sip_udp_channel_t *obj=belle_sip_object_new(belle_sip_udp_channel_t);
belle_sip_channel_init_with_addr((belle_sip_channel_t*)obj,stack,peer->ai_addr, peer->ai_addrlen);
obj->base.local_port=localport;
belle_sip_channel_set_socket((belle_sip_channel_t*)obj,sock,NULL);
/*this lookups the local address*/
udp_channel_connect((belle_sip_channel_t*)obj,peer);
return (belle_sip_channel_t*)obj;
}
belle_sip_certificates_chain_t* belle_sip_certificates_chain_parse_file(const char* path, belle_sip_certificate_raw_format_t format) {
belle_sip_certificates_chain_t* certificate = belle_sip_object_new(belle_sip_certificates_chain_t);
if (belle_sip_certificate_fill_from_file(certificate, path, format)) {
belle_sip_object_unref(certificate);
certificate=NULL;
}
return certificate;
}
belle_sip_dialog_t *belle_sip_dialog_new(belle_sip_transaction_t *t){
belle_sip_dialog_t *obj;
belle_sip_header_from_t *from;
const char *from_tag;
belle_sip_header_to_t *to;
const char *to_tag=NULL;
from=belle_sip_message_get_header_by_type(t->request,belle_sip_header_from_t);
if (from==NULL){
belle_sip_error("belle_sip_dialog_new(): no from!");
return NULL;
}
from_tag=belle_sip_header_from_get_tag(from);
if (from_tag==NULL){
belle_sip_error("belle_sip_dialog_new(): no from tag!");
return NULL;
}
if (t->last_response) {
to=belle_sip_message_get_header_by_type(t->last_response,belle_sip_header_to_t);
if (to==NULL){
belle_sip_error("belle_sip_dialog_new(): no to!");
return NULL;
}
to_tag=belle_sip_header_to_get_tag(to);
}
obj=belle_sip_object_new(belle_sip_dialog_t);
obj->terminate_on_bye=1;
obj->provider=t->provider;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(t,belle_sip_server_transaction_t)){
obj->remote_tag=belle_sip_strdup(from_tag);
obj->local_tag=to_tag?belle_sip_strdup(to_tag):NULL; /*might be null at dialog creation*/
obj->remote_party=(belle_sip_header_address_t*)belle_sip_object_ref(from);
obj->is_server=TRUE;
}else{
const belle_sip_list_t *predefined_routes=NULL;
obj->local_tag=belle_sip_strdup(from_tag);
obj->remote_tag=to_tag?belle_sip_strdup(to_tag):NULL; /*might be null at dialog creation*/
obj->local_party=(belle_sip_header_address_t*)belle_sip_object_ref(from);
obj->is_server=FALSE;
for(predefined_routes=belle_sip_message_get_headers((belle_sip_message_t*)t->request,BELLE_SIP_ROUTE);
predefined_routes!=NULL;predefined_routes=predefined_routes->next){
obj->route_set=belle_sip_list_append(obj->route_set,belle_sip_object_ref(predefined_routes->data));
}
}
belle_sip_message("New %s dialog [%p] , local tag [%s], remote tag [%s]"
,obj->is_server?"server":"client"
,obj
,obj->local_tag?obj->local_tag:""
,obj->remote_tag?obj->remote_tag:"");
set_state(obj,BELLE_SIP_DIALOG_NULL);
return obj;
}
belle_sip_stack_t * belle_sip_stack_new(const char *properties){
belle_sip_stack_t *stack=belle_sip_object_new(belle_sip_stack_t);
stack->ml=belle_sip_main_loop_new ();
stack->timer_config.T1=500;
stack->timer_config.T2=4000;
stack->timer_config.T4=5000;
stack->transport_timeout=30000;
stack->dns_timeout=15000;
stack->inactive_transport_timeout=3600; /*one hour*/
return stack;
}
static LinphoneContent * linphone_content_new_with_body_handler(SalBodyHandler *body_handler) {
LinphoneContent *content = belle_sip_object_new(LinphoneContent);
belle_sip_object_ref(content);
content->owned_fields = TRUE;
content->cryptoContext = NULL; /* this field is managed externally by encryption/decryption functions so be careful to initialise it to NULL */
if (body_handler == NULL) {
linphone_content_set_sal_body_handler(content, sal_body_handler_new());
} else {
linphone_content_set_sal_body_handler(content, body_handler);
}
return content;
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_file_body_handler_t *belle_sip_file_body_handler_new(const char *filepath, belle_sip_body_handler_progress_callback_t progress_cb, void *data) {
struct stat statbuf;
belle_sip_file_body_handler_t *obj = belle_sip_object_new(belle_sip_file_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj, progress_cb, data);
obj->filepath = belle_sip_strdup(filepath);
if (stat(obj->filepath, &statbuf) == 0) {
obj->base.expected_size = statbuf.st_size;
}
return obj;
}
belle_sip_listening_point_t * belle_sip_tls_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port){
belle_sip_tls_listening_point_t *lp=belle_sip_object_new(belle_sip_tls_listening_point_t);
#ifdef ENABLE_SERVER_SOCKETS
belle_sip_stream_listening_point_init((belle_sip_stream_listening_point_t*)lp,s,ipaddress,port,on_new_connection);
#else
belle_sip_stream_listening_point_init((belle_sip_stream_listening_point_t*)lp,s,ipaddress,port);
#endif /* ENABLE_SERVER_SOCKETS */
lp->crypto_config=belle_tls_crypto_config_new();
return BELLE_SIP_LISTENING_POINT(lp);
}
LinphoneAccountCreator * linphone_account_creator_new(LinphoneCore *core, const char *xmlrpc_url) {
LinphoneAccountCreator *creator;
const char* domain = lp_config_get_string(core->config, "assistant", "domain", NULL);
creator = belle_sip_object_new(LinphoneAccountCreator);
creator->callbacks = linphone_account_creator_cbs_new();
creator->core = core;
creator->xmlrpc_session = linphone_xml_rpc_session_new(core, xmlrpc_url);
if (domain) {
linphone_account_creator_set_domain(creator, domain);
}
return creator;
}
belle_sip_listening_point_t * belle_sip_stream_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port){
belle_sip_stream_listening_point_t *lp=belle_sip_object_new(belle_sip_stream_listening_point_t);
#ifdef ENABLE_SERVER_SOCKETS
belle_sip_stream_listening_point_init(lp,s,ipaddress,port,on_new_connection);
if (lp->server_sock==(belle_sip_socket_t)-1){
belle_sip_object_unref(lp);
return NULL;
}
#else
belle_sip_stream_listening_point_init(lp,s,ipaddress,port);
#endif /* ENABLE_SERVER_SOCKETS */
return BELLE_SIP_LISTENING_POINT(lp);
}
belle_sip_listening_point_t * belle_sip_tls_listening_point_new(belle_sip_stack_t *s, const char *ipaddress, int port){
belle_sip_tls_listening_point_t *lp=belle_sip_object_new(belle_sip_tls_listening_point_t);
belle_sip_stream_listening_point_init((belle_sip_stream_listening_point_t*)lp,s,ipaddress,port,on_new_connection);
lp->verify_exceptions=0;
/*try to load "system" default root ca, wihtout warranty...*/
#ifdef __linux
belle_sip_tls_listening_point_set_root_ca(lp,"/etc/ssl/certs");
#elif defined(__APPLE__)
belle_sip_tls_listening_point_set_root_ca(lp,"/opt/local/share/curl/curl-ca-bundle.crt");
#endif
return BELLE_SIP_LISTENING_POINT(lp);
}
belle_tls_verify_policy_t *belle_tls_verify_policy_new(){
belle_tls_verify_policy_t *obj=belle_sip_object_new(belle_tls_verify_policy_t);
/*default to "system" default root ca, wihtout warranty...*/
#ifdef __linux
belle_tls_verify_policy_set_root_ca(obj,"/etc/ssl/certs");
#elif defined(__APPLE__)
belle_tls_verify_policy_set_root_ca(obj,"/opt/local/share/curl/curl-ca-bundle.crt");
#elif __QNX__
belle_tls_verify_policy_set_root_ca(obj,"/var/certs/web_trusted@personal@certmgr");
#endif
return obj;
}
static int belle_sip_certificate_fill(belle_sip_certificates_chain_t* certificate,const char* buff, size_t size,belle_sip_certificate_raw_format_t format) {
#ifdef HAVE_POLARSSL
int err;
#if POLARSSL_VERSION_NUMBER < 0x01030000
if ((err=x509parse_crt(&certificate->cert,(const unsigned char *)buff,size)) <0) {
#else
if ((err=x509_crt_parse(&certificate->cert,(const unsigned char *)buff,size)) <0) {
#endif
char tmp[128];
error_strerror(err,tmp,sizeof(tmp));
belle_sip_error("cannot parse x509 cert because [%s]",tmp);
return -1;
}
return 0;
#else /*HAVE_POLARSSL*/
return -1;
#endif
}
static int belle_sip_certificate_fill_from_file(belle_sip_certificates_chain_t* certificate,const char* path,belle_sip_certificate_raw_format_t format) {
#ifdef HAVE_POLARSSL
int err;
#if POLARSSL_VERSION_NUMBER < 0x01030000
if ((err=x509parse_crtfile(&certificate->cert, path)) <0) {
#else
if ((err=x509_crt_parse_file(&certificate->cert, path)) <0) {
#endif
char tmp[128];
error_strerror(err,tmp,sizeof(tmp));
belle_sip_error("cannot parse x509 cert because [%s]",tmp);
return -1;
}
return 0;
#else /*HAVE_POLARSSL*/
return -1;
#endif
}
/*belle_sip_certificate */
belle_sip_certificates_chain_t* belle_sip_certificates_chain_parse(const char* buff, size_t size,belle_sip_certificate_raw_format_t format) {
belle_sip_certificates_chain_t* certificate = belle_sip_object_new(belle_sip_certificates_chain_t);
if (belle_sip_certificate_fill(certificate,buff, size,format)) {
belle_sip_object_unref(certificate);
certificate=NULL;
}
return certificate;
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
belle_sip_multipart_body_handler_t *belle_sip_multipart_body_handler_new(belle_sip_body_handler_progress_callback_t progress_cb, void *data,
belle_sip_body_handler_t *first_part, const char *boundary){
belle_sip_multipart_body_handler_t *obj=belle_sip_object_new(belle_sip_multipart_body_handler_t);
belle_sip_body_handler_init((belle_sip_body_handler_t*)obj,progress_cb,data);
if (boundary != NULL) {
obj->boundary = belle_sip_strdup(boundary);
} else {
obj->boundary = belle_sip_strdup(BELLESIP_MULTIPART_BOUNDARY);
}
obj->base.expected_size = strlen(obj->boundary) + 8; /* body's length will be part length(including boundary) + multipart end. 8 is for "\r\n--" and "--\r\n" */
if (first_part) belle_sip_multipart_body_handler_add_part(obj,first_part);
return obj;
}