/** Send request.
*
* @retval 0 success
* @retval -1 if error occurred, but event has not been sent,
* and caller has to destroy request message @ msg
* @retval -2 if error occurred, event has not been sent
* @retval >=1 if error event has been sent
*/
int nua_base_client_request(nua_client_request_t *cr, msg_t *msg, sip_t *sip,
tagi_t const *tags)
{
nua_handle_t *nh = cr->cr_owner;
int proxy_is_set = NH_PISSET(nh, proxy);
url_string_t * proxy = NH_PGET(nh, proxy);
if (nh->nh_auth) {
if (cr->cr_challenged ||
NH_PGET(nh, auth_cache) == nua_auth_cache_dialog) {
if (auc_authorize(&nh->nh_auth, msg, sip) < 0)
return nua_client_return(cr, 900, "Cannot add credentials", msg);
}
}
cr->cr_seq = sip->sip_cseq->cs_seq; /* Save last sequence number */
assert(cr->cr_orq == NULL);
cr->cr_orq = nta_outgoing_mcreate(nh->nh_nua->nua_nta,
nua_client_orq_response,
nua_client_request_ref(cr),
NULL,
msg,
TAG_IF(proxy_is_set,
NTATAG_DEFAULT_PROXY(proxy)),
TAG_NEXT(tags));
if (cr->cr_orq == NULL) {
nua_client_request_unref(cr);
return -1;
}
return 0;
}
static int nua_refer_server_preprocess(nua_server_request_t *sr)
{
nua_handle_t *nh = sr->sr_owner;
sip_t const *sip = sr->sr_request.sip;
struct notifier_usage *nu;
sip_event_t *o;
if (nh->nh_ds->ds_got_referrals || NH_PGET(nh, refer_with_id))
o = sip_event_format(nh->nh_home, "refer;id=%u", sip->sip_cseq->cs_seq);
else
o = sip_event_make(nh->nh_home, "refer");
if (o) {
sr->sr_usage = nua_dialog_usage_add(nh, nh->nh_ds, nua_notify_usage, o);
msg_header_free(nh->nh_home, (msg_header_t *)o);
}
if (!sr->sr_usage)
return SR_STATUS1(sr, SIP_500_INTERNAL_SERVER_ERROR);
nu = nua_dialog_usage_private(sr->sr_usage);
nu->nu_requested = sip_now() + NH_PGET(nh, refer_expires);
return 0;
}
int nua_subscribe_server_preprocess(nua_server_request_t *sr)
{
nua_handle_t *nh = sr->sr_owner;
nua_dialog_state_t *ds = nh->nh_ds;
nua_dialog_usage_t *du;
struct notifier_usage *nu;
sip_t const *sip = sr->sr_request.sip;
sip_event_t *o = sip->sip_event;
char const *event = o ? o->o_type : NULL;
/* Maximum expiration time */
unsigned long expires = sip->sip_expires ? sip->sip_expires->ex_delta : 3600;
sip_time_t now = sip_now();
sip_allow_events_t *appl_event = NH_PGET(nh, appl_event);
assert(nh && nh->nh_nua->nua_dhandle != nh);
du = nua_dialog_usage_get(ds, nua_notify_usage, o);
if (du == NULL) {
/* Create a new subscription */
du = nua_dialog_usage_add(nh, ds, nua_notify_usage, o);
if (du == NULL)
return SR_STATUS1(sr, SIP_500_INTERNAL_SERVER_ERROR);
}
else if (!msg_header_find_param((void *)appl_event, event)) {
unsigned max_expires;
/* Refresh existing subscription */
if (su_strmatch(event, "refer"))
max_expires = NH_PGET(nh, refer_expires);
else
max_expires = NH_PGET(nh, sub_expires);
if (expires >= max_expires)
expires = max_expires;
SR_STATUS1(sr, SIP_200_OK);
}
nu = nua_dialog_usage_private(du);
if (now + expires >= now)
nu->nu_requested = now + expires;
else
nu->nu_requested = SIP_TIME_MAX - 1;
#if SU_HAVE_EXPERIMENTAL
nu->nu_etags =
sip_suppress_body_if_match(sip) ||
sip_suppress_notify_if_match(sip) ||
sip_has_feature(sr->sr_request.sip->sip_supported, "etags");
#endif
sr->sr_usage = du;
return sr->sr_status <= 100 ? 0 : sr->sr_status;
}
/** Restart request.
*
* @retval 1 if restarted
* @retval 0 otherwise
*/
int nua_client_restart(nua_client_request_t *cr,
int status, char const *phrase)
{
nua_handle_t *nh = cr->cr_owner;
nta_outgoing_t *orq;
int error = -1, terminated, graceful;
if (cr->cr_retry_count > NH_PGET(nh, retry_count))
return 0;
orq = cr->cr_orq, cr->cr_orq = NULL; assert(orq);
terminated = cr->cr_terminated, cr->cr_terminated = 0;
graceful = cr->cr_graceful, cr->cr_graceful = 0;
cr->cr_restarting = 1;
error = nua_client_request_sendmsg(cr);
cr->cr_restarting = 0;
if (error) {
cr->cr_graceful = graceful;
cr->cr_terminated = terminated;
assert(cr->cr_orq == NULL);
cr->cr_orq = orq;
return 0;
}
nua_client_report(cr, status, phrase, NULL, orq, NULL);
nta_outgoing_destroy(orq);
nua_client_request_unref(cr); /* ... reference used by old orq */
return 1;
}
static
int nua_refer_server_respond(nua_server_request_t *sr, tagi_t const *tags)
{
nua_handle_t *nh = sr->sr_owner;
struct notifier_usage *nu = nua_dialog_usage_private(sr->sr_usage);
sip_refer_sub_t const *rs = sip_refer_sub(sr->sr_response.sip);
if (sr->sr_status < 200 || nu == NULL) {
}
else if (sr->sr_status < 300 &&
/* No subscription if Refer-Sub: false in response */
(rs == NULL || !su_casematch(rs->rs_value, "false"))) {
sr->sr_usage->du_ready = 1;
nu->nu_expires = sip_now() + NH_PGET(nh, refer_expires);
if (sr->sr_application) /* Application responded to REFER */
nu->nu_substate = nua_substate_active;
}
else {
/* Destroy the implicit subscription usage */
sr->sr_terminating = 1;
}
return nua_base_server_respond(sr, tags);
}
int nua_publish_server_init(nua_server_request_t *sr)
{
sip_allow_events_t *allow_events = NH_PGET(sr->sr_owner, allow_events);
sip_event_t *o = sr->sr_request.sip->sip_event;
char const *event = o ? o->o_type : NULL;
if (!allow_events)
return SR_STATUS1(sr, SIP_501_NOT_IMPLEMENTED);
else if (!event || !msg_header_find_param(allow_events->k_common, event))
return SR_STATUS1(sr, SIP_489_BAD_EVENT);
return 0;
}
/** @internal Respond to a SUBSCRIBE request.
*
*/
static
int nua_subscribe_server_respond(nua_server_request_t *sr, tagi_t const *tags)
{
struct notifier_usage *nu = nua_dialog_usage_private(sr->sr_usage);
msg_t *msg = sr->sr_response.msg;
sip_t *sip = sr->sr_response.sip;
if (200 <= sr->sr_status && sr->sr_status < 300) {
sip_expires_t ex[1];
sip_expires_init(ex);
if (nu) {
sip_time_t now = sip_now();
if (nu->nu_requested) {
if (sip->sip_expires) {
/* Expires in response can only shorten the expiration time */
if (nu->nu_requested > now + sip->sip_expires->ex_delta)
nu->nu_requested = now + sip->sip_expires->ex_delta;
}
else {
unsigned sub_expires = NH_PGET(sr->sr_owner, sub_expires);
if (nu->nu_requested > now + sub_expires)
nu->nu_requested = now + sub_expires;
}
if (nu->nu_requested >= now)
nu->nu_expires = nu->nu_requested;
else
nu->nu_expires = now;
if (nu->nu_expires <= now)
nu->nu_substate = nua_substate_terminated;
}
if (nu->nu_expires > now)
ex->ex_delta = nu->nu_expires - now;
}
else {
/* Always add header Expires: 0 */
}
if (!sip->sip_expires || sip->sip_expires->ex_delta > ex->ex_delta)
sip_add_dup(msg, sip, (sip_header_t *)ex);
}
return nua_base_server_respond(sr, tags);
}
/** Check if request should be restarted.
*
* @retval 1 if restarted or waiting for restart
* @retval 0 otherwise
*/
int nua_client_check_restart(nua_client_request_t *cr,
int status,
char const *phrase,
sip_t const *sip)
{
nua_handle_t *nh;
assert(cr && status >= 200 && phrase && sip);
nh = cr->cr_owner;
if (cr->cr_retry_count > NH_PGET(nh, retry_count))
return 0;
if (cr->cr_methods->crm_check_restart)
return cr->cr_methods->crm_check_restart(cr, status, phrase, sip);
else
return nua_base_client_check_restart(cr, status, phrase, sip);
}
int nua_subscribe_server_init(nua_server_request_t *sr)
{
nua_handle_t *nh = sr->sr_owner;
nua_dialog_state_t *ds = nh->nh_ds;
sip_allow_events_t const *allow_events = NH_PGET(nh, allow_events);
sip_t const *sip = sr->sr_request.sip;
sip_event_t *o = sip->sip_event;
char const *event = o ? o->o_type : NULL;
if (sr->sr_initial || !nua_dialog_usage_get(ds, nua_notify_usage, o)) {
if (su_strmatch(event, "refer"))
/* refer event subscription should be initiated with REFER */
return SR_STATUS1(sr, SIP_403_FORBIDDEN);
/* XXX - event is case-sensitive, should use msg_header_find_item() */
if (!event || !msg_header_find_param(allow_events->k_common, event))
return SR_STATUS1(sr, SIP_489_BAD_EVENT);
}
return 0;
}
/**Send a request message.
*
* @retval 0 if request is pending
* @retval >=1 if error event has been sent
* @retval < 0 if no error event has been sent
*/
static
int nua_client_request_sendmsg(nua_client_request_t *cr)
{
nua_handle_t *nh = cr->cr_owner;
nua_dialog_state_t *ds = nh->nh_ds;
sip_method_t method = cr->cr_method;
char const *name = cr->cr_method_name;
url_string_t const *url = (url_string_t *)cr->cr_target;
nta_leg_t *leg;
msg_t *msg;
sip_t *sip;
int error;
assert(cr->cr_orq == NULL);
cr->cr_offer_sent = cr->cr_answer_recv = 0;
cr->cr_offer_recv = cr->cr_answer_sent = 0;
if (!ds->ds_leg && cr->cr_dialog) {
ds->ds_leg = nta_leg_tcreate(nh->nh_nua->nua_nta,
nua_stack_process_request, nh,
SIPTAG_CALL_ID(cr->cr_sip->sip_call_id),
SIPTAG_FROM(cr->cr_sip->sip_from),
SIPTAG_TO(cr->cr_sip->sip_to),
SIPTAG_CSEQ(cr->cr_sip->sip_cseq),
TAG_END());
if (!ds->ds_leg)
return -1;
}
if (cr->cr_sip->sip_from && ds->ds_leg) {
if (cr->cr_sip->sip_from->a_tag == NULL) {
if (sip_from_tag(msg_home(cr->cr_msg), cr->cr_sip->sip_from,
nta_leg_tag(ds->ds_leg, NULL)) < 0) {
return -1;
}
}
}
cr->cr_retry_count++;
if (ds->ds_leg)
leg = ds->ds_leg;
else
leg = nh->nh_nua->nua_dhandle->nh_ds->ds_leg; /* Default leg */
msg = msg_copy(cr->cr_msg), sip = sip_object(msg);
if (msg == NULL)
return -1;
if (nua_dialog_is_established(ds)) {
while (sip->sip_route)
sip_route_remove(msg, sip);
}
else if (!ds->ds_route) {
sip_route_t *initial_route = NH_PGET(nh, initial_route);
if (initial_route) {
initial_route = sip_route_dup(msg_home(msg), initial_route);
if (!initial_route) return -1;
msg_header_prepend(msg, (msg_pub_t*)sip,
/* This should be
(msg_header_t **)&sip->sip_route
* but directly casting pointer &sip->sip_route gives
* spurious type-punning warning */
(msg_header_t **)((char *)sip + offsetof(sip_t, sip_route)),
(msg_header_t *)initial_route);
}
}
/**
* For in-dialog requests, the request URI is taken from the @Contact
* header received from the remote party during dialog establishment,
* and the NUTAG_URL() is ignored.
*
* Also, the @CallID and @CSeq headers and @From and @To tags are
* generated based on the dialog information and added to the request.
* If the dialog has a route, it is added to the request, too.
*/
if (nta_msg_request_complete(msg, leg, method, name, url) < 0) {
msg_destroy(msg);
return -1;
}
/**@MaxForwards header (with default value set by NTATAG_MAX_FORWARDS()) is
* also added now, if it does not exist.
*/
if (!ds->ds_remote)
ds->ds_remote = sip_to_dup(nh->nh_home, sip->sip_to);
if (!ds->ds_local)
ds->ds_local = sip_from_dup(nh->nh_home, sip->sip_from);
/**
* Next, values previously set with nua_set_params() or nua_set_hparams()
* are used: @Allow, @Supported, @Organization, @UserAgent and
* @AllowEvents headers are added to the request if they are not already
* set.
*/
if (!sip->sip_allow)
sip_add_dup(msg, sip, (sip_header_t*)NH_PGET(nh, allow));
if (!sip->sip_supported && NH_PGET(nh, supported))
sip_add_dup(msg, sip, (sip_header_t *)NH_PGET(nh, supported));
if (method == sip_method_register && NH_PGET(nh, path_enable) &&
!sip_has_feature(sip->sip_supported, "path") &&
!sip_has_feature(sip->sip_require, "path"))
sip_add_make(msg, sip, sip_supported_class, "path");
if (!sip->sip_organization && NH_PGET(nh, organization))
sip_add_make(msg, sip, sip_organization_class, NH_PGET(nh, organization));
if (!sip->sip_user_agent && NH_PGET(nh, user_agent))
sip_add_make(msg, sip, sip_user_agent_class, NH_PGET(nh, user_agent));
/** Any node implementing one or more event packages SHOULD include an
* appropriate @AllowEvents header indicating all supported events in
* all methods which initiate dialogs and their responses (such as
* INVITE) and OPTIONS responses.
*/
if (!sip->sip_allow_events &&
NH_PGET(nh, allow_events) &&
(method == sip_method_notify || /* Always in NOTIFY */
(!ds->ds_remote_tag && /* And in initial requests */
(method == sip_method_subscribe || method == sip_method_refer ||
method == sip_method_options ||
method == sip_method_invite))))
sip_add_dup(msg, sip, (void *)NH_PGET(nh, allow_events));
/**
* Next, the stack generates a @Contact header for the request (unless
* the application already gave a @Contact header or it does not want to
* use @Contact and indicates that by including SIPTAG_CONTACT(NULL) or
* SIPTAG_CONTACT(SIP_NONE) in the tagged parameters.) If the
* application has registered the URI in @From header, the @Contact
* header used with registration is used. Otherwise, the @Contact header
* is generated from the local IP address and port number.
*/
/**For the initial requests, @ServiceRoute set that was received from the
* registrar is also added to the request message.
*/
if (cr->cr_method != sip_method_register) {
if (cr->cr_contactize && cr->cr_has_contact) {
sip_contact_t *ltarget = sip_contact_dup(nh->nh_home, sip->sip_contact);
if (ds->ds_ltarget)
msg_header_free(nh->nh_home, (msg_header_t *)ds->ds_ltarget);
ds->ds_ltarget = ltarget;
}
if (ds->ds_ltarget && !cr->cr_has_contact)
sip_add_dup(msg, sip, (sip_header_t *)ds->ds_ltarget);
if (nua_registration_add_contact_to_request(nh, msg, sip,
cr->cr_contactize &&
!cr->cr_has_contact &&
!ds->ds_ltarget,
!ds->ds_route) < 0) {
msg_destroy(msg);
return -1;
}
}
cr->cr_wait_for_cred = 0;
if (cr->cr_methods->crm_send)
error = cr->cr_methods->crm_send(cr, msg, sip, NULL);
else
error = nua_base_client_request(cr, msg, sip, NULL);
if (error == -1)
msg_destroy(msg);
return error;
}
/**Initialize client request for sending.
*
* This function is called when the request is taken from queue and sent.
*
* @retval 0 if request is pending
* @retval >=1 if error event has been sent
*/
static
int nua_client_init_request0(nua_client_request_t *cr)
{
nua_handle_t *nh = cr->cr_owner;
nua_t *nua = nh->nh_nua;
nua_dialog_state_t *ds = nh->nh_ds;
msg_t *msg = NULL;
sip_t *sip;
url_string_t const *url = NULL;
tagi_t const *t;
int has_contact = 0;
int error = 0;
if (!cr->cr_method_name)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), NULL);
if (cr->cr_msg)
return nua_client_request_try(cr);
cr->cr_answer_recv = 0, cr->cr_offer_sent = 0;
cr->cr_offer_recv = 0, cr->cr_answer_sent = 0;
cr->cr_terminated = 0, cr->cr_graceful = 0;
nua_stack_init_handle(nua, nh, cr->cr_tags);
if (cr->cr_method == sip_method_cancel) {
if (cr->cr_methods->crm_init) {
error = cr->cr_methods->crm_init(cr, NULL, NULL, cr->cr_tags);
if (error)
return error;
}
if (cr->cr_methods->crm_send)
return cr->cr_methods->crm_send(cr, NULL, NULL, cr->cr_tags);
else
return nua_base_client_request(cr, NULL, NULL, cr->cr_tags);
}
if (!cr->cr_methods->crm_template ||
cr->cr_methods->crm_template(cr, &msg, cr->cr_tags) == 0)
msg = nua_client_request_template(cr);
sip = sip_object(msg);
if (!sip)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
if (nh->nh_tags) {
for (t = nh->nh_tags; t; t = t_next(t)) {
if (t->t_tag == siptag_contact ||
t->t_tag == siptag_contact_str)
has_contact = 1;
else if (t->t_tag == nutag_url)
url = (url_string_t const *)t->t_value;
}
}
/**@par Populating SIP Request Message with Tagged Arguments
*
* The tagged arguments can be used to pass values for any SIP headers
* to the stack. When the INVITE message (or any other SIP message) is
* created, the tagged values saved with nua_handle() are used first,
* next the tagged values given with the operation (nua_invite()) are
* added.
*
* When multiple tags for the same header are specified, the behaviour
* depends on the header type. If only a single header field can be
* included in a SIP message, the latest non-NULL value is used, e.g.,
* @Subject. However, if the SIP header can consist of multiple lines or
* header fields separated by comma, e.g., @Accept, all the tagged
* values are concatenated.
*
* However, if a tag value is #SIP_NONE (-1 casted as a void pointer),
* the values from previous tags are ignored.
*/
for (t = cr->cr_tags; t; t = t_next(t)) {
if (t->t_tag == siptag_contact ||
t->t_tag == siptag_contact_str)
has_contact = 1;
else if (t->t_tag == nutag_url)
url = (url_string_t const *)t->t_value;
else if (t->t_tag == nutag_dialog) {
cr->cr_dialog = t->t_value > 1;
cr->cr_contactize = t->t_value >= 1;
}
else if (t->t_tag == nutag_auth && t->t_value) {
/* XXX ignoring errors */
if (nh->nh_auth)
auc_credentials(&nh->nh_auth, nh->nh_home, (char *)t->t_value);
}
}
if (cr->cr_method == sip_method_register && url == NULL)
url = (url_string_t const *)NH_PGET(nh, registrar);
if ((t = cr->cr_tags)) {
if (sip_add_tagis(msg, sip, &t) < 0)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
}
/**
* Now, the target URI for the request needs to be determined.
*
* For initial requests, values from tags are used. If NUTAG_URL() is
* given, it is used as target URI. Otherwise, if SIPTAG_TO() is given,
* it is used as target URI. If neither is given, the complete request
* line already specified using SIPTAG_REQUEST() or SIPTAG_REQUEST_STR()
* is used. At this point, the target URI is stored in the request line,
* together with method name and protocol version ("SIP/2.0"). The
* initial dialog information is also created: @CallID, @CSeq headers
* are generated, if they do not exist, and a tag is added to the @From
* header.
*/
if (!ds->ds_leg) {
if (ds->ds_remote_tag && ds->ds_remote_tag[0] &&
sip_to_tag(nh->nh_home, sip->sip_to, ds->ds_remote_tag) < 0)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
if (sip->sip_from == NULL &&
sip_add_dup(msg, sip, (sip_header_t *)nua->nua_from) < 0)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
if (sip->sip_to == NULL && cr->cr_method == sip_method_register &&
sip_add_dup_as(msg, sip, sip_to_class,
(sip_header_t *)sip->sip_from) < 0) {
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
}
}
else {
if (ds->ds_route)
url = NULL;
}
if (url && nua_client_set_target(cr, (url_t *)url) < 0)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
cr->cr_has_contact = has_contact;
if (cr->cr_methods->crm_init) {
error = cr->cr_methods->crm_init(cr, msg, sip, cr->cr_tags);
if (error < -1)
msg = NULL;
if (error < 0)
return nua_client_return(cr, NUA_ERROR_AT(__FILE__, __LINE__), msg);
if (error != 0)
return error;
}
cr->cr_msg = msg;
cr->cr_sip = sip;
return nua_client_request_try(cr);
}
void
nua_stack_notifier(nua_t *nua, nua_handle_t *nh, nua_event_t e, tagi_t const *tags)
{
su_home_t home[1] = { SU_HOME_INIT(home) };
sip_event_t const *event = NULL;
sip_content_type_t const *ct = NULL;
sip_payload_t const *pl = NULL;
url_string_t const *url = NULL;
char const *event_s = NULL, *ct_s = NULL, *pl_s = NULL;
nea_event_t *ev;
int status = 900;
char const *phrase = nua_internal_error;
nua_stack_init_handle(nua, nh, tags);
tl_gets(tags,
NUTAG_URL_REF(url),
SIPTAG_EVENT_REF(event),
SIPTAG_EVENT_STR_REF(event_s),
SIPTAG_CONTENT_TYPE_STR_REF(ct_s),
SIPTAG_PAYLOAD_REF(pl),
SIPTAG_PAYLOAD_STR_REF(pl_s),
TAG_END());
if (!event && !event_s)
status = 400, phrase = "Missing Event";
else if (!ct && !ct_s)
status = 400, phrase = "Missing Content-Type";
else if (!nh->nh_notifier &&
!(nh->nh_notifier =
nea_server_create(nua->nua_nta, nua->nua_root,
url->us_url,
NH_PGET(nh, max_subscriptions),
NULL, nh,
TAG_NEXT(tags))))
status = 900, phrase = nua_internal_error;
else if (!event && !(event = sip_event_make(home, event_s)))
status = 900, phrase = "Could not create an event header";
else if (!(ev = nh_notifier_event(nh, home, event, tags)))
status = 900, phrase = "Could not create an event view";
else if (nea_server_update(nh->nh_notifier, ev, TAG_NEXT(tags)) < 0)
status = 900, phrase = "No content for event";
else if (nea_server_notify(nh->nh_notifier, ev) < 0)
status = 900, phrase = "Error when notifying watchers";
else
nua_stack_tevent(nua, nh, NULL, e, status = SIP_200_OK,
SIPTAG_EVENT(event),
SIPTAG_CONTENT_TYPE(ct),
TAG_END());
if (status != 200)
nua_stack_event(nua, nh, NULL, e, status, phrase, NULL);
su_home_deinit(home);
}
/* Callback from nea_server asking nua to authorize subscription */
static
void authorize_watcher(nea_server_t *nes,
nua_handle_t *nh,
nea_event_t *ev,
nea_subnode_t *sn,
sip_t const *sip)
{
nua_t *nua = nh->nh_nua;
msg_t *msg = NULL;
nta_incoming_t *irq = NULL;
int substate = sn->sn_state;
int status; char const *phrase;
SET_STATUS1(SIP_200_OK);
/* OK. In nhp (nua_handle_preferences_t) structure we have the
current default action (or state) for incoming
subscriptions.
Action can now be modified by the application with NUTAG_SUBSTATE().
*/
irq = nea_sub_get_request(sn->sn_subscriber);
msg = nta_incoming_getrequest(irq);
if (sn->sn_state == nea_embryonic) {
char const *what;
substate = NH_PGET(nh, substate);
if (substate == nua_substate_embryonic)
substate = nua_substate_pending;
if (substate == nua_substate_terminated) {
what = "rejected"; SET_STATUS1(SIP_403_FORBIDDEN);
}
else if (substate == nua_substate_pending) {
what = "pending"; SET_STATUS1(SIP_202_ACCEPTED);
}
else {
what = "active";
}
SU_DEBUG_7(("nua(%p): authorize_watcher: %s\n", (void *)nh, what));
nea_sub_auth(sn->sn_subscriber, (nea_state_t)substate,
TAG_IF(substate == nua_substate_pending,
NEATAG_FAKE(1)),
TAG_IF(substate == nua_substate_terminated,
NEATAG_REASON("rejected")),
TAG_END());
}
else if (sn->sn_state == nea_terminated || sn->sn_expires == 0) {
substate = nua_substate_terminated;
nea_server_flush(nes, NULL);
SU_DEBUG_7(("nua(%p): authorize_watcher: %s\n",
(void *)nh, "watcher is removed"));
}
nua_stack_tevent(nua, nh, msg, nua_i_subscription, status, phrase,
NUTAG_SUBSTATE(substate),
NEATAG_SUB(sn->sn_subscriber),
TAG_END());
}
int nua_base_client_check_restart(nua_client_request_t *cr,
int status,
char const *phrase,
sip_t const *sip)
{
nua_handle_t *nh = cr->cr_owner;
nta_outgoing_t *orq;
#if 0
if (status == 302 || status == 305) {
sip_route_t r[1];
if (!can_redirect(sip->sip_contact, cr->cr_method))
return 0;
switch (status) {
case 302:
if (nua_dialog_zap(nh, nh->nh_ds) == 0 &&
nua_client_set_target(cr, sip->sip_contact->m_url) >= 0)
return nua_client_restart(cr, 100, "Redirected");
break;
case 305:
sip_route_init(r);
*r->r_url = *sip->sip_contact->m_url;
if (nua_dialog_zap(nh, nh->nh_ds) == 0 &&
sip_add_dup(cr->cr_msg, cr->cr_sip, (sip_header_t *)r) >= 0)
return nua_client_restart(cr, 100, "Redirected via a proxy");
break;
default:
break;
}
}
#endif
if (status == 423) {
unsigned my_expires = 0;
if (cr->cr_sip->sip_expires)
my_expires = cr->cr_sip->sip_expires->ex_delta;
if (sip->sip_min_expires &&
sip->sip_min_expires->me_delta > my_expires) {
sip_expires_t ex[1];
sip_expires_init(ex);
ex->ex_delta = sip->sip_min_expires->me_delta;
if (sip_add_dup(cr->cr_msg, NULL, (sip_header_t *)ex) < 0)
return 0;
return nua_client_restart(cr, 100, "Re-Negotiating Expiration");
}
}
if (status == 403) {
if (nh->nh_auth) {
/* Bad username/password */
SU_DEBUG_7(("nua(%p): bad credentials, clearing them\n", (void *)nh));
auc_clear_credentials(&nh->nh_auth, NULL, NULL);
}
}
if ((status == 401 && sip->sip_www_authenticate) ||
(status == 407 && sip->sip_proxy_authenticate)) {
int server = 0, proxy = 0;
if (sip->sip_www_authenticate)
server = auc_challenge(&nh->nh_auth, nh->nh_home,
sip->sip_www_authenticate,
sip_authorization_class);
if (sip->sip_proxy_authenticate)
proxy = auc_challenge(&nh->nh_auth, nh->nh_home,
sip->sip_proxy_authenticate,
sip_proxy_authorization_class);
if (server >= 0 && proxy >= 0) {
int invalid = cr->cr_challenged && server + proxy == 0;
cr->cr_challenged = 1;
if (invalid) {
/* Bad username/password */
SU_DEBUG_7(("nua(%p): bad credentials, clearing them\n", (void *)nh));
auc_clear_credentials(&nh->nh_auth, NULL, NULL);
} else if (auc_has_authorization(&nh->nh_auth)) {
return nua_client_restart(cr, 100, "Request Authorized by Cache");
}
orq = cr->cr_orq, cr->cr_orq = NULL;
cr->cr_waiting = cr->cr_wait_for_cred = 1;
nua_client_report(cr, status, phrase, NULL, orq, NULL);
nta_outgoing_destroy(orq);
cr->cr_status = 0, cr->cr_phrase = NULL;
nua_client_request_unref(cr);
return 1;
}
}
/* GriGiu : RFC-3261 status supported Retry-After */
if ( (status == 404 || status == 413 || status == 480 || status == 486 ||
status == 500 || status == 503 ||
status == 600 || status == 603) &&
sip->sip_retry_after &&
NH_PGET(nh, retry_after_enable) &&
sip->sip_retry_after->af_delta < 3200) {
su_timer_t *timer;
char phrase[18]; /* Retry After XXXX\0 */
timer = su_timer_create(su_root_task(nh->nh_nua->nua_root), 0);
if (su_timer_set_interval(timer, nua_client_restart_after, cr,
sip->sip_retry_after->af_delta * 1000) < 0) {
su_timer_destroy(timer);
return 0; /* Too bad */
}
cr->cr_timer = timer; /* This takes over cr reference from orq */
snprintf(phrase, sizeof phrase, "Retry After %u",
(unsigned)sip->sip_retry_after->af_delta);
orq = cr->cr_orq, cr->cr_orq = NULL;
cr->cr_waiting = 1;
nua_client_report(cr, 100, phrase, NULL, orq, NULL);
nta_outgoing_destroy(orq);
cr->cr_status = 0, cr->cr_phrase = NULL;
return 1;
}
return 0; /* This was a final response that cannot be restarted. */
}
int nua_notify_server_preprocess(nua_server_request_t *sr)
{
nua_dialog_state_t *ds = sr->sr_owner->nh_ds;
nua_dialog_usage_t *du;
struct event_usage *eu;
sip_t const *sip = sr->sr_request.sip;
sip_event_t *o = sip->sip_event;
enum nua_substate substate = nua_substate_terminated;
sip_subscription_state_t *subs = sip->sip_subscription_state;
char const *what = "", *reason = NULL;
int solicited = 1;
du = nua_dialog_usage_get(ds, nua_subscribe_usage, o);
if (du == NULL) {
if (!sip_is_allowed(NH_PGET(sr->sr_owner, appl_method), SIP_METHOD_NOTIFY))
return SR_STATUS(sr, 481, "Subscription Does Not Exist");
solicited = 0; /* Let application to handle unsolicited NOTIFY */
du = nua_dialog_usage_add(sr->sr_owner, ds, nua_subscribe_usage, o);
if (!du)
return SR_STATUS1(sr, SIP_500_INTERNAL_SERVER_ERROR);
}
sr->sr_usage = du;
eu = nua_dialog_usage_private(du); assert(eu);
eu->eu_notified++;
if (!o || !o->o_id)
eu->eu_no_id = 1;
if (subs == NULL) {
/* Compatibility */
unsigned long delta = eu->eu_delta;
if (sip->sip_expires)
delta = sip->sip_expires->ex_delta;
if (delta == 0)
substate = nua_substate_terminated, what = "terminated";
else
substate = nua_substate_active, what = "active";
}
else if (su_casematch(subs->ss_substate, what = "terminated")) {
substate = nua_substate_terminated;
reason = subs->ss_reason;
if (su_casematch(reason, "deactivated") ||
su_casematch(reason, "probation"))
substate = nua_substate_embryonic;
}
else if (su_casematch(subs->ss_substate, what = "pending")) {
substate = nua_substate_pending;
}
else /* if (su_casematch(subs->ss_substate, what = "active")) */ {
/* Any extended state is considered as active */
what = subs->ss_substate;
substate = nua_substate_active;
}
eu->eu_substate = substate;
if (!solicited)
eu->eu_unsolicited = 1;
SU_DEBUG_5(("nua(%p): %s: %s (%s)\n",
(void *)sr->sr_owner, "nua_notify_server_preprocess",
what, reason ? reason : ""));
if (solicited)
return SR_STATUS1(sr, SIP_200_OK);
return 0;
}
static int nua_subscribe_client_response(nua_client_request_t *cr,
int status, char const *phrase,
sip_t const *sip)
{
nua_handle_t *nh = cr->cr_owner;
nua_dialog_usage_t *du = cr->cr_usage;
struct event_usage *eu = nua_dialog_usage_private(du);
enum nua_substate substate;
if (eu == NULL || cr->cr_terminated)
substate = nua_substate_terminated;
else if (status >= 300)
substate = eu->eu_substate;
else {
int win_messenger_enable = NH_PGET(nh, win_messenger_enable);
sip_time_t delta, now = sip_now();
du->du_ready = 1;
if (eu->eu_substate != nua_substate_terminated)
/* If there is no @Expires header,
use default value stored in eu_delta */
delta = sip_contact_expires(NULL, sip->sip_expires, sip->sip_date,
eu->eu_delta, now);
else
delta = 0;
if (delta > eu->eu_delta)
delta = eu->eu_delta;
if (win_messenger_enable && !nua_dialog_is_established(nh->nh_ds)) {
/* Notify from messanger does not match with dialog tag */
nh->nh_ds->ds_remote_tag = su_strdup(nh->nh_home, "");
}
if (delta > 0) {
nua_dialog_usage_set_refresh(du, delta);
eu->eu_expires = du->du_refquested + delta;
}
else {
if (eu->eu_substate == nua_substate_terminated) {
if (!eu->eu_notified)
eu->eu_substate = nua_substate_embryonic;
}
if (eu->eu_substate != nua_substate_terminated) {
/* Wait 32 seconds for NOTIFY. */
delta = 64 * NTA_SIP_T1 / 1000;
eu->eu_final_wait = 1;
if (!eu->eu_notified && win_messenger_enable)
delta = 4 * 60; /* Wait 4 minutes for NOTIFY from Messenger */
nua_dialog_usage_set_refresh_range(du, delta, delta);
}
else {
nua_dialog_usage_reset_refresh(du);
}
eu->eu_expires = du->du_refquested;
}
substate = eu->eu_substate;
if (substate == nua_substate_terminated)
/* let nua_base_client_tresponse to remove usage */
cr->cr_terminated = 1;
}
return nua_base_client_tresponse(cr, status, phrase, sip,
NUTAG_SUBSTATE(substate),
SIPTAG_EVENT(du ? du->du_event : NULL),
TAG_END());
}