예제 #1
0
END_TEST

START_TEST(client_2_0_1)
{
    nta_outgoing_t *orq;
    struct message *request;
    struct event *response;

    S2_CASE("client-2.0.1", "Send MESSAGE",
            "Basic non-INVITE transaction with "
            "numeric per-transaction outbound proxy");

    orq = nta_outgoing_tcreate(s2->default_leg,
                               s2_nta_orq_callback, NULL,
                               (url_string_t *)s2sip->contact->m_url,
                               SIP_METHOD_MESSAGE,
                               URL_STRING_MAKE("sip:test2.0.example.org"),
                               SIPTAG_FROM_STR("<sip:[email protected]>"),
                               TAG_END());
    fail_unless(orq != NULL);
    request = s2_sip_wait_for_request(SIP_METHOD_MESSAGE);
    fail_unless(request != NULL);
    s2_sip_respond_to(request, NULL, 200, "OK 2.0.1", TAG_END());
    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 200,
                               0);
    s2_sip_free_message(request);
    s2_nta_free_event(response);
    nta_outgoing_destroy(orq);
}
예제 #2
0
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);
}
예제 #3
0
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);
}
예제 #4
0
END_TEST


START_TEST(register_1_3_2_2)
{
  nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());
  struct message *m;

  S2_CASE("1.3.2.2", "Register behind NAT with TCP",
	  "Detect NAT over TCP using rport. "
	  "Authenticate, detect NAT, "
	  "close TCP at server, wait for re-REGISTERs.");

  nua_set_params(nua, NTATAG_TCP_RPORT(1), TAG_END());
  fail_unless_event(nua_r_set_params, 200);

  mark_point();
  s2->registration->nh = nh;
  make_auth_natted_register(
    nh, NUTAG_PROXY(s2sip->tcp.contact->m_url),
    NUTAG_OUTBOUND("no-options-keepalive, no-validate"),
    TAG_END());
  fail_if(!tport_is_tcp(s2->registration->tport));
  tport_shutdown(s2->registration->tport, 2);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  /* The "NAT binding" changed when new TCP connection is established */
  /* => NUA re-REGISTERs with newly detected contact */
  fail_unless_event(nua_r_register, 100);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  fail_if(!m->sip->sip_contact || !m->sip->sip_contact->m_next);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		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_register_teardown();
}
예제 #5
0
END_TEST


START_TEST(register_1_1_2)
{
    nua_handle_t *nh;
    struct message *m;

    S2_CASE("1.1.2", "Register with dual authentication",
            "Register, authenticate");

    nh = nua_handle(nua, NULL, TAG_END());

    nua_register(nh, TAG_END());

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    s2_sip_respond_to(m, NULL,
                      SIP_407_PROXY_AUTH_REQUIRED,
                      SIPTAG_PROXY_AUTHENTICATE_STR(s2_auth_digest_str),
                      TAG_END());
    s2_sip_free_message(m);
    fail_unless_event(nua_r_register, 407);

    nua_authenticate(nh, NUTAG_AUTH(s2_auth_credentials), TAG_END());

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    s2_sip_respond_to(m, NULL,
                      SIP_401_UNAUTHORIZED,
                      SIPTAG_WWW_AUTHENTICATE_STR(s2_auth2_digest_str),
                      SIPTAG_PROXY_AUTHENTICATE_STR(s2_auth_digest_str),
                      TAG_END());
    s2_sip_free_message(m);
    fail_unless_event(nua_r_register, 401);

    nua_authenticate(nh, NUTAG_AUTH(s2_auth2_credentials), TAG_END());

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    fail_if(!m->sip->sip_authorization);
    fail_if(!m->sip->sip_proxy_authorization);
    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);

    assert(s2->registration->contact != NULL);
    fail_unless_event(nua_r_register, 200);

    s2->registration->nh = nh;

    s2_register_teardown();

}
예제 #6
0
END_TEST

