PJ_DEF(pj_status_t) pjsip_regc_register(pjsip_regc *regc, pj_bool_t autoreg, pjsip_tx_data **p_tdata) { pjsip_msg *msg; pjsip_contact_hdr *hdr; pj_status_t status; pjsip_tx_data *tdata; PJ_ASSERT_RETURN(regc && p_tdata, PJ_EINVAL); pj_lock_acquire(regc->lock); status = create_request(regc, &tdata); if (status != PJ_SUCCESS) { pj_lock_release(regc->lock); return status; } msg = tdata->msg; /* Add Contact headers. */ hdr = regc->contact_hdr_list.next; while (hdr != ®c->contact_hdr_list) { pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_shallow_clone(tdata->pool, hdr)); hdr = hdr->next; } /* Also add bindings which are to be removed */ while (!pj_list_empty(®c->removed_contact_hdr_list)) { hdr = regc->removed_contact_hdr_list.next; pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr)); pj_list_erase(hdr); } if (regc->expires_hdr) pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_shallow_clone(tdata->pool, regc->expires_hdr)); if (regc->timer.id != 0) { pjsip_endpt_cancel_timer(regc->endpt, ®c->timer); regc->timer.id = 0; } regc->auto_reg = autoreg; pj_lock_release(regc->lock); /* Done */ *p_tdata = tdata; return PJ_SUCCESS; }
PJ_DEF(pj_status_t) pjsip_publishc_publish(pjsip_publishc *pubc, pj_bool_t auto_refresh, pjsip_tx_data **p_tdata) { pj_status_t status; pjsip_tx_data *tdata; PJ_ASSERT_RETURN(pubc && p_tdata, PJ_EINVAL); status = create_request(pubc, &tdata); if (status != PJ_SUCCESS) return status; /* Add Expires header */ if (pubc->expires_hdr) { pjsip_hdr *dup; dup = (pjsip_hdr*) pjsip_hdr_shallow_clone(tdata->pool, pubc->expires_hdr); if (dup) pjsip_msg_add_hdr(tdata->msg, dup); } /* Cancel existing timer */ if (pubc->timer.id != 0) { pjsip_endpt_cancel_timer(pubc->endpt, &pubc->timer); pubc->timer.id = 0; } pubc->auto_refresh = auto_refresh; /* Done */ *p_tdata = tdata; return PJ_SUCCESS; }
static int send_unsolicited_mwi_notify_to_contact(void *obj, void *arg, int flags) { struct unsolicited_mwi_data *mwi_data = arg; struct mwi_subscription *sub = mwi_data->sub; struct ast_sip_endpoint *endpoint = mwi_data->endpoint; pjsip_evsub_state state = mwi_data->state; const struct ast_sip_body *body = mwi_data->body; struct ast_sip_contact *contact = obj; const char *state_name; pjsip_tx_data *tdata; pjsip_sub_state_hdr *sub_state; pjsip_event_hdr *event; const pjsip_hdr *allow_events = pjsip_evsub_get_allow_events_hdr(NULL); if (ast_sip_create_request("NOTIFY", NULL, endpoint, NULL, contact, &tdata)) { ast_log(LOG_WARNING, "Unable to create unsolicited NOTIFY request to endpoint %s URI %s\n", sub->id, contact->uri); return 0; } if (!ast_strlen_zero(endpoint->subscription.mwi.fromuser)) { pjsip_fromto_hdr *from = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_FROM, NULL); pjsip_name_addr *from_name_addr = (pjsip_name_addr *) from->uri; pjsip_sip_uri *from_uri = pjsip_uri_get_uri(from_name_addr->uri); pj_strdup2(tdata->pool, &from_uri->user, endpoint->subscription.mwi.fromuser); } switch (state) { case PJSIP_EVSUB_STATE_ACTIVE: state_name = "active"; break; case PJSIP_EVSUB_STATE_TERMINATED: default: state_name = "terminated"; break; } sub_state = pjsip_sub_state_hdr_create(tdata->pool); pj_cstr(&sub_state->sub_state, state_name); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) sub_state); event = pjsip_event_hdr_create(tdata->pool); pj_cstr(&event->event_type, "message-summary"); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) event); pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, allow_events)); ast_sip_add_body(tdata, body); ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL); return 0; }
static pj_status_t create_request(pjsip_regc *regc, pjsip_tx_data **p_tdata) { pj_status_t status; pjsip_tx_data *tdata; PJ_ASSERT_RETURN(regc && p_tdata, PJ_EINVAL); /* Create the request. */ status = pjsip_endpt_create_request_from_hdr( regc->endpt, pjsip_get_register_method(), regc->srv_url, regc->from_hdr, regc->to_hdr, NULL, regc->cid_hdr, regc->cseq_hdr->cseq, NULL, &tdata); if (status != PJ_SUCCESS) return status; /* Add cached authorization headers. */ pjsip_auth_clt_init_req( ®c->auth_sess, tdata ); /* Add Route headers from route set, ideally after Via header */ if (!pj_list_empty(®c->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 = regc->route_set.next; while (route != ®c->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 additional request headers */ if (!pj_list_empty(®c->hdr_list)) { const pjsip_hdr *hdr; hdr = regc->hdr_list.next; while (hdr != ®c->hdr_list) { pjsip_hdr *new_hdr = (pjsip_hdr*) pjsip_hdr_shallow_clone(tdata->pool, hdr); pjsip_msg_add_hdr(tdata->msg, new_hdr); hdr = hdr->next; } } /* Done. */ *p_tdata = tdata; return PJ_SUCCESS; }
static void regc_tsx_callback(void *token, pjsip_event *event) { pj_status_t status; pjsip_regc *regc = (pjsip_regc*) token; pjsip_transaction *tsx = event->body.tsx_state.tsx; pj_bool_t handled = PJ_TRUE; pj_bool_t update_contact = PJ_FALSE; pj_atomic_inc(regc->busy_ctr); pj_lock_acquire(regc->lock); /* Decrement pending transaction counter. */ pj_assert(regc->has_tsx); regc->has_tsx = PJ_FALSE; /* Add reference to the transport */ if (tsx->transport != regc->last_transport) { if (regc->last_transport) { pjsip_transport_dec_ref(regc->last_transport); regc->last_transport = NULL; } if (tsx->transport) { regc->last_transport = tsx->transport; pjsip_transport_add_ref(regc->last_transport); } } if (regc->_delete_flag == 0 && regc->tsx_cb && regc->current_op == REGC_REGISTERING) { struct pjsip_regc_tsx_cb_param param; param.contact_cnt = -1; cbparam_init(¶m.cbparam, regc, PJ_SUCCESS, tsx->status_code, &tsx->status_text, (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ? event->body.tsx_state.src.rdata : NULL, -1, 0, NULL); /* Call regc tsx callback before handling any response */ pj_lock_release(regc->lock); (*regc->tsx_cb)(¶m); pj_lock_acquire(regc->lock); if (param.contact_cnt >= 0) { /* Since we receive non-2xx response, it means that (some) contact * bindings haven't been established so we can safely remove these * contact headers. This is to avoid removing non-existent contact * bindings later. */ if (tsx->status_code/100 != 2) { pjsip_contact_hdr *h; h = regc->contact_hdr_list.next; while (h != ®c->contact_hdr_list) { pjsip_contact_hdr *next = h->next; if (h->expires == -1) { pj_list_erase(h); } h = next; } } /* Update contact address */ pjsip_regc_update_contact(regc, param.contact_cnt, param.contact); update_contact = PJ_TRUE; } } /* Handle 401/407 challenge (even when _delete_flag is set) */ 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; /* reset current op */ regc->current_op = REGC_IDLE; if (update_contact) { pjsip_msg *msg; pjsip_hdr *hdr, *ins_hdr; pjsip_contact_hdr *chdr; /* Delete Contact headers, but we shouldn't delete headers * which are supposed to remove contact bindings since * we cannot reconstruct those headers. */ msg = tsx->last_tx->msg; hdr = msg->hdr.next; ins_hdr = &msg->hdr; while (hdr != &msg->hdr) { pjsip_hdr *next = hdr->next; if (hdr->type == PJSIP_H_CONTACT) { chdr = (pjsip_contact_hdr *)hdr; if (chdr->expires != 0) { pj_list_erase(hdr); ins_hdr = next; } } hdr = next; } /* Add Contact headers. */ chdr = regc->contact_hdr_list.next; while (chdr != ®c->contact_hdr_list) { pj_list_insert_before(ins_hdr, (pjsip_hdr*) pjsip_hdr_shallow_clone(tsx->last_tx->pool, chdr)); chdr = chdr->next; } /* Also add bindings which are to be removed */ while (!pj_list_empty(®c->removed_contact_hdr_list)) { chdr = regc->removed_contact_hdr_list.next; pj_list_insert_before(ins_hdr, (pjsip_hdr*) pjsip_hdr_clone(tsx->last_tx->pool, chdr)); pj_list_erase(chdr); } } status = pjsip_auth_clt_reinit_req( ®c->auth_sess, rdata, tsx->last_tx, &tdata); if (status == PJ_SUCCESS) { status = pjsip_regc_send(regc, tdata); } if (status != PJ_SUCCESS) { /* Only call callback if application is still interested * in it. */ if (regc->_delete_flag == 0) { /* Should be safe to release the lock temporarily. * We do this to avoid deadlock. */ pj_lock_release(regc->lock); call_callback(regc, status, tsx->status_code, &rdata->msg_info.msg->line.status.reason, rdata, -1, 0, NULL); pj_lock_acquire(regc->lock); } } } else if (regc->_delete_flag) { /* User has called pjsip_regc_destroy(), so don't call callback. * This regc will be destroyed later in this function. */ /* Just reset current op */ regc->current_op = REGC_IDLE; } else if (tsx->status_code == PJSIP_SC_INTERVAL_TOO_BRIEF && regc->current_op == REGC_REGISTERING) { /* Handle 423 response automatically: * - set requested expiration to Min-Expires header, ONLY IF * the original request is a registration (as opposed to * unregistration) and the requested expiration was indeed * lower than Min-Expires) * - resend the request */ pjsip_rx_data *rdata = event->body.tsx_state.src.rdata; pjsip_min_expires_hdr *me_hdr; pjsip_tx_data *tdata; pj_int32_t min_exp; /* reset current op */ regc->current_op = REGC_IDLE; /* Update requested expiration */ me_hdr = (pjsip_min_expires_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_MIN_EXPIRES, NULL); if (me_hdr) { min_exp = me_hdr->ivalue; } else { /* Broken server, Min-Expires doesn't exist. * Just guestimate then, BUT ONLY if if this is the * first time we received such response. */ enum { /* Note: changing this value would require changing couple of * Python test scripts. */ UNSPECIFIED_MIN_EXPIRES = 3601 }; if (!regc->expires_hdr || regc->expires_hdr->ivalue != UNSPECIFIED_MIN_EXPIRES) { min_exp = UNSPECIFIED_MIN_EXPIRES; } else { handled = PJ_FALSE; PJ_LOG(4,(THIS_FILE, "Registration failed: 423 response " "without Min-Expires header is invalid")); goto handle_err; } } if (regc->expires_hdr && regc->expires_hdr->ivalue >= min_exp) { /* But we already send with greater expiration time, why does * the server send us with 423? Oh well, just fail the request. */ handled = PJ_FALSE; PJ_LOG(4,(THIS_FILE, "Registration failed: invalid " "Min-Expires header value in response")); goto handle_err; } set_expires(regc, min_exp); status = pjsip_regc_register(regc, regc->auto_reg, &tdata); if (status == PJ_SUCCESS) { status = pjsip_regc_send(regc, tdata); } if (status != PJ_SUCCESS) { /* Only call callback if application is still interested * in it. */ if (!regc->_delete_flag) { /* Should be safe to release the lock temporarily. * We do this to avoid deadlock. */ pj_lock_release(regc->lock); call_callback(regc, status, tsx->status_code, &rdata->msg_info.msg->line.status.reason, rdata, -1, 0, NULL); pj_lock_acquire(regc->lock); } } } else { handled = PJ_FALSE; } handle_err: if (!handled) { pjsip_rx_data *rdata; pj_int32_t expiration = NOEXP; unsigned contact_cnt = 0; pjsip_contact_hdr *contact[PJSIP_REGC_MAX_CONTACT]; if (tsx->status_code/100 == 2) { rdata = event->body.tsx_state.src.rdata; /* Calculate expiration */ expiration = calculate_response_expiration(regc, rdata, &contact_cnt, PJSIP_REGC_MAX_CONTACT, contact); /* Schedule next registration */ schedule_registration(regc, expiration); } else { rdata = (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ? event->body.tsx_state.src.rdata : NULL; } /* Update registration */ if (expiration==NOEXP) expiration=-1; regc->expires = expiration; /* Mark operation as complete */ regc->current_op = REGC_IDLE; /* Call callback. */ /* Should be safe to release the lock temporarily. * We do this to avoid deadlock. */ pj_lock_release(regc->lock); call_callback(regc, PJ_SUCCESS, tsx->status_code, (rdata ? &rdata->msg_info.msg->line.status.reason : &tsx->status_text), rdata, expiration, contact_cnt, contact); pj_lock_acquire(regc->lock); } pj_lock_release(regc->lock); /* Delete the record if user destroy regc during the callback. */ if (pj_atomic_dec_and_get(regc->busy_ctr)==0 && regc->_delete_flag) { pjsip_regc_destroy(regc); } }
/* Initialize outgoing request. */ PJ_DEF(pj_status_t) pjsip_auth_clt_init_req( pjsip_auth_clt_sess *sess, pjsip_tx_data *tdata ) { const pjsip_method *method; pjsip_cached_auth *auth; pjsip_hdr added; PJ_ASSERT_RETURN(sess && tdata, PJ_EINVAL); PJ_ASSERT_RETURN(sess->pool, PJSIP_ENOTINITIALIZED); PJ_ASSERT_RETURN(tdata->msg->type==PJSIP_REQUEST_MSG, PJSIP_ENOTREQUESTMSG); /* Init list */ pj_list_init(&added); /* Get the method. */ method = &tdata->msg->line.req.method; auth = sess->cached_auth.next; while (auth != &sess->cached_auth) { /* Reset stale counter */ auth->stale_cnt = 0; if (auth->qop_value == PJSIP_AUTH_QOP_NONE) { # if defined(PJSIP_AUTH_HEADER_CACHING) && \ PJSIP_AUTH_HEADER_CACHING!=0 { pjsip_cached_auth_hdr *entry = auth->cached_hdr.next; while (entry != &auth->cached_hdr) { if (pjsip_method_cmp(&entry->method, method)==0) { pjsip_authorization_hdr *hauth; hauth = pjsip_hdr_shallow_clone(tdata->pool, entry->hdr); //pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hauth); pj_list_push_back(&added, hauth); break; } entry = entry->next; } # if defined(PJSIP_AUTH_AUTO_SEND_NEXT) && \ PJSIP_AUTH_AUTO_SEND_NEXT!=0 { if (entry == &auth->cached_hdr) new_auth_for_req( tdata, sess, auth, NULL); } # endif } # elif defined(PJSIP_AUTH_AUTO_SEND_NEXT) && \ PJSIP_AUTH_AUTO_SEND_NEXT!=0 { new_auth_for_req( tdata, sess, auth, NULL); } # endif } # if defined(PJSIP_AUTH_QOP_SUPPORT) && \ defined(PJSIP_AUTH_AUTO_SEND_NEXT) && \ (PJSIP_AUTH_QOP_SUPPORT && PJSIP_AUTH_AUTO_SEND_NEXT) else if (auth->qop_value == PJSIP_AUTH_QOP_AUTH) { /* For qop="auth", we have to re-create the authorization header. */ const pjsip_cred_info *cred; pjsip_authorization_hdr *hauth; pj_status_t status; cred = auth_find_cred(sess, &auth->realm, &auth->last_chal->scheme); if (!cred) { auth = auth->next; continue; } status = auth_respond( tdata->pool, auth->last_chal, tdata->msg->line.req.uri, cred, &tdata->msg->line.req.method, sess->pool, auth, &hauth); if (status != PJ_SUCCESS) return status; //pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hauth); pj_list_push_back(&added, hauth); } # endif /* PJSIP_AUTH_QOP_SUPPORT && PJSIP_AUTH_AUTO_SEND_NEXT */ auth = auth->next; } if (sess->pref.initial_auth == PJ_FALSE) { pjsip_hdr *h; /* Don't want to send initial empty Authorization header, so * just send whatever available in the list (maybe empty). */ h = added.next; while (h != &added) { pjsip_hdr *next = h->next; pjsip_msg_add_hdr(tdata->msg, h); h = next; } } else { /* For each realm, add either the cached authorization header * or add an empty authorization header. */ unsigned i; char *uri_str; int len; uri_str = (char*)pj_pool_alloc(tdata->pool, PJSIP_MAX_URL_SIZE); len = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, tdata->msg->line.req.uri, uri_str, PJSIP_MAX_URL_SIZE); if (len < 1 || len >= PJSIP_MAX_URL_SIZE) return PJSIP_EURITOOLONG; for (i=0; i<sess->cred_cnt; ++i) { pjsip_cred_info *c = &sess->cred_info[i]; pjsip_authorization_hdr *h; h = get_header_for_realm(&added, &c->realm); if (h) { pj_list_erase(h); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)h); } else { pjsip_authorization_hdr *hs; hs = pjsip_authorization_hdr_create(tdata->pool); pj_strdup(tdata->pool, &hs->scheme, &c->scheme); pj_strdup(tdata->pool, &hs->credential.digest.username, &c->username); pj_strdup(tdata->pool, &hs->credential.digest.realm, &c->realm); pj_strdup2(tdata->pool, &hs->credential.digest.uri, uri_str); pj_strdup(tdata->pool, &hs->credential.digest.algorithm, &sess->pref.algorithm); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hs); } } } 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 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; }
/* * Send notify. */ PJ_DEF(pj_status_t) pjsip_event_sub_notify(pjsip_event_sub *sub, pjsip_event_sub_state new_state, const pj_str_t *reason, pjsip_msg_body *body) { pjsip_tx_data *tdata; pjsip_sub_state_hdr *ss_hdr; const pjsip_route_hdr *route; pj_time_val now; pj_status_t status; pjsip_event_sub_state old_state = sub->state; pj_gettimeofday(&now); pj_assert(sub->role == PJSIP_ROLE_UAS); if (sub->role != PJSIP_ROLE_UAS) return -1; PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): sending NOTIFY", sub, state[new_state].ptr)); /* Lock subscription. */ pj_mutex_lock(sub->mutex); /* Can not send NOTIFY if current state is NULL. We can accept TERMINATED. */ if (sub->state==PJSIP_EVENT_SUB_STATE_NULL) { pj_assert(0); pj_mutex_unlock(sub->mutex); return -1; } /* Update state no matter what. */ sub_set_state(sub, new_state); /* Create transmit data. */ tdata = pjsip_endpt_create_request_from_hdr( sub->endpt, &NOTIFY, sub->to->uri, sub->from, sub->to, sub->contact, sub->call_id, sub->cseq++, NULL); if (!tdata) { pj_mutex_unlock(sub->mutex); return -1; } /* Add Event header. */ pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->event)); /* Add Subscription-State header. */ ss_hdr = pjsip_sub_state_hdr_create(tdata->pool); ss_hdr->sub_state = state[new_state]; ss_hdr->expires_param = sub->expiry_time.sec - now.sec; if (ss_hdr->expires_param < 0) ss_hdr->expires_param = 0; if (reason) pj_strdup(tdata->pool, &ss_hdr->reason_param, reason); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)ss_hdr); /* Add Allow-Events header. */ pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, mgr.allow_events)); /* Add authentication */ pjsip_auth_init_req( sub->pool, tdata, &sub->auth_sess, sub->cred_cnt, sub->cred_info); /* Route set. */ route = sub->route_set.next; while (route != &sub->route_set) { pj_list_insert_before( &tdata->msg->hdr, pjsip_hdr_shallow_clone(tdata->pool, route)); route = route->next; } /* Attach body. */ tdata->msg->body = body; /* That's it, send! */ status = pjsip_endpt_send_request( sub->endpt, tdata, -1, sub, &on_notify_response); if (status == 0) sub->pending_tsx++; /* If terminated notify application. */ if (new_state!=old_state && new_state==PJSIP_EVENT_SUB_STATE_TERMINATED) { if (sub->cb.on_sub_terminated) { sub->pending_tsx++; (*sub->cb.on_sub_terminated)(sub, reason); sub->pending_tsx--; } } /* Unlock subscription. */ pj_mutex_unlock(sub->mutex); if (status != 0) { PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): failed to send NOTIFY", sub, state[sub->state].ptr)); } if (sub->delete_flag && sub->pending_tsx <= 0) { pjsip_event_sub_destroy(sub); } return status; }
/* This function is called when we receive SUBSCRIBE request message * to refresh existing subscription. */ static void on_received_sub_refresh( pjsip_event_sub *sub, pjsip_transaction *tsx, pjsip_rx_data *rdata) { pjsip_event_hdr *e; pjsip_expires_hdr *expires; pj_str_t hname; int status = 200; pj_str_t reason_phrase = { NULL, 0 }; int new_state = sub->state; int old_state = sub->state; int new_interval = 0; pjsip_tx_data *tdata; PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): received target refresh", sub, state[sub->state].ptr)); /* Check that the event matches. */ hname = pj_str("Event"); e = pjsip_msg_find_hdr_by_name( rdata->msg, &hname, NULL); if (!e) { status = 400; reason_phrase = pj_str("Missing Event header"); goto send_response; } if (pj_stricmp(&e->event_type, &sub->event->event_type) != 0 || pj_stricmp(&e->id_param, &sub->event->id_param) != 0) { status = 481; reason_phrase = pj_str("Subscription does not exist"); goto send_response; } /* Check server state. */ if (sub->state == PJSIP_EVENT_SUB_STATE_TERMINATED) { status = 481; reason_phrase = pj_str("Subscription does not exist"); goto send_response; } /* Check expires header. */ expires = pjsip_msg_find_hdr(rdata->msg, PJSIP_H_EXPIRES, NULL); if (!expires) { /* status = 400; reason_phrase = pj_str("Missing Expires header"); goto send_response; */ new_interval = sub->default_interval; } else { /* Check that interval is not too short. * Note that expires time may be zero (for unsubscription). */ new_interval = expires->ivalue; if (new_interval != 0 && new_interval < SECONDS_BEFORE_EXPIRY) { status = PJSIP_SC_INTERVAL_TOO_BRIEF; goto send_response; } } /* Update interval. */ sub->default_interval = new_interval; pj_gettimeofday(&sub->expiry_time); sub->expiry_time.sec += new_interval; /* Update timer only if this is not unsubscription. */ if (new_interval > 0) { sub->default_interval = new_interval; sub_schedule_uas_expire( sub, new_interval ); /* Call callback. */ if (sub->cb.on_received_refresh) { sub->pending_tsx++; (*sub->cb.on_received_refresh)(sub, rdata); sub->pending_tsx--; } } send_response: tdata = pjsip_endpt_create_response( sub->endpt, rdata, status); if (tdata) { if (reason_phrase.slen) tdata->msg->line.status.reason = reason_phrase; /* Add Expires header. */ expires = pjsip_expires_hdr_create(tdata->pool); expires->ivalue = sub->default_interval; pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)expires); if (PJSIP_IS_STATUS_IN_CLASS(status,200)) { pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, mgr.allow_events)); } /* Send down to transaction. */ pjsip_tsx_on_tx_msg(tsx, tdata); } if (sub->default_interval==0 || !PJSIP_IS_STATUS_IN_CLASS(status,200)) { /* Notify application if sub is terminated. */ new_state = PJSIP_EVENT_SUB_STATE_TERMINATED; sub_set_state(sub, new_state); if (new_state!=old_state && sub->cb.on_sub_terminated) { pj_str_t reason = {"", 0}; if (reason_phrase.slen) reason = reason_phrase; else reason = *pjsip_get_status_text(status); sub->pending_tsx++; (*sub->cb.on_sub_terminated)(sub, &reason); sub->pending_tsx--; } } pj_mutex_unlock(sub->mutex); /* Prefer to call log when we're not holding the mutex. */ PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): sent refresh response %s, status=%d", sub, state[sub->state].ptr, (tdata ? tdata->obj_name : "null"), status)); /* Check if application has requested deletion. */ if (sub->delete_flag && sub->pending_tsx <= 0) { pjsip_event_sub_destroy(sub); } }
/* * Stop subscription. */ PJ_DEF(pj_status_t) pjsip_event_sub_unsubscribe( pjsip_event_sub *sub ) { pjsip_tx_data *tdata; const pjsip_route_hdr *route; pj_status_t status; PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): unsubscribing...", sub, state[sub->state].ptr)); /* Lock subscription. */ pj_mutex_lock(sub->mutex); pj_assert(sub->role == PJSIP_ROLE_UAC); /* Kill refresh timer, if any. */ if (sub->timer.id != 0) { sub->timer.id = 0; pjsip_endpt_cancel_timer(sub->endpt, &sub->timer); } /* Create request. */ tdata = pjsip_endpt_create_request_from_hdr( sub->endpt, &SUBSCRIBE, sub->to->uri, sub->from, sub->to, sub->contact, sub->call_id, sub->cseq++, NULL); if (!tdata) { pj_mutex_unlock(sub->mutex); return -1; } /* Add headers to request. */ pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->event)); sub->uac_expires->ivalue = 0; pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->uac_expires)); /* Add authentication. */ pjsip_auth_init_req( sub->pool, tdata, &sub->auth_sess, sub->cred_cnt, sub->cred_info); /* Route set. */ route = sub->route_set.next; while (route != &sub->route_set) { pj_list_insert_before( &tdata->msg->hdr, pjsip_hdr_shallow_clone(tdata->pool, route)); route = route->next; } /* Prevent timer from refreshing itself. */ sub->default_interval = 0; /* Set state. */ sub_set_state( sub, PJSIP_EVENT_SUB_STATE_TERMINATED ); /* Send the request. */ status = pjsip_endpt_send_request( sub->endpt, tdata, -1, sub, &on_subscribe_response); if (status == 0) { sub->pending_tsx++; } pj_mutex_unlock(sub->mutex); if (status != 0) { PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): FAILED to unsubscribe!", sub, state[sub->state].ptr)); } return status; }
/* * Refresh subscription. */ static pj_status_t send_sub_refresh( pjsip_event_sub *sub ) { pjsip_tx_data *tdata; pj_status_t status; const pjsip_route_hdr *route; pj_assert(sub->role == PJSIP_ROLE_UAC); pj_assert(sub->state != PJSIP_EVENT_SUB_STATE_TERMINATED); if (sub->role != PJSIP_ROLE_UAC || sub->state == PJSIP_EVENT_SUB_STATE_TERMINATED) { return -1; } PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): refreshing subscription", sub, state[sub->state].ptr)); /* Create request. */ tdata = pjsip_endpt_create_request_from_hdr( sub->endpt, &SUBSCRIBE, sub->to->uri, sub->from, sub->to, sub->contact, sub->call_id, sub->cseq++, NULL); if (!tdata) { PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): refresh: unable to create tx data!", sub, state[sub->state].ptr)); return -1; } pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->event)); pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->uac_expires)); pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, sub->local_accept)); pjsip_msg_add_hdr( tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, mgr.allow_events)); /* Authentication */ pjsip_auth_init_req( sub->pool, tdata, &sub->auth_sess, sub->cred_cnt, sub->cred_info); /* Route set. */ route = sub->route_set.next; while (route != &sub->route_set) { pj_list_insert_before( &tdata->msg->hdr, pjsip_hdr_shallow_clone(tdata->pool, route)); route = route->next; } /* Send */ status = pjsip_endpt_send_request( sub->endpt, tdata, -1, sub, &on_subscribe_response); if (status == 0) { sub->pending_tsx++; } else { PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): FAILED to refresh subscription!", sub, state[sub->state].ptr)); } return status; }
/* * This callback called when we receive incoming NOTIFY request. */ static void on_notify_request(pjsip_transaction *tsx, pjsip_rx_data *rdata) { pjsip_event_sub *sub; pjsip_tx_data *tdata; int status = 200; int old_state; pj_str_t reason = { NULL, 0 }; pj_str_t reason_phrase = { NULL, 0 }; int new_state = PJSIP_EVENT_SUB_STATE_NULL; /* Find subscription based on Call-ID and From tag. * This will also automatically lock the subscription, if it's found. */ sub = find_sub(rdata); if (!sub) { /* RFC 3265: Section 3.2 Description of NOTIFY Behavior: * Answer with 481 Subscription does not exist. */ PJ_LOG(4,(THIS_FILE, "Unable to find subscription for incoming NOTIFY!")); status = 481; reason_phrase = pj_str("Subscription does not exist"); } else { pj_assert(sub->role == PJSIP_ROLE_UAC); PJ_LOG(4,(THIS_FILE, "event_sub%p (%s): received NOTIFY", sub, state[sub->state].ptr)); } new_state = old_state = sub->state; /* RFC 3265: Section 3.2.1 * Check that the Event header match the subscription. */ if (status == 200) { pjsip_event_hdr *hdr; pj_str_t hname = { "Event", 5 }; hdr = pjsip_msg_find_hdr_by_name(rdata->msg, &hname, NULL); if (!hdr) { status = PJSIP_SC_BAD_REQUEST; reason_phrase = pj_str("No Event header found"); } else if (pj_stricmp(&hdr->event_type, &sub->event->event_type) != 0 || pj_stricmp(&hdr->id_param, &sub->event->id_param) != 0) { status = 481; reason_phrase = pj_str("Subscription does not exist"); } } /* Update subscription state and timer. */ if (status == 200) { pjsip_sub_state_hdr *hdr; const pj_str_t hname = { "Subscription-State", 18 }; const pj_str_t state_active = { "active", 6 }, state_pending = { "pending", 7}, state_terminated = { "terminated", 10 }; hdr = pjsip_msg_find_hdr_by_name( rdata->msg, &hname, NULL); if (!hdr) { status = PJSIP_SC_BAD_REQUEST; reason_phrase = pj_str("No Subscription-State header found"); goto process; } /* * Update subscription state. */ if (pj_stricmp(&hdr->sub_state, &state_active) == 0) { if (sub->state != PJSIP_EVENT_SUB_STATE_TERMINATED) new_state = PJSIP_EVENT_SUB_STATE_ACTIVE; } else if (pj_stricmp(&hdr->sub_state, &state_pending) == 0) { if (sub->state != PJSIP_EVENT_SUB_STATE_TERMINATED) new_state = PJSIP_EVENT_SUB_STATE_PENDING; } else if (pj_stricmp(&hdr->sub_state, &state_terminated) == 0) { new_state = PJSIP_EVENT_SUB_STATE_TERMINATED; } else { new_state = PJSIP_EVENT_SUB_STATE_UNKNOWN; } reason = hdr->reason_param; if (new_state != sub->state && new_state != PJSIP_EVENT_SUB_STATE_NULL && sub->state != PJSIP_EVENT_SUB_STATE_TERMINATED) { sub_set_state(sub, new_state); if (new_state == PJSIP_EVENT_SUB_STATE_UNKNOWN) { pj_strdup_with_null(sub->pool, &sub->state_str, &hdr->sub_state); } else { sub->state_str = state[new_state]; } } /* * Update timeout timer in required, just in case notifier changed the * expiration to shorter time. * Section 3.2.2: the expires param can only shorten the interval. */ if ((sub->state==PJSIP_EVENT_SUB_STATE_ACTIVE || sub->state==PJSIP_EVENT_SUB_STATE_PENDING) && hdr->expires_param > 0) { pj_time_val now, new_expiry; pj_gettimeofday(&now); new_expiry.sec = now.sec + hdr->expires_param; if (sub->timer.id==0 || new_expiry.sec < sub->expiry_time.sec-SECONDS_BEFORE_EXPIRY/2) { update_next_refresh(sub, hdr->expires_param); } } } process: /* Note: here we sub MAY BE NULL! */ /* Send response to NOTIFY */ tdata = pjsip_endpt_create_response( tsx->endpt, rdata, status ); if (tdata) { if (reason_phrase.slen) tdata->msg->line.status.reason = reason_phrase; if (PJSIP_IS_STATUS_IN_CLASS(status,200)) { pjsip_hdr *hdr; hdr = pjsip_hdr_shallow_clone(tdata->pool, mgr.allow_events); pjsip_msg_add_hdr( tdata->msg, hdr); } pjsip_tsx_on_tx_msg(tsx, tdata); } /* Call NOTIFY callback, if any. */ if (sub && PJSIP_IS_STATUS_IN_CLASS(status,200) && sub->cb.on_received_notify) { sub->pending_tsx++; (*sub->cb.on_received_notify)(sub, rdata); sub->pending_tsx--; } /* Check if subscription is terminated and call callback. */ if (sub && new_state!=old_state && new_state==PJSIP_EVENT_SUB_STATE_TERMINATED) { if (sub->cb.on_sub_terminated) { sub->pending_tsx++; (*sub->cb.on_sub_terminated)(sub, &reason); sub->pending_tsx--; } } /* Check if application has requested deletion. */ if (sub && sub->delete_flag && sub->pending_tsx <= 0) { pjsip_event_sub_destroy(sub); } else if (sub) { pj_mutex_unlock(sub->mutex); } }
/* This function is called when we receive SUBSCRIBE request message for * a new subscription. */ static void on_new_subscription( pjsip_transaction *tsx, pjsip_rx_data *rdata ) { package *pkg; pj_pool_t *pool; pjsip_event_sub *sub = NULL; pj_str_t hname; int status = 200; pj_str_t reason = { NULL, 0 }; pjsip_tx_data *tdata; pjsip_expires_hdr *expires; pjsip_accept_hdr *accept; pjsip_event_hdr *evhdr; /* Get the Event header. */ hname = pj_str("Event"); evhdr = pjsip_msg_find_hdr_by_name(rdata->msg, &hname, NULL); if (!evhdr) { status = 400; reason = pj_str("No Event header in request"); goto send_response; } /* Find corresponding package. * We don't lock the manager's mutex since we assume the package list * won't change once the application is running! */ pkg = mgr.pkg_list.next; while (pkg != &mgr.pkg_list) { if (pj_stricmp(&pkg->event, &evhdr->event_type) == 0) break; pkg = pkg->next; } if (pkg == &mgr.pkg_list) { /* Event type is not supported by any packages! */ status = 489; reason = pj_str("Bad Event"); goto send_response; } /* First check that the Accept specification matches the * package's Accept types. */ accept = pjsip_msg_find_hdr(rdata->msg, PJSIP_H_ACCEPT, NULL); if (accept) { unsigned i; pj_str_t *content_type = NULL; for (i=0; i<accept->count && !content_type; ++i) { int j; for (j=0; j<pkg->accept_cnt; ++j) { if (pj_stricmp(&accept->values[i], &pkg->accept[j])==0) { content_type = &pkg->accept[j]; break; } } } if (!content_type) { status = PJSIP_SC_NOT_ACCEPTABLE_HERE; goto send_response; } } /* Check whether the package wants to accept the subscription. */ pj_assert(pkg->cb.on_query_subscribe != NULL); (*pkg->cb.on_query_subscribe)(rdata, &status); if (!PJSIP_IS_STATUS_IN_CLASS(status,200)) goto send_response; /* Create new subscription record. */ pool = pjsip_endpt_create_pool(tsx->endpt, "esub", SUB_POOL_SIZE, SUB_POOL_INC); if (!pool) { status = 500; goto send_response; } sub = pj_pool_calloc(pool, 1, sizeof(*sub)); sub->pool = pool; sub->mutex = pj_mutex_create(pool, "esub", PJ_MUTEX_RECURSE); if (!sub->mutex) { status = 500; goto send_response; } PJ_LOG(4,(THIS_FILE, "event_sub%p: notifier is created.", sub)); /* Start locking mutex. */ pj_mutex_lock(sub->mutex); /* Init UAS subscription */ sub->endpt = tsx->endpt; sub->role = PJSIP_ROLE_UAS; sub->state = PJSIP_EVENT_SUB_STATE_PENDING; sub->state_str = state[sub->state]; pj_list_init(&sub->auth_sess); pj_list_init(&sub->route_set); sub->from = pjsip_hdr_clone(pool, rdata->to); pjsip_fromto_set_from(sub->from); if (sub->from->tag.slen == 0) { pj_create_unique_string(pool, &sub->from->tag); rdata->to->tag = sub->from->tag; } sub->to = pjsip_hdr_clone(pool, rdata->from); pjsip_fromto_set_to(sub->to); sub->contact = pjsip_contact_hdr_create(pool); sub->contact->uri = sub->from->uri; sub->call_id = pjsip_cid_hdr_create(pool); pj_strdup(pool, &sub->call_id->id, &rdata->call_id); sub->cseq = pj_rand() % 0xFFFF; expires = pjsip_msg_find_hdr( rdata->msg, PJSIP_H_EXPIRES, NULL); if (expires) { sub->default_interval = expires->ivalue; if (sub->default_interval > 0 && sub->default_interval < SECONDS_BEFORE_EXPIRY) { status = 423; /* Interval too short. */ goto send_response; } } else { sub->default_interval = 600; } /* Clone Event header. */ sub->event = pjsip_hdr_clone(pool, evhdr); /* Register to hash table. */ create_subscriber_key(&sub->key, pool, PJSIP_ROLE_UAS, &sub->call_id->id, &sub->from->tag); pj_mutex_lock(mgr.mutex); pj_hash_set(pool, mgr.ht, sub->key.ptr, sub->key.slen, sub); pj_mutex_unlock(mgr.mutex); /* Set timer where subscription will expire only when expires<>0. * Subscriber may send new subscription with expires==0. */ if (sub->default_interval != 0) { sub_schedule_uas_expire( sub, sub->default_interval-SECONDS_BEFORE_EXPIRY); } /* Notify application. */ if (pkg->cb.on_subscribe) { pjsip_event_sub_cb *cb = NULL; sub->pending_tsx++; (*pkg->cb.on_subscribe)(sub, rdata, &cb, &sub->default_interval); sub->pending_tsx--; if (cb == NULL) pj_memset(&sub->cb, 0, sizeof(*cb)); else pj_memcpy(&sub->cb, cb, sizeof(*cb)); } send_response: PJ_LOG(4,(THIS_FILE, "event_sub%p (%s)(UAS): status=%d", sub, state[sub->state].ptr, status)); tdata = pjsip_endpt_create_response( tsx->endpt, rdata, status); if (tdata) { if (reason.slen) { /* Customize reason text. */ tdata->msg->line.status.reason = reason; } if (PJSIP_IS_STATUS_IN_CLASS(status,200)) { /* Add Expires header. */ pjsip_expires_hdr *hdr; hdr = pjsip_expires_hdr_create(tdata->pool); hdr->ivalue = sub->default_interval; pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*)hdr ); } if (status == 423) { /* Add Min-Expires header. */ pjsip_min_expires_hdr *hdr; hdr = pjsip_min_expires_hdr_create(tdata->pool); hdr->ivalue = SECONDS_BEFORE_EXPIRY; pjsip_msg_add_hdr( tdata->msg, (pjsip_hdr*)hdr); } if (status == 489 || status==PJSIP_SC_NOT_ACCEPTABLE_HERE || PJSIP_IS_STATUS_IN_CLASS(status,200)) { /* Add Allow-Events header. */ pjsip_hdr *hdr; hdr = pjsip_hdr_shallow_clone(tdata->pool, mgr.allow_events); pjsip_msg_add_hdr(tdata->msg, hdr); /* Should add Accept header?. */ } pjsip_tsx_on_tx_msg(tsx, tdata); } /* If received new subscription with expires=0, terminate. */ if (sub && sub->default_interval == 0) { pj_assert(sub->state == PJSIP_EVENT_SUB_STATE_TERMINATED); if (sub->cb.on_sub_terminated) { pj_str_t reason = { "timeout", 7 }; (*sub->cb.on_sub_terminated)(sub, &reason); } } if (!PJSIP_IS_STATUS_IN_CLASS(status,200) || (sub && sub->delete_flag)) { if (sub && sub->mutex) { pjsip_event_sub_destroy(sub); } else if (sub) { pjsip_endpt_destroy_pool(tsx->endpt, sub->pool); } } else { pj_assert(status >= 200); pj_mutex_unlock(sub->mutex); } }
/* * Initialize new request message with authorization headers. * This function will put Authorization/Proxy-Authorization headers to the * outgoing request message. If caching is enabled (PJSIP_AUTH_HEADER_CACHING) * and the session has previously sent Authorization/Proxy-Authorization header * with the same method, then the same Authorization/Proxy-Authorization header * will be resent from the cache only if qop is not present. If the stack is * configured to automatically generate next Authorization/Proxy-Authorization * headers (PJSIP_AUTH_AUTO_SEND_NEXT flag), then new Authorization/Proxy- * Authorization headers are calculated and generated when they are not present * in the case or if authorization session has qop. * * If both PJSIP_AUTH_HEADER_CACHING flag and PJSIP_AUTH_AUTO_SEND_NEXT flag * are not set, this function will do nothing. The stack then will only send * Authorization/Proxy-Authorization to respond 401/407 response. */ PJ_DEF(pj_status_t) pjsip_auth_init_req( pj_pool_t *sess_pool, pjsip_tx_data *tdata, pjsip_auth_session *sess_list, int cred_count, const pjsip_cred_info cred_info[]) { pjsip_auth_session *sess; pjsip_method *method = &tdata->msg->line.req.method; pj_assert(tdata->msg->type == PJSIP_REQUEST_MSG); if (!sess_list) return 0; sess = sess_list->next; while (sess != sess_list) { if (sess->qop_value == PJSIP_AUTH_QOP_NONE) { # if (PJSIP_AUTH_HEADER_CACHING) { pjsip_cached_auth_hdr *entry = sess->cached_hdr.next; while (entry != &sess->cached_hdr) { if (pjsip_method_cmp(&entry->method, method)==0) { pjsip_authorization_hdr *hauth; hauth = pjsip_hdr_shallow_clone(tdata->pool, entry->hdr); pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hauth); } else { # if (PJSIP_AUTH_AUTO_SEND_NEXT) { new_auth_for_req( tdata, sess_pool, sess, cred_count, cred_info); } # else { PJ_UNUSED_ARG(sess_pool); PJ_UNUSED_ARG(cred_count); PJ_UNUSED_ARG(cred_info); } # endif /* PJSIP_AUTH_AUTO_SEND_NEXT */ } entry = entry->next; } } # elif (PJSIP_AUTH_AUTO_SEND_NEXT) { new_auth_for_req( tdata, sess_pool, sess, cred_count, cred_info); } # else { PJ_UNUSED_ARG(sess_pool); PJ_UNUSED_ARG(cred_count); PJ_UNUSED_ARG(cred_info); } # endif /* PJSIP_AUTH_HEADER_CACHING */ } # if (PJSIP_AUTH_QOP_SUPPORT && PJSIP_AUTH_AUTO_SEND_NEXT) else if (sess->qop_value == PJSIP_AUTH_QOP_AUTH) { /* For qop="auth", we have to re-create the authorization header. */ const pjsip_cred_info *cred; pjsip_authorization_hdr *hauth; cred = pjsip_auth_find_cred( cred_count, cred_info, &sess->realm, &sess->last_chal->scheme); if (!cred) { sess = sess->next; continue; } hauth = pjsip_auth_respond( tdata->pool, sess->last_chal, tdata->msg->line.req.uri, cred, &tdata->msg->line.req.method, sess_pool, sess ); if (hauth) { pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)hauth); } } # endif /* PJSIP_AUTH_QOP_SUPPORT && PJSIP_AUTH_AUTO_SEND_NEXT */ sess = sess->next; } return 0; }