Changeset 1111 for pjproject/trunk/pjnath/src/pjnath/ice_session.c

Timestamp:

Mar 28, 2007 3:49:48 PM (17 years ago)

Author:

bennylp

Message:

Updated projects and Makefiles with the new pjnath library

File:

• pjproject/trunk/pjnath/src/pjnath/ice_session.c (moved) (moved from pjproject/trunk/pjnath/src/pjnath/ice.c) (75 diffs)

pjproject/trunk/pjnath/src/pjnath/ice_session.c

@@ -17 +17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  */
-#include <pjnath/ice.h>
+#include <pjnath/ice_session.h>
 #include <pjnath/errno.h>
 #include <pj/addr_resolv.h>
@@ -40 +40 @@
 };
 
-/* String names for pj_ice_check_state */
+/* String names for pj_ice_sess_check_state */
 static const char *check_state_name[] = 
 {
@@ -66 +66 @@
 typedef struct stun_data
 {
-    pj_ice      *ice;
+    pj_ice_sess *ice;
     unsigned     lcand_id;
-    pj_ice_cand *lcand;
+    pj_ice_sess_cand    *lcand;
 } stun_data;
 
 typedef struct timer_data
 {
-    pj_ice              *ice;
-    pj_ice_checklist    *clist;
+    pj_ice_sess         *ice;
+    pj_ice_sess_checklist       *clist;
 } timer_data;
 
 
 
-static void destroy_ice(pj_ice *ice,
+static void destroy_ice(pj_ice_sess *ice,
                         pj_status_t reason);
 static pj_status_t start_periodic_check(pj_timer_heap_t *th, 
@@ -133 +133 @@
 PJ_DEF(const char*) pj_ice_get_cand_type_name(pj_ice_cand_type type)
 {
+    PJ_ASSERT_RETURN(type <= PJ_ICE_CAND_TYPE_RELAYED, "???");
     return cand_type_names[type];
 }
 
 
+/* Get the prefix for the foundation */
+static int get_type_prefix(pj_ice_cand_type type)
+{
+    switch (type) {
+    case PJ_ICE_CAND_TYPE_HOST:     return 'H';
+    case PJ_ICE_CAND_TYPE_SRFLX:    return 'S';
+    case PJ_ICE_CAND_TYPE_PRFLX:    return 'P';
+    case PJ_ICE_CAND_TYPE_RELAYED:  return 'R';
+    default:
+        pj_assert(!"Invalid type");
+        return 'U';
+    }
+}
+
+/* Calculate foundation */
+PJ_DEF(void) pj_ice_calc_foundation(pj_pool_t *pool,
+                                    pj_str_t *foundation,
+                                    pj_ice_cand_type type,
+                                    const pj_sockaddr *base_addr)
+{
+    char buf[64];
+
+    pj_ansi_snprintf(buf, sizeof(buf), "%c%x",
+                     get_type_prefix(type),
+                     (int)pj_ntohl(base_addr->ipv4.sin_addr.s_addr));
+    pj_strdup2(pool, foundation, buf);
+}
+
+
 /*
- * Create ICE stream session.
+ * Create ICE session.
  */
-PJ_DEF(pj_status_t) pj_ice_create(pj_stun_config *stun_cfg,
-                                  const char *name,
-                                  pj_ice_role role,
-                                  unsigned comp_cnt,
-                                  const pj_ice_cb *cb,
-                                  const pj_str_t *local_ufrag,
-                                  const pj_str_t *local_passwd,
-                                  pj_ice **p_ice)
+PJ_DEF(pj_status_t) pj_ice_sess_create(pj_stun_config *stun_cfg,
+                                       const char *name,
+                                       pj_ice_sess_role role,
+                                       unsigned comp_cnt,
+                                       const pj_ice_sess_cb *cb,
+                                       const pj_str_t *local_ufrag,
+                                       const pj_str_t *local_passwd,
+                                       pj_ice_sess **p_ice)
 {
     pj_pool_t *pool;
-    pj_ice *ice;
-    char tmp[32];
+    pj_ice_sess *ice;
+    char tmp[64];
     pj_str_t s;
     unsigned i;
@@ -162 +192 @@
 
     pool = pj_pool_create(stun_cfg->pf, name, 4000, 4000, NULL);
-    ice = PJ_POOL_ZALLOC_T(pool, pj_ice);
+    ice = PJ_POOL_ZALLOC_T(pool, pj_ice_sess);
     ice->pool = pool;
     ice->role = role;
@@ -181 +211 @@
     ice->comp_cnt = comp_cnt;
     for (i=0; i<comp_cnt; ++i) {
-        pj_ice_comp *comp;
+        pj_ice_sess_comp *comp;
         comp = &ice->comp[i];
         comp->valid_check = NULL;
@@ -187 +217 @@
 
     if (local_ufrag == NULL) {
-        pj_ansi_snprintf(tmp, sizeof(tmp), "%x", pj_rand());
+        pj_ansi_snprintf(tmp, sizeof(tmp), "%x%x", pj_rand(), pj_rand());
         s = pj_str(tmp);
         local_ufrag = &s;
@@ -194 +224 @@
 
     if (local_passwd == NULL) {
-        pj_ansi_snprintf(tmp, sizeof(tmp), "%x", pj_rand());
+        pj_ansi_snprintf(tmp, sizeof(tmp), "%x%x", pj_rand(), pj_rand());
         s = pj_str(tmp);
         local_passwd = &s;
@@ -204 +234 @@
     *p_ice = ice;
 
-    LOG4((ice->obj_name, "ICE stream session created, role is %s agent",
-         (ice->role==PJ_ICE_ROLE_CONTROLLING ? "controlling" : "controlled")));
+    LOG4((ice->obj_name, 
+         "ICE session created, comp_cnt=%d, role is %s agent",
+         comp_cnt,
+         (ice->role==PJ_ICE_SESS_ROLE_CONTROLLING ? 
+            "controlling":"controlled")));
 
     return PJ_SUCCESS;
@@ -214 +247 @@
  * Destroy
  */
-static void destroy_ice(pj_ice *ice,
+static void destroy_ice(pj_ice_sess *ice,
                         pj_status_t reason)
 {
@@ -248 +281 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_destroy(pj_ice *ice)
-{
+/*
+ * Destroy
+ */
+PJ_DEF(pj_status_t) pj_ice_sess_destroy(pj_ice_sess *ice)
+{
+    PJ_ASSERT_RETURN(ice, PJ_EINVAL);
     destroy_ice(ice, PJ_SUCCESS);
     return PJ_SUCCESS;
@@ -256 +293 @@
 
 /* Find component by ID */
-static pj_ice_comp *find_comp(const pj_ice *ice, unsigned comp_id)
+static pj_ice_sess_comp *find_comp(const pj_ice_sess *ice, unsigned comp_id)
 {
     pj_assert(comp_id > 0 && comp_id <= ice->comp_cnt);
-    return (pj_ice_comp*) &ice->comp[comp_id-1];
-}
-
-
+    return (pj_ice_sess_comp*) &ice->comp[comp_id-1];
+}
+
+
+/* Callback by STUN authentication when it needs to send 401 */
 static pj_status_t stun_auth_get_auth(void *user_data,
                                       pj_pool_t *pool,
@@ -290 +328 @@
     pj_stun_session *sess = (pj_stun_session *)user_data;
     stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
-    pj_ice *ice = sd->ice;
+    pj_ice_sess *ice = sd->ice;
 
     PJ_UNUSED_ARG(pool);
     realm->slen = nonce->slen = 0;
 
-    if (PJ_STUN_IS_RESPONSE(msg->hdr.type) ||
+    if (PJ_STUN_IS_SUCCESS_RESPONSE(msg->hdr.type) ||
         PJ_STUN_IS_ERROR_RESPONSE(msg->hdr.type))
     {
@@ -325 +363 @@
     pj_stun_session *sess = (pj_stun_session *)user_data;
     stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
-    pj_ice *ice = sd->ice;
+    pj_ice_sess *ice = sd->ice;
 
     PJ_UNUSED_ARG(realm);
     PJ_UNUSED_ARG(pool);
 
-    if (PJ_STUN_IS_RESPONSE(msg->hdr.type) ||
+    if (PJ_STUN_IS_SUCCESS_RESPONSE(msg->hdr.type) ||
         PJ_STUN_IS_ERROR_RESPONSE(msg->hdr.type))
     {
@@ -379 +417 @@
                                   pj_uint32_t comp_id)
 {
-    static pj_uint32_t type_pref[] =
+    pj_uint32_t type_pref[] =
     {
         PJ_ICE_HOST_PREF,
@@ -396 +434 @@
  * Add ICE candidate
  */
-PJ_DEF(pj_status_t) pj_ice_add_cand(pj_ice *ice,
-                                    unsigned comp_id,
-                                    pj_ice_cand_type type,
-                                    pj_uint16_t local_pref,
-                                    const pj_str_t *foundation,
-                                    const pj_sockaddr_t *addr,
-                                    const pj_sockaddr_t *base_addr,
-                                    const pj_sockaddr_t *rel_addr,
-                                    int addr_len,
-                                    unsigned *p_cand_id)
-{
-    pj_ice_cand *lcand;
+PJ_DEF(pj_status_t) pj_ice_sess_add_cand(pj_ice_sess *ice,
+                                         unsigned comp_id,
+                                         pj_ice_cand_type type,
+                                         pj_uint16_t local_pref,
+                                         const pj_str_t *foundation,
+                                         const pj_sockaddr_t *addr,
+                                         const pj_sockaddr_t *base_addr,
+                                         const pj_sockaddr_t *rel_addr,
+                                         int addr_len,
+                                         unsigned *p_cand_id)
+{
+    pj_ice_sess_cand *lcand;
     pj_stun_session_cb sess_cb;
     pj_stun_auth_cred auth_cred;
@@ -437 +475 @@
     else
         pj_bzero(&lcand->rel_addr, sizeof(lcand->rel_addr));
+
 
     /* Init STUN callbacks */
@@ -498 +537 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_find_default_cand(pj_ice *ice,
-                                             unsigned comp_id,
-                                             int *cand_id)
+/* Find default candidate ID for the component */
+PJ_DEF(pj_status_t) pj_ice_sess_find_default_cand(pj_ice_sess *ice,
+                                                  unsigned comp_id,
+                                                  int *cand_id)
 {
     unsigned i;
@@ -513 +553 @@
     /* First find in valid list if we have nominated pair */
     for (i=0; i<ice->valid_list.count; ++i) {
-        pj_ice_check *check = &ice->valid_list.checks[i];
+        pj_ice_sess_check *check = &ice->valid_list.checks[i];
         
         if (check->lcand->comp_id == comp_id) {
@@ -524 +564 @@
     /* If there's no nominated pair, find relayed candidate */
     for (i=0; i<ice->lcand_cnt; ++i) {
-        pj_ice_cand *lcand = &ice->lcand[i];
+        pj_ice_sess_cand *lcand = &ice->lcand[i];
         if (lcand->comp_id==comp_id &&
             lcand->type == PJ_ICE_CAND_TYPE_RELAYED) 
@@ -536 +576 @@
     /* If there's no relayed candidate, find reflexive candidate */
     for (i=0; i<ice->lcand_cnt; ++i) {
-        pj_ice_cand *lcand = &ice->lcand[i];
+        pj_ice_sess_cand *lcand = &ice->lcand[i];
         if (lcand->comp_id==comp_id &&
             (lcand->type == PJ_ICE_CAND_TYPE_SRFLX ||
@@ -549 +589 @@
     /* Otherwise return host candidate */
     for (i=0; i<ice->lcand_cnt; ++i) {
-        pj_ice_cand *lcand = &ice->lcand[i];
+        pj_ice_sess_cand *lcand = &ice->lcand[i];
         if (lcand->comp_id==comp_id &&
             lcand->type == PJ_ICE_CAND_TYPE_HOST) 
@@ -575 +615 @@
 #endif
 
-static pj_uint64_t CALC_CHECK_PRIO(const pj_ice *ice, 
-                                   const pj_ice_cand *lcand,
-                                   const pj_ice_cand *rcand)
+static pj_uint64_t CALC_CHECK_PRIO(const pj_ice_sess *ice, 
+                                   const pj_ice_sess_cand *lcand,
+                                   const pj_ice_sess_cand *rcand)
 {
     pj_uint32_t O, A;
 
-    if (ice->role == PJ_ICE_ROLE_CONTROLLING) {
+    if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLING) {
         O = lcand->prio; 
         A = rcand->prio;
@@ -594 +634 @@
 
 static const char *dump_check(char *buffer, unsigned bufsize,
-                              const pj_ice_checklist *clist,
-                              const pj_ice_check *check)
-{
-    const pj_ice_cand *lcand = check->lcand;
-    const pj_ice_cand *rcand = check->rcand;
+                              const pj_ice_sess_checklist *clist,
+                              const pj_ice_sess_check *check)
+{
+    const pj_ice_sess_cand *lcand = check->lcand;
+    const pj_ice_sess_cand *rcand = check->rcand;
     char laddr[CHECK_NAME_LEN];
     int len;
@@ -627 +667 @@
 
 #if PJ_LOG_MAX_LEVEL >= 4
-static void dump_checklist(const char *title, const pj_ice *ice, 
-                           const pj_ice_checklist *clist)
+static void dump_checklist(const char *title, const pj_ice_sess *ice, 
+                           const pj_ice_sess_checklist *clist)
 {
     unsigned i;
@@ -635 +675 @@
     LOG4((ice->obj_name, "%s", title));
     for (i=0; i<clist->count; ++i) {
-        const pj_ice_check *c = &clist->checks[i];
+        const pj_ice_sess_check *c = &clist->checks[i];
         LOG4((ice->obj_name, " %s (%s, state=%s)",
              dump_check(buffer, sizeof(buffer), clist, c),
@@ -647 +687 @@
 #endif
 
-static void check_set_state(pj_ice *ice, pj_ice_check *check,
-                            pj_ice_check_state st, 
+static void check_set_state(pj_ice_sess *ice, pj_ice_sess_check *check,
+                            pj_ice_sess_check_state st, 
                             pj_status_t err_code)
 {
     char buf[CHECK_NAME_LEN];
 
-    pj_assert(check->state < PJ_ICE_CHECK_STATE_SUCCEEDED);
+    pj_assert(check->state < PJ_ICE_SESS_CHECK_STATE_SUCCEEDED);
 
     LOG5((ice->obj_name, "Check %s: state changed from %s to %s",
@@ -663 +703 @@
 }
 
-static void clist_set_state(pj_ice *ice, pj_ice_checklist *clist,
-                            pj_ice_checklist_state st)
+static void clist_set_state(pj_ice_sess *ice, pj_ice_sess_checklist *clist,
+                            pj_ice_sess_checklist_state st)
 {
     if (clist->state != st) {
@@ -675 +715 @@
 
 /* Sort checklist based on priority */
-static void sort_checklist(pj_ice_checklist *clist)
+static void sort_checklist(pj_ice_sess_checklist *clist)
 {
     unsigned i;
@@ -688 +728 @@
 
         if (highest != i) {
-            pj_ice_check tmp;
-
-            pj_memcpy(&tmp, &clist->checks[i], sizeof(pj_ice_check));
+            pj_ice_sess_check tmp;
+
+            pj_memcpy(&tmp, &clist->checks[i], sizeof(pj_ice_sess_check));
             pj_memcpy(&clist->checks[i], &clist->checks[highest], 
-                      sizeof(pj_ice_check));
-            pj_memcpy(&clist->checks[highest], &tmp, sizeof(pj_ice_check));
+                      sizeof(pj_ice_sess_check));
+            pj_memcpy(&clist->checks[highest], &tmp, 
+                      sizeof(pj_ice_sess_check));
         }
     }
@@ -727 +768 @@
  * is sorted.
  */
-static void prune_checklist(pj_ice *ice, pj_ice_checklist *clist)
+static void prune_checklist(pj_ice_sess *ice, pj_ice_sess_checklist *clist)
 {
     unsigned i;
@@ -742 +783 @@
      */
     for (i=0; i<clist->count; ++i) {
-        pj_ice_cand *licand = clist->checks[i].lcand;
-        pj_ice_cand *ricand = clist->checks[i].rcand;
+        pj_ice_sess_cand *licand = clist->checks[i].lcand;
+        pj_ice_sess_cand *ricand = clist->checks[i].rcand;
         const pj_sockaddr *liaddr;
         unsigned j;
@@ -753 +794 @@
 
         for (j=i+1; j<clist->count;) {
-            pj_ice_cand *ljcand = clist->checks[j].lcand;
-            pj_ice_cand *rjcand = clist->checks[j].rcand;
+            pj_ice_sess_cand *ljcand = clist->checks[j].lcand;
+            pj_ice_sess_cand *rjcand = clist->checks[j].rcand;
             const pj_sockaddr *ljaddr;
 
@@ -784 +825 @@
 
 /* This function is called when ICE processing completes */
-static void on_ice_complete(pj_ice *ice, pj_status_t status)
+static void on_ice_complete(pj_ice_sess *ice, pj_status_t status)
 {
     if (!ice->is_complete) {
@@ -807 +848 @@
 
 /* This function is called when one check completes */
-static pj_bool_t on_check_complete(pj_ice *ice,
-                                   pj_ice_check *check)
+static pj_bool_t on_check_complete(pj_ice_sess *ice,
+                                   pj_ice_sess_check *check)
 {
     unsigned i;
 
-    pj_assert(check->state >= PJ_ICE_CHECK_STATE_SUCCEEDED);
+    pj_assert(check->state >= PJ_ICE_SESS_CHECK_STATE_SUCCEEDED);
 
     /* If there is at least one nominated pair in the valid list:
@@ -824 +865 @@
      */
     if (check->err_code==PJ_SUCCESS && check->nominated) {
-        pj_ice_comp *comp;
+        pj_ice_sess_comp *comp;
         char buf[CHECK_NAME_LEN];
 
@@ -831 +872 @@
 
         for (i=0; i<ice->clist.count; ++i) {
-            pj_ice_check *c = &ice->clist.checks[i];
+            pj_ice_sess_check *c = &ice->clist.checks[i];
             if (c->lcand->comp_id == check->lcand->comp_id) {
-                if (c->state < PJ_ICE_CHECK_STATE_IN_PROGRESS) {
+                if (c->state < PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
                     /* Just fail Frozen/Waiting check */
                     LOG5((ice->obj_name, 
@@ -839 +880 @@
                          dump_check(buf, sizeof(buf), &ice->clist, c), 
                          check_state_name[c->state]));
-                    check_set_state(ice, c, PJ_ICE_CHECK_STATE_FAILED,
+                    check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_FAILED,
                                     PJ_ECANCELLED);
 
-                } else if (c->state == PJ_ICE_CHECK_STATE_IN_PROGRESS) {
+                } else if (c->state == PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
                     /* State is IN_PROGRESS, cancel transaction */
                     if (c->tdata) {
@@ -851 +892 @@
                                                    c->tdata, PJ_FALSE, 0);
                         c->tdata = NULL;
-                        check_set_state(ice, c, PJ_ICE_CHECK_STATE_FAILED,
+                        check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_FAILED,
                                         PJ_ECANCELLED);
                     }
@@ -917 +958 @@
      */
     for (i=0; i<ice->clist.count; ++i) {
-        pj_ice_check *c = &ice->clist.checks[i];
-        if (c->state < PJ_ICE_CHECK_STATE_SUCCEEDED) {
+        pj_ice_sess_check *c = &ice->clist.checks[i];
+        if (c->state < PJ_ICE_SESS_CHECK_STATE_SUCCEEDED) {
             break;
         }
@@ -935 +976 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_create_check_list(pj_ice *ice,
-                                             const pj_str_t *rem_ufrag,
-                                             const pj_str_t *rem_passwd,
-                                             unsigned rcand_cnt,
-                                             const pj_ice_cand rcand[])
-{
-    pj_ice_checklist *clist;
+/* Create checklist by pairing local candidates with remote candidates */
+PJ_DEF(pj_status_t) 
+pj_ice_sess_create_check_list(pj_ice_sess *ice,
+                              const pj_str_t *rem_ufrag,
+                              const pj_str_t *rem_passwd,
+                              unsigned rcand_cnt,
+                              const pj_ice_sess_cand rcand[])
+{
+    pj_ice_sess_checklist *clist;
     char buf[128];
     pj_str_t username;
@@ -975 +1018 @@
     ice->rcand_cnt = 0;
     for (i=0; i<rcand_cnt; ++i) {
-        pj_ice_cand *cn = &ice->rcand[ice->rcand_cnt];
+        pj_ice_sess_cand *cn = &ice->rcand[ice->rcand_cnt];
 
         /* Ignore candidate which has no matching component ID */
-        pj_assert(rcand[i].comp_id > 0);
         if (rcand[i].comp_id==0 || rcand[i].comp_id > ice->comp_cnt) {
             continue;
         }
 
-        pj_memcpy(cn, &rcand[i], sizeof(pj_ice_cand));
+        pj_memcpy(cn, &rcand[i], sizeof(pj_ice_sess_cand));
         pj_strdup(ice->pool, &cn->foundation, &rcand[i].foundation);
         ice->rcand_cnt++;
@@ -993 +1035 @@
         for (j=0; j<ice->rcand_cnt; ++j) {
 
-            pj_ice_cand *lcand = &ice->lcand[i];
-            pj_ice_cand *rcand = &ice->rcand[j];
-            pj_ice_check *chk = &clist->checks[clist->count];
+            pj_ice_sess_cand *lcand = &ice->lcand[i];
+            pj_ice_sess_cand *rcand = &ice->rcand[j];
+            pj_ice_sess_check *chk = &clist->checks[clist->count];
 
             if (clist->count > PJ_ICE_MAX_CHECKS) {
@@ -1015 +1057 @@
             chk->lcand = lcand;
             chk->rcand = rcand;
-            chk->state = PJ_ICE_CHECK_STATE_FROZEN;
+            chk->state = PJ_ICE_SESS_CHECK_STATE_FROZEN;
 
             chk->prio = CALC_CHECK_PRIO(ice, lcand, rcand);
@@ -1049 +1091 @@
 
 
+/* This is the data that will be attached as user data to outgoing
+ * STUN requests, and it will be given back when we receive completion
+ * status of the request.
+ */
 struct req_data
 {
-    pj_ice              *ice;
-    pj_ice_checklist    *clist;
-    unsigned             ckid;
+    pj_ice_sess             *ice;
+    pj_ice_sess_checklist   *clist;
+    unsigned                 ckid;
 };
 
+
 /* Perform check on the specified candidate pair */
-static pj_status_t perform_check(pj_ice *ice, pj_ice_checklist *clist,
+static pj_status_t perform_check(pj_ice_sess *ice, 
+                                 pj_ice_sess_checklist *clist,
                                  unsigned check_id)
 {
-    pj_ice_comp *comp;
+    pj_ice_sess_comp *comp;
     struct req_data *rd;
-    pj_ice_check *check;
-    const pj_ice_cand *lcand;
-    const pj_ice_cand *rcand;
+    pj_ice_sess_check *check;
+    const pj_ice_sess_cand *lcand;
+    const pj_ice_sess_cand *rcand;
     pj_uint32_t prio;
     char buffer[128];
@@ -1101 +1149 @@
 
     /* Add USE-CANDIDATE and set this check to nominated */
-    if (ice->role == PJ_ICE_ROLE_CONTROLLING) {
+    if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLING) {
         pj_stun_msg_add_empty_attr(check->tdata->pool, check->tdata->msg, 
                                    PJ_STUN_ATTR_USE_CANDIDATE);
@@ -1120 +1168 @@
     }
 
-    check_set_state(ice, check, PJ_ICE_CHECK_STATE_IN_PROGRESS, PJ_SUCCESS);
+    check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS, 
+                    PJ_SUCCESS);
     return PJ_SUCCESS;
 }
@@ -1132 +1181 @@
 {
     timer_data *td;
-    pj_ice *ice;
-    pj_ice_checklist *clist;
+    pj_ice_sess *ice;
+    pj_ice_sess_checklist *clist;
     unsigned i, start_count=0;
     pj_status_t status;
@@ -1147 +1196 @@
 
     /* Set checklist state to Running */
-    clist_set_state(ice, clist, PJ_ICE_CHECKLIST_ST_RUNNING);
+    clist_set_state(ice, clist, PJ_ICE_SESS_CHECKLIST_ST_RUNNING);
 
     LOG5((ice->obj_name, "Starting checklist periodic check"));
@@ -1155 +1204 @@
      */
     for (i=0; i<clist->count; ++i) {
-        pj_ice_check *check = &clist->checks[i];
-
-        if (check->state == PJ_ICE_CHECK_STATE_WAITING) {
+        pj_ice_sess_check *check = &clist->checks[i];
+
+        if (check->state == PJ_ICE_SESS_CHECK_STATE_WAITING) {
             status = perform_check(ice, clist, i);
             if (status != PJ_SUCCESS) {
@@ -1174 +1223 @@
     if (start_count==0) {
         for (i=0; i<clist->count; ++i) {
-            pj_ice_check *check = &clist->checks[i];
-
-            if (check->state == PJ_ICE_CHECK_STATE_FROZEN) {
+            pj_ice_sess_check *check = &clist->checks[i];
+
+            if (check->state == PJ_ICE_SESS_CHECK_STATE_FROZEN) {
                 status = perform_check(ice, clist, i);
                 if (status != PJ_SUCCESS) {
@@ -1193 +1242 @@
      */
     if (start_count==0) {
-        clist_set_state(ice, clist, PJ_ICE_CHECKLIST_ST_COMPLETED);
+        clist_set_state(ice, clist, PJ_ICE_SESS_CHECKLIST_ST_COMPLETED);
 
     } else {
@@ -1210 +1259 @@
 
 /* Start ICE check */
-PJ_DEF(pj_status_t) pj_ice_start_check(pj_ice *ice)
-{
-    pj_ice_checklist *clist;
-    const pj_ice_cand *cand0;
+PJ_DEF(pj_status_t) pj_ice_sess_start_check(pj_ice_sess *ice)
+{
+    pj_ice_sess_checklist *clist;
+    const pj_ice_sess_cand *cand0;
     unsigned i;
 
@@ -1225 +1274 @@
 
     /* Pickup the first pair and set the state to Waiting */
-    clist->checks[0].state = PJ_ICE_CHECK_STATE_WAITING;
+    clist->checks[0].state = PJ_ICE_SESS_CHECK_STATE_WAITING;
     cand0 = clist->checks[0].lcand;
 
@@ -1233 +1282 @@
      */
     for (i=1; i<clist->count; ++i) {
-        const pj_ice_cand *cand1;
+        const pj_ice_sess_cand *cand1;
 
         cand1 = clist->checks[i].lcand;
@@ -1240 +1289 @@
             pj_strcmp(&cand0->foundation, &cand1->foundation)!=0)
         {
-            clist->checks[i].state = PJ_ICE_CHECK_STATE_WAITING;
+            clist->checks[i].state = PJ_ICE_SESS_CHECK_STATE_WAITING;
         }
     }
@@ -1251 +1300 @@
 //////////////////////////////////////////////////////////////////////////////
 
+/* Callback called by STUN session to send the STUN message.
+ * STUN session also doesn't have a transport, remember?!
+ */
 static pj_status_t on_stun_send_msg(pj_stun_session *sess,
                                     const void *pkt,
@@ -1271 +1323 @@
 {
     struct req_data *rd = (struct req_data*) tdata->user_data;
-    pj_ice *ice;
-    pj_ice_check *check, *new_check;
-    pj_ice_cand *lcand;
-    pj_ice_checklist *clist;
+    pj_ice_sess *ice;
+    pj_ice_sess_check *check, *new_check;
+    pj_ice_sess_cand *lcand;
+    pj_ice_sess_checklist *clist;
     pj_stun_xor_mapped_addr_attr *xaddr;
     char buffer[CHECK_NAME_LEN];
@@ -1303 +1355 @@
 
     if (status != PJ_SUCCESS) {
-        check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, status);
+        check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, status);
         on_check_complete(ice, check);
         pj_mutex_unlock(ice->mutex);
@@ -1321 +1373 @@
             pj_stun_msg_find_attr(response, PJ_STUN_ATTR_XOR_MAPPED_ADDR,0);
     if (!xaddr) {
-        check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, 
+        check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, 
                         PJNATH_ESTUNNOMAPPEDADDR);
         on_check_complete(ice, check);
@@ -1344 +1396 @@
     if (lcand == NULL) {
         unsigned cand_id;
-        char buf[32];
         pj_str_t foundation;
 
-        pj_ansi_snprintf(buf, sizeof(buf), "P%x", 
-                         lcand->base_addr.ipv4.sin_addr.s_addr);
-        foundation = pj_str(buf);
+        pj_ice_calc_foundation(ice->pool, &foundation, PJ_ICE_CAND_TYPE_PRFLX,
+                               &lcand->base_addr);
 
         /* Add new peer reflexive candidate */
-        status = pj_ice_add_cand(ice, lcand->comp_id, 
+        status = pj_ice_sess_add_cand(ice, lcand->comp_id, 
                                  PJ_ICE_CAND_TYPE_PRFLX,
                                  65535, &foundation,
@@ -1358 +1408 @@
                                  sizeof(pj_sockaddr_in), &cand_id);
         if (status != PJ_SUCCESS) {
-            check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, status);
+            check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, 
+                            status);
             on_check_complete(ice, check);
             pj_mutex_unlock(ice->mutex);
@@ -1373 +1424 @@
     new_check->rcand = check->rcand;
     new_check->prio = CALC_CHECK_PRIO(ice, lcand, check->rcand);
-    new_check->state = PJ_ICE_CHECK_STATE_SUCCEEDED;
+    new_check->state = PJ_ICE_SESS_CHECK_STATE_SUCCEEDED;
     new_check->nominated = check->nominated;
     new_check->err_code = PJ_SUCCESS;
@@ -1384 +1435 @@
      * succeeded. 
      */
-    check_set_state(ice, check, PJ_ICE_CHECK_STATE_SUCCEEDED, PJ_SUCCESS);
+    check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_SUCCEEDED, 
+                    PJ_SUCCESS);
 
     /* Inform about check completion.
@@ -1404 +1456 @@
 
         for (i=0; i<clist->count; ++i)  {
-            pj_ice_check *c = &clist->checks[i];
-
-            if (c->state == PJ_ICE_CHECK_STATE_FROZEN &&
+            pj_ice_sess_check *c = &clist->checks[i];
+
+            if (c->state == PJ_ICE_SESS_CHECK_STATE_FROZEN &&
                 c->lcand->comp_id != lcand->comp_id &&
                 pj_strcmp(&c->lcand->foundation, &lcand->foundation)==0)
             {
                 /* Unfreeze and start check */
-                check_set_state(ice, c, PJ_ICE_CHECK_STATE_WAITING, 
+                check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_WAITING, 
                                 PJ_SUCCESS);
                 unfrozen = PJ_TRUE;
@@ -1453 +1505 @@
 {
     stun_data *sd;
-    pj_ice *ice;
+    pj_ice_sess *ice;
     pj_stun_priority_attr *ap;
     pj_stun_use_candidate_attr *uc;
-    pj_ice_comp *comp;
-    pj_ice_cand *lcand;
-    pj_ice_cand *rcand;
+    pj_ice_sess_comp *comp;
+    pj_ice_sess_cand *lcand;
+    pj_ice_sess_cand *rcand;
     unsigned i;
     pj_stun_tx_data *tdata;
@@ -1574 +1626 @@
      */
     for (i=0; i<ice->clist.count; ++i) {
-        pj_ice_check *c = &ice->clist.checks[i];
+        pj_ice_sess_check *c = &ice->clist.checks[i];
         if (c->lcand == lcand && c->rcand == rcand)
             break;
@@ -1593 +1645 @@
      */
     if (i != ice->clist.count) {
-        pj_ice_check *c = &ice->clist.checks[i];
+        pj_ice_sess_check *c = &ice->clist.checks[i];
 
         /* If USE-CANDIDATE is present, set nominated flag 
@@ -1600 +1652 @@
         c->nominated = ((uc != NULL) || c->nominated);
 
-        if (c->state == PJ_ICE_CHECK_STATE_FROZEN ||
-            c->state == PJ_ICE_CHECK_STATE_WAITING)
+        if (c->state == PJ_ICE_SESS_CHECK_STATE_FROZEN ||
+            c->state == PJ_ICE_SESS_CHECK_STATE_WAITING)
         {
             LOG5((ice->obj_name, "Performing triggered check for check %d",i));
             perform_check(ice, &ice->clist, i);
 
-        } else if (c->state == PJ_ICE_CHECK_STATE_IN_PROGRESS) {
+        } else if (c->state == PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
             /* Should retransmit here, but how??
              * TODO
@@ -1612 +1664 @@
             LOG5((ice->obj_name, "Triggered check for check %d not performed "
                                 "because it's in progress", i));
-        } else if (c->state == PJ_ICE_CHECK_STATE_SUCCEEDED) {
+        } else if (c->state == PJ_ICE_SESS_CHECK_STATE_SUCCEEDED) {
             /* Check complete for this component.
              * Note this may end ICE process.
@@ -1637 +1689 @@
     else if (ice->clist.count < PJ_ICE_MAX_CHECKS) {
 
-        pj_ice_check *c = &ice->clist.checks[ice->clist.count];
+        pj_ice_sess_check *c = &ice->clist.checks[ice->clist.count];
 
         c->lcand = lcand;
         c->rcand = rcand;
         c->prio = CALC_CHECK_PRIO(ice, lcand, rcand);
-        c->state = PJ_ICE_CHECK_STATE_WAITING;
+        c->state = PJ_ICE_SESS_CHECK_STATE_WAITING;
         c->nominated = (uc != NULL);
         c->err_code = PJ_SUCCESS;
@@ -1680 +1732 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_send_data( pj_ice *ice,
+PJ_DEF(pj_status_t) pj_ice_sess_send_data( pj_ice_sess *ice,
                                       unsigned comp_id,
                                       const void *data,
@@ -1686 +1738 @@
 {
     pj_status_t status = PJ_SUCCESS;
-    pj_ice_comp *comp;
+    pj_ice_sess_comp *comp;
     unsigned cand_id;
 
@@ -1715 +1767 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_on_rx_pkt( pj_ice *ice,
+PJ_DEF(pj_status_t) pj_ice_sess_on_rx_pkt( pj_ice_sess *ice,
                                       unsigned comp_id,
                                       unsigned cand_id,
@@ -1724 +1776 @@
 {
     pj_status_t status = PJ_SUCCESS;
-    pj_ice_comp *comp;
-    pj_ice_cand *lcand;
+    pj_ice_sess_comp *comp;
+    pj_ice_sess_cand *lcand;
     pj_status_t stun_status;