END_TEST START_TEST(subscribe_6_1_3) { nua_handle_t *nh; struct message *response; struct event *notify, *event; S2_CASE("6.1.3", "Subscription terminated by notifier", "NUA sends SUBSCRIBE, waits for NOTIFY, " "gets NOTIFY terminating the subscription,"); 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); fail_if(s2_sip_request_to(dialog, SIP_METHOD_NOTIFY, NULL, SIPTAG_EVENT_STR(event_type), SIPTAG_SUBSCRIPTION_STATE_STR("terminated;reason=noresource"), 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); nua_handle_destroy(nh); }
END_TEST START_TEST(fetch_6_2_3) { nua_handle_t *nh; struct message *subscribe; struct event *event; S2_CASE("6.2.3", "Event fetch - no NOTIFY", "NUA sends SUBSCRIBE with Expires 0, waits for NOTIFY, times out"); nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_subscribe(nh, SIPTAG_EVENT_STR(event_type), SIPTAG_EXPIRES_STR("0"), TAG_END()); subscribe = s2_sip_wait_for_request(SIP_METHOD_SUBSCRIBE); s2_sip_respond_to(subscribe, dialog, SIP_202_ACCEPTED, SIPTAG_EXPIRES_STR("0"), TAG_END()); s2_sip_free_message(subscribe); event = s2_wait_for_event(nua_r_subscribe, 202); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_embryonic)); s2_free_event(event); s2_nua_fast_forward(600, s2base->root); event = s2_wait_for_event(nua_i_notify, 408); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_terminated)); s2_free_event(event); nua_handle_destroy(nh); }
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); }
END_TEST START_TEST(client_1_4_2) { nua_handle_t *nh; struct message *message; struct event *response; S2_CASE("1.4.2", "Retry-After a delay", "Retry MESSAGE after a delay"); nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_message(nh, SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello"), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_503_SERVICE_UNAVAILABLE, SIPTAG_RETRY_AFTER_STR("3"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 100); s2_free_event(response); s2_nua_fast_forward(32, s2base->root); /* Too long delay */ message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_503_SERVICE_UNAVAILABLE, SIPTAG_RETRY_AFTER_STR("32"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 503); s2_free_event(response); nua_set_params(nua, NUTAG_MAX_RETRY_AFTER(0), TAG_END()); fail_unless_event(nua_r_set_params, 200); /* Disable feature */ nua_message(nh, SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello"), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_503_SERVICE_UNAVAILABLE, SIPTAG_RETRY_AFTER_STR("3"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 503); s2_free_event(response); nua_handle_destroy(nh); }
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; }
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); }
nua_handle_t * subscribe_to_nua(char const *event, tag_type_t tag, tag_value_t value, ...) { ta_list ta; struct event *subscribe; struct message *response; nua_handle_t *nh; nua_set_params(nua, NUTAG_APPL_METHOD("SUBSCRIBE"), SIPTAG_ALLOW_EVENTS_STR(event), TAG_END()); fail_unless_event(nua_r_set_params, 200); ta_start(ta, tag, value); s2_sip_request_to(dialog, SIP_METHOD_SUBSCRIBE, NULL, SIPTAG_EVENT_STR(event), ta_tags(ta)); ta_end(ta); subscribe = s2_wait_for_event(nua_i_subscribe, 100); nh = subscribe->nh; nua_respond(nh, SIP_202_ACCEPTED, NUTAG_WITH_SAVED(subscribe->event), TAG_END()); s2_free_event(subscribe); response = s2_sip_wait_for_response(202, SIP_METHOD_SUBSCRIBE); s2_sip_update_dialog(dialog, response); fail_unless(response->sip->sip_expires != NULL); s2_sip_free_message(response); return nh; }
END_TEST START_TEST(subscribe_6_1_4) { nua_handle_t *nh; struct message *response; struct event *notify, *event; S2_CASE("6.1.4", "Subscription terminated by notifier, re-established", "NUA sends SUBSCRIBE, waits for NOTIFY, " "gets NOTIFY terminating the subscription,"); 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); fail_if(s2_sip_request_to(dialog, SIP_METHOD_NOTIFY, NULL, SIPTAG_EVENT_STR(event_type), SIPTAG_SUBSCRIPTION_STATE_STR("terminated;reason=deactivated"), TAG_END())); event = s2_wait_for_event(nua_i_notify, 200); fail_if(!event); fail_unless(s2_check_substate(event, nua_substate_embryonic)); s2_free_event(event); response = s2_sip_wait_for_response(200, SIP_METHOD_NOTIFY); fail_if(!response); s2_sip_free_message(response); su_home_unref((void *)dialog), dialog = su_home_new(sizeof *dialog); fail_if(!dialog); s2_nua_fast_forward(5, s2base->root); /* nua re-establishes the subscription */ notify = subscription_by_nua(nh, nua_substate_embryonic, TAG_END()); s2_free_event(notify); /* Unsubscribe with nua_subscribe() Expires: 0 */ nua_subscribe(nh, SIPTAG_EVENT_STR(event_type), SIPTAG_EXPIRES_STR("0"), TAG_END()); notify = subscription_by_nua(nh, nua_substate_active, TAG_END()); s2_free_event(notify); nua_handle_destroy(nh); }
int s2_check_callstate(enum nua_callstate state) { int retval = 0; tagi_t const *tagi; struct event *e; e = s2_wait_for_event(nua_i_state, 0); if (e) { tagi = tl_find(e->data->e_tags, nutag_callstate); if (tagi) { retval = (tag_value_t)state == tagi->t_value; } } s2_free_event(e); return retval; }
END_TEST START_TEST(subscribe_6_1_5) { nua_handle_t *nh; struct event *notify; sip_via_t *vorig = s2_sip_tport_via(s2sip->udp.tport); sip_via_t via[2]; char *v0_params[8] = {}, *v1_params[8] = {}; char branch0[32], branch1[32]; S2_CASE("6.1.5", "Via handling in response to NOTIFY", "NUA sends SUBSCRIBE, waits for NOTIFY, sends un-SUBSCRIBE"); nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_subscribe(nh, SIPTAG_EVENT_STR(event_type), TAG_END()); s2_sip_msg_flags = MSG_FLG_COMMA_LISTS|MSG_FLG_COMPACT; fail_if(vorig == NULL); via[0] = *vorig; via[0].v_host = "example.org"; via[0].v_params = (void *)v0_params; snprintf(v0_params[0] = branch0, sizeof branch0, "branch=z9hG4bK%lx", ++s2sip->tid); fail_if(vorig == NULL); via[1] = *vorig; via[1].v_params = (void *)v1_params; snprintf(v1_params[0] = branch1, sizeof branch1, "branch=z9hG4bK%lx", ++s2sip->tid); notify = subscription_by_nua(nh, nua_substate_embryonic, SIPTAG_VIA(via + 1), SIPTAG_VIA(via + 0), TAG_END()); s2_sip_msg_flags = 0; s2_free_event(notify); unsubscribe_by_nua(nh, TAG_END()); nua_handle_destroy(nh); }
END_TEST START_TEST(fetch_6_2_2) { nua_handle_t *nh; struct event *notify; S2_CASE("6.2.2", "Event fetch - NOTIFY before 200", "NUA sends SUBSCRIBE with Expires 0, waits for NOTIFY"); send_notify_before_response = 1; nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_subscribe(nh, SIPTAG_EVENT_STR(event_type), SIPTAG_EXPIRES_STR("0"), TAG_END()); notify = subscription_by_nua(nh, nua_substate_embryonic, TAG_END()); s2_check_substate(notify, nua_substate_terminated); s2_free_event(notify); nua_handle_destroy(nh); }
END_TEST START_TEST(message_6_4_3) { nua_handle_t *nh; struct message *message; struct event *response; sip_call_id_t *i; S2_CASE("6.4.1", "SIMPLE MESSAGE", "Send MESSAGE"); nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_message(nh, SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello"), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_407_PROXY_AUTH_REQUIRED, SIPTAG_PROXY_AUTHENTICATE_STR(s2_auth_digest_str), TAG_END()); i = sip_call_id_dup(NULL, message->sip->sip_call_id); fail_unless(i != NULL); s2_sip_free_message(message); fail_unless_event(nua_r_message, 407); nua_authenticate(nh, NUTAG_AUTH(s2_auth_credentials), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_202_ACCEPTED, TAG_END()); fail_unless(su_strmatch(i->i_id, message->sip->sip_call_id->i_id)); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 202); s2_free_event(response); nua_handle_destroy(nh); }
END_TEST START_TEST(notify_6_3_6) { nua_handle_t *nh; struct event *subscribe; struct message *notify, *response; sip_t *sip; S2_CASE("6.3.6", "Explicit refresh with NUTAG_APPL_EVENT()", "Process subscription refresh by application"); nua_set_params(nua, NUTAG_APPL_METHOD("SUBSCRIBE"), NUTAG_APPL_EVENT("presence"), SIPTAG_ALLOW_EVENTS_STR("presence"), TAG_END()); fail_unless_event(nua_r_set_params, 200); s2_sip_request_to(dialog, SIP_METHOD_SUBSCRIBE, NULL, SIPTAG_EVENT_STR("presence"), TAG_END()); subscribe = s2_wait_for_event(nua_i_subscribe, 100); nh = subscribe->nh; nua_respond(nh, SIP_202_ACCEPTED, NUTAG_WITH_SAVED(subscribe->event), TAG_END()); s2_free_event(subscribe); response = s2_sip_wait_for_response(202, SIP_METHOD_SUBSCRIBE); s2_sip_update_dialog(dialog, response); fail_unless(response->sip->sip_expires != NULL); s2_sip_free_message(response); nua_notify(nh, NUTAG_SUBSTATE(nua_substate_active), SIPTAG_PAYLOAD_STR(presence_closed), TAG_END()); notify = s2_sip_wait_for_request(SIP_METHOD_NOTIFY); fail_unless(notify != NULL); sip = notify->sip; fail_unless(sip->sip_subscription_state != NULL); fail_unless(su_strmatch(sip->sip_subscription_state->ss_substate, "active")); s2_sip_respond_to(notify, dialog, SIP_200_OK, TAG_END()); fail_unless_event(nua_r_notify, 200); s2_sip_request_to(dialog, SIP_METHOD_SUBSCRIBE, NULL, SIPTAG_EVENT_STR("presence"), TAG_END()); subscribe = s2_wait_for_event(nua_i_subscribe, 100); nh = subscribe->nh; nua_respond(nh, SIP_202_ACCEPTED, NUTAG_WITH_SAVED(subscribe->event), TAG_END()); s2_free_event(subscribe); response = s2_sip_wait_for_response(202, SIP_METHOD_SUBSCRIBE); s2_sip_update_dialog(dialog, response); fail_unless(response->sip->sip_expires != NULL); s2_sip_free_message(response); notify = s2_sip_wait_for_request(SIP_METHOD_NOTIFY); fail_unless(notify != NULL); sip = notify->sip; fail_unless(sip->sip_subscription_state != NULL); fail_unless(su_strmatch(sip->sip_subscription_state->ss_substate, "active")); s2_sip_respond_to(notify, dialog, SIP_200_OK, TAG_END()); fail_unless_event(nua_r_notify, 200); /* Now clear list of application events */ nua_set_params(nua, NUTAG_APPL_EVENT(NULL), NUTAG_SUB_EXPIRES(360), TAG_END()); fail_unless_event(nua_r_set_params, 200); s2_sip_request_to(dialog, SIP_METHOD_SUBSCRIBE, NULL, SIPTAG_EVENT_STR("presence"), TAG_END()); /* Automatically responded && refreshed */ subscribe = s2_wait_for_event(nua_i_subscribe, 200); s2_free_event(subscribe); response = s2_sip_wait_for_response(200, SIP_METHOD_SUBSCRIBE); s2_sip_update_dialog(dialog, response); fail_unless(response->sip->sip_expires != NULL); fail_unless(response->sip->sip_expires->ex_delta == 360); s2_sip_free_message(response); notify = s2_sip_wait_for_request(SIP_METHOD_NOTIFY); fail_unless(notify != NULL); sip = notify->sip; fail_unless(sip->sip_subscription_state != NULL); fail_unless(su_strmatch(sip->sip_subscription_state->ss_substate, "active")); s2_sip_respond_to(notify, dialog, SIP_200_OK, TAG_END()); fail_unless_event(nua_r_notify, 200); nua_handle_destroy(nh); notify = s2_sip_wait_for_request(SIP_METHOD_NOTIFY); sip = notify->sip; fail_unless(sip->sip_subscription_state != NULL); fail_unless(su_strmatch(sip->sip_subscription_state->ss_substate, "terminated")); s2_sip_respond_to(notify, dialog, SIP_481_NO_TRANSACTION, TAG_END()); }
void s2_flush_events(void) { while (s2->events) { s2_free_event(s2->events); } }
int s2_check_event(nua_event_t event, int status) { struct event *e = s2_wait_for_event(event, status); s2_free_event(e); return e != NULL; }
END_TEST #include <sys/time.h> START_TEST(register_1_2_4) { nua_handle_t *nh = nua_handle(nua, NULL, TAG_END()); struct message *m; struct event *e; unsigned t1, n; S2_CASE("1.2.4", "Register behind NAT", "Authenticate, outbound activated, " "drop OPTIONS, check that OPTIONS is not retried"); mark_point(); make_auth_natted_register(nh, NUTAG_OUTBOUND("validate, no-options-keepalive"), /* test with a round of unanswered plain keepalives as well? */ TAG_END()); s2->registration->nh = nh; mark_point(); t1 = 500; for (t1 = 500, n = 0; n < 20; n++) { e = NULL, m = NULL; s2_next_thing(&e, &m); if (e) break; fail_if(!m); fail_if(!m->sip->sip_request); fail_if(m->sip->sip_request->rq_method != sip_method_options); s2_sip_free_message(m); mark_point(); s2_nua_fast_forward((t1 + 500) / 1000, s2base->root); t1 *= 2; if (t1 > 4000) t1 = 4000; } fail_unless(e != NULL); fail_unless(e->data->e_event == nua_i_outbound); fail_unless(e->data->e_status == 408); s2_free_event(e); s2_sip_flush_messages(); s2_nua_fast_forward(3600, s2base->root); m = s2_sip_wait_for_request(SIP_METHOD_REGISTER); fail_if(!m); fail_if(!m->sip->sip_authorization); fail_if(!m->sip->sip_contact); s2_default_registration_duration = 120; s2_save_register(m); s2_sip_respond_to(m, NULL, SIP_200_OK, SIPTAG_CONTACT(s2->registration->contact), TAG_END()); s2_sip_free_message(m); fail_unless_event(nua_r_register, 200); fail_unless(s2->registration->contact != NULL); fail_if(s2->registration->contact->m_next != NULL); s2_sip_flush_messages(); while (s2sip->received == NULL) { s2_nua_fast_forward(10, s2base->root); } m = s2_sip_remove_message(s2sip->received); fail_if(!m); fail_unless(m->sip->sip_request->rq_method == sip_method_register); fail_if(!m->sip->sip_authorization); fail_if(!m->sip->sip_contact); s2_save_register(m); s2_sip_respond_to(m, NULL, SIP_200_OK, SIPTAG_CONTACT(s2->registration->contact), TAG_END()); s2_sip_free_message(m); fail_unless_event(nua_r_register, 200); s2_register_teardown(); }
END_TEST START_TEST(message_6_4_2) { nua_handle_t *nh; struct message *message; struct event *response; S2_CASE("6.4.2", "MESSAGE with 302/305", "Send MESSAGE"); nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END()); nua_message(nh, SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello"), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_302_MOVED_TEMPORARILY, SIPTAG_CONTACT_STR("<sip:[email protected]>"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 100); s2_free_event(response); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); fail_unless(message->sip->sip_request->rq_url->url_user != NULL); fail_if(strcmp(message->sip->sip_request->rq_url->url_user, "302ed")); s2_sip_respond_to(message, NULL, SIP_305_USE_PROXY, SIPTAG_CONTACT_STR("<sip:[email protected];lr>"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 100); s2_free_event(response); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); fail_unless(message->sip->sip_route != NULL); fail_unless(message->sip->sip_route->r_url->url_user != NULL); fail_if(strcmp(message->sip->sip_route->r_url->url_user, "routed")); s2_sip_respond_to(message, NULL, SIP_200_OK, TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 200); s2_free_event(response); /* ---------------------------------------------------------------------- */ nua_message(nh, NUTAG_AUTO302(0), SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello 2"), TAG_END()); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); s2_sip_respond_to(message, NULL, SIP_302_MOVED_TEMPORARILY, SIPTAG_CONTACT_STR("<sip:[email protected]>"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 302); fail_unless(response->sip && response->sip->sip_contact); nua_message(nh, NUTAG_URL(response->sip->sip_contact->m_url), NUTAG_AUTO305(0), SIPTAG_CONTENT_TYPE_STR("text/plain"), SIPTAG_PAYLOAD_STR("hello 2"), TAG_END()); s2_free_event(response); message = s2_sip_wait_for_request(SIP_METHOD_MESSAGE); fail_unless(message->sip->sip_request->rq_url->url_user != NULL); fail_if(strcmp(message->sip->sip_request->rq_url->url_user, "not302ed")); s2_sip_respond_to(message, NULL, SIP_305_USE_PROXY, SIPTAG_CONTACT_STR("<sip:[email protected]>"), TAG_END()); s2_sip_free_message(message); response = s2_wait_for_event(nua_r_message, 305); s2_free_event(response); nua_handle_destroy(nh); }