START_TEST(notify_6_3_5)
{
    nua_handle_t *nh;
    struct message *notify;
    struct event *response;
    sip_t *sip;

    S2_CASE("6.3.4", "NOTIFY server - terminate with error response to NOTIFY",
            "NUA receives SUBSCRIBE, sends 202 and NOTIFY. "
            "The subscription terminates when watcher "
            "returns 481 to NOTIFY.");

    nh = subscribe_to_nua("presence", SIPTAG_EXPIRES_STR("300"), TAG_END());

    nua_notify(nh,
               SIPTAG_SUBSCRIPTION_STATE_STR("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);

    nua_notify(nh,
               SIPTAG_SUBSCRIPTION_STATE_STR("active"),
               SIPTAG_PAYLOAD_STR(presence_open),
               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"));

    nua_notify(nh,
               NUTAG_NEWSUB(1),
               SIPTAG_SUBSCRIPTION_STATE_STR("active"),
               SIPTAG_PAYLOAD_STR(presence_open),
               TAG_END());

    s2_sip_respond_to(notify, dialog, SIP_481_NO_TRANSACTION, TAG_END());
    response = s2_wait_for_event(nua_r_notify, 481);
    fail_unless(s2_event_substate(response) == nua_substate_terminated);

    notify = s2_sip_wait_for_request(SIP_METHOD_NOTIFY);
    s2_sip_respond_to(notify, dialog, SIP_481_NO_TRANSACTION, TAG_END());
    response = s2_wait_for_event(nua_r_notify, 481);
    fail_unless(s2_event_substate(response) == nua_substate_terminated);

    nua_handle_destroy(nh);
}
예제 #7
0
END_TEST


START_TEST(register_1_2_2_3)
{
    nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());
    struct message *m;

    S2_CASE("1.2.2.3", "Register behind NAT",
            "Authenticate, outbound activated, "
            "detect NAT binding change when re-REGISTERing");

    mark_point();

    make_auth_natted_register(nh,
                              NUTAG_OUTBOUND("no-options-keepalive, no-validate"),
                              TAG_END());
    s2->registration->nh = nh;

    s2_nua_fast_forward(3600, s2base->root);
    mark_point();

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    fail_if(!m->sip->sip_authorization);
    s2_save_register(m);

    s2_sip_respond_to(m, NULL,
                      SIP_200_OK,
                      SIPTAG_CONTACT(s2->registration->contact),
                      SIPTAG_VIA(natted_via(m, receive_natted2)),
                      TAG_END());
    s2_sip_free_message(m);

    fail_unless_event(nua_r_register, 100);

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    fail_if(!m->sip->sip_authorization);
    fail_if(!m->sip->sip_contact || !m->sip->sip_contact->m_next);
    s2_save_register(m);

    s2_sip_respond_to(m, NULL,
                      SIP_200_OK,
                      SIPTAG_CONTACT(s2->registration->contact),
                      SIPTAG_VIA(natted_via(m, receive_natted2)),
                      TAG_END());
    s2_sip_free_message(m);

    fail_unless(s2->registration->contact != NULL);
    fail_if(s2->registration->contact->m_next != NULL);

    fail_unless_event(nua_r_register, 200);

    s2_register_teardown();

}
예제 #8
0
END_TEST


/* ---------------------------------------------------------------------- */

START_TEST(register_1_3_1)
{
    nua_handle_t *nh;
    struct message *m;

    S2_CASE("1.3.1", "Register over TCP via NAT",
            "REGISTER via TCP, detect NTA, re-REGISTER");

    nh = nua_handle(nua, NULL, TAG_END());

    nua_register(nh, NUTAG_PROXY(s2sip->tcp.contact->m_url), TAG_END());

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    fail_if(!m->sip->sip_contact || m->sip->sip_contact->m_next);
    fail_if(!tport_is_tcp(m->tport));
    s2_save_register(m);

    s2_sip_respond_to(m, NULL,
                      SIP_200_OK,
                      SIPTAG_CONTACT(s2->registration->contact),
                      SIPTAG_VIA(natted_via(m, receive_natted)),
                      TAG_END());
    s2_sip_free_message(m);

    assert(s2->registration->contact != NULL);
    fail_unless_event(nua_r_register, 100);

    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
    fail_if(!m);
    fail_if(!m->sip->sip_contact || !m->sip->sip_contact->m_next);
    s2_save_register(m);

    s2_sip_respond_to(m, NULL,
                      SIP_200_OK,
                      SIPTAG_CONTACT(s2->registration->contact),
                      SIPTAG_VIA(natted_via(m, receive_natted)),
                      TAG_END());
    s2_sip_free_message(m);

    fail_unless(s2->registration->contact != NULL);
    fail_if(s2->registration->contact->m_next != NULL);
    fail_unless(
        url_has_param(s2->registration->contact->m_url, "transport=tcp"));
    fail_unless_event(nua_r_register, 200);

    s2->registration->nh = nh;

    s2_register_teardown();

}
예제 #9
0
} END_TEST


START_TEST(register_1_1_1)
{
  S2_CASE("1.1.1", "Basic Register", "REGISTER returning 200 OK");

  s2_register_setup();

  s2_register_teardown();

} END_TEST
예제 #10
0
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);
}
예제 #11
0
END_TEST

