test_nta.c

Sofia SIP is an open-source SIP User-Agent library, compliant with the IETF RFC3261 specification.

  agent_t *ag = c->c_ag;

  for (ag->ag_acked = 0; !ag->ag_acked;) {
    if (tstflags & tst_verbatim) {
      fputs(".", stdout); fflush(stdout);
    }
    su_root_step(ag->ag_root, 500L);
  }
}

static 
int client_run_until_acked(client_t *c, int expected)
{
  return client_run_with(c, expected, until_server_acked);
}

void 
until_server_canceled(client_t *c)
{
  agent_t *ag = c->c_ag;

  for (ag->ag_canceled = 0; !ag->ag_canceled;) {
    if (tstflags & tst_verbatim) {
      fputs(".", stdout); fflush(stdout);
    }
    su_root_step(ag->ag_root, 500L);
  }
}

static 
int client_run_until_canceled(client_t *c, int expected)
{
  return client_run_with(c, expected, until_server_canceled);
}


#include <sofia-sip/msg_mclass.h>

int test_init(agent_t *ag, char const *resolv_conf)
{
  char const *contact = "sip:*:*;comp=sigcomp";
  su_sockaddr_t su;
  socklen_t sulen, sulen0;
  su_socket_t s; 
  int af, err = -1;

  BEGIN();

  ag->ag_root = su_root_create(ag);
  TEST_1(ag->ag_root);

  ag->ag_mclass = msg_mclass_clone(sip_default_mclass(), 0, 0);
  TEST_1(ag->ag_mclass);

#if SU_HAVE_IN6
  if (str0cmp(getenv("ipv6"), "true") == 0) {
    contact = "sip:[::]:*;comp=sigcomp";
    af = AF_INET6, sulen0 = sizeof (struct sockaddr_in6);
  }
  else {
    af = AF_INET, sulen0 = sizeof (struct sockaddr_in);
    contact = "sip:0.0.0.0:*;comp=sigcomp";
  }
#else
  af = AF_INET, sulen0 = sizeof (struct sockaddr_in);
  contact = "sip:0.0.0.0:*;comp=sigcomp";
#endif

  if (ag->ag_m)
    contact = ag->ag_m;
  else if (getenv("SIPCONTACT"))
    contact = getenv("SIPCONTACT");

  /* Sink server */
  s = su_socket(af, SOCK_DGRAM, 0); TEST_1(s != INVALID_SOCKET);
  memset(&su, 0, sulen = sulen0);
  su.su_family = af;
  if (getenv("sink")) {
    su.su_port = htons(atoi(getenv("sink")));
  }
  TEST_1(bind(s, &su.su_sa, sulen) < 0 ? (perror("bind"), 0) : 1);
  TEST_1(getsockname(s, &su.su_sa, &sulen) == 0);

  ag->ag_sink_socket = s;
  su_wait_init(ag->ag_sink_wait);
  su_wait_create(ag->ag_sink_wait, ag->ag_sink_socket, SU_WAIT_IN);

  ag->ag_sink_port = su_sprintf(ag->ag_home, "%u", ntohs(su.su_sin.sin_port));

  /* Down server */
  s = su_socket(af, SOCK_STREAM, 0); TEST_1(s != INVALID_SOCKET);
  memset(&su, 0, sulen = sulen0);
  su.su_family = af;
  if (getenv("down")) {
    su.su_port = htons(atoi(getenv("down")));
  }
  TEST_1(bind(s, &su.su_sa, sulen) < 0 ? (perror("bind"), 0) : 1);
  ag->ag_down_socket = s;
  
  /* Create agent */
  ag->ag_agent = nta_agent_create(ag->ag_root,
				  (url_string_t *)contact,
				  NULL,
				  NULL,
				  NTATAG_MCLASS(ag->ag_mclass),
				  NTATAG_USE_TIMESTAMP(1),
				  SRESTAG_RESOLV_CONF(resolv_conf),
				  NTATAG_USE_NAPTR(0),
				  NTATAG_USE_SRV(0),
				  NTATAG_PRELOAD(2048),
				  TAG_END());
  TEST_1(ag->ag_agent);

  {
    /* Initialize our headers */
    sip_from_t from[1];
    sip_to_t to[1];
    sip_contact_t m[1];

    su_sockaddr_t *su = ag->ag_su_nta;

    sip_from_init(from);
    sip_to_init(to);
    sip_contact_init(m);


    TEST_1(ag->ag_contact = nta_agent_contact(ag->ag_agent));

    *m->m_url = *ag->ag_contact->m_url;

    if (host_is_ip4_address(m->m_url->url_host)) {
      su_inet_pton(su->su_family = AF_INET,
		   m->m_url->url_host,
		   &su->su_sin.sin_addr);
      ag->ag_su_nta_len = (sizeof su->su_sin);
    }
    else {
      TEST_1(host_is_ip_address(m->m_url->url_host));
      su_inet_pton(su->su_family = AF_INET6,
		   m->m_url->url_host,
		   &su->su_sin6.sin6_addr);
      ag->ag_su_nta_len = (sizeof su->su_sin6);
    }

    su->su_port = htons(5060);
    if (m->m_url->url_port && strlen(m->m_url->url_port)) {
      unsigned long port = strtoul(m->m_url->url_port, NULL, 10);
      su->su_port = htons(port);
    }
    TEST_1(su->su_port != 0);

    m->m_url->url_user = "bob";
    TEST_1(ag->ag_m_bob = sip_contact_dup(ag->ag_home, m));

    to->a_display = "Bob";
    *to->a_url = *ag->ag_contact->m_url;
    to->a_url->url_user = "bob";
    to->a_url->url_port = NULL;
    TEST_1(ag->ag_bob = sip_to_dup(ag->ag_home, to));

    *m->m_url = *ag->ag_contact->m_url;
    m->m_url->url_user = "alice";
    TEST_1(ag->ag_m_alice = sip_contact_dup(ag->ag_home, m));

    from->a_display = "Alice";
    *from->a_url = *ag->ag_contact->m_url;
    from->a_url->url_user = "alice";
    from->a_url->url_port = NULL;
    TEST_1(ag->ag_alice = sip_from_dup(ag->ag_home, from));
  }
  {
    char const data[] = 
      "v=0\r\n"
      "o=- 425432 423412 IN IP4 127.0.0.1\r\n"
      "s= \r\n"
      "c=IN IP4 127.0.0.1\r\n"
      "m=5004 audio 8 0\r\n";

    ag->ag_content_type = sip_content_type_make(ag->ag_home, "application/sdp");
    ag->ag_payload = sip_payload_make(ag->ag_home, data);
  }

  {
    sip_contact_t *m;

    ag->ag_aliases = 
      sip_contact_make(ag->ag_home, "sip:127.0.0.1, sip:localhost, sip:[::1]");
    TEST_1(ag->ag_aliases);
    TEST_1(ag->ag_aliases->m_next);
    TEST_1(ag->ag_aliases->m_next->m_next);
    TEST_P(ag->ag_aliases->m_next->m_next->m_next, NULL);

    for (m = ag->ag_aliases; m; m = m->m_next)
      m->m_url->url_port = ag->ag_contact->m_url->url_port;

    TEST_1(m = sip_contact_dup(ag->ag_home, ag->ag_contact));

    m->m_next = ag->ag_aliases;
    ag->ag_aliases = m;

    err = nta_agent_set_params(ag->ag_agent, 
			       NTATAG_ALIASES(ag->ag_aliases),
			       NTATAG_REL100(1),
			       NTATAG_UA(1), 
			       NTATAG_MERGE_482(1), 
			       NTATAG_USE_NAPTR(1),
			       NTATAG_USE_SRV(1),
			       NTATAG_MAX_FORWARDS(20),
			       TAG_END());
    TEST(err, 7);

    err = nta_agent_set_params(ag->ag_agent, 
			       NTATAG_ALIASES(ag->ag_aliases),
			       NTATAG_DEFAULT_PROXY("sip:127.0.0.1"),
			       TAG_END());
    TEST(err, 2);

    err = nta_agent_set_params(ag->ag_agent, 
			       NTATAG_ALIASES(ag->ag_aliases),
			       NTATAG_DEFAULT_PROXY(NULL),
			       TAG_END());
    TEST(err, 2);

    err = nta_agent_set_params(ag->ag_agent, 
			       NTATAG_DEFAULT_PROXY("tel:[phone]"),
			       TAG_END());
    TEST(err, -1);

  }
  
  {
    url_t url[1];

    /* Create the server leg */
    *url = *ag->ag_aliases->m_url;
    url->url_user = "%";
    ag->ag_server_leg = nta_leg_tcreate(ag->ag_agent, 
					leg_callback_200,
					ag,
					NTATAG_NO_DIALOG(1),
					URLTAG_URL(url),
					TAG_END());
    TEST_1(ag->ag_server_leg);
  }

  END();
}  

