static struct event * subscription_by_nua(nua_handle_t *nh, enum nua_substate current, tag_type_t tag, tag_value_t value, ...) { struct message *subscribe; struct event *notify, *event; ta_list ta; enum nua_substate substate = nua_substate_active; char const *substate_str = subscription_state; char const *expires = "600"; subscribe = s2_sip_wait_for_request(SIP_METHOD_SUBSCRIBE); if (event_type) fail_if(!subscribe->sip->sip_event || strcmp(event_type, subscribe->sip->sip_event->o_type)); if (subscribe->sip->sip_expires && subscribe->sip->sip_expires->ex_delta == 0) { substate = nua_substate_terminated; substate_str = "terminated;reason=timeout"; expires = "0"; } ta_start(ta, tag, value); if (send_notify_before_response) { s2_sip_save_uas_dialog(dialog, subscribe->sip); notify = notify_to_nua(substate, SIPTAG_EVENT(subscribe->sip->sip_event), SIPTAG_SUBSCRIPTION_STATE_STR(substate_str), ta_tags(ta)); event = respond_to_subscribe(subscribe, nua_r_subscribe, substate, SIP_200_OK, SIPTAG_EXPIRES_STR(expires), TAG_END()); s2_free_event(event); } else { event = respond_to_subscribe(subscribe, nua_r_subscribe, current, SIP_202_ACCEPTED, SIPTAG_EXPIRES_STR(expires), TAG_END()); s2_free_event(event); notify = notify_to_nua(substate, SIPTAG_EVENT(subscribe->sip->sip_event), SIPTAG_SUBSCRIPTION_STATE_STR(substate_str), ta_tags(ta)); } s2_sip_free_message(subscribe); return notify; }
/** Refresh subscription */ static void nua_subscribe_usage_refresh(nua_handle_t *nh, nua_dialog_state_t *ds, nua_dialog_usage_t *du, sip_time_t now) { nua_client_request_t *cr = du->du_cr; struct event_usage *eu = nua_dialog_usage_private(du); assert(eu); if (eu->eu_final_wait) { /* Did not receive NOTIFY for fetch */ sip_event_t const *o = du->du_event; char const *id = o ? o->o_id : NULL; SU_DEBUG_3(("nua(%p): event %s%s%s fetch timeouts\n", (void *)nh, o ? o->o_type : "(empty)", id ? "; id=" : "", id ? id : "")); nua_stack_tevent(nh->nh_nua, nh, NULL, nua_i_notify, 408, "Fetch Timeouts without NOTIFY", NUTAG_SUBSTATE(nua_substate_terminated), SIPTAG_EVENT(du->du_event), TAG_END()); nua_dialog_usage_remove(nh, ds, du, NULL, NULL); return; } if (cr) { if (nua_client_resend_request(cr, 0) >= 0) return; } else if (eu->eu_refer) { /* * XXX - If we have received a NOTIFY, we should try to terminate * subscription */ } if (!eu->eu_unsolicited) nua_stack_tevent(nh->nh_nua, nh, NULL, nua_i_notify, NUA_ERROR_AT(__FILE__, __LINE__), NUTAG_SUBSTATE(nua_substate_terminated), SIPTAG_EVENT(du->du_event), TAG_END()); nua_dialog_usage_remove(nh, ds, du, NULL, NULL); }
static void unsubscribe_by_nua(nua_handle_t *nh, tag_type_t tag, tag_value_t value, ...) { struct message *subscribe, *response; struct event *event; nua_unsubscribe(nh, TAG_END()); subscribe = s2_sip_wait_for_request(SIP_METHOD_SUBSCRIBE); s2_sip_respond_to(subscribe, dialog, SIP_200_OK, SIPTAG_EXPIRES_STR("0"), TAG_END()); event = s2_wait_for_event(nua_r_unsubscribe, 200); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_active)); s2_free_event(event); fail_if(s2_sip_request_to(dialog, SIP_METHOD_NOTIFY, NULL, SIPTAG_EVENT(subscribe->sip->sip_event), SIPTAG_SUBSCRIPTION_STATE_STR("terminated;reason=timeout"), SIPTAG_CONTENT_TYPE_STR(event_mime_type), SIPTAG_PAYLOAD_STR(event_state), TAG_END())); event = s2_wait_for_event(nua_i_notify, 200); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_terminated)); s2_free_event(event); response = s2_sip_wait_for_response(200, SIP_METHOD_NOTIFY); fail_if(!response); s2_sip_free_message(response); s2_sip_free_message(subscribe); }
static int nua_refer_client_response(nua_client_request_t *cr, int status, char const *phrase, sip_t const *sip) { nua_dialog_usage_t *du = cr->cr_usage; enum nua_substate substate = nua_substate_terminated; if (du) { struct event_usage *eu = nua_dialog_usage_private(du); if (status < 200) { substate = eu->eu_substate; } else if (status < 300) { sip_refer_sub_t const *rs = sip_refer_sub(sip); if (rs && su_casematch("false", rs->rs_value)) cr->cr_terminated = 1; if (!cr->cr_terminated) substate = eu->eu_substate; } } return nua_base_client_tresponse(cr, status, phrase, sip, NUTAG_SUBSTATE(substate), SIPTAG_EVENT(du ? du->du_event : NULL), TAG_END()); }
/** @interal Shut down NOTIFY usage. * * @retval >0 shutdown done * @retval 0 shutdown in progress * @retval <0 try again later */ static int nua_notify_usage_shutdown(nua_handle_t *nh, nua_dialog_state_t *ds, nua_dialog_usage_t *du) { struct notifier_usage *nu = nua_dialog_usage_private(du); nua_client_request_t *cr = du->du_cr; nu->nu_substate = nua_substate_terminated; if (cr) { SU_DEBUG_5(("%s(%p, %p, %p): using existing cr=%p\n", "nua_notify_usage_shutdown", (void *)nh, (void *)ds, (void *)du, (void *)cr)); if (nua_client_resend_request(cr, 1) >= 0) return 0; } else { SU_DEBUG_5(("%s(%p, %p, %p): new NOTIFY cr for %s\n", "nua_notify_usage_shutdown", (void *)nh, (void *)ds, (void *)du, du->du_event ? du->du_event->o_type : "<implicit>")); if (nua_client_tcreate(nh, nua_r_notify, &nua_notify_client_methods, SIPTAG_EVENT(du->du_event), NUTAG_SUBSTATE(nua_substate_terminated), TAG_END()) >= 0) return 0; } nua_dialog_usage_remove(nh, ds, du, NULL, NULL); return 200; }
static int nua_notify_client_report(nua_client_request_t *cr, int status, char const *phrase, sip_t const *sip, nta_outgoing_t *orq, tagi_t const *tags) { nua_handle_t *nh = cr->cr_owner; nua_dialog_usage_t *du = cr->cr_usage; struct notifier_usage *nu = nua_dialog_usage_private(du); enum nua_substate substate = nua_substate_terminated; if (nu && !cr->cr_terminated) substate = nu->nu_substate; nua_stack_tevent(nh->nh_nua, nh, nta_outgoing_getresponse(orq), (enum nua_event_e)cr->cr_event, status, phrase, NUTAG_SUBSTATE(substate), SIPTAG_EVENT(du ? du->du_event : NULL), TAG_NEXT(tags)); if (du && du->du_cr == cr && !cr->cr_terminated) { if (nu->nu_requested) { /* Re-SUBSCRIBEd while NOTIFY was in progress, resend NOTIFY */ nua_client_resend_request(cr, 0); } else if (nu->nu_expires) { nua_dialog_usage_set_refresh_at(du, nu->nu_expires); } } return 0; }
END_TEST START_TEST(subscribe_6_1_2) { nua_handle_t *nh; struct message *subscribe, *response; struct event *notify, *event; S2_CASE("6.1.2", "Basic subscription with refresh", "NUA sends SUBSCRIBE, waits for NOTIFY, " "sends re-SUBSCRIBE, waits for NOTIFY, " "sends un-SUBSCRIBE"); send_notify_before_response = 1; nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_subscribe(nh, SIPTAG_EVENT_STR(event_type), TAG_END()); notify = subscription_by_nua(nh, nua_substate_embryonic, TAG_END()); s2_free_event(notify); /* Wait for refresh */ s2_nua_fast_forward(600, s2base->root); subscribe = s2_sip_wait_for_request(SIP_METHOD_SUBSCRIBE); s2_sip_respond_to(subscribe, dialog, SIP_200_OK, SIPTAG_EXPIRES_STR("600"), TAG_END()); event = s2_wait_for_event(nua_r_subscribe, 200); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_active)); s2_free_event(event); fail_if(s2_sip_request_to(dialog, SIP_METHOD_NOTIFY, NULL, SIPTAG_EVENT(subscribe->sip->sip_event), SIPTAG_SUBSCRIPTION_STATE_STR("active;expires=600"), SIPTAG_CONTENT_TYPE_STR(event_mime_type), SIPTAG_PAYLOAD_STR(event_state), TAG_END())); event = s2_wait_for_event(nua_i_notify, 200); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_active)); s2_free_event(event); response = s2_sip_wait_for_response(200, SIP_METHOD_NOTIFY); fail_if(!response); s2_sip_free_message(response); unsubscribe_by_nua(nh, TAG_END()); nua_handle_destroy(nh); }
static int nua_refer_client_request(nua_client_request_t *cr, msg_t *msg, sip_t *sip, tagi_t const *tags) { nua_handle_t *nh = cr->cr_owner; nua_dialog_usage_t *du, *du0 = cr->cr_usage; struct event_usage *eu; sip_event_t *event; int error; cr->cr_usage = NULL; event = sip_event_format(nh->nh_home, "refer;id=%u", sip->sip_cseq->cs_seq); if (!event) return -1; if (du0 == NULL || du0->du_event == NULL || du0->du_event->o_id == NULL || strcmp(du0->du_event->o_id, event->o_id)) { du = nua_dialog_usage_add(nh, nh->nh_ds, nua_subscribe_usage, event); if (!du) return -1; } else { du = du0, du0 = NULL; } if (du0) nua_dialog_usage_remove(nh, nh->nh_ds, du0, NULL, NULL); eu = nua_dialog_usage_private(cr->cr_usage = du); eu ->eu_refer = 1; error = nua_base_client_request(cr, msg, sip, tags); if (!error) { /* Give application an Event header for matching NOTIFYs with REFER */ nua_stack_tevent(nh->nh_nua, nh, NULL, (enum nua_event_e)cr->cr_event, SIP_100_TRYING, NUTAG_REFER_EVENT(event), SIPTAG_EVENT(event), TAG_END()); su_free(nh->nh_home, event); } return error; }
static int nua_refer_server_report(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_t const *sip = sr->sr_request.sip; sip_referred_by_t *by = sip->sip_referred_by, default_by[1]; sip_event_t const *o = sr->sr_usage->du_event; enum nua_substate substate = nua_substate_terminated; int initial = sr->sr_initial, retval; if (nu) { if (!sr->sr_terminating) substate = nu->nu_substate; } if (by == NULL) { by = sip_referred_by_init(default_by); by->b_display = sip->sip_from->a_display; *by->b_url = *sip->sip_from->a_url; } retval = nua_base_server_treport(sr, NUTAG_SUBSTATE(substate), NUTAG_REFER_EVENT(o), TAG_IF(by, SIPTAG_REFERRED_BY(by)), TAG_END()); if (retval >= 2 || nu == NULL) return retval; if (initial) nua_stack_post_signal(nh, nua_r_notify, SIPTAG_EVENT(o), SIPTAG_CONTENT_TYPE_STR("message/sipfrag"), SIPTAG_PAYLOAD_STR("SIP/2.0 100 Trying\r\n"), TAG_END()); return retval; }
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); }
int nua_notify_server_report(nua_server_request_t *sr, tagi_t const *tags) { nua_handle_t *nh = sr->sr_owner; nua_dialog_usage_t *du = sr->sr_usage; struct event_usage *eu = nua_dialog_usage_private(du); sip_t const *sip = sr->sr_request.sip; enum nua_substate substate = nua_substate_terminated; sip_time_t delta = SIP_TIME_MAX; sip_event_t const *o = sip->sip_event; int retry = -1; int retval; if (eu) { sip_subscription_state_t *subs = sip->sip_subscription_state; substate = eu->eu_substate; if (substate == nua_substate_active || substate == nua_substate_pending) { if (subs && subs->ss_expires) { sip_time_t now = sip_now(); sip_time_t delta0 = strtoul(subs->ss_expires, NULL, 10); if (now + delta0 <= eu->eu_expires) delta = delta0; } } else if (substate == nua_substate_embryonic) { if (subs && subs->ss_reason) { if (su_casematch(subs->ss_reason, "deactivated")) { retry = 0; /* retry immediately */ } else if (su_casematch(subs->ss_reason, "probation")) { retry = 30; if (subs->ss_retry_after) retry = strtoul(subs->ss_retry_after, NULL, 10); if (retry > 3600) retry = 3600; } } } else if (substate == nua_substate_terminated) { sr->sr_terminating = 1; } } retval = nua_base_server_treport(sr, /* can destroy sr */ NUTAG_SUBSTATE(substate), SIPTAG_EVENT(o), TAG_NEXT(tags)); if (retval != 1 || du == NULL) return retval; if (eu->eu_unsolicited) { /* Xyzzy */; } else if (retry >= 0) { /* Try to subscribe again */ /* XXX - this needs through testing */ nua_dialog_remove(nh, nh->nh_ds, du); /* tear down */ nua_dialog_usage_set_refresh_range(du, retry, retry + 5); } else { if (delta < SIP_TIME_MAX) { nua_dialog_usage_set_refresh(du, delta); eu->eu_expires = du->du_refquested + delta; } } return retval; }
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()); }