START_TEST(SIP_CC_OE_CE_TI_011_012)
{
  nua_handle_t *nh;
  struct message *invite;

  S2_CASE("6.1.2", "SIP_CC_OE_CE_TI_011_012",
          "Ensure that the IUT, when an INVITE client transaction "
          "has been in the Terminated state, on receipt of a "
          "retransmitted Success (200 OK) responses sends an ACK "
          "request until 64*T1 duration expires, after this, "
          "on receipt of a retransmitted Success (200 OK) "
          "responses does not send an ACK request.");

  nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END());

  invite = invite_sent_by_nua(nh, TAG_END());

  process_offer(invite);

  respond_with_sdp(invite, d1, SIP_200_OK, TAG_END());

  fail_unless_event(nua_r_invite, 200);
  fail_unless(s2_check_callstate(nua_callstate_ready));
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(5, s2base->root);
  respond_with_sdp(invite, d1, SIP_200_OK, TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(5, s2base->root);
  respond_with_sdp(invite, d1, SIP_200_OK, TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(20, s2base->root);
  respond_with_sdp(invite, d1, SIP_200_OK, TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  /* Stack times out the INVITE transaction */
  s2_nua_fast_forward(5, s2base->root);

  respond_with_sdp(invite, d1, SIP_200_OK,
		   SIPTAG_SUBJECT_STR("Stray 200 OK"),
		   TAG_END());
  s2_sip_free_message(invite);
  mark_point();
  fail_if(s2_sip_check_request_timeout(SIP_METHOD_ACK, 3));

  bye_by_nua(d1, nh, TAG_END());

  nua_handle_destroy(nh);
}
예제 #12
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);
}
예제 #13
0
END_TEST

START_TEST(SIP_CC_OE_CE_TI_008)
{
  nua_handle_t *nh;
  struct message *invite;

  S2_CASE("6.1.2", "SIP_CC_OE_CE_TI_008",
          "If an unreliable transport is used, ensure that "
          "the IUT, when an INVITE client transaction is in "
          "the Completed state, on receipt of final responses "
          "that matches the transaction, still answer with an "
          "ACK request until timer D set to at least 32 second expires.");

  nh = nua_handle(nua, NULL, SIPTAG_TO(s2sip->aor), TAG_END());

  invite = invite_sent_by_nua(nh, TAG_END());

  s2_sip_respond_to(invite, d1, 404, "First not found", TAG_END());
  fail_unless_event(nua_r_invite, 404);
  fail_unless(s2_check_callstate(nua_callstate_terminated));
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(5, s2base->root);

  s2_sip_respond_to(invite, d1, 404, "Not found after 5 seconds", TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(5, s2base->root);

  s2_sip_respond_to(invite, d1, 404, "Not found after 10 seconds", TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(21, s2base->root);

  s2_sip_respond_to(invite, d1, 404, "Not found after 31 seconds", TAG_END());
  fail_unless(s2_sip_check_request(SIP_METHOD_ACK));

  s2_nua_fast_forward(5, s2base->root);

  /* Wake up nua thread and let it time out INVITE transaction */
  nua_set_params(s2->nua, TAG_END());
  fail_unless_event(nua_r_set_params, 0);

  s2_sip_respond_to(invite, d1, 404, "Not found after 32 seconds", TAG_END());
  s2_sip_free_message(invite);
  fail_if(s2_sip_check_request_timeout(SIP_METHOD_ACK, 3));

  nua_handle_destroy(nh);
}
예제 #14
0
} END_TEST


START_TEST(register_1_3_2_1)
{
  nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());

  S2_CASE("1.3.2.1", "Register behind NAT",
	  "Authenticate, outbound activated");

  mark_point();
  s2->registration->nh = nh;
  make_auth_natted_register(nh, NUTAG_PROXY(s2sip->tcp.contact->m_url), TAG_END());
  fail_if(!tport_is_tcp(s2->registration->tport));
  s2_register_teardown();
}
예제 #15
0
} END_TEST


