/*
* Call this function to create request to initiate REFER subscription.
*
*/
PJ_DEF(pj_status_t) pjsip_xfer_initiate( pjsip_evsub *sub,
const pj_str_t *refer_to_uri,
pjsip_tx_data **p_tdata)
{
pjsip_xfer *xfer;
const pj_str_t refer_to = { "Refer-To", 8};
pjsip_tx_data *tdata;
pjsip_generic_string_hdr *hdr;
pj_status_t status;
/* sub and p_tdata argument must be valid. */
PJ_ASSERT_RETURN(sub && p_tdata, PJ_EINVAL);
/* Get the xfer object. */
xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id);
PJ_ASSERT_RETURN(xfer != NULL, PJSIP_ENOREFERSESSION);
/* refer_to_uri argument MAY be NULL for subsequent REFER requests,
* but it MUST be specified in the first REFER.
*/
PJ_ASSERT_RETURN((refer_to_uri || xfer->refer_to_uri.slen), PJ_EINVAL);
/* Lock dialog. */
pjsip_dlg_inc_lock(xfer->dlg);
/* Create basic REFER request */
status = pjsip_evsub_initiate(sub, pjsip_get_refer_method(), -1,
&tdata);
if (status != PJ_SUCCESS)
goto on_return;
/* Save Refer-To URI. */
if (refer_to_uri == NULL) {
refer_to_uri = &xfer->refer_to_uri;
} else {
pj_strdup(xfer->dlg->pool, &xfer->refer_to_uri, refer_to_uri);
}
/* Create and add Refer-To header. */
hdr = pjsip_generic_string_hdr_create(tdata->pool, &refer_to,
refer_to_uri);
if (!hdr) {
pjsip_tx_data_dec_ref(tdata);
status = PJ_ENOMEM;
goto on_return;
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hdr);
/* Done. */
*p_tdata = tdata;
status = PJ_SUCCESS;
on_return:
pjsip_dlg_dec_lock(xfer->dlg);
return status;
}
PJ_DECL(pj_status_t) csipsimple_init_acc_msg_data(pj_pool_t* pool, pjsua_acc_id acc_id, pjsua_msg_data* msg_data){
csipsimple_acc_config *additional_acc_cfg = NULL;
// P-Asserted-Identity header
pj_str_t hp_preferred_identity_name = { "P-Preferred-Identity", 20 };
// Sanity check
PJ_ASSERT_RETURN(msg_data != NULL, PJ_EINVAL);
// Get acc infos
if(pjsua_acc_is_valid(acc_id)){
additional_acc_cfg = (csipsimple_acc_config *) pjsua_acc_get_user_data(acc_id);
}
// Process additionnal config for this account
if(additional_acc_cfg != NULL){
if(additional_acc_cfg->p_preferred_identity.slen > 0){
// Create new P-Asserted-Identity hdr if necessary
pjsip_generic_string_hdr* hdr = pjsip_generic_string_hdr_create(pool,
&hp_preferred_identity_name, &additional_acc_cfg->p_preferred_identity);
// Push it to msg data
pj_list_push_back(&msg_data->hdr_list, hdr);
}
}
return PJ_SUCCESS;
}
/*!
* \internal
* \brief Adds a path header to an outgoing 2XX response
*
* \param endpoint The endpoint to which the INVITE response is to be sent
* \param contact The contact to which the INVITE response is to be sent
* \param tdata The outbound INVITE response
*/
static void path_outgoing_response(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact, pjsip_tx_data *tdata)
{
struct pjsip_status_line status = tdata->msg->line.status;
pj_str_t path_dup;
pjsip_generic_string_hdr *path_hdr;
pjsip_contact_hdr *contact_hdr;
RAII_VAR(struct ast_sip_aor *, aor, NULL, ao2_cleanup);
pjsip_cseq_hdr *cseq = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL);
const pj_str_t REGISTER_METHOD = {"REGISTER", 8};
if (!endpoint
|| !pj_stristr(®ISTER_METHOD, &cseq->method.name)
|| !PJSIP_IS_STATUS_IN_CLASS(status.code, 200)) {
return;
}
contact_hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CONTACT, NULL);
if (!contact_hdr) {
return;
}
aor = find_aor(endpoint, contact_hdr->uri);
if (!aor || !aor->support_path || add_supported(tdata)
|| path_get_string(tdata->pool, contact, &path_dup)) {
return;
}
path_hdr = pjsip_generic_string_hdr_create(tdata->pool, &PATH_NAME, &path_dup);
if (!path_hdr) {
return;
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)path_hdr);
}
void SIPPresence::fillDoc(pjsip_tx_data *tdata, const pres_msg_data *msg_data)
{
if (tdata->msg->type == PJSIP_REQUEST_MSG) {
const pj_str_t STR_USER_AGENT = CONST_PJ_STR("User-Agent");
std::string useragent(acc_->getUserAgentName());
pj_str_t pJuseragent = pj_str((char*) useragent.c_str());
pjsip_hdr *h = (pjsip_hdr*) pjsip_generic_string_hdr_create(tdata->pool, &STR_USER_AGENT, &pJuseragent);
pjsip_msg_add_hdr(tdata->msg, h);
}
if (msg_data == NULL)
return;
const pjsip_hdr *hdr;
hdr = msg_data->hdr_list.next;
while (hdr && hdr != &msg_data->hdr_list) {
pjsip_hdr *new_hdr;
new_hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr);
DEBUG("adding header", new_hdr->name.ptr);
pjsip_msg_add_hdr(tdata->msg, new_hdr);
hdr = hdr->next;
}
if (msg_data->content_type.slen && msg_data->msg_body.slen) {
pjsip_msg_body *body;
const pj_str_t type = CONST_PJ_STR("application");
const pj_str_t subtype = CONST_PJ_STR("pidf+xml");
body = pjsip_msg_body_create(tdata->pool, &type, &subtype, &msg_data->msg_body);
tdata->msg->body = body;
}
}
/// Delete all existing copies of a header and replace with a new one.
/// The header to delete must not be one that has an abbreviation.
void PJUtils::set_generic_header(pjsip_tx_data* tdata,
const pj_str_t* name,
const pj_str_t* value)
{
delete_header(tdata->msg, name);
pjsip_generic_string_hdr* new_hdr = pjsip_generic_string_hdr_create(tdata->pool, name, value);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)new_hdr);
}
/**
* Create rport header for MESSAGE.
*/
pjsip_generic_int_hdr* pjsua_im_create_rport(pj_pool_t *pool, pj_str_t *rport_value)
{
/* Create Accept header. */
pjsip_generic_int_hdr *rport;
rport = pjsip_generic_string_hdr_create(pool, &im_rport_hdr, rport_value);
return rport;
}
/**
* Create timeout header for MESSAGE.
*/
pjsip_generic_int_hdr* pjsua_im_create_timtout(pj_pool_t *pool, pj_str_t *timeout_value)
{
/* Create Accept header. */
pjsip_generic_int_hdr *timeout;
timeout = pjsip_generic_string_hdr_create(pool, &im_timeout_hdr, timeout_value);
return timeout;
}
/*
* A simple registrar, invoked by default_mod_on_rx_request()
*/
static void simple_registrar(pjsip_rx_data *rdata)
{
pjsip_tx_data *tdata;
const pjsip_expires_hdr *exp;
const pjsip_hdr *h;
unsigned cnt = 0;
pjsip_generic_string_hdr *srv;
pj_status_t status;
status = pjsip_endpt_create_response(pjsua_get_pjsip_endpt(),
rdata, 200, NULL, &tdata);
if (status != PJ_SUCCESS)
return;
exp = (pjsip_expires_hdr*)
pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL);
h = rdata->msg_info.msg->hdr.next;
while (h != &rdata->msg_info.msg->hdr) {
if (h->type == PJSIP_H_CONTACT) {
const pjsip_contact_hdr *c = (const pjsip_contact_hdr*)h;
int e = c->expires;
if (e < 0) {
if (exp)
e = exp->ivalue;
else
e = 3600;
}
if (e > 0) {
pjsip_contact_hdr *nc = (pjsip_contact_hdr*)
pjsip_hdr_clone(tdata->pool, h);
nc->expires = e;
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)nc);
++cnt;
}
}
h = h->next;
}
srv = pjsip_generic_string_hdr_create(tdata->pool, NULL, NULL);
srv->name = pj_str((char*)"Server");
srv->hvalue = pj_str((char*)"pjsua simple registrar");
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)srv);
pjsip_endpt_send_response2(pjsua_get_pjsip_endpt(),
rdata, tdata, NULL, NULL);
}
PJ_DECL(pj_status_t) csipsimple_msg_data_add_string_hdr(pj_pool_t* pool, pjsua_msg_data* msg_data, pj_str_t* hdr_name, pj_str_t* hdr_value){
// Sanity check
PJ_ASSERT_RETURN(msg_data != NULL && hdr_name != NULL && hdr_value != NULL, PJ_EINVAL);
if(hdr_name->slen <= 2 || hdr_value->slen <= 0){
return PJ_EINVAL;
}
// Ensure it's a X- prefixed header. This is to avoid crappy usage/override of specified headers
// That should be implemented properly elsewhere.
if(hdr_name->ptr[0] != 'X' || hdr_name->ptr[1] != '-'){
return PJ_EINVAL;
}
pjsip_generic_string_hdr* hdr = pjsip_generic_string_hdr_create(pool,
hdr_name, hdr_value);
// Push it to msg data
pj_list_push_back(&msg_data->hdr_list, hdr);
}
/*!
* \internal
* \brief Add a Privacy header to an outbound message
*
* When sending a P-Asserted-Identity header, if privacy is requested, then we
* will need to indicate such by adding a Privacy header. Similarly, if no
* privacy is requested, and a Privacy header already exists on the message,
* then the old Privacy header should be removed.
*
* \param tdata The outbound message to add the Privacy header to
* \param id The id information used to determine privacy
*/
static void add_privacy_header(pjsip_tx_data *tdata, const struct ast_party_id *id)
{
static const pj_str_t pj_privacy_name = { "Privacy", 7 };
static const pj_str_t pj_privacy_value = { "id", 2 };
pjsip_hdr *old_privacy;
old_privacy = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_privacy_name, NULL);
if ((ast_party_id_presentation(id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
if (old_privacy) {
pj_list_erase(old_privacy);
}
} else if (!old_privacy) {
pjsip_generic_string_hdr *privacy_hdr = pjsip_generic_string_hdr_create(
tdata->pool, &pj_privacy_name, &pj_privacy_value);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)privacy_hdr);
}
}
/* Postprocess the request before forwarding it */
static void proxy_postprocess(pjsip_tx_data *tdata)
{
/* Optionally record-route */
if (global.record_route) {
char uribuf[128];
pj_str_t uri;
const pj_str_t H_RR = { "Record-Route", 12 };
pjsip_generic_string_hdr *rr;
pj_ansi_snprintf(uribuf, sizeof(uribuf), "<sip:%.*s:%d;lr>",
(int)global.name[0].host.slen,
global.name[0].host.ptr,
global.name[0].port);
uri = pj_str(uribuf);
rr = pjsip_generic_string_hdr_create(tdata->pool,
&H_RR, &uri);
pjsip_msg_insert_first_hdr(tdata->msg, (pjsip_hdr*)rr);
}
}
/// Delete all existing copies of a header and replace with a new one.
void PJUtils::set_generic_header(pjsip_tx_data* tdata,
const pj_str_t* name,
const pj_str_t* value)
{
while (1)
{
pjsip_hdr* hdr = (pjsip_hdr*)pjsip_msg_find_hdr_by_name(tdata->msg, name, NULL);
if (hdr)
{
pj_list_erase(hdr);
}
else
{
break;
}
}
pjsip_generic_string_hdr* new_hdr = pjsip_generic_string_hdr_create(tdata->pool, name, value);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)new_hdr);
}
/*!
* \internal
* \brief Implements PJSIP_HEADER 'add' by inserting the specified header into thge list.
*
* Retrieve the header_datastore from the session or create one if it doesn't exist.
* Create and initialize the list if needed.
* Create the pj_strs for name and value.
* Create pjsip_msg and hdr_list_entry.
* Add the entry to the list.
*/
static int add_header(void *obj)
{
struct header_data *data = obj;
struct ast_sip_session *session = data->channel->session;
pj_pool_t *pool = session->inv_session->dlg->pool;
pj_str_t pj_header_name;
pj_str_t pj_header_value;
struct hdr_list_entry *le;
struct hdr_list *list;
RAII_VAR(struct ast_datastore *, datastore,
ast_sip_session_get_datastore(session, header_datastore.type), ao2_cleanup);
if (!datastore) {
if (!(datastore = ast_sip_session_alloc_datastore(&header_datastore,
header_datastore.type))
|| !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list)))
|| ast_sip_session_add_datastore(session, datastore)) {
ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n");
return -1;
}
AST_LIST_HEAD_INIT((struct hdr_list *) datastore->data);
}
ast_debug(1, "Adding header %s with value %s\n", data->header_name,
data->header_value);
pj_cstr(&pj_header_name, data->header_name);
pj_cstr(&pj_header_value, data->header_value);
le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry));
le->hdr = (pjsip_hdr *) pjsip_generic_string_hdr_create(pool, &pj_header_name,
&pj_header_value);
list = datastore->data;
AST_LIST_INSERT_TAIL(list, le, nextptr);
return 0;
}
void process_subscription_request(pjsip_rx_data* rdata)
{
pj_status_t status;
int st_code = PJSIP_SC_OK;
SAS::TrailId trail = get_trail(rdata);
// Get the URI from the To header and check it is a SIP or SIPS URI.
pjsip_uri* uri = (pjsip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
pjsip_msg *msg = rdata->msg_info.msg;
pjsip_expires_hdr* expires = (pjsip_expires_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
int expiry = (expires != NULL) ? expires->ivalue : DEFAULT_SUBSCRIPTION_EXPIRES;
if (expiry > max_expires)
{
// Expiry is too long, set it to the maximum.
expiry = max_expires;
}
if ((!PJSIP_URI_SCHEME_IS_SIP(uri)) && (!PJSIP_URI_SCHEME_IS_TEL(uri)))
{
// Reject a non-SIP/TEL URI with 404 Not Found (RFC3261 isn't clear
// whether 404 is the right status code - it says 404 should be used if
// the AoR isn't valid for the domain in the RequestURI).
LOG_ERROR("Rejecting subscribe request using invalid URI scheme");
SAS::Event event(trail, SASEvent::SUBSCRIBE_FAILED_EARLY_URLSCHEME, 0);
// Can't log the public ID as the subscribe has failed too early
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_NOT_FOUND,
NULL,
NULL,
NULL);
return;
}
bool emergency_subscription = false;
pjsip_contact_hdr* contact_hdr = (pjsip_contact_hdr*)
pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, NULL);
while (contact_hdr != NULL)
{
emergency_subscription = PJUtils::is_emergency_registration(contact_hdr);
if (!emergency_subscription)
{
break;
}
contact_hdr = (pjsip_contact_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg,
PJSIP_H_CONTACT,
contact_hdr->next);
}
if (emergency_subscription)
{
// Reject a subscription with a Contact header containing a contact address
// that's been registered for emergency service.
LOG_ERROR("Rejecting subscribe request from emergency registration");
SAS::Event event(trail, SASEvent::SUBSCRIBE_FAILED_EARLY_EMERGENCY, 0);
// Can't log the public ID as the subscribe has failed too early
SAS::report_event(event);
// Allow-Events is a mandatory header on 489 responses.
pjsip_generic_string_hdr* allow_events_hdr = pjsip_generic_string_hdr_create(rdata->tp_info.pool, &STR_ALLOW_EVENTS, &STR_REG);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_BAD_EVENT,
NULL,
(pjsip_hdr*)allow_events_hdr,
NULL);
return;
}
ACR* acr = acr_factory->get_acr(get_trail(rdata),
CALLING_PARTY,
ACR::requested_node_role(rdata->msg_info.msg));
acr->rx_request(rdata->msg_info.msg, rdata->pkt_info.timestamp);
// Canonicalize the public ID from the URI in the To header.
std::string public_id = PJUtils::public_id_from_uri(uri);
LOG_DEBUG("Process SUBSCRIBE for public ID %s", public_id.c_str());
// Get the call identifier from the headers.
std::string cid = PJUtils::pj_str_to_string((const pj_str_t*)&rdata->msg_info.cid->id);;
// Add SAS markers to the trail attached to the message so the trail
// becomes searchable.
SAS::Event event(trail, SASEvent::SUBSCRIBE_START, 0);
event.add_var_param(public_id);
SAS::report_event(event);
LOG_DEBUG("Report SAS start marker - trail (%llx)", trail);
SAS::Marker start_marker(trail, MARKER_ID_START, 1u);
SAS::report_marker(start_marker);
PJUtils::report_sas_to_from_markers(trail, rdata->msg_info.msg);
PJUtils::mark_sas_call_branch_ids(trail, NULL, rdata->msg_info.msg);
// Query the HSS for the associated URIs.
std::vector<std::string> uris;
std::map<std::string, Ifcs> ifc_map;
// Subscriber must have already registered to be making a subscribe
std::string state;
HTTPCode http_code = hss->get_registration_data(public_id, state, ifc_map, uris, trail);
if ((http_code != HTTP_OK) || (state != "REGISTERED"))
{
// We failed to get the list of associated URIs. This indicates that the
// HSS is unavailable, the public identity doesn't exist or the public
// identity doesn't belong to the private identity.
// The client shouldn't retry when the subscriber isn't present in the
// HSS; reject with a 403 in this case.
//
// The client should retry on timeout but no other Clearwater nodes should
// (as Sprout will already have retried on timeout). Reject with a 504
// (503 is used for overload).
st_code = PJSIP_SC_SERVER_TIMEOUT;
if (http_code == HTTP_NOT_FOUND)
{
st_code = PJSIP_SC_FORBIDDEN;
}
LOG_ERROR("Rejecting SUBSCRIBE request");
PJUtils::respond_stateless(stack_data.endpt,
rdata,
st_code,
NULL,
NULL,
NULL);
delete acr;
return;
}
// Determine the AOR from the first entry in the uris array.
std::string aor = uris.front();
LOG_DEBUG("aor = %s", aor.c_str());
LOG_DEBUG("SUBSCRIBE for public ID %s uses AOR %s", public_id.c_str(), aor.c_str());
// Get the system time in seconds for calculating absolute expiry times.
int now = time(NULL);
// Write to the local store, checking the remote store if there is no entry locally. If the write to the local store succeeds, then write to the remote store.
pjsip_tx_data* tdata_notify = NULL;
RegStore::AoR* aor_data = NULL;
std::string subscription_id;
pj_status_t notify_status = write_subscriptions_to_store(store, aor, rdata,
now, NULL, remote_store,
&tdata_notify, &aor_data,
true, subscription_id,
trail);
if (aor_data != NULL)
{
// Log the subscriptions.
log_subscriptions(aor, aor_data);
// If we have a remote store, try to store this there too. We don't worry
// about failures in this case.
if (remote_store != NULL)
{
RegStore::AoR* remote_aor_data = NULL;
std::string ignore;
write_subscriptions_to_store(remote_store, aor, rdata, now, aor_data, NULL,
&tdata_notify, &remote_aor_data, false, ignore,
trail);
delete remote_aor_data;
}
}
else
{
// Failed to connect to the local store. Reject the subscribe with a 500
// response.
// LCOV_EXCL_START - the can't fail to connect to the store we use for UT
st_code = PJSIP_SC_INTERNAL_SERVER_ERROR;
// LCOV_EXCL_STOP
}
// Build and send the reply.
pjsip_tx_data* tdata;
status = PJUtils::create_response(stack_data.endpt, rdata, st_code, NULL, &tdata);
if (status != PJ_SUCCESS)
{
// LCOV_EXCL_START - don't know how to get PJSIP to fail to create a response
LOG_ERROR("Error building SUBSCRIBE %d response %s", st_code,
PJUtils::pj_status_to_string(status).c_str());
SAS::Event event(trail, SASEvent::SUBSCRIBE_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Error building SUBSCRIBE (" + std::to_string(st_code) + ") " + PJUtils::pj_status_to_string(status);
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL,
NULL,
NULL);
delete acr;
delete aor_data;
return;
// LCOV_EXCL_STOP
}
// Add expires headers
pjsip_expires_hdr* expires_hdr = pjsip_expires_hdr_create(tdata->pool, expiry);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)expires_hdr);
// Add the to tag to the response
pjsip_to_hdr *to = (pjsip_to_hdr*) pjsip_msg_find_hdr(tdata->msg,
PJSIP_H_TO,
NULL);
pj_strdup2(tdata->pool, &to->tag, subscription_id.c_str());
// Pass the response to the ACR.
acr->tx_response(tdata->msg);
// Send the response.
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
// Send the ACR and delete it.
acr->send_message();
delete acr;
// Send the Notify
if (tdata_notify != NULL && notify_status == PJ_SUCCESS)
{
set_trail(tdata_notify, trail);
status = PJUtils::send_request(tdata_notify, 0, NULL, NULL, true);
if (status != PJ_SUCCESS)
{
// LCOV_EXCL_START
SAS::Event event(trail, SASEvent::NOTIFICATION_FAILED, 0);
std::string error_msg = "Failed to send NOTIFY - error code: " + std::to_string(status);
event.add_var_param(error_msg);
SAS::report_event(event);
// LCOV_EXCL_STOP
}
}
LOG_DEBUG("Report SAS end marker - trail (%llx)", trail);
SAS::Marker end_marker(trail, MARKER_ID_END, 1u);
SAS::report_marker(end_marker);
delete aor_data;
}
void process_register_request(pjsip_rx_data* rdata)
{
pj_status_t status;
int st_code = PJSIP_SC_OK;
// Get the URI from the To header and check it is a SIP or SIPS URI.
pjsip_uri* uri = (pjsip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
if (!PJSIP_URI_SCHEME_IS_SIP(uri))
{
// Reject a non-SIP/SIPS URI with 404 Not Found (RFC3261 isn't clear
// whether 404 is the right status code - it says 404 should be used if
// the AoR isn't valid for the domain in the RequestURI).
// LCOV_EXCL_START
LOG_ERROR("Rejecting register request using non SIP URI");
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_NOT_FOUND,
NULL,
NULL,
NULL);
return;
// LCOV_EXCL_STOP
}
// Canonicalize the public ID from the URI in the To header.
std::string public_id = PJUtils::aor_from_uri((pjsip_sip_uri*)uri);
LOG_DEBUG("Process REGISTER for public ID %s", public_id.c_str());
// Get the call identifier and the cseq number from the respective headers.
std::string cid = PJUtils::pj_str_to_string((const pj_str_t*)&rdata->msg_info.cid->id);;
int cseq = rdata->msg_info.cseq->cseq;
pjsip_msg *msg = rdata->msg_info.msg;
// Add SAS markers to the trail attached to the message so the trail
// becomes searchable.
SAS::TrailId trail = get_trail(rdata);
LOG_DEBUG("Report SAS start marker - trail (%llx)", trail);
SAS::Marker start_marker(trail, SASMarker::INIT_TIME, 1u);
SAS::report_marker(start_marker);
SAS::Marker calling_dn(trail, SASMarker::CALLING_DN, 1u);
pjsip_sip_uri* calling_uri = (pjsip_sip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
calling_dn.add_var_param(calling_uri->user.slen, calling_uri->user.ptr);
SAS::report_marker(calling_dn);
SAS::Marker cid_marker(trail, SASMarker::SIP_CALL_ID, 1u);
cid_marker.add_var_param(rdata->msg_info.cid->id.slen, rdata->msg_info.cid->id.ptr);
SAS::report_marker(cid_marker, SAS::Marker::Scope::TrailGroup);
// Query the HSS for the associated URIs.
// This should really include the private ID, but we don't yet have a
// homestead API for it. Homestead won't be able to query a third-party HSS
// without the private ID.
Json::Value* uris = hss->get_associated_uris(public_id, trail);
if ((uris == NULL) ||
(uris->size() == 0))
{
// We failed to get the list of associated URIs. This indicates that the
// HSS is unavailable, the public identity doesn't exist or the public
// identity doesn't belong to the private identity. Reject with 403.
LOG_ERROR("Rejecting register request with invalid public/private identity");
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_FORBIDDEN,
NULL,
NULL,
NULL);
return;
}
// Determine the AOR from the first entry in the uris array.
std::string aor = uris->get((Json::ArrayIndex)0, Json::Value::null).asString();
LOG_DEBUG("REGISTER for public ID %s uses AOR %s", public_id.c_str(), aor.c_str());
// Find the expire headers in the message.
pjsip_expires_hdr* expires = (pjsip_expires_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
// Get the system time in seconds for calculating absolute expiry times.
int now = time(NULL);
int expiry = 0;
// The registration service uses optimistic locking to avoid concurrent
// updates to the same AoR conflicting. This means we have to loop
// reading, updating and writing the AoR until the write is successful.
RegData::AoR* aor_data = NULL;
do
{
if (aor_data != NULL)
{
delete aor_data; // LCOV_EXCL_LINE - Single-threaded tests mean we'll
// always pass CAS.
}
// Find the current bindings for the AoR.
aor_data = store->get_aor_data(aor);
LOG_DEBUG("Retrieved AoR data %p", aor_data);
if (aor_data == NULL)
{
// Failed to get data for the AoR because there is no connection
// to the store. Reject the register with a 500 response.
// LCOV_EXCL_START - local store (used in testing) never fails
LOG_ERROR("Failed to get AoR binding for %s from store", aor.c_str());
st_code = PJSIP_SC_INTERNAL_SERVER_ERROR;
break;
// LCOV_EXCL_STOP
}
// Now loop through all the contacts. If there are multiple contacts in
// the contact header in the SIP message, pjsip parses them to separate
// contact header structures.
pjsip_contact_hdr* contact = (pjsip_contact_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, NULL);
while (contact != NULL)
{
if (contact->star)
{
// Wildcard contact, which can only be used to clear all bindings for
// the AoR.
aor_data->clear();
break;
}
pjsip_uri* uri = (contact->uri != NULL) ?
(pjsip_uri*)pjsip_uri_get_uri(contact->uri) :
NULL;
if ((uri != NULL) &&
(PJSIP_URI_SCHEME_IS_SIP(uri)))
{
// The binding identifier is based on the +sip.instance parameter if
// it is present. If not the contact URI is used instead.
std::string contact_uri = PJUtils::uri_to_string(PJSIP_URI_IN_CONTACT_HDR, uri);
std::string binding_id = get_binding_id(contact);
if (binding_id == "")
{
binding_id = contact_uri;
}
LOG_DEBUG(". Binding identifier for contact = %s", binding_id.c_str());
// Find the appropriate binding in the bindings list for this AoR.
RegData::AoR::Binding* binding = aor_data->get_binding(binding_id);
if ((cid != binding->_cid) ||
(cseq > binding->_cseq))
{
// Either this is a new binding, has come from a restarted device, or
// is an update to an existing binding.
binding->_uri = contact_uri;
// TODO Examine Via header to see if we're the first hop
// TODO Only if we're not the first hop, check that the top path header has "ob" parameter
// Get the Path headers, if present. RFC 3327 allows us the option of
// rejecting a request with a Path header if there is no corresponding
// "path" entry in the Supported header but we don't do so on the assumption
// that the edge proxy knows what it's doing.
binding->_path_headers.clear();
pjsip_generic_string_hdr* path_hdr =
(pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, NULL);
while (path_hdr)
{
std::string path = PJUtils::pj_str_to_string(&path_hdr->hvalue);
LOG_DEBUG("Path header %s", path.c_str());
// Extract all the paths from this header.
Utils::split_string(path, ',', binding->_path_headers, 0, true);
// Look for the next header.
path_hdr = (pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, path_hdr->next);
}
binding->_cid = cid;
binding->_cseq = cseq;
binding->_priority = contact->q1000;
binding->_params.clear();
pjsip_param* p = contact->other_param.next;
while ((p != NULL) && (p != &contact->other_param))
{
std::string pname = PJUtils::pj_str_to_string(&p->name);
std::string pvalue = PJUtils::pj_str_to_string(&p->value);
binding->_params.push_back(std::make_pair(pname, pvalue));
p = p->next;
}
// Calculate the expiry period for the updated binding.
expiry = (contact->expires != -1) ? contact->expires :
(expires != NULL) ? expires->ivalue : 300;
if (expiry > 300)
{
// Expiry is too long, set it to the maximum of 300 seconds (5 minutes).
expiry = 300;
}
binding->_expires = now + expiry;
if (analytics != NULL)
{
// Generate an analytics log for this binding update.
analytics->registration(aor, binding_id, contact_uri, expiry);
}
}
}
contact = (pjsip_contact_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, contact->next);
}
}
while (!store->set_aor_data(aor, aor_data));
if (aor_data != NULL)
{
// Log the bindings.
log_bindings(aor, aor_data);
}
// Build and send the reply.
pjsip_tx_data* tdata;
status = PJUtils::create_response(stack_data.endpt, rdata, st_code, NULL, &tdata);
if (status != PJ_SUCCESS)
{
// LCOV_EXCL_START - don't know how to get PJSIP to fail to create a response
LOG_ERROR("Error building REGISTER %d response %s", st_code,
PJUtils::pj_status_to_string(status).c_str());
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL,
NULL,
NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
if (st_code != PJSIP_SC_OK)
{
// LCOV_EXCL_START - we only reject REGISTER if something goes wrong, and
// we aren't covering any of those paths so we can't hit this either
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
// Add supported and require headers for RFC5626.
pjsip_generic_string_hdr* gen_hdr;
gen_hdr = pjsip_generic_string_hdr_create(tdata->pool,
&STR_SUPPORTED,
&STR_OUTBOUND);
if (gen_hdr == NULL)
{
// LCOV_EXCL_START - can't see how this could ever happen
LOG_ERROR("Failed to add RFC 5626 headers");
tdata->msg->line.status.code = PJSIP_SC_INTERNAL_SERVER_ERROR;
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
delete aor_data;
return;
// LCOV_EXCL_STOP
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)gen_hdr);
// Add contact headers for all active bindings.
for (RegData::AoR::Bindings::const_iterator i = aor_data->bindings().begin();
i != aor_data->bindings().end();
++i)
{
RegData::AoR::Binding* binding = i->second;
if (binding->_expires > now)
{
// The binding hasn't expired.
pjsip_uri* uri = PJUtils::uri_from_string(binding->_uri, tdata->pool);
if (uri != NULL)
{
// Contact URI is well formed, so include this in the response.
pjsip_contact_hdr* contact = pjsip_contact_hdr_create(tdata->pool);
contact->star = 0;
contact->uri = uri;
contact->q1000 = binding->_priority;
contact->expires = binding->_expires - now;
pj_list_init(&contact->other_param);
for (std::list<std::pair<std::string, std::string> >::iterator j = binding->_params.begin();
j != binding->_params.end();
++j)
{
pjsip_param *new_param = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
pj_strdup2(tdata->pool, &new_param->name, j->first.c_str());
pj_strdup2(tdata->pool, &new_param->value, j->second.c_str());
pj_list_insert_before(&contact->other_param, new_param);
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)contact);
}
else
{
// Contact URI is malformed. Log an error, but otherwise don't try and
// fix it.
// LCOV_EXCL_START hard to hit - needs bad data in the store
LOG_WARNING("Badly formed contact URI %s for address of record %s",
binding->_uri.c_str(), aor.c_str());
// LCOV_EXCL_STOP
}
}
}
// Deal with path header related fields in the response.
pjsip_generic_string_hdr* path_hdr =
(pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, NULL);
if ((path_hdr != NULL) &&
(!aor_data->bindings().empty()))
{
// We have bindings with path headers so we must require outbound.
pjsip_require_hdr* require_hdr = pjsip_require_hdr_create(tdata->pool);
require_hdr->count = 1;
require_hdr->values[0] = STR_OUTBOUND;
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)require_hdr);
}
// Echo back any Path headers as per RFC 3327, section 5.3. We take these
// from the request as they may not exist in the bindings any more if the
// bindings have expired.
while (path_hdr)
{
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, path_hdr));
path_hdr = (pjsip_generic_string_hdr*)pjsip_msg_find_hdr_by_name(msg, &STR_PATH, path_hdr->next);
}
// Construct a Service-Route header pointing at the sprout cluster. We don't
// care which sprout handles the subsequent requests as they all have access
// to all subscriber information.
pjsip_sip_uri* service_route_uri = pjsip_sip_uri_create(tdata->pool, false);
pj_strdup(tdata->pool,
&service_route_uri->host,
&stack_data.sprout_cluster_domain);
service_route_uri->port = stack_data.trusted_port;
service_route_uri->transport_param = pj_str("TCP");
service_route_uri->lr_param = 1;
pjsip_route_hdr* service_route = pjsip_route_hdr_create(tdata->pool);
service_route->name = STR_SERVICE_ROUTE;
service_route->sname = pj_str("");
service_route->name_addr.uri = (pjsip_uri*)service_route_uri;
pjsip_msg_insert_first_hdr(tdata->msg, (pjsip_hdr*)service_route);
// Add P-Associated-URI headers for all of the associated URIs.
static const pj_str_t p_associated_uri_hdr_name = pj_str("P-Associated-URI");
for (Json::ValueIterator it = uris->begin(); it != uris->end(); it++)
{
pj_str_t associated_uri = {(char*)(*it).asCString(), strlen((*it).asCString())};
pjsip_hdr* associated_uri_hdr =
(pjsip_hdr*)pjsip_generic_string_hdr_create(tdata->pool,
&p_associated_uri_hdr_name,
&associated_uri);
pjsip_msg_add_hdr(tdata->msg, associated_uri_hdr);
}
delete uris;
// Send the response, but prevent the transmitted data from being freed, as we may need to inform the
// ASes of the 200 OK response we sent.
pjsip_tx_data_add_ref(tdata);
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
RegistrationUtils::register_with_application_servers(ifchandler, store, rdata, tdata, "");
// Now we can free the tdata.
pjsip_tx_data_dec_ref(tdata);
LOG_DEBUG("Report SAS end marker - trail (%llx)", trail);
SAS::Marker end_marker(trail, SASMarker::END_TIME, 1u);
SAS::report_marker(end_marker);
delete aor_data;
}
void process_register_request(pjsip_rx_data* rdata)
{
pj_status_t status;
int st_code = PJSIP_SC_OK;
SAS::TrailId trail = get_trail(rdata);
// Get the URI from the To header and check it is a SIP or SIPS URI.
pjsip_uri* uri = (pjsip_uri*)pjsip_uri_get_uri(rdata->msg_info.to->uri);
if ((!PJSIP_URI_SCHEME_IS_SIP(uri)) && (!PJSIP_URI_SCHEME_IS_TEL(uri)))
{
// Reject a non-SIP/TEL URI with 404 Not Found (RFC3261 isn't clear
// whether 404 is the right status code - it says 404 should be used if
// the AoR isn't valid for the domain in the RequestURI).
LOG_ERROR("Rejecting register request using invalid URI scheme");
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
// Can't log the public ID as the REGISTER has failed too early
std::string public_id = "UNKNOWN";
std::string error_msg = "Rejecting register request using invalid URI scheme";
event.add_var_param(public_id);
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_NOT_FOUND,
NULL,
NULL,
NULL);
return;
}
// Allocate an ACR for this transaction and pass the request to it.
ACR* acr = acr_factory->get_acr(get_trail(rdata),
CALLING_PARTY,
ACR::requested_node_role(rdata->msg_info.msg));
acr->rx_request(rdata->msg_info.msg, rdata->pkt_info.timestamp);
// Canonicalize the public ID from the URI in the To header.
std::string public_id = PJUtils::public_id_from_uri(uri);
LOG_DEBUG("Process REGISTER for public ID %s", public_id.c_str());
// Get the call identifier and the cseq number from the respective headers.
std::string cid = PJUtils::pj_str_to_string((const pj_str_t*)&rdata->msg_info.cid->id);;
pjsip_msg *msg = rdata->msg_info.msg;
// Add SAS markers to the trail attached to the message so the trail
// becomes searchable.
LOG_DEBUG("Report SAS start marker - trail (%llx)", trail);
SAS::Marker start_marker(trail, MARKER_ID_START, 1u);
SAS::report_marker(start_marker);
PJUtils::report_sas_to_from_markers(trail, rdata->msg_info.msg);
PJUtils::mark_sas_call_branch_ids(trail, NULL, rdata->msg_info.msg);
// Query the HSS for the associated URIs.
std::vector<std::string> uris;
std::map<std::string, Ifcs> ifc_map;
std::string private_id;
std::string private_id_for_binding;
bool success = get_private_id(rdata, private_id);
if (!success)
{
// There are legitimate cases where we don't have a private ID
// here (for example, on a re-registration where Bono has set the
// Integrity-Protected header), so this is *not* a failure
// condition.
// We want the private ID here so that Homestead can use it to
// subscribe for updates from the HSS - but on a re-registration,
// Homestead should already have subscribed for updates during the
// initial registration, so we can just make a request using our
// public ID.
private_id = "";
// IMS compliant clients will always have the Auth header on all REGISTERs,
// including reREGISTERS. Non-IMS clients won't, but their private ID
// will always be the public ID with the sip: removed.
private_id_for_binding = PJUtils::default_private_id_from_uri(uri);
}
else
{
private_id_for_binding = private_id;
}
SAS::Event event(trail, SASEvent::REGISTER_START, 0);
event.add_var_param(public_id);
event.add_var_param(private_id);
SAS::report_event(event);
std::string regstate;
std::deque<std::string> ccfs;
std::deque<std::string> ecfs;
HTTPCode http_code = hss->update_registration_state(public_id,
private_id,
HSSConnection::REG,
regstate,
ifc_map,
uris,
ccfs,
ecfs,
trail);
if ((http_code != HTTP_OK) || (regstate != HSSConnection::STATE_REGISTERED))
{
// We failed to register this subscriber at the HSS. This indicates that the
// HSS is unavailable, the public identity doesn't exist or the public
// identity doesn't belong to the private identity.
// The client shouldn't retry when the subscriber isn't present in the
// HSS; reject with a 403 in this case.
//
// The client should retry on timeout but no other Clearwater nodes should
// (as Sprout will already have retried on timeout). Reject with a 504
// (503 is used for overload).
st_code = PJSIP_SC_SERVER_TIMEOUT;
if (http_code == HTTP_NOT_FOUND)
{
st_code = PJSIP_SC_FORBIDDEN;
}
LOG_ERROR("Rejecting register request with invalid public/private identity");
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Rejecting register request with invalid public/private identity";
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
st_code,
NULL,
NULL,
NULL);
delete acr;
return;
}
// Determine the AOR from the first entry in the uris array.
std::string aor = uris.front();
LOG_DEBUG("REGISTER for public ID %s uses AOR %s", public_id.c_str(), aor.c_str());
// Get the system time in seconds for calculating absolute expiry times.
int now = time(NULL);
int expiry = 0;
bool is_initial_registration;
// Loop through each contact header. If every registration is an emergency
// registration and its expiry is 0 then reject with a 501.
// If there are valid registration updates to make then attempt to write to
// store, which also stops emergency registrations from being deregistered.
bool reject_with_501 = true;
bool any_emergency_registrations = false;
bool reject_with_400 = false;
pjsip_contact_hdr* contact_hdr = (pjsip_contact_hdr*)
pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
while (contact_hdr != NULL)
{
pjsip_expires_hdr* expires = (pjsip_expires_hdr*)pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL);
expiry = (contact_hdr->expires != -1) ? contact_hdr->expires :
(expires != NULL) ? expires->ivalue :
max_expires;
if ((contact_hdr->star) && (expiry != 0))
{
// Wildcard contact, which can only be used if the expiry is 0
LOG_ERROR("Attempted to deregister all bindings, but expiry value wasn't 0");
reject_with_400 = true;
break;
}
reject_with_501 = (reject_with_501 &&
PJUtils::is_emergency_registration(contact_hdr) && (expiry == 0));
any_emergency_registrations = (any_emergency_registrations ||
PJUtils::is_emergency_registration(contact_hdr));
contact_hdr = (pjsip_contact_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg,
PJSIP_H_CONTACT,
contact_hdr->next);
}
if (reject_with_400)
{
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Rejecting register request with invalid contact header";
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_BAD_REQUEST,
NULL,
NULL,
NULL);
delete acr;
return;
}
if (reject_with_501)
{
LOG_ERROR("Rejecting register request as attempting to deregister an emergency registration");
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Rejecting deregister request for emergency registrations";
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_NOT_IMPLEMENTED,
NULL,
NULL,
NULL);
delete acr;
return;
}
// Write to the local store, checking the remote store if there is no entry locally.
RegStore::AoR* aor_data = write_to_store(store, aor, rdata, now, expiry,
is_initial_registration, NULL, remote_store,
true, private_id_for_binding, trail);
if (aor_data != NULL)
{
// Log the bindings.
log_bindings(aor, aor_data);
// If we have a remote store, try to store this there too. We don't worry
// about failures in this case.
if (remote_store != NULL)
{
int tmp_expiry = 0;
bool ignored;
RegStore::AoR* remote_aor_data = write_to_store(remote_store, aor, rdata, now,
tmp_expiry, ignored, aor_data,
NULL, false, private_id_for_binding,
trail);
delete remote_aor_data;
}
}
else
{
// Failed to connect to the local store. Reject the register with a 500
// response.
// LCOV_EXCL_START - the can't fail to connect to the store we use for UT
st_code = PJSIP_SC_INTERNAL_SERVER_ERROR;
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Unable to access Registration Store";
event.add_var_param(error_msg);
SAS::report_event(event);
// LCOV_EXCL_STOP
}
// Build and send the reply.
pjsip_tx_data* tdata;
status = PJUtils::create_response(stack_data.endpt, rdata, st_code, NULL, &tdata);
if (status != PJ_SUCCESS)
{
// LCOV_EXCL_START - don't know how to get PJSIP to fail to create a response
std::string error_msg = "Error building REGISTER " + std::to_string(status) +
" response " + PJUtils::pj_status_to_string(status);
LOG_ERROR(error_msg.c_str());
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
event.add_var_param(error_msg);
SAS::report_event(event);
PJUtils::respond_stateless(stack_data.endpt,
rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL,
NULL,
NULL);
delete acr;
delete aor_data;
return;
// LCOV_EXCL_STOP
}
if (st_code != PJSIP_SC_OK)
{
// LCOV_EXCL_START - we only reject REGISTER if something goes wrong, and
// we aren't covering any of those paths so we can't hit this either
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "REGISTER failed with status code: " + std::to_string(st_code);
event.add_var_param(error_msg);
SAS::report_event(event);
delete acr;
delete aor_data;
return;
// LCOV_EXCL_STOP
}
// Add supported and require headers for RFC5626.
pjsip_generic_string_hdr* gen_hdr;
gen_hdr = pjsip_generic_string_hdr_create(tdata->pool,
&STR_SUPPORTED,
&STR_OUTBOUND);
if (gen_hdr == NULL)
{
// LCOV_EXCL_START - can't see how this could ever happen
LOG_ERROR("Failed to add RFC 5626 headers");
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Failed to add RFC 5636 headers";
event.add_var_param(error_msg);
SAS::report_event(event);
tdata->msg->line.status.code = PJSIP_SC_INTERNAL_SERVER_ERROR;
pjsip_tx_data_invalidate_msg(tdata);
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
delete acr;
delete aor_data;
return;
// LCOV_EXCL_STOP
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)gen_hdr);
// Add contact headers for all active bindings.
for (RegStore::AoR::Bindings::const_iterator i = aor_data->bindings().begin();
i != aor_data->bindings().end();
++i)
{
RegStore::AoR::Binding* binding = i->second;
if (binding->_expires > now)
{
// The binding hasn't expired. Parse the Contact URI from the store,
// making sure it is formatted as a name-address.
pjsip_uri* uri = PJUtils::uri_from_string(binding->_uri, tdata->pool, PJ_TRUE);
if (uri != NULL)
{
// Contact URI is well formed, so include this in the response.
pjsip_contact_hdr* contact = pjsip_contact_hdr_create(tdata->pool);
contact->star = 0;
contact->uri = uri;
contact->q1000 = binding->_priority;
contact->expires = binding->_expires - now;
pj_list_init(&contact->other_param);
for (std::map<std::string, std::string>::iterator j = binding->_params.begin();
j != binding->_params.end();
++j)
{
pjsip_param *new_param = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
pj_strdup2(tdata->pool, &new_param->name, j->first.c_str());
pj_strdup2(tdata->pool, &new_param->value, j->second.c_str());
pj_list_insert_before(&contact->other_param, new_param);
}
// The pub-gruu parameter on the Contact header is calculated
// from the instance-id, to avoid unnecessary storage in
// memcached.
std::string gruu = binding->pub_gruu_quoted_string(tdata->pool);
if (!gruu.empty())
{
pjsip_param *new_param = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
pj_strdup2(tdata->pool, &new_param->name, "pub-gruu");
pj_strdup2(tdata->pool, &new_param->value, gruu.c_str());
pj_list_insert_before(&contact->other_param, new_param);
}
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)contact);
}
else
{
// Contact URI is malformed. Log an error, but otherwise don't try and
// fix it.
// LCOV_EXCL_START hard to hit - needs bad data in the store
LOG_WARNING("Badly formed contact URI %s for address of record %s",
binding->_uri.c_str(), aor.c_str());
SAS::Event event(trail, SASEvent::REGISTER_FAILED, 0);
event.add_var_param(public_id);
std::string error_msg = "Badly formed contact URI - " + binding->_uri;
event.add_var_param(error_msg);
SAS::report_event(event);
// LCOV_EXCL_STOP
}
}
}
// Deal with path header related fields in the response.
pjsip_routing_hdr* path_hdr = (pjsip_routing_hdr*)
pjsip_msg_find_hdr_by_name(msg, &STR_PATH, NULL);
if ((path_hdr != NULL) &&
(!aor_data->bindings().empty()))
{
// We have bindings with path headers so we must require outbound.
pjsip_require_hdr* require_hdr = pjsip_require_hdr_create(tdata->pool);
require_hdr->count = 1;
require_hdr->values[0] = STR_OUTBOUND;
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)require_hdr);
}
// Echo back any Path headers as per RFC 3327, section 5.3. We take these
// from the request as they may not exist in the bindings any more if the
// bindings have expired.
while (path_hdr)
{
pjsip_msg_add_hdr(tdata->msg,
(pjsip_hdr*)pjsip_hdr_clone(tdata->pool, path_hdr));
path_hdr = (pjsip_routing_hdr*)
pjsip_msg_find_hdr_by_name(msg, &STR_PATH, path_hdr->next);
}
// Add the Service-Route header. It isn't safe to do this with the
// pre-built header from the global pool because the chaining data
// structures in the header may get overwritten, but it is safe to do a
// shallow clone.
pjsip_hdr* clone = (pjsip_hdr*)
pjsip_hdr_shallow_clone(tdata->pool, service_route);
pjsip_msg_insert_first_hdr(tdata->msg, clone);
// Add P-Associated-URI headers for all of the associated URIs.
for (std::vector<std::string>::iterator it = uris.begin();
it != uris.end();
it++)
{
pjsip_routing_hdr* pau =
identity_hdr_create(tdata->pool, STR_P_ASSOCIATED_URI);
pau->name_addr.uri = PJUtils::uri_from_string(*it, tdata->pool);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pau);
}
// Add a PCFA header.
PJUtils::add_pcfa_header(tdata->msg, tdata->pool, ccfs, ecfs, true);
// Pass the response to the ACR.
acr->tx_response(tdata->msg);
// Send the response, but prevent the transmitted data from being freed, as we may need to inform the
// ASes of the 200 OK response we sent.
pjsip_tx_data_add_ref(tdata);
status = pjsip_endpt_send_response2(stack_data.endpt, rdata, tdata, NULL, NULL);
// Send the ACR and delete it.
acr->send_message();
delete acr;
// TODO in sto397: we should do third-party registration once per
// service profile (i.e. once per iFC, using an arbitrary public
// ID). hss->get_subscription_data should be enhanced to provide an
// appropriate data structure (representing the ServiceProfile
// nodes) and we should loop through that. Don't send any register that
// contained emergency registrations to the application servers.
if (!any_emergency_registrations)
{
RegistrationUtils::register_with_application_servers(ifc_map[public_id],
store,
rdata,
tdata,
expiry,
is_initial_registration,
public_id,
trail);
}
// Now we can free the tdata.
pjsip_tx_data_dec_ref(tdata);
LOG_DEBUG("Report SAS end marker - trail (%llx)", trail);
SAS::Marker end_marker(trail, MARKER_ID_END, 1u);
SAS::report_marker(end_marker);
delete aor_data;
}
/*
* Create PRACK request for the incoming reliable provisional response.
*/
PJ_DEF(pj_status_t) pjsip_100rel_create_prack( pjsip_inv_session *inv,
pjsip_rx_data *rdata,
pjsip_tx_data **p_tdata)
{
dlg_data *dd;
uac_state_t *uac_state = NULL;
const pj_str_t *to_tag = &rdata->msg_info.to->tag;
pjsip_transaction *tsx;
pjsip_msg *msg;
pjsip_generic_string_hdr *rseq_hdr;
pjsip_generic_string_hdr *rack_hdr;
unsigned rseq;
pj_str_t rack;
char rack_buf[80];
pjsip_tx_data *tdata;
pj_status_t status;
*p_tdata = NULL;
dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
PJ_ASSERT_RETURN(dd != NULL, PJSIP_ENOTINITIALIZED);
tsx = pjsip_rdata_get_tsx(rdata);
msg = rdata->msg_info.msg;
/* Check our assumptions */
pj_assert( tsx->role == PJSIP_ROLE_UAC &&
tsx->method.id == PJSIP_INVITE_METHOD &&
msg->line.status.code > 100 &&
msg->line.status.code < 200);
/* Get the RSeq header */
rseq_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &RSEQ, NULL);
if (rseq_hdr == NULL) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response with no RSeq header"));
return PJSIP_EMISSINGHDR;
}
rseq = (pj_uint32_t) pj_strtoul(&rseq_hdr->hvalue);
/* Find UAC state for the specified call leg */
uac_state = dd->uac_state_list;
while (uac_state) {
if (pj_stricmp(&uac_state->tag, to_tag)==0)
break;
uac_state = uac_state->next;
}
/* Create new UAC state if we don't have one */
if (uac_state == NULL) {
uac_state = PJ_POOL_ZALLOC_T(dd->inv->dlg->pool, uac_state_t);
uac_state->cseq = rdata->msg_info.cseq->cseq;
uac_state->rseq = rseq - 1;
pj_strdup(dd->inv->dlg->pool, &uac_state->tag, to_tag);
uac_state->next = dd->uac_state_list;
dd->uac_state_list = uac_state;
}
/* If this is from new INVITE transaction, reset UAC state. */
if (rdata->msg_info.cseq->cseq != uac_state->cseq) {
uac_state->cseq = rdata->msg_info.cseq->cseq;
uac_state->rseq = rseq - 1;
}
/* Ignore provisional response retransmission */
if (rseq <= uac_state->rseq) {
/* This should have been handled before */
return PJ_EIGNORED;
/* Ignore provisional response with out-of-order RSeq */
} else if (rseq != uac_state->rseq + 1) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response because RSeq jump "
"(expecting %u, got %u)",
uac_state->rseq+1, rseq));
return PJ_EIGNORED;
}
/* Update our RSeq */
uac_state->rseq = rseq;
/* Create PRACK */
status = pjsip_dlg_create_request(dd->inv->dlg, &pjsip_prack_method,
-1, &tdata);
if (status != PJ_SUCCESS)
return status;
/* If this response is a forked response from a different call-leg,
* update the req URI (https://trac.pjsip.org/repos/ticket/1364)
*/
if (pj_stricmp(&uac_state->tag, &dd->inv->dlg->remote.info->tag)) {
const pjsip_contact_hdr *mhdr;
mhdr = (const pjsip_contact_hdr*)
pjsip_msg_find_hdr(rdata->msg_info.msg,
PJSIP_H_CONTACT, NULL);
if (!mhdr || !mhdr->uri) {
PJ_LOG(4,(dd->inv->dlg->obj_name,
"Ignoring 100rel response with no or "
"invalid Contact header"));
pjsip_tx_data_dec_ref(tdata);
return PJ_EIGNORED;
}
tdata->msg->line.req.uri = (pjsip_uri*)
pjsip_uri_clone(tdata->pool, mhdr->uri);
}
/* Create RAck header */
rack.ptr = rack_buf;
rack.slen = pj_ansi_snprintf(rack.ptr, sizeof(rack_buf),
"%u %u %.*s",
rseq, rdata->msg_info.cseq->cseq,
(int)tsx->method.name.slen,
tsx->method.name.ptr);
if (rack.slen < 1 || rack.slen >= (int)sizeof(rack_buf)) {
return PJ_ETOOSMALL;
}
rack_hdr = pjsip_generic_string_hdr_create(tdata->pool, &RACK, &rack);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) rack_hdr);
/* Done */
*p_tdata = tdata;
return PJ_SUCCESS;
}
static pj_status_t create_request(pjsip_publishc *pubc,
pjsip_tx_data **p_tdata)
{
const pj_str_t STR_EVENT = { "Event", 5 };
pj_status_t status;
pjsip_generic_string_hdr *hdr;
pjsip_tx_data *tdata;
PJ_ASSERT_RETURN(pubc && p_tdata, PJ_EINVAL);
/* Create the request. */
status = pjsip_endpt_create_request_from_hdr( pubc->endpt,
&pjsip_publish_method,
pubc->target_uri,
pubc->from_hdr,
pubc->to_hdr,
NULL,
pubc->cid_hdr,
pubc->cseq_hdr->cseq,
NULL,
&tdata);
if (status != PJ_SUCCESS)
return status;
/* Add cached authorization headers. */
pjsip_auth_clt_init_req( &pubc->auth_sess, tdata );
/* Add Route headers from route set, ideally after Via header */
if (!pj_list_empty(&pubc->route_set)) {
pjsip_hdr *route_pos;
const pjsip_route_hdr *route;
route_pos = (pjsip_hdr*)
pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL);
if (!route_pos)
route_pos = &tdata->msg->hdr;
route = pubc->route_set.next;
while (route != &pubc->route_set) {
pjsip_hdr *new_hdr = (pjsip_hdr*)
pjsip_hdr_shallow_clone(tdata->pool, route);
pj_list_insert_after(route_pos, new_hdr);
route_pos = new_hdr;
route = route->next;
}
}
/* Add Event header */
hdr = pjsip_generic_string_hdr_create(tdata->pool, &STR_EVENT,
&pubc->event);
if (hdr)
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hdr);
/* Add SIP-If-Match if we have etag */
if (pubc->etag.slen) {
const pj_str_t STR_HNAME = { "SIP-If-Match", 12 };
hdr = pjsip_generic_string_hdr_create(tdata->pool, &STR_HNAME,
&pubc->etag);
if (hdr)
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hdr);
}
/* Done. */
*p_tdata = tdata;
return PJ_SUCCESS;
}
void SubscriptionSproutletTsx::process_subscription_request(pjsip_msg* req)
{
SAS::TrailId trail_id = trail();
// Get the URI from the To header and check it is a SIP or SIPS URI.
pjsip_uri* uri = (pjsip_uri*)pjsip_uri_get_uri(PJSIP_MSG_TO_HDR(req)->uri);
if ((!PJSIP_URI_SCHEME_IS_SIP(uri)) && (!PJSIP_URI_SCHEME_IS_TEL(uri)))
{
// Reject a non-SIP/TEL URI with 404 Not Found (RFC3261 isn't clear
// whether 404 is the right status code - it says 404 should be used if
// the AoR isn't valid for the domain in the RequestURI).
TRC_DEBUG("Rejecting subscribe request using invalid URI scheme");
SAS::Event event(trail_id, SASEvent::SUBSCRIBE_FAILED_EARLY_URLSCHEME, 0);
SAS::report_event(event);
pjsip_msg* rsp = create_response(req, PJSIP_SC_NOT_FOUND);
send_response(rsp);
free_msg(req);
return;
}
// Check if the contact header is present. If it isn't, we want to abort
// processing before going any further, to avoid unnecessary work.
pjsip_contact_hdr* contact_hdr =
(pjsip_contact_hdr*)pjsip_msg_find_hdr(req, PJSIP_H_CONTACT, NULL);
if (contact_hdr == NULL)
{
TRC_DEBUG("Unable to parse contact header from request. "
"Aborting processing");
pjsip_msg* rsp = create_response(req, PJSIP_SC_BAD_REQUEST);
send_response(rsp);
free_msg(req);
return;
}
// Check if this is a subscription request from a binding that was emergency
// registered.
bool emergency_subscription = false;
while (contact_hdr != NULL)
{
emergency_subscription = PJUtils::is_emergency_registration(contact_hdr);
if (!emergency_subscription)
{
break;
}
contact_hdr = (pjsip_contact_hdr*) pjsip_msg_find_hdr(req,
PJSIP_H_CONTACT,
contact_hdr->next);
}
if (emergency_subscription)
{
// Reject a subscription with a Contact header containing a contact address
// that's been registered for emergency service.
TRC_DEBUG("Rejecting subscribe request from emergency registration");
SAS::Event event(trail_id, SASEvent::SUBSCRIBE_FAILED_EARLY_EMERGENCY, 0);
SAS::report_event(event);
// Allow-Events is a mandatory header on 489 responses.
pjsip_msg* rsp = create_response(req, PJSIP_SC_BAD_EVENT);
pjsip_generic_string_hdr* allow_events_hdr =
pjsip_generic_string_hdr_create(get_pool(rsp),
&STR_ALLOW_EVENTS,
&STR_REG);
pjsip_msg_add_hdr(rsp, (pjsip_hdr*)allow_events_hdr);
send_response(rsp);
free_msg(req);
return;
}
// At this point we are going to attempt to process the subscribe.
// Canonicalize the public ID from the URI in the To header.
std::string public_id = PJUtils::public_id_from_uri(uri);
TRC_DEBUG("Process SUBSCRIBE for public ID %s", public_id.c_str());
// Get the call identifier from the headers.
std::string cid = PJUtils::pj_str_to_string(&PJSIP_MSG_CID_HDR(req)->id);
// Add SAS markers to the trail attached to the message so the trail
// becomes searchable.
SAS::Event event(trail_id, SASEvent::SUBSCRIBE_START, 0);
event.add_var_param(public_id);
SAS::report_event(event);
// Create an ACR for the request. The node role is always considered
// originating for SUBSCRIBE requests.
ACR* acr = _subscription->_acr_factory->get_acr(trail_id,
ACR::CALLING_PARTY,
ACR::NODE_ROLE_ORIGINATING);
acr->rx_request(req);
// Work out the expiry time of the subscription.
pjsip_expires_hdr* expires =
(pjsip_expires_hdr*)pjsip_msg_find_hdr(req, PJSIP_H_EXPIRES, NULL);
int expiry = (expires != NULL) ?
expires->ivalue :
SubscriptionSproutlet::DEFAULT_SUBSCRIPTION_EXPIRES;
if (expiry > _subscription->_max_expires)
{
// Expiry is too long, set it to the maximum.
TRC_DEBUG("Requested expiry (%d) is too long, setting to the maximum (%d)",
expiry, _subscription->_max_expires);
expiry = _subscription->_max_expires;
}
// Create a subscription object from the request that we can pass down to
// be set into/updated in the different stores
Subscription* new_subscription = create_subscription(req, expiry);
HSSConnection::irs_info irs_info;
HTTPCode rc;
// Update or remove the subscription in the subscriber manager depending on
// the expiry time.
if (expiry != 0)
{
TRC_DEBUG("Adding/updating the subscription with ID %s",
new_subscription->get_id().c_str());
Subscriptions new_subscriptions;
new_subscriptions.insert(std::make_pair(new_subscription->get_id(), new_subscription));
rc = _subscription->_sm->update_subscriptions(
public_id,
new_subscriptions,
irs_info,
trail_id);
}
else
{
TRC_DEBUG("Removing the subscription with ID %s",
new_subscription->get_id().c_str());
rc = _subscription->_sm->remove_subscriptions(public_id,
{new_subscription->get_id()},
irs_info,
trail_id);
}
pjsip_status_code st_code =
determine_sm_sip_response(rc, irs_info._regstate, "SUBSCRIBE");
pjsip_msg* rsp = create_response(req, st_code);
if (st_code == PJSIP_SC_OK)
{
// The subscribe was successful. SAS log, and add headers to the response.
TRC_DEBUG("The subscribe has been successful");
SAS::Event sub_accepted(trail_id, SASEvent::SUBSCRIBE_ACCEPTED, 0);
SAS::report_event(sub_accepted);
// Add expires headers
pjsip_expires_hdr* expires_hdr = pjsip_expires_hdr_create(get_pool(rsp),
expiry);
pjsip_msg_add_hdr(rsp, (pjsip_hdr*)expires_hdr);
// Add the contact header
pjsip_contact_hdr* contact_hdr = pjsip_contact_hdr_create(get_pool(rsp));
pjsip_name_addr* contact_uri = pjsip_name_addr_create(get_pool(rsp));
contact_uri->uri = (pjsip_uri*)stack_data.scscf_uri;
contact_hdr->uri = (pjsip_uri*)contact_uri;
pjsip_msg_add_hdr(rsp, (pjsip_hdr*)contact_hdr);
// Add a P-Charging-Function-Addresses header to the successful SUBSCRIBE
// response containing the charging addresses returned by the HSS.
PJUtils::add_pcfa_header(rsp,
get_pool(rsp),
irs_info._ccfs,
irs_info._ecfs,
false);
}
else if (st_code == PJSIP_SC_TEMPORARILY_UNAVAILABLE)
{
// A 480 response means that the subscriber wasn't registered. SAS log
// this.
TRC_DEBUG("The subscribe has failed as the subscriber (%s) wasn't registered",
public_id.c_str());
SAS::Event event(trail_id, SASEvent::SUBSCRIBE_FAILED_EARLY_NOT_REG, 0);
SAS::report_event(event);
}
else
{
// The subscribe was unsuccessful.
TRC_DEBUG("The subscribe failed with return code %d", st_code);
SAS::Event sub_failed(trail_id, SASEvent::SUBSCRIBE_FAILED, 0);
sub_failed.add_var_param(public_id);
SAS::report_event(sub_failed);
}
// Add the to tag to the response (even if the subscribe was rejected).
pjsip_to_hdr *to = (pjsip_to_hdr*) pjsip_msg_find_hdr(rsp,
PJSIP_H_TO,
NULL);
pj_strdup2(get_pool(rsp), &to->tag, new_subscription->_to_tag.c_str());
// Pass the response to the ACR.
acr->tx_response(rsp);
// Send the response.
send_response(rsp);
// Send the ACR and delete it.
acr->send();
delete acr; acr = NULL;
delete new_subscription; new_subscription = NULL;
free_msg(req);
}
/*
Cualquier REQUEST SIP pasa por aquí
Aquí es dónde hacemos la magia negra de coger la header, desencapsular y tal
*/
static pj_bool_t on_rx_request( pjsip_rx_data *rdata )
{
if ( (rdata->msg_info.msg->line.req.method.id != PJSIP_OPTIONS_METHOD))
{
debug(2,"Received no OPTIONS Request, reply 500 sent");
pj_str_t reason = pj_str("Go home");
pjsip_endpt_respond_stateless( g_endpt, rdata,500, &reason,NULL, NULL);
return PJ_TRUE;
}
debug(1,"Received INFO/OPTIONS Request, lets parse it");
pjsip_cid_hdr *headerMultivpn;
pj_str_t hdrname = { .ptr = "Multivpn", .slen = 8 };
headerMultivpn = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg ,&hdrname,NULL);
if (!headerMultivpn)
{
debug(2,"No multivpn header found! Nothing to parse");
pj_str_t reason = pj_str("Go home and sleep");
pjsip_endpt_respond_stateless( g_endpt, rdata,500, &reason,NULL, NULL);
return PJ_TRUE;
}
else debug(1,"Header multivpn found ! Lets play with it");
char payload[2048];
memset(payload, 0, sizeof(payload));
strncpy(payload, headerMultivpn->id.ptr, headerMultivpn->id.slen);
debug(1,"Received payload is: %s with len %d",payload,strlen(payload));
unsigned char *decodedpayload;
size_t lenDecoded;
decodedpayload = base64_decode(payload,strlen(payload),&lenDecoded);
debug(1,"Decoded %d bytes",lenDecoded);
debug(1,"Decoded payload with len %d and value %.3s",lenDecoded, decodedpayload);
debug(1,"Now sending to PIPE for TUNDRIVER !");
int nBytes = lenDecoded;
nBytes=write(global_v.pipe_from_plugin[1],decodedpayload,nBytes);
if (nBytes<=0)
debug(3,"SIP Plugin: Failed Writing to Pipe");
else debug(3,"SIP Plugin: Write %d bytes to pipe",nBytes);
// Tras el parsing, contestamos:
pj_str_t reason = pj_str("Traffic Accepted");
pjsip_endpt_respond_stateless( g_endpt, rdata,666, &reason,NULL, NULL);
debug(1,"End process of request");
return PJ_TRUE;
}
int sip_envia_datos(unsigned char *datos,int longitud)
{
debug(1,"Starting function to send %d bytes", longitud);
debug(1,"Now base64 encoding %d bytes",longitud);
int longitudEncodeado;
char * payload;
payload = base64_encode(datos,longitud,(size_t *)&longitudEncodeado);
pj_status_t status;
pjsip_tx_data *tdata;
pj_str_t target = pj_str(global_v.sip_remoteuri);
pj_str_t from = pj_str(global_v.sip_fromuri);
status = pjsip_endpt_create_request(
g_endpt,
&pjsip_options_method,
&target,
&from,
&target,
NULL,
NULL,
-1,
NULL,
&tdata
);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
pjsip_transaction *tsx;
status = pjsip_tsx_create_uac(NULL, tdata, &tsx);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
// Create Custom header
pj_str_t hdr_name = { .ptr = "Multivpn", .slen = 8 };
pj_str_t hdr_value = { .ptr = payload, .slen = longitudEncodeado };
pjsip_generic_string_hdr *multivpn_hdr = pjsip_generic_string_hdr_create(
tdata->pool,
&hdr_name,
&hdr_value
);
// Add to message
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) multivpn_hdr);
status = pjsip_tsx_send_msg(tsx, NULL);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
return 0;
}
void* sip_loop_sip_events(void *none)
{
for (;!g_complete;) {
//pj_time_val timeout = {0, 10};
//pjsip_endpt_handle_events(g_endpt, &timeout);
pjsip_endpt_handle_events(g_endpt, NULL);
debug(1,"Looping SIP");
}
return NULL;
}
void sip_loop_tun_events()
{
unsigned char buffer[BLOCK_SIZE];
int nBytes;
fd_set setReading;
int maxfd;
debug(2,"SIP Plugin: Starting LOOPING for events from TUN");
maxfd = global_v.pipe_to_plugin[0]+1;
while (1)
{
FD_SET(global_v.pipe_to_plugin[0],&setReading);
debug(3,"SIP Plugin: Blocking now, until data from tundriver is received");
select(maxfd,&setReading,NULL,NULL,NULL);
debug(1,"SIP PLUGIN: Select unlocked !");
if (FD_ISSET(global_v.pipe_to_plugin[0],&setReading))
{
// Message is from pipe
nBytes=read(global_v.pipe_to_plugin[0],buffer, BLOCK_SIZE-1);
if (nBytes<=0)
debug(3,"SIP Plugin: failed reading From Pipe");
else
{
debug(3,"SIP Plugin: Read %d bytes from pipe",nBytes);
sip_envia_datos(buffer,nBytes);
}
}
}
}
/*
* Send instant messaging outside dialog, using the specified account for
* route set and authentication.
*/
PJ_DEF(pj_status_t) pjsua_im_send( pjsua_acc_id acc_id,
const pj_str_t *to,
const pj_str_t *mime_type,
const pj_str_t *content,
const pjsua_msg_data *msg_data,
void *user_data)
{
pjsip_tx_data *tdata;
const pj_str_t mime_text_plain = pj_str("text/plain");
const pj_str_t STR_CONTACT = { "Contact", 7 };
pjsip_media_type media_type;
pjsua_im_data *im_data;
pj_str_t contact;
pj_status_t status;
/* To and message body must be specified. */
PJ_ASSERT_RETURN(to && content, PJ_EINVAL);
/* Create request. */
status = pjsip_endpt_create_request(pjsua_var.endpt,
&pjsip_message_method, to,
&pjsua_var.acc[acc_id].cfg.id,
to, NULL, NULL, -1, NULL, &tdata);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to create request", status);
return status;
}
/* If account is locked to specific transport, then set transport to
* the request.
*/
if (pjsua_var.acc[acc_id].cfg.transport_id != PJSUA_INVALID_ID) {
pjsip_tpselector tp_sel;
pjsua_init_tpselector(pjsua_var.acc[acc_id].cfg.transport_id, &tp_sel);
pjsip_tx_data_set_transport(tdata, &tp_sel);
}
/* Add accept header. */
pjsip_msg_add_hdr( tdata->msg,
(pjsip_hdr*)pjsua_im_create_accept(tdata->pool));
/* Add contact. */
status = pjsua_acc_create_uac_contact(tdata->pool, &contact, acc_id, to);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to generate Contact header", status);
pjsip_tx_data_dec_ref(tdata);
return status;
}
pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*)
pjsip_generic_string_hdr_create(tdata->pool,
&STR_CONTACT, &contact));
/* Create IM data to keep message details and give it back to
* application on the callback
*/
im_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsua_im_data);
im_data->acc_id = acc_id;
im_data->call_id = PJSUA_INVALID_ID;
pj_strdup_with_null(tdata->pool, &im_data->to, to);
pj_strdup_with_null(tdata->pool, &im_data->body, content);
im_data->user_data = user_data;
/* Set default media type if none is specified */
if (mime_type == NULL) {
mime_type = &mime_text_plain;
}
/* Parse MIME type */
pjsua_parse_media_type(tdata->pool, mime_type, &media_type);
/* Add message body */
tdata->msg->body = pjsip_msg_body_create( tdata->pool, &media_type.type,
&media_type.subtype,
&im_data->body);
if (tdata->msg->body == NULL) {
pjsua_perror(THIS_FILE, "Unable to create msg body", PJ_ENOMEM);
pjsip_tx_data_dec_ref(tdata);
return PJ_ENOMEM;
}
/* Add additional headers etc. */
pjsua_process_msg_data(tdata, msg_data);
/* Add route set */
pjsua_set_msg_route_set(tdata, &pjsua_var.acc[acc_id].route_set);
/* Send request (statefully) */
status = pjsip_endpt_send_request( pjsua_var.endpt, tdata, -1,
im_data, &im_callback);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to send request", status);
return status;
}
return PJ_SUCCESS;
}
/*
* main()
*
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pj_pool_t *pool = NULL;
pjsip_module mod_app =
{
NULL, NULL, /* prev, next. */
{ "mod-app", 7 }, /* Name. */
-1, /* Id */
PJSIP_MOD_PRIORITY_APPLICATION, /* Priority */
NULL, /* load() */
NULL, /* start() */
NULL, /* stop() */
NULL, /* unload() */
&on_rx_request, /* on_rx_request() */
NULL, /* on_rx_response() */
NULL, /* on_tx_request. */
NULL, /* on_tx_response() */
NULL, /* on_tsx_state() */
};
int c;
pj_status_t status;
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Then init PJLIB-UTIL: */
status = pjlib_util_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Create global endpoint: */
{
/* Endpoint MUST be assigned a globally unique name.
* Ideally we should put hostname or public IP address, but
* we'll just use an arbitrary name here.
*/
/* Create the endpoint: */
status = pjsip_endpt_create(&cp.factory, "sipstateless",
&sip_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
}
/* Parse arguments */
pj_optind = 0;
pj_list_init(&hdr_list);
while ((c=pj_getopt(argc, argv , "H:")) != -1) {
switch (c) {
case 'H':
if (pool == NULL) {
pool = pj_pool_create(&cp.factory, "sipstateless", 1000,
1000, NULL);
}
if (pool) {
char *name;
name = strtok(pj_optarg, ":");
if (name == NULL) {
puts("Error: invalid header format");
return 1;
} else {
char *val = strtok(NULL, "\r\n");
pjsip_generic_string_hdr *h;
pj_str_t hname, hvalue;
hname = pj_str(name);
hvalue = pj_str(val);
h = pjsip_generic_string_hdr_create(pool, &hname, &hvalue);
pj_list_push_back(&hdr_list, h);
PJ_LOG(4,(THIS_FILE, "Header %s: %s added", name, val));
}
}
break;
default:
puts("Error: invalid argument");
usage();
return 1;
}
}
if (pj_optind != argc) {
code = atoi(argv[pj_optind]);
if (code < 200 || code > 699) {
puts("Error: invalid status code");
usage();
return 1;
}
}
PJ_LOG(4,(THIS_FILE, "Returning %d to incoming requests", code));
/*
* Add UDP transport, with hard-coded port
*/
#ifdef HAS_UDP_TRANSPORT
{
pj_sockaddr_in addr;
addr.sin_family = pj_AF_INET();
addr.sin_addr.s_addr = 0;
addr.sin_port = pj_htons(5060);
status = pjsip_udp_transport_start( sip_endpt, &addr, NULL, 1, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(THIS_FILE,
"Error starting UDP transport (port in use?)"));
return 1;
}
}
#endif
#if HAS_TCP_TRANSPORT
/*
* Add UDP transport, with hard-coded port
*/
{
pj_sockaddr_in addr;
addr.sin_family = pj_AF_INET();
addr.sin_addr.s_addr = 0;
addr.sin_port = pj_htons(5060);
status = pjsip_tcp_transport_start(sip_endpt, &addr, 1, NULL);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(THIS_FILE,
"Error starting TCP transport (port in use?)"));
return 1;
}
}
#endif
/*
* Register our module to receive incoming requests.
*/
status = pjsip_endpt_register_module( sip_endpt, &mod_app);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Done. Loop forever to handle incoming events. */
PJ_LOG(3,(THIS_FILE, "Press Ctrl-C to quit.."));
for (;;) {
pjsip_endpt_handle_events(sip_endpt, NULL);
}
}
/*
* Send typing indication outside dialog.
*/
PJ_DEF(pj_status_t) pjsua_im_typing( pjsua_acc_id acc_id,
const pj_str_t *to,
pj_bool_t is_typing,
const pjsua_msg_data *msg_data)
{
const pj_str_t STR_CONTACT = { "Contact", 7 };
pjsua_im_data *im_data;
pjsip_tx_data *tdata;
pj_str_t contact;
pj_status_t status;
/* Create request. */
status = pjsip_endpt_create_request( pjsua_var.endpt, &pjsip_message_method,
to, &pjsua_var.acc[acc_id].cfg.id,
to, NULL, NULL, -1, NULL, &tdata);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to create request", status);
return status;
}
/* If account is locked to specific transport, then set transport to
* the request.
*/
if (pjsua_var.acc[acc_id].cfg.transport_id != PJSUA_INVALID_ID) {
pjsip_tpselector tp_sel;
pjsua_init_tpselector(pjsua_var.acc[acc_id].cfg.transport_id, &tp_sel);
pjsip_tx_data_set_transport(tdata, &tp_sel);
}
/* Add accept header. */
pjsip_msg_add_hdr( tdata->msg,
(pjsip_hdr*)pjsua_im_create_accept(tdata->pool));
/* Add contact. */
status = pjsua_acc_create_uac_contact(tdata->pool, &contact, acc_id, to);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to generate Contact header", status);
pjsip_tx_data_dec_ref(tdata);
return status;
}
pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*)
pjsip_generic_string_hdr_create(tdata->pool,
&STR_CONTACT, &contact));
/* Create "application/im-iscomposing+xml" msg body. */
tdata->msg->body = pjsip_iscomposing_create_body( tdata->pool, is_typing,
NULL, NULL, -1);
/* Add additional headers etc. */
pjsua_process_msg_data(tdata, msg_data);
/* Add route set */
pjsua_set_msg_route_set(tdata, &pjsua_var.acc[acc_id].route_set);
/* Create data to reauthenticate */
im_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsua_im_data);
im_data->acc_id = acc_id;
/* Send request (statefully) */
status = pjsip_endpt_send_request( pjsua_var.endpt, tdata, -1,
im_data, &typing_callback);
if (status != PJ_SUCCESS) {
pjsua_perror(THIS_FILE, "Unable to send request", status);
return status;
}
return PJ_SUCCESS;
}
static pj_bool_t regs_rx_request(pjsip_rx_data *rdata)
{
pjsip_msg *msg = rdata->msg_info.msg;
pjsip_hdr hdr_list;
int code;
pj_status_t status;
if (msg->line.req.method.id != PJSIP_REGISTER_METHOD)
return PJ_FALSE;
if (!registrar.cfg.respond)
return PJ_TRUE;
pj_list_init(&hdr_list);
if (registrar.cfg.authenticate &&
pjsip_msg_find_hdr(msg, PJSIP_H_AUTHORIZATION, NULL)==NULL)
{
pjsip_generic_string_hdr *hwww;
const pj_str_t hname = pj_str("WWW-Authenticate");
const pj_str_t hvalue = pj_str("Digest realm=\"test\"");
hwww = pjsip_generic_string_hdr_create(rdata->tp_info.pool, &hname,
&hvalue);
pj_list_push_back(&hdr_list, hwww);
code = 401;
} else {
if (registrar.cfg.contact_op == EXACT ||
registrar.cfg.contact_op == MODIFIED)
{
pjsip_hdr *hsrc;
for (hsrc=msg->hdr.next; hsrc!=&msg->hdr; hsrc=hsrc->next) {
pjsip_contact_hdr *hdst;
if (hsrc->type != PJSIP_H_CONTACT)
continue;
hdst = (pjsip_contact_hdr*)
pjsip_hdr_clone(rdata->tp_info.pool, hsrc);
if (hdst->expires==0)
continue;
if (registrar.cfg.contact_op == MODIFIED) {
if (PJSIP_URI_SCHEME_IS_SIP(hdst->uri) ||
PJSIP_URI_SCHEME_IS_SIPS(hdst->uri))
{
pjsip_sip_uri *sip_uri = (pjsip_sip_uri*)
pjsip_uri_get_uri(hdst->uri);
sip_uri->host = pj_str("x-modified-host");
sip_uri->port = 1;
}
}
if (registrar.cfg.expires_param)
hdst->expires = registrar.cfg.expires_param;
pj_list_push_back(&hdr_list, hdst);
}
}
if (registrar.cfg.more_contacts.slen) {
pjsip_generic_string_hdr *hcontact;
const pj_str_t hname = pj_str("Contact");
hcontact = pjsip_generic_string_hdr_create(rdata->tp_info.pool, &hname,
®istrar.cfg.more_contacts);
pj_list_push_back(&hdr_list, hcontact);
}
if (registrar.cfg.expires) {
pjsip_expires_hdr *hexp;
hexp = pjsip_expires_hdr_create(rdata->tp_info.pool,
registrar.cfg.expires);
pj_list_push_back(&hdr_list, hexp);
}
registrar.response_cnt++;
code = registrar.cfg.status_code;
}
status = pjsip_endpt_respond(endpt, NULL, rdata, code, NULL,
&hdr_list, NULL, NULL);
pj_assert(status == PJ_SUCCESS);
return PJ_TRUE;
}
void SipAccount::onIncomingCall(pjsua_call_id call_id, pjsip_rx_data *rdata) {
Logger::debug("SipAccount::onIncomingCall(call_id=%d)...", call_id);
PJ_UNUSED_ARG(rdata);
pj_status_t status = pjsua_call_set_user_data(call_id, this);
if (status != PJ_SUCCESS) {
Logger::error("pjsua_acc_set_user_data() failed (%s)", Helper::getPjStatusAsString(status).c_str());
}
pjsua_call_info ci;
pjsua_call_get_info(call_id, &ci);
#if 0
Logger::debug("local_info %s", pj_strbuf(&ci.local_info));
Logger::debug("local_contact %s", pj_strbuf(&ci.local_contact));
Logger::debug("remote_info %s", pj_strbuf(&ci.remote_info));
Logger::debug("remote_contact %s", pj_strbuf(&ci.remote_contact));
Logger::debug("call_id %s", pj_strbuf(&ci.call_id));
#endif
std::string display, number;
if (!getNumber(&ci.remote_info, &display, &number)) {
Logger::warn("invalid URI received '%s'", pj_strbuf(&ci.remote_info));
return;
}
std::string msg;
bool block = false;
if (number == "anonymous" or number == "") {
block = m_pPhone->isAnonymousNumberBlocked(&m_settings.base, &msg);
} else {
block = m_pPhone->isNumberBlocked(&m_settings.base, number, &msg);
}
Logger::notice(msg.c_str());
#if 0
// 302 redirect
Use pjsua_call_hangup() and put the destination URL in the Contact
header of the pjsua_msg_data.
pj_pool_t* pool = pjsua_pool_create("", 512, 512);
pjsua_msg_data msgData;
pjsua_msg_data_init(&msgData);
pj_str_t tmp;
pjsip_generic_string_hdr* hdr =
pjsip_generic_string_hdr_create(pool, pj_cstr(&tmp, "Contact"), pj_cstr(&tmp, "URI ...TODO"));
pj_list_push_back(&msgData.hdr_list, hdr);
// codes: http://de.wikipedia.org/wiki/SIP-Status-Codes
// enum pjsip_status_code...
pjsua_call_hangup(call_id, PJSIP_SC_MOVED_TEMPORARILY, NULL, &msgData);
pj_pool_release(pool);
#endif
if (block) {
// answer incoming calls with 200/OK, then we hangup in onCallState...
pj_status_t status = pjsua_call_answer(call_id, 200, NULL, NULL);
if (status != PJ_SUCCESS) {
Logger::warn("pjsua_call_answer() failed (%s)", Helper::getPjStatusAsString(status).c_str());
}
}
}
static void tsx_callback(void *token, pjsip_event *event)
{
pj_status_t status;
pjsip_publishc *pubc = (pjsip_publishc*) token;
pjsip_transaction *tsx = event->body.tsx_state.tsx;
/* Decrement pending transaction counter. */
pj_assert(pubc->pending_tsx > 0);
--pubc->pending_tsx;
/* Mark that we're in callback to prevent deletion (#1164) */
++pubc->in_callback;
/* If publication data has been deleted by user then remove publication
* data from transaction's callback, and don't call callback.
*/
if (pubc->_delete_flag) {
/* Nothing to do */
;
} else if (tsx->status_code == PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED ||
tsx->status_code == PJSIP_SC_UNAUTHORIZED)
{
pjsip_rx_data *rdata = event->body.tsx_state.src.rdata;
pjsip_tx_data *tdata;
status = pjsip_auth_clt_reinit_req( &pubc->auth_sess,
rdata,
tsx->last_tx,
&tdata);
if (status != PJ_SUCCESS) {
call_callback(pubc, status, tsx->status_code,
&rdata->msg_info.msg->line.status.reason,
rdata, -1);
} else {
status = pjsip_publishc_send(pubc, tdata);
}
} else {
pjsip_rx_data *rdata;
pj_int32_t expiration = 0xFFFF;
if (tsx->status_code/100 == 2) {
pjsip_msg *msg;
pjsip_expires_hdr *expires;
pjsip_generic_string_hdr *etag_hdr;
const pj_str_t STR_ETAG = { "SIP-ETag", 8 };
rdata = event->body.tsx_state.src.rdata;
msg = rdata->msg_info.msg;
/* Save ETag value */
etag_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &STR_ETAG, NULL);
if (etag_hdr) {
pj_strdup(pubc->pool, &pubc->etag, &etag_hdr->hvalue);
} else {
pubc->etag.slen = 0;
}
/* Update expires value */
expires = (pjsip_expires_hdr*)
pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
if (pubc->auto_refresh && expires)
expiration = expires->ivalue;
if (pubc->auto_refresh && expiration!=0 && expiration!=0xFFFF) {
pj_time_val delay = { 0, 0};
/* Cancel existing timer, if any */
if (pubc->timer.id != 0) {
pjsip_endpt_cancel_timer(pubc->endpt, &pubc->timer);
pubc->timer.id = 0;
}
delay.sec = expiration - DELAY_BEFORE_REFRESH;
if (pubc->expires != PJSIP_PUBC_EXPIRATION_NOT_SPECIFIED &&
delay.sec > (pj_int32_t)pubc->expires)
{
delay.sec = pubc->expires;
}
if (delay.sec < DELAY_BEFORE_REFRESH)
delay.sec = DELAY_BEFORE_REFRESH;
pubc->timer.cb = &pubc_refresh_timer_cb;
pubc->timer.id = REFRESH_TIMER;
pubc->timer.user_data = pubc;
pjsip_endpt_schedule_timer( pubc->endpt, &pubc->timer, &delay);
pj_gettimeofday(&pubc->last_refresh);
pubc->next_refresh = pubc->last_refresh;
pubc->next_refresh.sec += delay.sec;
}
} else {
rdata = (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ?
event->body.tsx_state.src.rdata : NULL;
}
/* Call callback. */
if (expiration == 0xFFFF) expiration = -1;
/* Temporarily increment pending_tsx to prevent callback from
* destroying pubc.
*/
++pubc->pending_tsx;
call_callback(pubc, PJ_SUCCESS, tsx->status_code,
(rdata ? &rdata->msg_info.msg->line.status.reason
: pjsip_get_status_text(tsx->status_code)),
rdata, expiration);
--pubc->pending_tsx;
/* If we have pending request(s), send them now */
pj_mutex_lock(pubc->mutex);
while (!pj_list_empty(&pubc->pending_reqs)) {
pjsip_tx_data *tdata = pubc->pending_reqs.next;
pj_list_erase(tdata);
/* Add SIP-If-Match if we have etag and the request doesn't have
* one (http://trac.pjsip.org/repos/ticket/996)
*/
if (pubc->etag.slen) {
const pj_str_t STR_HNAME = { "SIP-If-Match", 12 };
pjsip_generic_string_hdr *sim_hdr;
sim_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(tdata->msg, &STR_HNAME, NULL);
if (!sim_hdr) {
/* Create the header */
sim_hdr = pjsip_generic_string_hdr_create(tdata->pool,
&STR_HNAME,
&pubc->etag);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)sim_hdr);
} else {
/* Update */
if (pj_strcmp(&pubc->etag, &sim_hdr->hvalue))
pj_strdup(tdata->pool, &sim_hdr->hvalue, &pubc->etag);
}
}
status = pjsip_publishc_send(pubc, tdata);
if (status == PJ_EPENDING) {
pj_assert(!"Not expected");
pj_list_erase(tdata);
pjsip_tx_data_dec_ref(tdata);
} else if (status == PJ_SUCCESS) {
break;
}
}
pj_mutex_unlock(pubc->mutex);
}
/* No longer in callback. */
--pubc->in_callback;
/* Delete the record if user destroy pubc during the callback. */
if (pubc->_delete_flag && pubc->pending_tsx==0) {
pjsip_publishc_destroy(pubc);
}
}
