/** * init module function */ static int mod_init(void) { LM_DBG("initialize module...\n"); bind_pua_t bind_pua; bind_usrloc_t bind_usrloc; if(server_address.s== NULL) { LM_ERR("compulsory 'server_address' parameter not set!"); return -1; } server_address.len= strlen(server_address.s); if(presence_server.s) { presence_server.len= strlen(presence_server.s); } if(default_domain.s) { default_domain.len= strlen(default_domain.s); } if(header_name.s == NULL ) { LM_ERR("header_name parameter not set\n"); return -1; } header_name.len= strlen(header_name.s); if(bla_outbound_proxy.s == NULL ) { LM_DBG("No outbound proxy set\n"); } else bla_outbound_proxy.len= strlen(bla_outbound_proxy.s); bind_pua= (bind_pua_t)find_export("bind_pua", 1,0); if (!bind_pua) { LM_ERR("Can't bind pua\n"); return -1; } if (bind_pua(&pua) < 0) { LM_ERR("Can't bind pua\n"); return -1; } if(pua.send_publish == NULL) { LM_ERR("Could not import send_publish\n"); return -1; } pua_send_publish= pua.send_publish; if(pua.send_subscribe == NULL) { LM_ERR("Could not import send_subscribe\n"); return -1; } pua_send_subscribe= pua.send_subscribe; if(pua.is_dialog == NULL) { LM_ERR("Could not import send_subscribe\n"); return -1; } pua_is_dialog= pua.is_dialog; if(pua.register_puacb== NULL) { LM_ERR("Could not import register callback\n"); return -1; } bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0); if (!bind_usrloc) { LM_ERR("Can't bind usrloc\n"); return -1; } if (bind_usrloc(&ul) < 0) { LM_ERR("Can't bind usrloc\n"); return -1; } if(ul.register_ulcb == NULL) { LM_ERR("Could not import ul_register_ulcb\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_INSERT, bla_cb , 0)< 0) { LM_ERR("can not register callback for" " insert\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_EXPIRE, bla_cb, 0)< 0) { LM_ERR("can not register callback for" " insert\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_UPDATE, bla_cb, 0)< 0) { LM_ERR("can not register callback for" " update\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_DELETE, bla_cb, 0)< 0) { LM_ERR("can not register callback for" " delete\n"); return -1; } return 0; }
static int mod_init(void) { pv_spec_t avp_spec; str s; bind_usrloc_t bind_usrloc; qvalue_t dq; callback_singleton = shm_malloc(sizeof (int)); *callback_singleton = 0; /*build the required strings */ scscf_serviceroute_uri_str.s = (char*) pkg_malloc(orig_prefix.len + scscf_name_str.len); if (!scscf_serviceroute_uri_str.s) { LM_ERR("Unable to allocate memory for service route uri\n"); return -1; } if (contact_expires_buffer_percentage < 0 || contact_expires_buffer_percentage > 90) { LM_ERR("contact expires percentage not valid, must be >0 and <=90"); return -1; } memcpy(scscf_serviceroute_uri_str.s, orig_prefix.s, orig_prefix.len); scscf_serviceroute_uri_str.len = orig_prefix.len; if (scscf_name_str.len > 4 && strncasecmp(scscf_name_str.s, "sip:", 4) == 0) { memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len, scscf_name_str.s + 4, scscf_name_str.len - 4); scscf_serviceroute_uri_str.len += scscf_name_str.len - 4; } else { memcpy(scscf_serviceroute_uri_str.s + scscf_serviceroute_uri_str.len, scscf_name_str.s, scscf_name_str.len); scscf_serviceroute_uri_str.len += scscf_name_str.len; } pv_tmx_data_init(); /* </build required strings> */ #ifdef STATISTICS /* register statistics */ if (register_module_stats(exports.name, mod_stats) != 0) { LM_ERR("failed to register core statistics\n"); return -1; } if (!register_stats()) { LM_ERR("Unable to register statistics\n"); return -1; } #endif /*register space for notification processors*/ register_procs(notification_processes); cfg_register_child(notification_processes); /* bind the SL API */ if (sl_load_api(&slb) != 0) { LM_ERR("cannot bind to SL API\n"); return -1; } /* load the TM API */ if (load_tm_api(&tmb) != 0) { LM_ERR("can't load TM API\n"); return -1; } /* load the CDP API */ if (load_cdp_api(&cdpb) != 0) { LM_ERR("can't load CDP API\n"); return -1; } cdp_avp = load_cdp_avp(); if (!cdp_avp) { LM_ERR("can't load CDP_AVP API\n"); return -1; } if (cfg_declare("registrar", registrar_cfg_def, &default_registrar_cfg, cfg_sizeof(registrar), ®istrar_cfg)) { LM_ERR("Fail to declare the configuration\n"); return -1; } if (rcv_avp_param && *rcv_avp_param) { s.s = rcv_avp_param; s.len = strlen(s.s); if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) { LM_ERR("malformed or non AVP %s AVP definition\n", rcv_avp_param); return -1; } if (pv_get_avp_name(0, &avp_spec.pvp, &rcv_avp_name, &rcv_avp_type) != 0) { LM_ERR("[%s]- invalid AVP definition\n", rcv_avp_param); return -1; } } else { rcv_avp_name.n = 0; rcv_avp_type = 0; } if (aor_avp_param && *aor_avp_param) { s.s = aor_avp_param; s.len = strlen(s.s); if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) { LM_ERR("malformed or non AVP %s AVP definition\n", aor_avp_param); return -1; } if (pv_get_avp_name(0, &avp_spec.pvp, &aor_avp_name, &aor_avp_type) != 0) { LM_ERR("[%s]- invalid AVP definition\n", aor_avp_param); return -1; } } else { aor_avp_name.n = 0; aor_avp_type = 0; } if (reg_callid_avp_param && *reg_callid_avp_param) { s.s = reg_callid_avp_param; s.len = strlen(s.s); if (pv_parse_spec(&s, &avp_spec) == 0 || avp_spec.type != PVT_AVP) { LM_ERR("malformed or non AVP %s AVP definition\n", reg_callid_avp_param); return -1; } if (pv_get_avp_name(0, &avp_spec.pvp, ®_callid_avp_name, ®_callid_avp_type) != 0) { LM_ERR("[%s]- invalid AVP definition\n", reg_callid_avp_param); return -1; } } else { reg_callid_avp_name.n = 0; reg_callid_avp_type = 0; } bind_usrloc = (bind_usrloc_t) find_export("ul_bind_usrloc", 1, 0); if (!bind_usrloc) { LM_ERR("can't bind usrloc\n"); return -1; } /* Normalize default_q parameter */ dq = cfg_get(registrar, registrar_cfg, default_q); if (dq != Q_UNSPECIFIED) { if (dq > MAX_Q) { LM_DBG("default_q = %d, lowering to MAX_Q: %d\n", dq, MAX_Q); dq = MAX_Q; } else if (dq < MIN_Q) { LM_DBG("default_q = %d, raising to MIN_Q: %d\n", dq, MIN_Q); dq = MIN_Q; } } cfg_get(registrar, registrar_cfg, default_q) = dq; if (bind_usrloc(&ul) < 0) { return -1; } /*Register for callback of URECORD being deleted - so we can send a SAR*/ if (ul.register_ulcb == NULL) { LM_ERR("Could not import ul_register_ulcb\n"); return -1; } if (ul.register_ulcb(0, 0, UL_IMPU_INSERT, ul_impu_inserted, 0) < 0) { LM_ERR("can not register callback for insert\n"); return -1; } if (sock_hdr_name.s) { if (sock_hdr_name.len == 0 || sock_flag == -1) { LM_WARN("empty sock_hdr_name or sock_flag no set -> reseting\n"); sock_hdr_name.len = 0; sock_flag = -1; } } else if (sock_flag != -1) { LM_WARN("sock_flag defined but no sock_hdr_name -> reseting flag\n"); sock_flag = -1; } /* fix the flags */ sock_flag = (sock_flag != -1) ? (1 << sock_flag) : 0; tcp_persistent_flag = (tcp_persistent_flag != -1) ? (1 << tcp_persistent_flag) : 0; /* init the registrar notifications */ if (!notify_init()) return -1; /* register the registrar notifications timer */ //Currently we do not use this - we send notifies immediately //if (register_timer(notification_timer, notification_list, 5) < 0) return -1; return 0; }
void async_aar_reg_callback(int is_timeout, void *param, AAAMessage *aaa, long elapsed_msecs) { struct cell *t = 0; pcontact_t* pcontact; unsigned int cdp_result; struct pcontact_info ci; udomain_t* domain_t; int finalReply = 0; AAASession *auth = 0; rx_authsessiondata_t* p_session_data = 0; int result = CSCF_RETURN_ERROR; pcontact_info_t contact_info; LM_DBG("Received AAR callback\n"); saved_transaction_local_t* local_data = (saved_transaction_local_t*) param; saved_transaction_t* data = local_data->global_data; domain_t = data->domain; int is_rereg = local_data->is_rereg; //before we do anything else, lets decrement the reference counter on replies lock_get(data->lock); data->answers_not_received--; if (data->answers_not_received <= 0) { finalReply = 1; } if (data->ignore_replies) { //there was obv. a subsequent error AFTER we had sent one/more AAR's - so we can ignore these replies and just free memory free_saved_transaction_data(local_data); if (finalReply) { free_saved_transaction_global_data(data); } return; } lock_release(data->lock); LM_DBG("received answer and we are waiting for [%d] answers so far failures flag is [%d]\n", data->answers_not_received, data->failed); if (tmb.t_lookup_ident(&t, data->tindex, data->tlabel) < 0) { LM_ERR("t_continue: transaction not found\n"); goto error; } //we have T, lets restore our state (esp. for AVPs) set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &t->uri_avps_from); set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &t->uri_avps_to); set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &t->user_avps_from); set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &t->user_avps_to); set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &t->domain_avps_from); set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &t->domain_avps_to); if (is_timeout != 0) { LM_ERR("Error timeout when sending AAR message via CDP\n"); counter_inc(ims_qos_cnts_h.registration_aar_timeouts); goto error; } if (!aaa) { LM_ERR("Error sending message via CDP\n"); goto error; } counter_inc(ims_qos_cnts_h.registration_aars); counter_add(ims_qos_cnts_h.registration_aar_response_time, elapsed_msecs); counter_inc(ims_qos_cnts_h.registration_aar_replies_received); /* Process the response to AAR, retrieving result code and associated Rx session ID */ if (rx_process_aaa(aaa, &cdp_result) < 0) { LM_ERR("Failed to process AAA from PCRF\n"); //puri.host.len, puri.host.s); goto error; } if (cdp_result >= 2000 && cdp_result < 3000) { counter_inc(ims_qos_cnts_h.successful_registration_aars); if (is_rereg) { LM_DBG("this is a re-registration, therefore we don't need to do anything except know that the the subscription was successful\n"); result = CSCF_RETURN_TRUE; create_return_code(result); goto done; } //need to set Rx auth data to say this session has been successfully opened //This is used elsewhere to prevent acting on termination events when the session has not been opened //getting auth session auth = cdpb.AAAGetAuthSession(aaa->sessionId->data); if (!auth) { LM_DBG("Could not get Auth Session for session id: [%.*s]\n", aaa->sessionId->data.len, aaa->sessionId->data.s); goto error; } //getting session data p_session_data = (rx_authsessiondata_t*) auth->u.auth.generic_data; if (!p_session_data) { LM_DBG("Could not get session data on Auth Session for session id: [%.*s]\n", aaa->sessionId->data.len, aaa->sessionId->data.s); if (auth) cdpb.AAASessionsUnlock(auth->hash); goto error; } p_session_data->session_has_been_opened = 1; counter_inc(ims_qos_cnts_h.active_registration_rx_sessions); if (auth) cdpb.AAASessionsUnlock(auth->hash); LM_DBG("Success, received code: [%i] from PCRF for AAR request (contact: [%.*s]), (auth session id: %.*s)\n", cdp_result, local_data->contact.len, local_data->contact.s, local_data->auth_session_id.len, local_data->auth_session_id.s); LM_DBG("Registering for Usrloc callbacks on DELETE\n"); ul.lock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto); contact_info.received_host = local_data->recv_host; contact_info.received_port = local_data->recv_port; contact_info.received_proto = local_data->recv_proto; contact_info.searchflag = (1 << SEARCH_RECEIVED); contact_info.aor = local_data->contact; contact_info.via_host = local_data->via_host; contact_info.via_port = local_data->via_port; contact_info.via_prot = local_data->via_proto; if (ul.get_pcontact(domain_t, &contact_info, &pcontact) != 0) { LM_ERR("Shouldn't get here, can't find contact....\n"); ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto); goto error; } //at this point we have the contact /*set the contact state to say we have succesfully done ARR for register and that we dont need to do it again * for the duration of the registration. * */ if (ul.update_rx_regsession(domain_t, &local_data->auth_session_id, pcontact) != 0) { LM_ERR("unable to update pcontact......\n"); ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto); goto error; } memset(&ci, 0, sizeof (struct pcontact_info)); ci.reg_state = PCONTACT_REG_PENDING_AAR; ci.num_service_routes = 0; ci.num_public_ids = 0; LM_DBG("impu: [%.*s] updating status to PCONTACT_REG_PENDING\n", pcontact->aor.len, pcontact->aor.s); ul.update_pcontact(domain_t, &ci, pcontact); //register for callbacks on contact ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE, callback_pcscf_contact_cb, NULL); ul.unlock_udomain(domain_t, &local_data->via_host, local_data->via_port, local_data->via_proto); result = CSCF_RETURN_TRUE; } else { LM_DBG("Received negative reply from PCRF for AAR Request\n"); counter_inc(ims_qos_cnts_h.failed_registration_aars); result = CSCF_RETURN_FALSE; goto error; } //set success response code AVP create_return_code(result); goto done; error: //set failure response code create_return_code(result); done: if (t) tmb.unref_cell(t); //free memory if (aaa) cdpb.AAAFreeMessage(&aaa); if (finalReply) { tmb.t_continue(data->tindex, data->tlabel, data->act); free_saved_transaction_global_data(data); } free_saved_transaction_data(local_data); }
int ipsec_create(struct sip_msg* m, udomain_t* d) { pcontact_t* pcontact = NULL; struct pcontact_info ci; int ret = IPSEC_CMD_FAIL; // FAIL by default // Find the contact if(fill_contact(&ci, m) != 0) { LM_ERR("Error filling in contact data\n"); return ret; } ul.lock_udomain(d, &ci.via_host, ci.via_port, ci.via_prot); if (ul.get_pcontact(d, &ci, &pcontact) != 0) { LM_ERR("Contact doesn't exist\n"); goto cleanup; } // Get security parameters if(pcontact->security_temp == NULL) { LM_ERR("No security parameters found in contact\n"); goto cleanup; } if(pcontact->security_temp->type != SECURITY_IPSEC ) { LM_ERR("Unsupported security type: %d\n", pcontact->security_temp->type); goto cleanup; } ipsec_t* s = pcontact->security_temp->data.ipsec; if(update_contact_ipsec_params(s, m) != 0) { goto cleanup; } if(create_ipsec_tunnel(ci.received_host, s) != 0) { goto cleanup; } // TODO: Save security_tmp to security!!!!! if (ul.update_pcontact(d, &ci, pcontact) != 0) { LM_ERR("Error updating contact\n"); goto cleanup; } // Destroy the tunnel, if the contact expires if(ul.register_ulcb(pcontact, PCSCF_CONTACT_EXPIRE|PCSCF_CONTACT_DELETE, on_expire, NULL) != 1) { LM_ERR("Error subscribing for contact\n"); goto cleanup; } if(add_supported_secagree_header(m) != 0) { goto cleanup; } if(add_security_server_header(m, s) != 0) { goto cleanup; } ret = IPSEC_CMD_SUCCESS; // all good, set ret to SUCCESS, and exit cleanup: // Do not free str* sec_header! It will be freed in data_lump.c -> free_lump() ul.unlock_udomain(d, &ci.via_host, ci.via_port, ci.via_prot); pkg_free(ci.received_host.s); return ret; }
/** * init module function */ static int mod_init(void) { bind_usrloc_t bind_usrloc; bind_pua_t bind_pua; LM_DBG("initializing module ...\n"); if(default_domain.s == NULL ) { LM_ERR("default domain parameter not set\n"); return -1; } default_domain.len= strlen(default_domain.s); if(pres_prefix.s == NULL ) { LM_DBG("No pres_prefix configured\n"); } else pres_prefix.len= strlen(pres_prefix.s); if(presence_server.s) { presence_server.len= strlen(presence_server.s); } bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0); if (!bind_usrloc) { LM_ERR("Can't bind usrloc\n"); return -1; } if (bind_usrloc(&ul) < 0) { LM_ERR("Can't bind usrloc\n"); return -1; } if(ul.register_ulcb == NULL) { LM_ERR("Could not import ul_register_ulcb\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_INSERT, ul_publish, 0)< 0) { LM_ERR("can not register callback for" " insert\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_EXPIRE, ul_publish, 0)< 0) { LM_ERR("can not register callback for" " expire\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_UPDATE, ul_publish, 0)< 0) { LM_ERR("can not register callback for update\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_DELETE, ul_publish, 0)< 0) { LM_ERR("can not register callback for delete\n"); return -1; } bind_pua= (bind_pua_t)find_export("bind_pua", 1,0); if (!bind_pua) { LM_ERR("Can't bind pua\n"); return -1; } if (bind_pua(&pua) < 0) { LM_ERR("Can't bind pua\n"); return -1; } if(pua.send_publish == NULL) { LM_ERR("Could not import send_publish\n"); return -1; } pua_send_publish= pua.send_publish; if(pua.send_subscribe == NULL) { LM_ERR("Could not import send_subscribe\n"); return -1; } pua_send_subscribe= pua.send_subscribe; /* register post-script pua_unset_publish unset function */ if(register_script_cb(pua_unset_publish, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0) { LM_ERR("failed to register POST request callback\n"); return -1; } return 0; }
/*! \brief * init module function */ static int mod_init(void) { bind_usrloc_t bind_usrloc; bind_pua_t bind_pua; if(!default_domain.s || default_domain.len<=0) { LM_ERR("default domain parameter not set\n"); return -1; } if(!pres_prefix.s || pres_prefix.len<=0) LM_DBG("No pres_prefix configured\n"); bind_usrloc = (bind_usrloc_t)find_export("ul_bind_usrloc", 1, 0); if (!bind_usrloc) { LM_ERR("Can't bind usrloc\n"); return -1; } if (bind_usrloc(&ul) < 0) { LM_ERR("Can't bind usrloc\n"); return -1; } if(ul.register_ulcb == NULL) { LM_ERR("Could not import ul_register_ulcb\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_INSERT, ul_publish, 0)< 0) { LM_ERR("can not register callback for" " insert\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_EXPIRE, ul_publish, 0)< 0) { LM_ERR("can not register callback for" " expire\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_UPDATE, ul_publish, 0)< 0) { LM_ERR("can not register callback for update\n"); return -1; } if(ul.register_ulcb(UL_CONTACT_DELETE, ul_publish, 0)< 0) { LM_ERR("can not register callback for delete\n"); return -1; } bind_pua= (bind_pua_t)find_export("bind_pua", 1,0); if (!bind_pua) { LM_ERR("Can't bind pua\n"); return -1; } if (bind_pua(&_pu_pua) < 0) { LM_ERR("Can't bind pua\n"); return -1; } if(_pu_pua.send_publish == NULL) { LM_ERR("Could not import send_publish\n"); return -1; } if(_pu_pua.send_subscribe == NULL) { LM_ERR("Could not import send_subscribe\n"); return -1; } /* register post-script pua_unset_publish unset function */ if(register_script_cb(pua_unset_publish, POST_SCRIPT_CB|REQUEST_CB, 0)<0) { LM_ERR("failed to register POST request callback\n"); return -1; } if(pua_ul_bflag!=-1) pua_ul_bmask = 1 << pua_ul_bflag; return 0; }
int process_contact(udomain_t * _d, int expires, str contact_uri, int contact_state) { char bufport[5], *rest, *sep, *val, *port, *trans; pcontact_t* pcontact; struct pcontact_info ci; struct sip_uri puri, uri; unsigned int received_proto, received_port_len; int local_time_now, rest_len, val_len, has_alias; int ret = RESULT_CONTACTS_FOUND; pcscf_act_time(); local_time_now = time_now; has_alias = 0; //get contact //if does not exist then add it //if it does exist check if state it terminated - if so delete it, if not update it memset(&ci, 0, sizeof (struct pcontact_info)); ci.num_public_ids = 0; ci.num_service_routes = 0; LM_DBG("Processing contact using contact from NOTIFY [%.*s]\n", contact_uri.len, contact_uri.s); if (parse_uri(contact_uri.s, contact_uri.len, &puri) < 0) { LM_DBG("Error parsing Contact URI <%.*s>\n", contact_uri.len, contact_uri.s); return RESULT_ERROR; } expires = local_time_now + expires; //turn expires into correct time since epoch format LM_DBG("Changed expires to format time since the epoch: %d", expires); ci.expires = expires; ci.reg_state = PCONTACT_REGISTERED; ul.lock_udomain(_d, &puri.host, puri.port_no, puri.proto); ci.aor = contact_uri; ci.via_host = puri.host; ci.via_prot = puri.proto; ci.via_port = puri.port_no; /* parse the uri in the NOTIFY */ if (parse_uri(contact_uri.s, contact_uri.len, &uri) != 0) { LM_ERR("Unable to parse contact in SIP notify [%.*s]\n", contact_uri.len, contact_uri.s); return RESULT_ERROR; } /*check for alias - NAT */ rest = uri.sip_params.s; rest_len = uri.sip_params.len; while (rest_len >= ALIAS_LEN) { if (strncmp(rest, ALIAS, ALIAS_LEN) == 0) { has_alias = 1; break; } sep = memchr(rest, 59 /* ; */, rest_len); if (sep == NULL) { LM_DBG("no alias param\n"); break; } else { rest_len = rest_len - (sep - rest + 1); rest = sep + 1; } } if (has_alias) { val = rest + ALIAS_LEN; val_len = rest_len - ALIAS_LEN; port = memchr(val, 126 /* ~ */, val_len); if (port == NULL) { LM_ERR("no '~' in alias param value\n"); return RESULT_ERROR; } port++; // received_port = atoi(port); trans = memchr(port, 126 /* ~ */, val_len - (port - val)); if (trans == NULL) { LM_ERR("no second '~' in alias param value\n"); return RESULT_ERROR; } received_port_len = trans - port; trans = trans + 1; received_proto = *trans - 48 /* char 0 */; memcpy(bufport, port, received_port_len); bufport[received_port_len]=0; ci.received_host.s = val; ci.received_host.len = port - val - 1; LM_DBG("Setting received host in search to [%.*s]\n", ci.received_host.len, ci.received_host.s); ci.received_port = atoi(bufport); LM_DBG("Setting received port in search to %d\n", ci.received_port); ci.received_proto = received_proto; LM_DBG("Setting received proto in search to %d\n", ci.received_proto); ci.searchflag = SEARCH_RECEIVED; } else { LM_DBG("Contact in NOTIFY does not have an alias....\n"); } if (ul.get_pcontact(_d, &ci, &pcontact) != 0) { //contact does not exist if (contact_state == STATE_TERMINATED) { LM_DBG("This contact: <%.*s> is in state terminated and is not in usrloc, ignore\n", contact_uri.len, contact_uri.s); ret = RESULT_CONTACTS_FOUND; goto done; } //LM_WARN("This contact: <%.*s> is in state active and is not in usrloc - must be another contact on a different P so going to ignore\n", contact_uri.len, contact_uri.s); LM_DBG("This contact: <%.*s> is in state active and is not in usrloc so adding it to usrloc, expires: %d which is in %d seconds\n", contact_uri.len, contact_uri.s, expires, expires-local_time_now); if (ul.insert_pcontact(_d, &contact_uri, &ci, &pcontact) != 0) { LM_ERR("Failed inserting new pcontact\n"); ret = RESULT_ERROR; goto done; } else { //register for callbacks on this contact so we can send PUBLISH to SCSCF should status change LM_DBG("registering for UL callback\n"); ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE, callback_pcscf_contact_cb, NULL); } } else {//contact exists if (contact_state == STATE_TERMINATED) { //delete contact LM_DBG("This contact <%.*s> is in state terminated and is in usrloc so removing it from usrloc\n", contact_uri.len, contact_uri.s); if (ul.delete_pcontact(_d, pcontact) != 0) { LM_DBG("failed to delete pcscf contact <%.*s> - not a problem this may have been removed by de registration", contact_uri.len, contact_uri.s); } /*TODO_LATEST - put this back */ } else {//state is active //update this contact LM_DBG("This contact: <%.*s> is in state active and is in usrloc so just updating - old expires: %li, new expires: %i which is in %i seconds\n", contact_uri.len, contact_uri.s, pcontact->expires, expires, expires - local_time_now); if (ul.update_pcontact(_d, &ci, pcontact) != 0) { LM_ERR("failed to update pcscf contact\n"); ret = RESULT_ERROR; goto done; } pcontact->expires = expires; } } done: ul.unlock_udomain(_d, &puri.host, puri.port_no, puri.proto); return ret; }
/** * Save contact based on REGISTER request. this will be a pending save, until we receive response * from SCSCF. If no response after pending_timeout seconds, the contacts is removed. Can only be used from REQUEST ROUTE */ int save_pending(struct sip_msg* _m, udomain_t* _d) { contact_body_t* cb = 0; int cexpires = 0; pcontact_t* pcontact; contact_t* c; struct pcontact_info ci; struct via_body* vb; unsigned short port, proto; int_str val; struct sip_uri parsed_received; char srcip[50]; memset(&ci, 0, sizeof(struct pcontact_info)); vb = cscf_get_ue_via(_m); port = vb->port?vb->port:5060; proto = vb->proto; cb = cscf_parse_contacts(_m); if (!cb || (!cb->contacts)) { LM_ERR("No contact headers\n"); goto error; } c = cb->contacts; //TODO: need support for multiple contacts - currently assume one contact //make sure this is not a de-registration int expires_hdr = cscf_get_expires_hdr(_m, 0); if (expires_hdr < 0) { //no global header we have to check the contact expiry if (c && c->expires && c->expires->body.len) { str2int(&(c->expires->body), (unsigned int*) &cexpires); } if (!cexpires){ //assume de-registration LM_DBG("not doing pending reg on de-registration\n"); return 1; } } pcscf_act_time(); int local_time_now = time_now; int expires = calc_contact_expires(c, expires_hdr, local_time_now); if (expires <= 0) { LM_DBG("not doing pending reg on de-registration\n"); return 1; } LM_DBG("Save Pending"); LM_DBG("contact requesting to expire in %d seconds\n", expires-local_time_now); /*populate CI with bare minimum*/ ci.via_host = vb->host; ci.via_port = port; ci.via_prot = proto; ci.aor = c->uri; ci.num_public_ids=0; ci.num_service_routes=0; ci.expires=local_time_now + pending_reg_expires; ci.reg_state=PCONTACT_ANY; ci.searchflag=SEARCH_RECEIVED; //we want to make sure we are very specific with this search to make sure we get the correct contact to put into reg_pending. // Received Info: First try AVP, otherwise simply take the source of the request: memset(&val, 0, sizeof(int_str)); if (rcv_avp_name.n != 0 && search_first_avp(rcv_avp_type, rcv_avp_name, &val, 0) && val.s.len > 0) { if (val.s.len > RECEIVED_MAX_SIZE) { LM_ERR("received too long\n"); goto error; } if (parse_uri(val.s.s, val.s.len, &parsed_received) < 0) { LM_DBG("Error parsing Received URI <%.*s>\n", val.s.len, val.s.s); goto error; } ci.received_host = parsed_received.host; ci.received_port = parsed_received.port_no; ci.received_proto = parsed_received.proto; } else { ci.received_host.len = ip_addr2sbuf(&_m->rcv.src_ip, srcip, sizeof(srcip)); ci.received_host.s = srcip; ci.received_port = _m->rcv.src_port; ci.received_proto = _m->rcv.proto; } // Set to default, if not set: if (ci.received_port == 0) ci.received_port = 5060; ul.lock_udomain(_d, &ci.via_host, ci.via_port, ci.via_prot); if (ul.get_pcontact(_d, &ci, &pcontact) != 0) { //need to insert new contact LM_DBG("Adding pending pcontact: <%.*s>\n", c->uri.len, c->uri.s); ci.reg_state=PCONTACT_REG_PENDING; if (ul.insert_pcontact(_d, &c->uri, &ci, &pcontact) != 0) { LM_ERR("Failed inserting new pcontact\n"); } else { LM_DBG("registering for UL callback\n"); ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE | PCSCF_CONTACT_UPDATE, callback_pcscf_contact_cb, NULL); } } else { //contact already exists - update LM_DBG("Contact already exists - not doing anything for now\n"); } ul.unlock_udomain(_d, &ci.via_host, ci.via_port, ci.via_prot); return 1; error: LM_DBG("Error saving pending contact\n"); return -1; }
/** * Updates the registrar with the new values * @param req - the REGISTER request - to extract NAT info * @param rpl - the REGISTER reply - to extract contact info * @param is_star - whether this was a STAR contact header * @param expires_hdr - value of the Expires header * @param public_id - array of public identities attached to this contact * @param public_id_cnt - size of the public_id array * @param service_route - array of Service-Routes * @param service_route_cnt - size of the service_route array * @param requires_nat - if to create pinholes * @returns the maximum expiration time, -1 on error */ static inline int update_contacts(struct sip_msg *req,struct sip_msg *rpl, udomain_t* _d, unsigned char is_star,int expires_hdr, str *public_id,int public_id_cnt,str *service_route,int service_route_cnt, int requires_nat) { int local_time_now, expires=0; struct hdr_field* h; contact_t* c; struct sip_uri puri; struct sip_uri parsed_received; struct pcontact_info ci; pcontact_t* pcontact; char srcip[50]; int_str val; pcscf_act_time(); local_time_now = time_now; if (is_star) { /* first of all, we shouldn't get here... * then, we will update on NOTIFY */ return 0; } // Set the structure to "0", to make sure it's properly initialized memset(&ci, 0, sizeof(struct pcontact_info)); for (h = rpl->contact; h; h = h->next) { if (h->type == HDR_CONTACT_T && h->parsed) for (c = ((contact_body_t*) h->parsed)->contacts; c; c = c->next) { expires = calc_contact_expires(c, expires_hdr, local_time_now); if (parse_uri(c->uri.s, c->uri.len, &puri) < 0) { LM_DBG("Error parsing Contact URI <%.*s>\n", c->uri.len, c->uri.s); continue; } //build contact info ci.expires = expires; ci.public_ids = public_id; ci.num_public_ids = public_id_cnt; ci.service_routes = service_route; ci.num_service_routes = service_route_cnt; ci.reg_state = PCONTACT_REGISTERED; ci.received_host.len = 0; ci.received_host.s = 0; ci.received_port = 0; ci.received_proto = 0; // Received Info: First try AVP, otherwise simply take the source of the request: memset(&val, 0, sizeof(int_str)); if (rcv_avp_name.n!=0 && search_first_avp(rcv_avp_type, rcv_avp_name, &val, 0) && val.s.len > 0) { if (val.s.len>RECEIVED_MAX_SIZE) { LM_ERR("received too long\n"); goto error; } if (parse_uri(val.s.s, val.s.len, &parsed_received) < 0) { LM_DBG("Error parsing Received URI <%.*s>\n", val.s.len, val.s.s); continue; } ci.received_host = parsed_received.host; ci.received_port = parsed_received.port_no; ci.received_proto = parsed_received.proto; } else { ci.received_host.len = ip_addr2sbuf(&req->rcv.src_ip, srcip, sizeof(srcip)); ci.received_host.s = srcip; ci.received_port = req->rcv.src_port; ci.received_proto = req->rcv.proto; } // Set to default, if not set: if (ci.received_port == 0) ci.received_port = 5060; ul.lock_udomain(_d, &c->uri); if (ul.get_pcontact(_d, &c->uri, &pcontact) != 0) { //need to insert new contact if ((expires-local_time_now)<=0) { //remove contact - de-register LM_DBG("This is a de-registration for contact <%.*s> but contact is not in usrloc - ignore\n", c->uri.len, c->uri.s); goto next_contact; } LM_DBG("Adding pcontact: <%.*s>, expires: %d which is in %d seconds\n", c->uri.len, c->uri.s, expires, expires-local_time_now); if (ul.insert_pcontact(_d, &c->uri, &ci, &pcontact) != 0) { LM_ERR("Failed inserting new pcontact\n"); } else { //register for callbacks on this contact so we can send PUBLISH to SCSCF should status change LM_DBG("registering for UL callback\n"); ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE, callback_pcscf_contact_cb, NULL); //we also need to subscribe to reg event of this contact at SCSCF } } else { //contact already exists - update LM_DBG("contact already exists and is in state (%d) : [%s]\n",pcontact->reg_state, reg_state_to_string(pcontact->reg_state)); if ((expires-local_time_now)<=0) { //remove contact - de-register LM_DBG("This is a de-registration for contact <%.*s>\n", c->uri.len, c->uri.s); if (ul.delete_pcontact(_d, &c->uri, pcontact) != 0) { LM_ERR("failed to delete pcscf contact <%.*s>\n", c->uri.len, c->uri.s); } } else { //update contact LM_DBG("Updating contact: <%.*s>, old expires: %li, new expires: %i which is in %i seconds\n", c->uri.len, c->uri.s, pcontact->expires-local_time_now, expires, expires-local_time_now); if (ul.update_pcontact(_d, &ci, pcontact) != 0) { LM_ERR("failed to update pcscf contact\n"); } pcontact->expires = expires; } } next_contact: ul.unlock_udomain(_d, &c->uri); } } return 1; error: return 0; }
int process_contact(udomain_t * _d, int expires, str contact_uri, int contact_state) { pcontact_t* pcontact; struct pcontact_info ci; int local_time_now; int ret = RESULT_CONTACTS_FOUND; pcscf_act_time(); local_time_now = time_now; //get contact //if does not exist then add it //if it does exist check if state it terminated - if so delete it, if not update it memset(&ci, 0, sizeof(struct pcontact_info)); ci.num_public_ids=0; ci.num_service_routes=0; expires = local_time_now + expires; //turn expires into correct time since epoch format LM_DBG("Changed expires to format time since the epoch: %d", expires); ci.expires=expires; ci.reg_state = PCONTACT_REGISTERED; ul.lock_udomain(_d, &contact_uri); if (ul.get_pcontact(_d, &contact_uri, &pcontact) != 0) { //contact does not exist if (contact_state == STATE_TERMINATED) { LM_DBG("This contact: <%.*s> is in state terminated and is not in usrloc, ignore\n", contact_uri.len, contact_uri.s); ret = RESULT_CONTACTS_FOUND; goto done; } LM_DBG("This contact: <%.*s> is in state active and is not in usrloc so adding it to usrloc, expires: %d which is in %d seconds\n", contact_uri.len, contact_uri.s, expires, expires-local_time_now); if (ul.insert_pcontact(_d, &contact_uri, &ci, &pcontact) != 0) { LM_ERR("Failed inserting new pcontact\n"); ret = RESULT_ERROR; goto done; } else { //register for callbacks on this contact so we can send PUBLISH to SCSCF should status change LM_DBG("registering for UL callback\n"); ul.register_ulcb(pcontact, PCSCF_CONTACT_DELETE | PCSCF_CONTACT_EXPIRE, callback_pcscf_contact_cb, NULL); } } else {//contact exists if (contact_state == STATE_TERMINATED) { //delete contact LM_DBG("This contact <%.*s> is in state terminated and is in usrloc so removing it from usrloc\n", contact_uri.len, contact_uri.s); if (ul.delete_pcontact(_d, &contact_uri, pcontact) != 0) { LM_DBG("failed to delete pcscf contact <%.*s> - not a problem this may have been removed by de registration", contact_uri.len, contact_uri.s); } } else {//state is active //update this contact LM_DBG("This contact: <%.*s> is in state active and is in usrloc so just updating - old expires: %li, new expires: %i which is in %i seconds\n", contact_uri.len, contact_uri.s, pcontact->expires, expires, expires-local_time_now); if (ul.update_pcontact(_d, &ci, pcontact) != 0) { LM_ERR("failed to update pcscf contact\n"); ret = RESULT_ERROR; goto done; } pcontact->expires = expires; } } done: ul.unlock_udomain(_d, &contact_uri); return ret; }