nua_register.c

this is simple sip stack.

    if (pair)
      /* Don't use protocol if we have both udp and tcp */
      protocol = NULL /*, v2[0].v_next = &v2[1], v2[1] = *pair */;
    else
      protocol = via->v_protocol /*, v2[0].v_next = NULL */;

    contact = sip_contact_create_from_via_with_transport(home, v, NULL, protocol);
    /* v = sip_via_dup(home, v2); */

    if (!contact) {
      su_free(home, nr);
      break;
    }

    nr->nr_ready = 1, nr->nr_default = 1, nr->nr_public = public;
    nr->nr_secure = contact->m_url->url_type == url_sips;
    nr->nr_contact = contact;
    /* nr->nr_via = v; */

    SU_DEBUG_9(("nua_register: Adding contact URL '%s' to list.\n", contact->m_url->url_host));

    ++nr_items;
    nr->nr_next = *next, nr->nr_prev = next; *next = nr, next = &nr->nr_next;
    nr->nr_list = list;
  }

  su_home_deinit(autohome);

  return 0;
}

static
void nua_stack_tport_update(nua_t *nua, nta_agent_t *nta)
{
#if 0
  nua_registration_t *default_oc;
  nua_registration_t const *defaults = nua->nua_registrations;
  sip_via_t *via = nta_agent_via(nta);

  default_oc = outbound_by_aor(defaults, NULL, 1);

  if (default_oc) {
    assert(default_oc->nr_via);

    outbound_contacts_from_via(default_oc,
				       via,
				       via->v_next);

    /* refresh_register(nua_handle_t *nh, nua_dialog_usage_t *du, sip_time_t now); */
  }
#endif
  return;
}

nua_registration_t *nua_registration_by_aor(nua_registration_t const *list,
					    sip_from_t const *aor,
					    url_t const *remote_uri,
					    int only_default)
{
  sip_from_t *alt_aor = NULL, _alt_aor[1];
  int sips_aor = aor && aor->a_url->url_type == url_sips;
  int sips_uri = remote_uri && remote_uri->url_type == url_sips;

  nua_registration_t const *nr, *public = NULL, *any = NULL;
  nua_registration_t const *namewise = NULL, *sipswise = NULL;

  if (only_default || aor == NULL) {
    /* Ignore AoR, select only by remote_uri */
    for (nr = list; nr; nr = nr->nr_next) {
      if (!nr->nr_ready)
	continue;
      if (only_default && !nr->nr_default)
	continue;
      if (sips_uri ? nr->nr_secure : !nr->nr_secure) 
	return (nua_registration_t *)nr;
      if (!public && nr->nr_public)
	public = nr;
      if (!any)
	any = nr;
    }
    if (public)
      return (nua_registration_t *)public;
    if (any)
      return (nua_registration_t *)any;
    return NULL;
  }

  if (!sips_aor && aor)
    alt_aor = memcpy(_alt_aor, aor, sizeof _alt_aor);

  for (nr = list; nr; nr = nr->nr_next) {
    if (!nr->nr_ready)
      continue;
    if (nr->nr_aor) {
      if (aor && url_cmp(nr->nr_aor->a_url, aor->a_url) == 0)
	return (nua_registration_t *)nr;
      if (!namewise && alt_aor && url_cmp(nr->nr_aor->a_url, aor->a_url) == 0)
	namewise = nr;
    }
    if (!sipswise && (sips_aor || sips_uri) ? nr->nr_secure : !nr->nr_secure) 
      sipswise = nr;
    if (!public && nr->nr_public)
      public = nr;
    if (!any)
      any = nr;
  }

  if (namewise)
    return (nua_registration_t *)namewise;
  if (sipswise)
    return (nua_registration_t *)sipswise;

  /* XXX - 
     should we do some policing whether sips_aor or sips_uri can be used
     with sip contact?
  */
  if (public)
    return (nua_registration_t *)public;
  if (any)
    return (nua_registration_t *)any;

  return NULL;
}


nua_registration_t *
nua_registration_for_msg(nua_registration_t const *list, sip_t const *sip)
{
  sip_from_t const *aor;
  url_t *uri;

  if (sip == NULL)
    return NULL;

  if (sip->sip_request) {
    aor = sip->sip_from;
    uri = sip->sip_request->rq_url;
  }
  else {
    /* This is much hairier! */
    aor = sip->sip_to;
    if (sip->sip_record_route)
      uri = sip->sip_record_route->r_url;
    else if (sip->sip_contact)
      uri = sip->sip_contact->m_url;
    else
      uri = sip->sip_from->a_url;
    assert(uri != ((sip_contact_t *)NULL)->m_url);
  }

  return nua_registration_by_aor(list, aor, uri, 0);
}