START_TEST(register_1_2_3) {
  nua_handle_t *nh;
  struct message *m;

  S2_CASE("1.2.3", "Register behind NAT",
	  "Outbound activated by error response");

  nh = nua_handle(nua, NULL, TAG_END());
  nua_register(nh, TAG_END());

  mark_point();

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m);
  fail_if(!m->sip->sip_contact || m->sip->sip_contact->m_next);

  s2_sip_respond_to(m, NULL,
		400, "Bad Contact",
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  fail_unless_event(nua_r_register, 100);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  fail_unless(s2->registration->contact != NULL);
  fail_if(s2->registration->contact->m_next != NULL);
  fail_unless_event(nua_r_register, 200);

  s2->registration->nh = nh;

  s2_register_teardown();

} END_TEST
예제 #16
0
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);
}
예제 #17
0
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);
}
예제 #18
0
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);
}
예제 #19
0
END_TEST

START_TEST(notify_6_3_2)
{
    nua_handle_t *nh;
    struct message *notify;
    sip_t *sip;

    S2_CASE("6.3.2", "NOTIFY server - automatic subscription termination",
            "NUA receives SUBSCRIBE, sends 202 and NOTIFY. "
            "The subscription terminates with timeout. ");

    nh = subscribe_to_nua("presence", SIPTAG_EXPIRES_STR("300"), TAG_END());

    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_nua_fast_forward(300, s2base->root);

    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,
                            "terminated"));
    s2_sip_respond_to(notify, dialog, SIP_200_OK, TAG_END());
    fail_unless_event(nua_r_notify, 200);

    nua_handle_destroy(nh);
}
예제 #20
0
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);
}
예제 #21
0
END_TEST

START_TEST(client_2_0_2)
{
    nta_outgoing_t *orq;
    struct message *request;
    struct event *response;

    char payload[2048];

    S2_CASE("client-2.0.2", "Send MESSAGE",
            "Basic non-INVITE transaction exceeding "
            "default path MTU (1300 bytes)");

    memset(payload, 'x', sizeof payload);
    payload[(sizeof payload) - 1] = '\0';

    orq = nta_outgoing_tcreate(s2->default_leg,
                               s2_nta_orq_callback, NULL, NULL,
                               SIP_METHOD_MESSAGE,
                               URL_STRING_MAKE("sip:test2.0.example.org"),
                               SIPTAG_FROM_STR("<sip:[email protected]>"),
                               SIPTAG_PAYLOAD_STR(payload),
                               TAG_END());
    fail_unless(orq != NULL);
    request = s2_sip_wait_for_request(SIP_METHOD_MESSAGE);
    fail_unless(request != NULL);
    fail_unless(request->sip->sip_via->v_protocol == sip_transport_tcp);

    s2_sip_respond_to(request, NULL, 200, "OK 2.0.2", TAG_END());
    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 200,
                               0);
    s2_nta_free_event(response);
    nta_outgoing_destroy(orq);
}
예제 #22
0
END_TEST

