static void qualify_and_schedule_all(void) { struct ast_variable *var = ast_variable_new("qualify_frequency >", "0", ""); struct ao2_container *aors; struct ao2_container *contacts; if (!var) { return; } aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "aor", AST_RETRIEVE_FLAG_MULTIPLE, var); ao2_callback(sched_qualifies, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, unschedule_all_cb, NULL); if (aors) { ao2_callback(aors, OBJ_NODATA, qualify_and_schedule_all_cb, NULL); ao2_ref(aors, -1); } contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE, var); if (contacts) { ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb_without_aor, NULL); ao2_ref(contacts, -1); } ast_variables_destroy(var); }
/*! \brief Helper function which returns a UDP transport bound to the given address and port */ static pjsip_transport *multihomed_get_udp_transport(pj_str_t *address, int port) { struct ao2_container *transports = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); struct ast_sip_transport *transport; struct ao2_iterator iter; pjsip_transport *sip_transport = NULL; if (!transports) { return NULL; } for (iter = ao2_iterator_init(transports, 0); (transport = ao2_iterator_next(&iter)); ao2_ref(transport, -1)) { if ((transport->type != AST_TRANSPORT_UDP) || (pj_strcmp(&transport->state->transport->local_name.host, address)) || (transport->state->transport->local_name.port != port)) { continue; } sip_transport = transport->state->transport; ao2_ref(transport, -1); break; } ao2_iterator_destroy(&iter); ao2_ref(transports, -1); return sip_transport; }
static int on_aor_update_endpoint_state(void *obj, void *arg, int flags) { struct ast_sip_aor *aor = obj; struct ao2_container *endpoints; RAII_VAR(struct ast_variable *, var, NULL, ast_variables_destroy); const char *aor_name = ast_sorcery_object_get_id(aor); char *aor_like; if (ast_strlen_zero(aor_name)) { return -1; } if (aor->permanent_contacts && ((int)(aor->qualify_frequency * 1000)) <= 0) { aor_like = ast_alloca(strlen(aor_name) + 3); sprintf(aor_like, "%%%s%%", aor_name); var = ast_variable_new("aors LIKE", aor_like, ""); if (!var) { return -1; } endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var); if (endpoints) { /* * Because aors are a string list, we have to use a pattern match but since a simple * pattern match could return an endpoint that has an aor of "aaabccc" when searching * for "abc", we still have to iterate over them to find an exact aor match. */ ao2_callback(endpoints, 0, aor_update_endpoint_state, (char *)aor_name); ao2_ref(endpoints, -1); } } return 0; }
static struct ao2_container *cli_get_auths(void) { struct ao2_container *auths; auths = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "auth", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); return auths; }
static void update_all_unqualified_endpoints(void) { struct ao2_container *aors; struct ao2_container *contacts; RAII_VAR(struct ast_variable *, var_aor, NULL, ast_variables_destroy); RAII_VAR(struct ast_variable *, var_contact, NULL, ast_variables_destroy); RAII_VAR(char *, time_now, NULL, ast_free); struct timeval tv = ast_tvnow(); if (!(var_aor = ast_variable_new("contact !=", "", ""))) { return; } if (!(var_aor->next = ast_variable_new("qualify_frequency <=", "0", ""))) { return; } if (ast_asprintf(&time_now, "%ld", tv.tv_sec) == -1) { return; } if (!(var_contact = ast_variable_new("expiration_time >", time_now, ""))) { return; } if (!(var_contact->next = ast_variable_new("qualify_frequency <=", "0", ""))) { return; } aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "aor", AST_RETRIEVE_FLAG_MULTIPLE, var_aor); if (aors) { ao2_callback(aors, OBJ_NODATA, on_aor_update_endpoint_state, NULL); ao2_ref(aors, -1); } contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE, var_contact); if (contacts) { ao2_callback(contacts, OBJ_NODATA, contact_update_endpoint_state, NULL); ao2_ref(contacts, -1); } }
/*! \brief Initialize auto-expiration of any existing contacts */ static void contact_expiration_initialize_existing(void) { struct ao2_container *contacts; contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); if (!contacts) { return; } ao2_callback(contacts, OBJ_NODATA, contact_expiration_setup, NULL); ao2_ref(contacts, -1); }
static struct ast_sip_endpoint *username_identify(pjsip_rx_data *rdata) { char endpoint_name[64], domain_name[64], id[AST_UUID_STR_LEN]; struct ast_sip_endpoint *endpoint; RAII_VAR(struct ast_sip_domain_alias *, alias, NULL, ao2_cleanup); RAII_VAR(struct ao2_container *, transports, NULL, ao2_cleanup); RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup); if (get_endpoint_details(rdata, endpoint_name, sizeof(endpoint_name), domain_name, sizeof(domain_name))) { return NULL; } /* Attempt to find the endpoint given the name and domain provided */ snprintf(id, sizeof(id), "%s@%s", endpoint_name, domain_name); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } /* See if an alias exists for the domain provided */ if ((alias = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "domain_alias", domain_name))) { snprintf(id, sizeof(id), "%s@%s", endpoint_name, alias->domain); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } } /* See if the transport this came in on has a provided domain */ if ((transports = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL)) && (transport = ao2_callback(transports, 0, find_transport_in_use, rdata)) && !ast_strlen_zero(transport->domain)) { snprintf(id, sizeof(id), "%s@%s", endpoint_name, transport->domain); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } } /* Fall back to no domain */ endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", endpoint_name); done: if (endpoint) { if (!(endpoint->ident_method & AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME)) { ao2_ref(endpoint, -1); return NULL; } ast_debug(3, "Retrieved endpoint %s\n", ast_sorcery_object_get_id(endpoint)); } else { ast_debug(3, "Could not identify endpoint by username '%s'\n", endpoint_name); } return endpoint; }
static struct ast_sip_endpoint *anonymous_identify(pjsip_rx_data *rdata) { char domain_name[64], id[AST_UUID_STR_LEN]; struct ast_sip_endpoint *endpoint; RAII_VAR(struct ast_sip_domain_alias *, alias, NULL, ao2_cleanup); RAII_VAR(struct ao2_container *, transports, NULL, ao2_cleanup); RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup); if (get_endpoint_details(rdata, domain_name, sizeof(domain_name))) { return NULL; } /* Attempt to find the endpoint given the name and domain provided */ snprintf(id, sizeof(id), "anonymous@%s", domain_name); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } /* See if an alias exists for the domain provided */ if ((alias = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "domain_alias", domain_name))) { snprintf(id, sizeof(id), "anonymous@%s", alias->domain); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } } /* See if the transport this came in on has a provided domain */ if ((transports = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL)) && (transport = ao2_callback(transports, 0, find_transport_in_use, rdata)) && !ast_strlen_zero(transport->domain)) { snprintf(id, sizeof(id), "anonymous@%s", transport->domain); if ((endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", id))) { goto done; } } /* Fall back to no domain */ endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", "anonymous"); done: if (endpoint) { ast_debug(3, "Retrieved anonymous endpoint '%s'\n", ast_sorcery_object_get_id(endpoint)); } return endpoint; }
static void create_mwi_subscriptions(void) { struct ao2_container *endpoints; endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); if (!endpoints) { return; } /* We remove all the old stasis subscriptions first before applying the new configuration. This * prevents a situation where there might be multiple overlapping stasis subscriptions for an * endpoint for mailboxes. Though there may be mailbox changes during the gap between unsubscribing * and resubscribing, up-to-date mailbox state will be sent out to the endpoint when the * new stasis subscription is established */ ao2_lock(unsolicited_mwi); ao2_callback(unsolicited_mwi, OBJ_NOLOCK | OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe, NULL); ao2_callback(endpoints, OBJ_NODATA, create_mwi_subscriptions_for_endpoint, NULL); ao2_unlock(unsolicited_mwi); ao2_ref(endpoints, -1); }
static struct ao2_container *cli_get_container(void) { RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup); struct ao2_container *s_container; container = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "auth", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); if (!container) { return NULL; } s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, ast_sorcery_object_id_sort, ast_sorcery_object_id_compare); if (!s_container) { return NULL; } if (ao2_container_dup(s_container, container, 0)) { ao2_ref(s_container, -1); return NULL; } return s_container; }
/*! * \internal * \brief Find an endpoint associated with the given contact. */ static struct ast_sip_endpoint *find_an_endpoint(struct ast_sip_contact *contact) { struct ao2_container *endpoints; struct ast_sip_endpoint *endpoint; struct ast_variable *var; char *aor = ast_alloca(strlen(contact->aor) + 3); sprintf(aor, "%%%s%%", contact->aor); var = ast_variable_new("aors LIKE", aor, ""); endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var); ast_variables_destroy(var); /* * Because aors are a string list, we have to use a pattern match but since a simple * pattern match could return an endpoint that has an aor of "aaabccc" when searching * for "abc", we still have to iterate over them to find an exact aor match. */ endpoint = ao2_callback(endpoints, 0, on_endpoint, (char *)contact->aor); ao2_ref(endpoints, -1); return endpoint; }
static pj_status_t nat_on_tx_message(pjsip_tx_data *tdata) { RAII_VAR(struct ao2_container *, transports, NULL, ao2_cleanup); RAII_VAR(struct ast_sip_transport *, transport, NULL, ao2_cleanup); struct request_transport_details details = { 0, }; pjsip_via_hdr *via = NULL; struct ast_sockaddr addr = { { 0, } }; pjsip_sip_uri *uri = NULL; RAII_VAR(struct ao2_container *, hooks, NULL, ao2_cleanup); /* If a transport selector is in use we know the transport or factory, so explicitly find it */ if (tdata->tp_sel.type == PJSIP_TPSELECTOR_TRANSPORT) { details.transport = tdata->tp_sel.u.transport; } else if (tdata->tp_sel.type == PJSIP_TPSELECTOR_LISTENER) { details.factory = tdata->tp_sel.u.listener; } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP || tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_UDP6) { /* Connectionless uses the same transport for all requests */ details.type = AST_TRANSPORT_UDP; details.transport = tdata->tp_info.transport; } else { if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TCP) { details.type = AST_TRANSPORT_TCP; } else if (tdata->tp_info.transport->key.type == PJSIP_TRANSPORT_TLS) { details.type = AST_TRANSPORT_TLS; } else { /* Unknown transport type, we can't map and thus can't apply NAT changes */ return PJ_SUCCESS; } if ((uri = nat_get_contact_sip_uri(tdata))) { details.local_address = uri->host; details.local_port = uri->port; } else if ((tdata->msg->type == PJSIP_REQUEST_MSG) && (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL))) { details.local_address = via->sent_by.host; details.local_port = via->sent_by.port; } else { return PJ_SUCCESS; } if (!details.local_port) { details.local_port = (details.type == AST_TRANSPORT_TLS) ? 5061 : 5060; } } if (!(transports = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "transport", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL)) || !(transport = ao2_callback(transports, 0, find_transport_in_use, &details)) || !transport->localnet || ast_sockaddr_isnull(&transport->external_address)) { return PJ_SUCCESS; } ast_sockaddr_parse(&addr, tdata->tp_info.dst_name, PARSE_PORT_FORBID); ast_sockaddr_set_port(&addr, tdata->tp_info.dst_port); /* See if where we are sending this request is local or not, and if not that we can get a Contact URI to modify */ if (ast_apply_ha(transport->localnet, &addr) != AST_SENSE_ALLOW) { return PJ_SUCCESS; } /* Update the contact header with the external address */ if (uri || (uri = nat_get_contact_sip_uri(tdata))) { pj_strdup2(tdata->pool, &uri->host, ast_sockaddr_stringify_host(&transport->external_address)); if (transport->external_signaling_port) { uri->port = transport->external_signaling_port; ast_debug(4, "Re-wrote Contact URI port to %d\n", uri->port); } } /* Update the via header if relevant */ if ((tdata->msg->type == PJSIP_REQUEST_MSG) && (via || (via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL)))) { pj_strdup2(tdata->pool, &via->sent_by.host, ast_sockaddr_stringify_host(&transport->external_address)); if (transport->external_signaling_port) { via->sent_by.port = transport->external_signaling_port; } } /* Invoke any additional hooks that may be registered */ if ((hooks = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "nat_hook", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL))) { struct nat_hook_details hook_details = { .tdata = tdata, .transport = transport, }; ao2_callback(hooks, 0, nat_invoke_hook, &hook_details); } return PJ_SUCCESS; }
struct ao2_container *ast_mwi_mailbox_get_all(void) { return ast_sorcery_retrieve_by_fields(mwi_sorcery, MWI_MAILBOX_TYPE, AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL); }