/** Return Contact usable in dialogs */
sip_contact_t const *nua_registration_contact(nua_registration_t const *nr)
{
  if (nr->nr_by_stack && nr->nr_ob) {
    sip_contact_t const *m = outbound_dialog_contact(nr->nr_ob);
    if (m)
      return m;
  }

  return nr->nr_contact;
}

/** Return initial route. */
sip_route_t const *nua_registration_route(nua_registration_t const *nr)
{
  return nr ? nr->nr_route : NULL;
}

sip_contact_t const *nua_stack_get_contact(nua_registration_t const *nr)
{
  nr = nua_registration_by_aor(nr, NULL, NULL, 1);
  return nr ? nr->nr_contact : NULL;
}

/** Add a Contact (and Route) header to request (or response) */
int nua_registration_add_contact(nua_handle_t *nh,
				 msg_t *msg,
				 sip_t *sip,
				 int add_contact,
				 int add_service_route)
{
  nua_registration_t *nr = NULL;

  if (!add_contact && !add_service_route)
    return 0;

  if (nh == NULL || msg == NULL)
    return -1;

  if (sip == NULL)
    sip = sip_object(msg);

  if (nr == NULL)
    nr = nua_registration_for_msg(nh->nh_nua->nua_registrations, sip);

  if (nr == NULL)
    return -1;

  if (add_contact) {
    sip_contact_t const *m = nua_registration_contact(nr);
    if (!m || msg_header_add_dup(msg, (msg_pub_t *)sip, (void const *)m) < 0)
      return -1;
  }

  if (add_service_route && !sip->sip_status) {
    sip_route_t const *sr = nua_registration_route(nr);
    if (msg_header_add_dup(msg, (msg_pub_t *)sip, (void const *)sr) < 0)
      return -1;
  }

  return 0;
}



/** Add a registration to list of contacts */
int nua_registration_add(nua_registration_t **list,
			 nua_registration_t *nr)
{
  assert(list && nr);

  if (nr->nr_list == NULL) {
    nua_registration_t *next = *list;
    if (next)
      next->nr_prev = &nr->nr_next;
    nr->nr_next = next, nr->nr_prev = list, nr->nr_list = list;
    *list = nr;
  }

  return 0;
}

/** Remove from list of registrations */
void nua_registration_remove(nua_registration_t *nr)
{
  if ((*nr->nr_prev = nr->nr_next))
    nr->nr_next->nr_prev = nr->nr_prev;
  nr->nr_next = NULL, nr->nr_prev = NULL, nr->nr_list = NULL;
}

/** Set address-of-record. */
int nua_registration_set_aor(su_home_t *home,
			     nua_registration_t *nr,
			     sip_from_t const *aor)
{
  sip_from_t *new_aor, *old_aor;

  if (!home || !nr || !aor)
    return -1;

  new_aor = sip_from_dup(home, aor);
  if (!new_aor)
    return -1;

  old_aor = nr->nr_aor;
  nr->nr_aor = new_aor;
  msg_header_free(home, (void *)old_aor);

  return 0;
}

/** Set contact. */
int nua_registration_set_contact(su_home_t *home,
				 nua_registration_t *nr,
				 sip_contact_t const *application_contact,
				 int terminating)
{
  sip_contact_t *m = NULL, *previous;
  url_t *uri;

  if (!home || !nr)
    return -1;

  uri = nr->nr_aor ? nr->nr_aor->a_url : NULL;
    
  previous = nr->nr_contact;

  if (application_contact) {
    m = sip_contact_dup(home, application_contact);
  }
  else if (terminating && nr->nr_contact) {
    return 0;
  }
  else {
    nua_registration_t *nr0;
    
    nr0 = nua_registration_by_aor(*nr->nr_list, NULL, uri, 1);

    if (nr0)
      m = sip_contact_dup(home, nr0->nr_contact);
  }

  if (!m)
    return -1;

  nr->nr_contact = m;
  nr->nr_by_stack = !application_contact;

  msg_header_free(home, (void *)previous);

  return 0;
}

/** Mark registration as ready */
void nua_registration_set_ready(nua_registration_t *nr, int ready)
{
  nr->nr_ready = ready;
}

/** @internal Hook for processing incoming request by registration.
 *
 * This is used for keepalive/validate OPTIONS.
 */
int nua_registration_process_request(nua_registration_t *list,
				     nta_incoming_t *irq,
				     sip_t const *sip)
{
  sip_call_id_t *i;
  nua_registration_t *nr;

  if (!outbound_targeted_request(sip))
    return 0;

  /* Process by outbound... */
  i = sip->sip_call_id;

  for (nr = list; nr; nr = nr->nr_next) {
    outbound_t *ob = nr->nr_ob;
    if (ob)
      if (outbound_process_request(ob, irq, sip))
	return 501;		/* Just in case  */
  }

  return 481;			/* Call/Transaction does not exist */
}