START_TEST(client_2_3_2)
{
    nta_outgoing_t *orq, *tagged, *prack;
    struct message *request, *r_prack, *r_ack;
    sip_t *sip;
    struct event *response;

    S2_CASE("client-2.3.2", "INVITE with 100rel",
            "Forked INVITE transaction with 100rel");

    orq = nta_outgoing_tcreate(leg, s2_nta_orq_callback, NULL, NULL,
                               SIP_METHOD_INVITE,
                               (url_string_t *)s2sip->udp.contact->m_url,
                               SIPTAG_SUPPORTED_STR("100rel"),
                               TAG_END());
    fail_unless(orq != NULL);

    request = s2_sip_wait_for_request(SIP_METHOD_INVITE);
    fail_unless(request != NULL);

    s2_sip_respond_to(request, dialog, SIP_183_SESSION_PROGRESS,
                      SIPTAG_RSEQ_STR("1"),
                      SIPTAG_REQUIRE_STR("100rel"),
                      TAG_END());

    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 183,
                               0);

    sip = response->sip;
    tagged = nta_outgoing_tagged(orq, s2_nta_orq_callback, NULL,
                                 sip->sip_to->a_tag, sip->sip_rseq);
    fail_unless(tagged != NULL);

    fail_unless(nta_leg_rtag(leg, sip->sip_to->a_tag) != NULL);

    prack = nta_outgoing_prack(leg, tagged, s2_nta_orq_callback, NULL,
                               NULL, sip, TAG_END());
    r_prack = s2_sip_wait_for_request(SIP_METHOD_PRACK);
    fail_unless(r_prack != NULL);
    s2_sip_respond_to(r_prack, dialog, SIP_200_OK,
                      TAG_END());
    s2_sip_free_message(r_prack);

    response = s2_nta_wait_for(wait_for_orq, prack,
                               wait_for_status, 200,
                               0);
    fail_unless(response != NULL);

    nta_outgoing_destroy(prack);

    s2_sip_respond_to(request, NULL, SIP_480_TEMPORARILY_UNAVAILABLE, TAG_END());
    s2_nta_free_event(response);
    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 480,
                               0);
    fail_unless(response != NULL);
    s2_nta_free_event(response), response = NULL;
    r_ack = s2_sip_wait_for_request(SIP_METHOD_ACK);
    s2_sip_free_message(r_ack);
    nta_outgoing_destroy(orq), orq = NULL;
    s2_sip_free_message(request);

    /* 408 is eventually received by tagged transaction */
    response = s2_nta_wait_for(wait_for_orq, tagged,
                               wait_for_status, 408,
                               0);
    fail_unless(response != NULL);
    nta_outgoing_destroy(tagged);

    s2_nta_free_event(response);
}
예제 #23
0
END_TEST

START_TEST(client_2_1_2)
{
    nta_outgoing_t *orq;
    struct message *request;
    struct event *response;
    url_t udpurl[1];

    S2_CASE("client-2.1.2", "Send MESSAGE",
            "Non-INVITE transaction to TCP-only server");

    client_setup_tcp_only_server();

    *udpurl = *s2sip->tcp.contact->m_url;
    udpurl->url_params = "transport=udp";

    /* Create DNS records for both UDP and TCP, resolver matches UDP */
    s2_dns_domain("udptcp.org", 1,
                  "s2", 1, udpurl,
                  "s2", 2, s2sip->tcp.contact->m_url,
                  NULL);

    /* Sent to tport selected by resolver */
    orq = nta_outgoing_tcreate(s2->default_leg,
                               s2_nta_orq_callback, NULL,
                               URL_STRING_MAKE("sip:udptcp.org"),
                               SIP_METHOD_MESSAGE,
                               URL_STRING_MAKE("sip:test2.0.example.org"),
                               SIPTAG_FROM_STR("<sip:[email protected]>"),
                               TAG_END());
    fail_unless(orq != NULL);
    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 503,
                               0);
    s2_nta_free_event(response);
    nta_outgoing_destroy(orq);

    /* Message size exceeds 1300, tries to use TCP even if NAPTR points to UDP */
    orq = nta_outgoing_tcreate(s2->default_leg,
                               s2_nta_orq_callback, NULL,
                               URL_STRING_MAKE("sip:udptcp.org"),
                               SIP_METHOD_MESSAGE,
                               URL_STRING_MAKE("sip:test2.0.example.org"),
                               SIPTAG_FROM_STR("<sip:[email protected]>"),
#define ROW "012345678901234567890123456789012345678901234\n"
                               SIPTAG_PAYLOAD_STR( /* > 1300 bytes */
                                   "0000 " ROW "0050 " ROW
                                   "0100 " ROW "0150 " ROW
                                   "0200 " ROW "0250 " ROW
                                   "0300 " ROW "0350 " ROW
                                   "0400 " ROW "0450 " ROW
                                   "0500 " ROW "0550 " ROW
                                   "0600 " ROW "0650 " ROW
                                   "0700 " ROW "0750 " ROW
                                   "0800 " ROW "0850 " ROW
                                   "0900 " ROW "0950 " ROW
                                   "1000 " ROW "1050 " ROW
                                   "1100 " ROW "1150 " ROW
                                   "1200 " ROW "1250 " ROW
                               ),
#undef ROW
                               TAG_END());
    fail_unless(orq != NULL);
    request = s2_sip_wait_for_request(SIP_METHOD_MESSAGE);
    fail_unless(request != NULL);
    fail_unless(request->sip->sip_via->v_protocol == sip_transport_tcp);
    s2_sip_respond_to(request, NULL, 200, "2.1.2", TAG_END());
    s2_sip_free_message(request);
    response = s2_nta_wait_for(wait_for_orq, orq,
                               wait_for_status, 200,
                               0);
    s2_nta_free_event(response);
    nta_outgoing_destroy(orq);
}
예제 #24
0
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();

}
예제 #25
0
END_TEST
#endif