int test_reinit(agent_t *ag)
{
  BEGIN();
  /* Create a new default leg */
  nta_leg_destroy(ag->ag_default_leg), ag->ag_default_leg = NULL;
  TEST_1(ag->ag_default_leg = nta_leg_tcreate(ag->ag_agent, 
					      leg_callback_200,
					      ag,
					      NTATAG_NO_DIALOG(1),
					      TAG_END()));
  END();
}

int test_deinit(agent_t *ag)
{
  BEGIN();

  if (ag->ag_request) msg_destroy(ag->ag_request), ag->ag_request = NULL;

  su_free(ag->ag_home, ag->ag_in_via), ag->ag_in_via = NULL;

  nta_leg_destroy(ag->ag_alice_leg);
  nta_leg_destroy(ag->ag_bob_leg);
  nta_leg_destroy(ag->ag_default_leg);
  nta_leg_destroy(ag->ag_server_leg);

  nta_agent_destroy(ag->ag_agent);
  su_root_destroy(ag->ag_root);

  if (ag->ag_sink_port) {
    su_free(ag->ag_home, (void *)ag->ag_sink_port), ag->ag_sink_port = NULL;
    su_wait_destroy(ag->ag_sink_wait);
    su_close(ag->ag_sink_socket);
  }

  free(ag->ag_mclass), ag->ag_mclass = NULL;

  END();
}  

