PJ_DEF(pj_status_t) pjsip_publishc_update_expires( pjsip_publishc *pubc,
pj_uint32_t expires )
{
PJ_ASSERT_RETURN(pubc, PJ_EINVAL);
set_expires( pubc, expires );
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjsip_publishc_init(pjsip_publishc *pubc,
const pj_str_t *event,
const pj_str_t *target_uri,
const pj_str_t *from_uri,
const pj_str_t *to_uri,
pj_uint32_t expires)
{
pj_str_t tmp;
PJ_ASSERT_RETURN(pubc && event && target_uri && from_uri && to_uri &&
expires, PJ_EINVAL);
/* Copy event type */
pj_strdup_with_null(pubc->pool, &pubc->event, event);
/* Copy server URL. */
pj_strdup_with_null(pubc->pool, &pubc->str_target_uri, target_uri);
/* Set server URL. */
tmp = pubc->str_target_uri;
pubc->target_uri = pjsip_parse_uri( pubc->pool, tmp.ptr, tmp.slen, 0);
if (pubc->target_uri == NULL) {
return PJSIP_EINVALIDURI;
}
/* Set "From" header. */
pj_strdup_with_null(pubc->pool, &pubc->from_uri, from_uri);
tmp = pubc->from_uri;
pubc->from_hdr = pjsip_from_hdr_create(pubc->pool);
pubc->from_hdr->uri = pjsip_parse_uri(pubc->pool, tmp.ptr, tmp.slen,
PJSIP_PARSE_URI_AS_NAMEADDR);
if (!pubc->from_hdr->uri) {
return PJSIP_EINVALIDURI;
}
/* Set "To" header. */
pj_strdup_with_null(pubc->pool, &tmp, to_uri);
pubc->to_hdr = pjsip_to_hdr_create(pubc->pool);
pubc->to_hdr->uri = pjsip_parse_uri(pubc->pool, tmp.ptr, tmp.slen,
PJSIP_PARSE_URI_AS_NAMEADDR);
if (!pubc->to_hdr->uri) {
return PJSIP_EINVALIDURI;
}
/* Set "Expires" header, if required. */
set_expires( pubc, expires);
/* Set "Call-ID" header. */
pubc->cid_hdr = pjsip_cid_hdr_create(pubc->pool);
pj_create_unique_string(pubc->pool, &pubc->cid_hdr->id);
/* Set "CSeq" header. */
pubc->cseq_hdr = pjsip_cseq_hdr_create(pubc->pool);
pubc->cseq_hdr->cseq = pj_rand() % 0xFFFF;
pjsip_method_set( &pubc->cseq_hdr->method, PJSIP_REGISTER_METHOD);
/* Done. */
return PJ_SUCCESS;
}
static void
set_inactive_state( probe_timer_entry *entry ) {
if ( entry->state != PROBE_TIMER_STATE_INACTIVE ) {
entry->state = PROBE_TIMER_STATE_INACTIVE;
entry->retry_count = 1;
}
set_expires( 0, entry );
}
static void
set_confirmed_state( probe_timer_entry *entry ) {
if ( entry->state != PROBE_TIMER_STATE_CONFIRMED ) {
entry->state = PROBE_TIMER_STATE_CONFIRMED;
entry->retry_count = 6;
}
set_expires( 10000, entry );
}
PJ_DEF(pj_status_t) pjsip_regc_update_expires( pjsip_regc *regc,
pj_uint32_t expires )
{
PJ_ASSERT_RETURN(regc, PJ_EINVAL);
pj_lock_acquire(regc->lock);
set_expires( regc, expires );
pj_lock_release(regc->lock);
return PJ_SUCCESS;
}
Cookie::Cookie(const std::string& name, const std::string& value, const std::vector<std::string>& options)
: Cookie{name, value}
{
// Check that the vector has an even number of elements (key, value)
if(options.size() % 2 not_eq 0)
throw CookieException{"Invalid number of elements in cookie's options vector!"};
// for-loop on vector - set input values from vector:
for(size_t i = 0; i < options.size(); i += 2) {
std::string nm = options[i];
if(not valid_option_name(nm))
throw CookieException{"Invalid name (" + nm + ") of cookie option!"};
std::string val = options[i+1];
if(caseInsCompare(nm, C_EXPIRES)) {
set_expires(val);
} else if(caseInsCompare(nm, C_MAX_AGE)) {
try {
int age = std::stoi(val);
if(age < 0)
throw CookieException{"Invalid max-age attribute (" + val + ") of cookie! Negative number of seconds not allowed."};
set_max_age(age);
} catch(std::exception& e){
throw CookieException{"Invalid max-age attribute (" + val + ") of cookie! Invalid integer value."};
}
} else if(caseInsCompare(nm, C_DOMAIN)) {
set_domain(val);
} else if(caseInsCompare(nm, C_PATH)) {
set_path(val);
} else if(caseInsCompare(nm, C_SECURE)) {
bool s = (caseInsCompare(val, "true")) ? true : false;
set_secure(s);
} else if(caseInsCompare(nm, C_HTTP_ONLY)) {
bool s = (caseInsCompare(val, "true")) ? true : false;
set_http_only(s);
}
}
}
PJ_DEF(pj_status_t) pjsip_regc_init( pjsip_regc *regc,
const pj_str_t *srv_url,
const pj_str_t *from_url,
const pj_str_t *to_url,
int contact_cnt,
const pj_str_t contact[],
pj_uint32_t expires)
{
pj_str_t tmp;
pj_status_t status;
PJ_ASSERT_RETURN(regc && srv_url && from_url && to_url &&
expires, PJ_EINVAL);
/* Copy server URL. */
pj_strdup_with_null(regc->pool, ®c->str_srv_url, srv_url);
/* Set server URL. */
tmp = regc->str_srv_url;
regc->srv_url = pjsip_parse_uri( regc->pool, tmp.ptr, tmp.slen, 0);
if (regc->srv_url == NULL) {
return PJSIP_EINVALIDURI;
}
/* Set "From" header. */
pj_strdup_with_null(regc->pool, ®c->from_uri, from_url);
tmp = regc->from_uri;
regc->from_hdr = pjsip_from_hdr_create(regc->pool);
regc->from_hdr->uri = pjsip_parse_uri(regc->pool, tmp.ptr, tmp.slen,
PJSIP_PARSE_URI_AS_NAMEADDR);
if (!regc->from_hdr->uri) {
PJ_LOG(4,(THIS_FILE, "regc: invalid source URI %.*s",
from_url->slen, from_url->ptr));
return PJSIP_EINVALIDURI;
}
/* Set "To" header. */
pj_strdup_with_null(regc->pool, &tmp, to_url);
regc->to_hdr = pjsip_to_hdr_create(regc->pool);
regc->to_hdr->uri = pjsip_parse_uri(regc->pool, tmp.ptr, tmp.slen,
PJSIP_PARSE_URI_AS_NAMEADDR);
if (!regc->to_hdr->uri) {
PJ_LOG(4,(THIS_FILE, "regc: invalid target URI %.*s", to_url->slen, to_url->ptr));
return PJSIP_EINVALIDURI;
}
/* Set "Contact" header. */
status = set_contact( regc, contact_cnt, contact);
if (status != PJ_SUCCESS)
return status;
/* Set "Expires" header, if required. */
set_expires( regc, expires);
regc->delay_before_refresh = DELAY_BEFORE_REFRESH;
/* Set "Call-ID" header. */
regc->cid_hdr = pjsip_cid_hdr_create(regc->pool);
pj_create_unique_string(regc->pool, ®c->cid_hdr->id);
/* Set "CSeq" header. */
regc->cseq_hdr = pjsip_cseq_hdr_create(regc->pool);
regc->cseq_hdr->cseq = pj_rand() % 0xFFFF;
pjsip_method_set( ®c->cseq_hdr->method, PJSIP_REGISTER_METHOD);
/* Done. */
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);
}
}
static inline void
set_random_expires( long min, long max, probe_timer_entry *entry ) {
long millisecond = min + ( max - min ) * random() / RAND_MAX;
set_expires( millisecond, entry );
}