START_TEST(register_1_3_3_2)
{
  nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());
  struct message *m;
  tport_t *tcp;
  int i;

  S2_CASE("1.3.3.2", "Register behind NAT with TCP",
	  "Register w/ TCP using rport, pingpong. ");

  nua_set_params(nua, NTATAG_TCP_RPORT(1), TAG_END());
  fail_unless_event(nua_r_set_params, 200);

  mark_point();
  s2->registration->nh = nh;

  nua_register(nh,
	       NUTAG_PROXY(s2sip->tcp.contact->m_url),
	       NUTAG_OUTBOUND("no-options-keepalive, no-validate"),
	       TAG_END());

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER); fail_if(!m);

  fail_unless(tport_is_tcp(m->tport));

  tcp = tport_ref(m->tport);

  /* Respond to request over TCP */
  s2_sip_respond_to(m, NULL,
		SIP_401_UNAUTHORIZED,
		SIPTAG_WWW_AUTHENTICATE_STR(s2_auth_digest_str),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);
  fail_unless_event(nua_r_register, 401);
  nua_authenticate(nh, NUTAG_AUTH(s2_auth_credentials), TAG_END());

  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_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		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);

  /* Turn off pong */
  tport_set_params(tcp, TPTAG_PONG2PING(0), TAG_END());

  /* Wait until ping-pong failure closes the TCP connection */
  for (i = 0; i < 100; i++) {
    s2_nua_fast_forward(5, s2base->root);
    if (tport_is_closed(tcp))
      break;
  }

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_unless(tport_is_tcp(m->tport));
  fail_unless(tcp != m->tport);
  fail_if(!m); 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),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  tport_unref(tcp);

  /* Contact changed */
  fail_unless_event(nua_r_register, 100);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  fail_if(!m->sip->sip_contact);
  fail_if(!m->sip->sip_contact->m_next);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  fail_unless_event(nua_r_register, 200);

  s2_register_teardown();
}
예제 #26
0
END_TEST