static
int readfile(FILE *f, void **contents)
{
  /* Read in whole (binary!) file */
  char *buffer = NULL;
  long size;
  size_t len;
  
  /* Read whole file in */
  if (fseek(f, 0, SEEK_END) < 0 ||
      (size = ftell(f)) < 0 ||
      fseek(f, 0, SEEK_SET) < 0 ||
      (long)(len = (size_t)size) != size) {
    fprintf(stderr, "%s: unable to determine file size (%s)\n", 
	    __func__, strerror(errno));
    return -1;
  }

  if (!(buffer = malloc(len + 2)) ||
      fread(buffer, 1, len, f) != len) {
    fprintf(stderr, "%s: unable to read file (%s)\n", __func__, strerror(errno));
    if (buffer)
      free(buffer);
    return -1;
  }

  buffer[len] = '\0';

  *contents = buffer;

  return (int)len;
}

#if HAVE_DIRENT_H
#include <dirent.h>
#endif 

static int test_bad_messages(agent_t *ag)
{
  BEGIN();

#if HAVE_DIRENT_H
  DIR *dir;
  struct dirent *d;
  char name[PATH_MAX + 1] = "../sip/tests/";
  size_t offset;
  char const *host, *port;
  su_addrinfo_t *ai,  hints[1];
  su_socket_t s;
  su_sockaddr_t su[1];
  socklen_t sulen;
  char via[64];
  size_t vlen;
  int i;

  dir = opendir(name);
  if (dir == NULL && getenv("srcdir")) {
    strncpy(name, getenv("srcdir"), PATH_MAX);
    strncat(name, "/../sip/tests/", PATH_MAX);
    dir = opendir(name);
  }

  if (dir == NULL) {
    fprintf(stderr, "test_nta: cannot find sip torture messages\n"); 
    fprintf(stderr, "test_nta: tried %s\n", name); 
  }

  offset = strlen(name);

  TEST_1(ag->ag_default_leg = nta_leg_tcreate(ag->ag_agent, 
					      leg_callback_500,
					      ag,
					      NTATAG_NO_DIALOG(1),
					      TAG_END()));

  host = ag->ag_contact->m_url->url_host;
  if (host_is_ip6_reference(host)) {
    host = strcpy(via, host + 1);
    via[strlen(via) - 1] = '\0';
  }
  port = url_port(ag->ag_contact->m_url);

  memset(hints, 0, sizeof hints);
  hints->ai_socktype = SOCK_DGRAM;
  hints->ai_protocol = IPPROTO_UDP;
  
  TEST(su_getaddrinfo(host, port, hints, &ai), 0); TEST_1(ai);
  s = su_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); TEST_1(s != -1);
  memset(su, 0, sulen = ai->ai_addrlen); 
  su->su_len = sizeof su; su->su_family = ai->ai_family;
  TEST_1(bind(s, &su->su_sa, sulen) == 0);
  TEST_1(getsockname(s, &su->su_sa, &sulen) == 0);
  sprintf(via, "v: SIP/2.0/UDP is.invalid:%u\r\n", ntohs(su->su_port));
  vlen = strlen(via);

  for (d = dir ? readdir(dir) : NULL; d; d = readdir(dir)) {
    size_t len = strlen(d->d_name);
    FILE *f;
    int blen, n;
    void *buffer; char *r;

    if (len < strlen(".txt"))
      continue;
    if (strcmp(d->d_name + len - strlen(".txt"), ".txt"))
      continue;
    strncpy(name + offset, d->d_name, PATH_MAX - offset);
    TEST_1(f = fopen(name, "rb"));
    TEST_1((blen = readfile(f, &buffer)) > 0);
    fclose(f);
    r = buffer;

    if (strncmp(r, "JUNK ", 5) == 0) {
      TEST_SIZE(su_sendto(s, r, blen, 0, ai->ai_addr, ai->ai_addrlen), blen);
    }
    else if (strncmp(r, "INVITE ", 7) != 0) {
      su_iovec_t vec[3];
      n = strcspn(r, "\r\n"); n += strspn(r + n, "\r\n");
      vec[0].siv_base = r, vec[0].siv_len = n;
      vec[1].siv_base = via, vec[1].siv_len = vlen;
      vec[2].siv_base = r + n, vec[2].siv_len = blen - n;
      TEST_SIZE(su_vsend(s, vec, 3, 0, (void *)ai->ai_addr, ai->ai_addrlen),
		blen + vlen);
    }
    free(buffer);
    su_root_step(ag->ag_root, 1);
  }

  TEST_SIZE(su_sendto(s, "\r\n\r\n", 4, 0, (void *)ai->ai_addr, ai->ai_addrlen), 4);

  su_root_step(ag->ag_root, 1);

  TEST_SIZE(su_sendto(s, "", 0, 0, ai->ai_addr, ai->ai_addrlen), 0);

  su_close(s);

  for (i = 0; i < 20; i++)
    su_root_step(ag->ag_root, 1);

  nta_leg_destroy(ag->ag_default_leg), ag->ag_default_leg = NULL;

  if (dir)
    closedir(dir);