/**@internal
 * Fix contacts for un-REGISTER.
 *
 * Remove (possible non-zero) "expires" parameters from contacts and extra
 * contacts, add Expire: 0.
 */
static
void unregister_expires_contacts(msg_t *msg, sip_t *sip)
{
  sip_contact_t *m;
  int unregister_all;

  if (msg == NULL || sip == NULL)
    return;

  /* Remove payload */
  while (sip->sip_payload)
    sip_header_remove(msg, sip, (sip_header_t *)sip->sip_payload);
  while (sip->sip_content_type)
    sip_header_remove(msg, sip, (sip_header_t *)sip->sip_content_type);

  for (m = sip->sip_contact; m; m = m->m_next) {
    if (m->m_url->url_type == url_any)
      break;
    msg_header_remove_param(m->m_common, "expires");
#if 0
    msg_header_add_param(msg_home(msg), m->m_common, "expires=0");
#endif
  }

  unregister_all = m && (m != sip->sip_contact || m->m_next);

  sip_add_tl(msg, sip,
             /* Remove existing contacts */
             TAG_IF(unregister_all, SIPTAG_CONTACT(NONE)),
             /* Add '*' contact: 0 */
             TAG_IF(unregister_all, SIPTAG_CONTACT_STR("*")),
             SIPTAG_EXPIRES_STR("0"),
             TAG_END());
}


/** Outbound requests us to refres registration */
static int nua_stack_outbound_refresh(nua_handle_t *nh,
				      outbound_t *ob)
{
  nua_dialog_usage_t *du = nua_dialog_usage_get(nh->nh_ds, nua_register_usage, NULL);
  if (du)
    nua_dialog_usage_refresh(nh, du, 1);
  return 0;
}


/** @internal Callback from outbound_t */
static int nua_stack_outbound_status(nua_handle_t *nh, outbound_t *ob,
				     int status, char const *phrase,
				     tag_type_t tag, tag_value_t value, ...)
{
  ta_list ta;

  ta_start(ta, tag, value);

  nua_stack_event(nh->nh_nua, nh, NULL,
		  nua_i_outbound, status, phrase,
		  ta_tags(ta));

  ta_end(ta);

  return 0;
}

/** @internal Callback from outbound_t */
static int nua_stack_outbound_failed(nua_handle_t *nh, outbound_t *ob,
				     int status, char const *phrase,
				     tag_type_t tag, tag_value_t value, ...)
{
  ta_list ta;
  ta_start(ta, tag, value);

  nua_stack_event(nh->nh_nua, nh, NULL,
		  nua_i_outbound, status, phrase,
		  ta_tags(ta));

  ta_end(ta);

  return 0;
}

/** @internal Callback for obtaining credentials for keepalive */
static int nua_stack_outbound_credentials(nua_handle_t *nh, 
					  auth_client_t **auc)
{
  return auc_copy_credentials(auc, nh->nh_auth);
}

/** @internal Return a string describing our features. */
static char *nua_handle_features(nua_handle_t *nh)
{
  char *retval = NULL;
  su_strlst_t *l = su_strlst_create(NULL);
  su_home_t *home = su_strlst_home(l);

  if (!l)
    return NULL;

  if (NH_PGET(nh, callee_caps)) {
    sip_allow_t const *allow = NH_PGET(nh, allow);

    if (allow) {
      /* Skip ";" if this is first one */
      su_strlst_append(l, ";methods=\"" + (su_strlst_len(l) == 0));
      if (allow->k_items) {
        int i;
        for (i = 0; allow->k_items[i]; i++) {
          su_strlst_append(l, allow->k_items[i]);
          if (allow->k_items[i + 1])
            su_strlst_append(l, ",");
        }
      }
      su_strlst_append(l, "\"");
    }

    if (nh->nh_soa) {
      char **media = soa_media_features(nh->nh_soa, 0, home);

      while (*media) {
        if (su_strlst_len(l))
          su_strlst_append(l, ";");
        su_strlst_append(l, *media++);
      }
    }
  }

  if (su_strlst_len(l))
    retval = su_strlst_join(l, nh->nh_home, "");

  su_strlst_destroy(l);

  return retval;
}

static int nua_stack_outbound_features(nua_handle_t *nh, outbound_t *ob)
{
  char *features;
  int retval;

  if (!nh)
    return -1;
  if (!ob)
    return 0;

  features = nua_handle_features(nh);
  retval = outbound_set_features(ob, features);
  su_free(nh->nh_home, features);

  return retval;
}