#if nomore
START_TEST(register_1_3_3_1)
{
  nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());
  struct message *m;
  tport_t *tcp;

  S2_CASE("1.3.3.1", "Register behind NAT with UDP and TCP",
	  "Register with UDP, UDP time-outing, then w/ TCP using rport. ");

  nua_set_params(nua, NTATAG_TCP_RPORT(1), TAG_END());
  fail_unless_event(nua_r_set_params, 200);

  mark_point();
  s2->registration->nh = nh;

  nua_register(nh,
	       NUTAG_OUTBOUND("no-options-keepalive, no-validate"),
	       TAG_END());

  /* NTA tries with UDP, we drop them */
  for (;;) {
    m = s2_sip_wait_for_request(SIP_METHOD_REGISTER); fail_if(!m);
    if (!tport_is_udp(m->tport)) /* Drop UDP */
      break;
    s2_sip_free_message(m);
    s2_nua_fast_forward(4, s2base->root);
  }

  tcp = tport_ref(m->tport);

  /* Respond to request over TCP */
  s2_sip_respond_to(m, NULL,
		SIP_401_UNAUTHORIZED,
		SIPTAG_WWW_AUTHENTICATE_STR(s2_auth_digest_str),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);
  fail_unless_event(nua_r_register, 401);
  nua_authenticate(nh, NUTAG_AUTH(s2_auth_credentials), TAG_END());

  /* Turn off pong */
  tport_set_params(tcp, TPTAG_PONG2PING(0), TAG_END());

  /* Now request over UDP ... registering TCP contact! */
  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  s2_save_register(m);
  fail_unless(
    url_has_param(s2->registration->contact->m_url, "transport=tcp"));
  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  /* NUA detects oops... re-registers UDP */
  fail_unless_event(nua_r_register, 100);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  fail_if(!m->sip->sip_contact || !m->sip->sip_contact->m_next);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted)),
		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);

  /* Wait until ping-pong failure closes the TCP connection */
  {
    int i;
    for (i = 0; i < 5; i++) {
      su_root_step(s2base->root, 5);
      su_root_step(s2base->root, 5);
      su_root_step(s2base->root, 5);
      s2_nua_fast_forward(5, s2base->root);
    }
  }

  s2_register_teardown();
}
예제 #27
0
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);
}
예제 #28
0
END_TEST

START_TEST(register_1_2_2_2)
{
  nua_handle_t *nh = nua_handle(nua, NULL, TAG_END());
  struct message *m;

  S2_CASE("1.2.2.2", "Register behind NAT",
	  "Authenticate, outbound activated, "
	  "authenticate OPTIONS probe, "
	  "NAT binding change");

  mark_point();
  make_auth_natted_register(nh, TAG_END());
  s2->registration->nh = nh;

  mark_point();

  m = s2_sip_wait_for_request(SIP_METHOD_OPTIONS);
  fail_if(!m);
  s2_sip_respond_to(m, NULL,
		SIP_407_PROXY_AUTH_REQUIRED,
		SIPTAG_VIA(natted_via(m, receive_natted)),
		SIPTAG_PROXY_AUTHENTICATE_STR(s2_auth_digest_str),
		TAG_END());
  s2_sip_free_message(m);
  mark_point();

  m = s2_sip_wait_for_request(SIP_METHOD_OPTIONS);
  fail_if(!m); fail_if(!m->sip->sip_proxy_authorization);
  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  su_root_step(s2base->root, 20); su_root_step(s2base->root, 20);
  s2_nua_fast_forward(120, s2base->root);	  /* Default keepalive interval */
  mark_point();

  m = s2_sip_wait_for_request(SIP_METHOD_OPTIONS);
  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_VIA(natted_via(m, receive_natted)),
		TAG_END());
  s2_sip_free_message(m);

  su_root_step(s2base->root, 20); su_root_step(s2base->root, 20);
  s2_nua_fast_forward(120, s2base->root);	  /* Default keepalive interval */
  mark_point();

  m = s2_sip_wait_for_request(SIP_METHOD_OPTIONS);
  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_VIA(natted_via(m, receive_natted2)),
		TAG_END());
  s2_sip_free_message(m);

  fail_unless_event(nua_i_outbound, 0);

  m = s2_sip_wait_for_request(SIP_METHOD_REGISTER);
  fail_if(!m); fail_if(!m->sip->sip_authorization);
  fail_if(!m->sip->sip_contact || !m->sip->sip_contact->m_next);
  s2_save_register(m);

  s2_sip_respond_to(m, NULL,
		SIP_200_OK,
		SIPTAG_CONTACT(s2->registration->contact),
		SIPTAG_VIA(natted_via(m, receive_natted2)),
		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_register_teardown();

} END_TEST
예제 #29
0
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());
}