#endif /* HAVE_DIRENT_H */

  END();
}

static unsigned char const code[] = 
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

#include <sofia-sip/su_uniqueid.h>

sip_payload_t *test_payload(su_home_t *home, size_t size)
{
  sip_payload_t *pl = sip_payload_create(home, NULL, (isize_t)size);

  if (pl) {
    size_t i;
    char *data = (char *)pl->pl_data;
    
    for (i = 0; i < size; i++) {
      if ((i & 63) != 63)
	data[i] = code[su_randint(0, 63)];
      else
	data[i] = '\n';
    }
  }

  return pl;
}

static 
int client_check_to_tag(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)
{
  if (sip) 
    TEST_1(sip->sip_to && sip->sip_to->a_tag);
  return 0;
}

static 
int check_magic_branch(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)
{
  if (sip) {
    TEST_1(sip->sip_via);
    TEST_S(sip->sip_via->v_branch, "MagicalBranch");
  }
  return 0;
}

static
int check_via_with_sigcomp(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)
{
  if (sip && sip->sip_via) {
    TEST_S(sip->sip_via->v_comp, "sigcomp");
  }
  return 0;
}

static
int check_via_without_sigcomp(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)
{
  if (sip && sip->sip_via) {
    TEST_1(sip->sip_via->v_comp == NULL);
  }
  return 0;
}

static
int check_via_with_tcp(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)
{
  if (sip && sip->sip_via) {
    TEST_S(sip->sip_via->v_protocol, "SIP/2.0/TCP");
  }
  return 0;
}

static
int check_via_with_sctp(client_t *ctx, nta_outgoing_t *orq, sip_t const *sip)