Changeset 2705 for pjproject/branches/projects/sipit24/pjnath/src/pjnath/ice_session.c

Timestamp:

May 17, 2009 5:57:19 PM (15 years ago)

Author:

bennylp

Message:

Ticket #851: initial code to support regular nomination in ICE:

• Added option to change nomination strategy in ICE strans and session. Default is still aggressive.
• Added option to control nomination timer
• Renamed no_host_cand to max_host_cands in ICE config
• Updated icedemo
• Also added timer for controlled agent to wait for nomination from controlling agent

File:

• pjproject/branches/projects/sipit24/pjnath/src/pjnath/ice_session.c (modified) (29 diffs)

pjproject/branches/projects/sipit24/pjnath/src/pjnath/ice_session.c

@@ -67 +67 @@
 };
 
+typedef enum timer_type
+{
+    TIMER_NONE,                 /**< Timer not active                   */
+    TIMER_COMPLETION_CALLBACK,  /**< Call on_ice_complete() callback    */
+    TIMER_CONTROLLED_WAIT_NOM,  /**< Controlled agent is waiting for 
+                                     controlling agent to send connectivity
+                                     check with nominated flag after it has
+                                     valid check for every components.  */
+    TIMER_START_NOMINATED_CHECK,/**< Controlling agent start connectivity
+                                     checks with USE-CANDIDATE flag.    */
+                                        
+
+};
+
 /* Candidate type preference */
 static pj_uint8_t cand_type_prefs[4] =
@@ -119 +133 @@
 
 /* Forward declarations */
+static void on_timer(pj_timer_heap_t *th, pj_timer_entry *te);
+static void on_ice_complete(pj_ice_sess *ice, pj_status_t status);
 static void destroy_ice(pj_ice_sess *ice,
                         pj_status_t reason);
 static pj_status_t start_periodic_check(pj_timer_heap_t *th, 
                                         pj_timer_entry *te);
+static void start_nominated_check(pj_ice_sess *ice);
 static void periodic_timer(pj_timer_heap_t *th, 
                           pj_timer_entry *te);
@@ -297 +314 @@
 
 
+/* Init options with default values */
+PJ_DEF(void) pj_ice_sess_options_default(pj_ice_sess_options *opt)
+{
+    opt->aggressive = PJ_TRUE;
+    opt->nominated_check_delay = PJ_ICE_NOMINATED_CHECK_DELAY;
+    opt->controlled_agent_want_nom_timeout = 
+        ICE_CONTROLLED_AGENT_WAIT_NOMINATION_TIMEOUT;
+}
+
 /*
  * Create ICE session.
@@ -327 +353 @@
     ice->tie_breaker.u32.lo = pj_rand();
     ice->prefs = cand_type_prefs;
+    pj_ice_sess_options_default(&ice->opt);
+
+    pj_timer_entry_init(&ice->timer, TIMER_NONE, (void*)ice, &on_timer);
 
     pj_ansi_snprintf(ice->obj_name, sizeof(ice->obj_name),
@@ -346 +375 @@
         comp = &ice->comp[i];
         comp->valid_check = NULL;
+        comp->nominated_check = NULL;
 
         status = init_comp(ice, i+1, comp);
@@ -390 +420 @@
 
 /*
+ * Get the value of various options of the ICE session.
+ */
+PJ_DEF(pj_status_t) pj_ice_sess_get_options(pj_ice_sess *ice,
+                                            pj_ice_sess_options *opt)
+{
+    PJ_ASSERT_RETURN(ice, PJ_EINVAL);
+    pj_memcpy(opt, &ice->opt, sizeof(*opt));
+    return PJ_SUCCESS;
+}
+
+/*
+ * Specify various options for this ICE session.
+ */
+PJ_DEF(pj_status_t) pj_ice_sess_set_options(pj_ice_sess *ice,
+                                            const pj_ice_sess_options *opt)
+{
+    PJ_ASSERT_RETURN(ice && opt, PJ_EINVAL);
+    pj_memcpy(&ice->opt, opt, sizeof(*opt));
+    return PJ_SUCCESS;
+}
+
+
+/*
  * Destroy
  */
@@ -407 +460 @@
     }
 
-    if (ice->completion_timer.id) {
+    if (ice->timer.id) {
         pj_timer_heap_cancel(ice->stun_cfg.timer_heap, 
-                             &ice->completion_timer);
-        ice->completion_timer.id = PJ_FALSE;
+                             &ice->timer);
+        ice->timer.id = PJ_FALSE;
     }
 
@@ -1040 +1093 @@
 }
 
-/* Timer callback to call on_ice_complete() callback */
-static void on_completion_timer(pj_timer_heap_t *th, 
-                                pj_timer_entry *te)
+/* Timer callback */
+static void on_timer(pj_timer_heap_t *th, pj_timer_entry *te)
 {
     pj_ice_sess *ice = (pj_ice_sess*) te->user_data;
+    enum timer_time type = (enum timer_type)te->id;
 
     PJ_UNUSED_ARG(th);
 
-    te->id = PJ_FALSE;
-
-    if (ice->cb.on_ice_complete)
-        (*ice->cb.on_ice_complete)(ice, ice->ice_status);
+    te->id = TIMER_NONE;
+
+    switch (type) {
+    case TIMER_CONTROLLED_WAIT_NOM:
+        LOG4((ice->obj_name, 
+              "Controlled agent timed-out in waiting for the controlling "
+              "agent to send nominated check. Setting state to fail now.."));
+        on_ice_complete(ice, PJNATH_EICENOMTIMEOUT);
+        break;
+    case TIMER_COMPLETION_CALLBACK:
+        if (ice->cb.on_ice_complete)
+            (*ice->cb.on_ice_complete)(ice, ice->ice_status);
+        break;
+    case TIMER_START_NOMINATED_CHECK:
+        start_nominated_check(ice);
+        break;
+    }
 }
 
@@ -1061 +1127 @@
         ice->ice_status = status;
     
+        if (ice->timer.id != TIMER_NONE) {
+            pj_timer_heap_cancel(ice->stun_cfg.timer_heap, &ice->timer);
+            ice->timer.id = TIMER_NONE;
+        }
+
         /* Log message */
         LOG4((ice->obj_name, "ICE process complete, status=%s", 
@@ -1072 +1143 @@
             pj_time_val delay = {0, 0};
 
-            ice->completion_timer.cb = &on_completion_timer;
-            ice->completion_timer.user_data = (void*) ice;
-            ice->completion_timer.id = PJ_TRUE;
-
+            ice->timer.id = TIMER_COMPLETION_CALLBACK;
             pj_timer_heap_schedule(ice->stun_cfg.timer_heap, 
-                                   &ice->completion_timer,
-                                   &delay);
+                                   &ice->timer, &delay);
         }
     }
@@ -1088 +1155 @@
                                    pj_ice_sess_check *check)
 {
+    pj_ice_sess_comp *comp;
     unsigned i;
 
     pj_assert(check->state >= PJ_ICE_SESS_CHECK_STATE_SUCCEEDED);
+
+    comp = find_comp(ice, check->lcand->comp_id);
 
     /* 7.1.2.2.2.  Updating Pair States
@@ -1105 +1175 @@
      */
     if (check->err_code==PJ_SUCCESS) {
+
         for (i=0; i<ice->clist.count; ++i) {
             pj_ice_sess_check *c = &ice->clist.checks[i];
@@ -1113 +1184 @@
             }
         }
+
+        /* Update valid check */
+        if (comp->valid_check == NULL) {
+            comp->valid_check = check;
+        } else {
+            if (CMP_CHECK_PRIO(comp->valid_check, check) < 0)
+                comp->valid_check = check;
+        }
+
+        LOG5((ice->obj_name, "Check %d is successful%s",
+             GET_CHECK_ID(&ice->clist, check),
+             (check->nominated ? "  and nominated" : "")));
+
     }
 
@@ -1137 +1221 @@
      */
     if (check->err_code==PJ_SUCCESS && check->nominated) {
-        pj_ice_sess_comp *comp;
-
-        LOG5((ice->obj_name, "Check %d is successful and nominated",
-             GET_CHECK_ID(&ice->clist, check)));
-
-        comp = find_comp(ice, check->lcand->comp_id);
 
         for (i=0; i<ice->clist.count; ++i) {
@@ -1182 +1260 @@
 
         /* Update the nominated check for the component */
-        if (comp->valid_check == NULL) {
-            comp->valid_check = check;
+        if (comp->nominated_check == NULL) {
+            comp->nominated_check = check;
         } else {
-            if (CMP_CHECK_PRIO(comp->valid_check, check) < 0)
-                comp->valid_check = check;
+            if (CMP_CHECK_PRIO(comp->nominated_check, check) < 0)
+                comp->nominated_check = check;
         }
     }
@@ -1212 +1290 @@
      */
     for (i=0; i<ice->comp_cnt; ++i) {
-        if (ice->comp[i].valid_check == NULL)
+        if (ice->comp[i].nominated_check == NULL)
             break;
     }
@@ -1259 +1337 @@
          * If agent's role is controlled, check if all components have
          * valid pair. If it does, this means the controlled agent has
-         * finished the check list early and it's waiting for controlling
-         * agent to send a check with USE-CANDIDATE flag set.
+         * finished the check list and it's waiting for controlling
+         * agent to send checks with USE-CANDIDATE flag set.
          */
         if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLED) {
-            unsigned comp_id;
-            for (comp_id=1; comp_id <= ice->comp_cnt; ++comp_id) {
-                unsigned j;
-                for (j=0; j<ice->valid_list.count; ++j) {
-                    pj_ice_sess_check *vc = &ice->valid_list.checks[j];
-                    if (vc->lcand->comp_id == comp_id)
-                        break;
-                }
-                if (j == ice->valid_list.count)
+            for (i=0; i < ice->comp_cnt; ++i) {
+                if (ice->comp[i].valid_check == NULL)
                     break;
             }
 
-            if (comp_id <= ice->comp_cnt) {
+            if (i < ice->comp_cnt) {
                 /* This component ID doesn't have valid pair.
                  * Mark ICE as failed. 
@@ -1285 +1356 @@
                  * We should wait until we receive nominated checks.
                  */
+                if (ice->timer.id == TIMER_NONE &&
+                    ice->opt.controlled_agent_want_nom_timeout >= 0) 
+                {
+                    pj_time_val delay;
+
+                    delay.sec = 0;
+                    delay.msec = ice->opt.controlled_agent_want_nom_timeout;
+                    pj_time_val_normalize(&delay);
+
+                    ice->timer.id = TIMER_CONTROLLED_WAIT_NOM;
+                    pj_timer_heap_schedule(ice->stun_cfg.timer_heap, 
+                                           &ice->timer,
+                                           &delay);
+
+                    LOG5((ice->obj_name, 
+                          "All checks have completed. Controlled agent now "
+                          "waits for nomination from controlling agent "
+                          "(timeout=%d msec)",
+                          ice->opt.controlled_agent_want_nom_timeout));
+                }
                 return PJ_FALSE;
             }
-        }
-
-        on_ice_complete(ice, PJNATH_EICEFAILED);
-        return PJ_TRUE;
+
+            /* Unreached */
+
+        } else if (ice->is_nominating) {
+            /* We are controlling agent and all checks have completed but
+             * there's at least one component without nominated pair (or
+             * more likely we don't have any nominated pairs at all).
+             */
+            on_ice_complete(ice, PJNATH_EICEFAILED);
+            return PJ_TRUE;
+
+        } else {
+            /* We are controlling agent and all checks have completed. If
+             * we have valid list for every component, then move on to
+             * sending nominated check, otherwise we have failed.
+             */
+            for (i=0; i<ice->comp_cnt; ++i) {
+                if (ice->comp[i].valid_check == NULL)
+                    break;
+            }
+
+            if (i < ice->comp_cnt) {
+                /* At least one component doesn't have a valid check. Mark
+                 * ICE as failed.
+                 */
+                on_ice_complete(ice, PJNATH_EICEFAILED);
+                return PJ_TRUE;
+            }
+
+            /* Now it's time to send connectivity check with nomination 
+             * flag set.
+             */
+            LOG5((ice->obj_name, 
+                  "All checks have completed, starting nominated checks now"));
+            start_nominated_check(ice);
+            return PJ_FALSE;
+        }
+    }
+
+    /* If this connectivity check has been successful, scan all components
+     * and see if they have a valid pair, if we are controlling and we haven't
+     * started our nominated check yet.
+     */
+    if (check->err_code == PJ_SUCCESS && 
+        ice->role==PJ_ICE_SESS_ROLE_CONTROLLING &&
+        !ice->is_nominating &&
+        ice->timer.id == TIMER_NONE) 
+    {
+        pj_time_val delay;
+
+        for (i=0; i<ice->comp_cnt; ++i) {
+            if (ice->comp[i].valid_check == NULL)
+                break;
+        }
+
+        if (i < ice->comp_cnt) {
+            /* Some components still don't have valid pair, continue
+             * processing.
+             */
+            return PJ_FALSE;
+        }
+
+        LOG5((ice->obj_name, 
+              "Scheduling nominated check in %d ms",
+              ice->opt.nominated_check_delay));
+
+        /* All components have valid pair. Let connectivity checks run for
+         * a little bit more time, then start our nominated check.
+         */
+        delay.sec = 0;
+        delay.msec = ice->opt.nominated_check_delay;
+        pj_time_val_normalize(&delay);
+
+        ice->timer.id = TIMER_START_NOMINATED_CHECK;
+        pj_timer_heap_schedule(ice->stun_cfg.timer_heap, &ice->timer, &delay);
+        return PJ_FALSE;
     }
 
@@ -1296 +1459 @@
     return PJ_FALSE;
 }
-
 
 
@@ -1431 +1593 @@
 }
 
-/* Perform check on the specified candidate pair */
+/* Perform check on the specified candidate pair. */
 static pj_status_t perform_check(pj_ice_sess *ice, 
                                  pj_ice_sess_checklist *clist,
-                                 unsigned check_id)
+                                 unsigned check_id,
+                                 pj_bool_t nominate)
 {
     pj_ice_sess_comp *comp;
@@ -1482 +1645 @@
      */
     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);
-        check->nominated = PJ_TRUE;
+        if (nominate) {
+            pj_stun_msg_add_empty_attr(check->tdata->pool, check->tdata->msg,
+                                       PJ_STUN_ATTR_USE_CANDIDATE);
+            check->nominated = PJ_TRUE;
+        }
 
         pj_stun_msg_add_uint64_attr(check->tdata->pool, check->tdata->msg, 
@@ -1550 +1715 @@
 
         if (check->state == PJ_ICE_SESS_CHECK_STATE_WAITING) {
-            status = perform_check(ice, clist, i);
+            status = perform_check(ice, clist, i, ice->is_nominating);
             if (status != PJ_SUCCESS) {
                 pj_mutex_unlock(ice->mutex);
@@ -1569 +1734 @@
 
             if (check->state == PJ_ICE_SESS_CHECK_STATE_FROZEN) {
-                status = perform_check(ice, clist, i);
+                status = perform_check(ice, clist, i, ice->is_nominating);
                 if (status != PJ_SUCCESS) {
                     pj_mutex_unlock(ice->mutex);
@@ -1596 +1761 @@
 }
 
+
+/* Start sending connectivity check with USE-CANDIDATE */
+static void start_nominated_check(pj_ice_sess *ice)
+{
+    pj_time_val delay;
+    unsigned i;
+    pj_status_t status;
+
+    LOG4((ice->obj_name, "Starting nominated check.."));
+
+    pj_assert(ice->is_nominating == PJ_FALSE);
+
+    /* Stop our timer if it's active */
+    if (ice->timer.id == TIMER_START_NOMINATED_CHECK) {
+        pj_timer_heap_cancel(ice->stun_cfg.timer_heap, &ice->timer);
+        ice->timer.id = TIMER_NONE;
+    }
+
+    /* For each component, set the check state of valid check with
+     * highest priority to Waiting (it should have Success state now).
+     */
+    for (i=0; i<ice->comp_cnt; ++i) {
+        pj_assert(ice->comp[i].nominated_check == NULL);
+        pj_assert(ice->comp[i].valid_check->err_code == PJ_SUCCESS);
+
+        ice->comp[i].valid_check->state = PJ_ICE_SESS_CHECK_STATE_FROZEN;
+        check_set_state(ice, ice->comp[i].valid_check, 
+                        PJ_ICE_SESS_CHECK_STATE_WAITING, PJ_SUCCESS);
+    }
+
+    /* And (re)start the periodic check */
+    if (!ice->clist.timer.id) {
+        ice->clist.timer.id = PJ_TRUE;
+        delay.sec = delay.msec = 0;
+        status = pj_timer_heap_schedule(ice->stun_cfg.timer_heap, 
+                                        &ice->clist.timer, &delay);
+        if (status != PJ_SUCCESS) {
+            ice->clist.timer.id = PJ_FALSE;
+        }
+    }
+
+    ice->is_nominating = PJ_TRUE;
+}
 
 /* Timer callback to perform periodic check */
@@ -1642 +1850 @@
 
     LOG4((ice->obj_name, "Starting ICE check.."));
+
+    /* If we are using aggressive nomination, set the is_nominating state */
+    if (ice->opt.aggressive)
+        ice->is_nominating = PJ_TRUE;
 
     /* The agent examines the check list for the first media stream (a
@@ -1827 +2039 @@
             LOG4((ice->obj_name, "Resending check because of role conflict"));
             check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_WAITING, 0);
-            perform_check(ice, clist, msg_data->data.req.ckid);
+            perform_check(ice, clist, msg_data->data.req.ckid, 
+                          check->nominated);
             pj_mutex_unlock(ice->mutex);
             return;
@@ -2313 +2526 @@
             c->state == PJ_ICE_SESS_CHECK_STATE_WAITING)
         {
+            /* See if we shall nominate this check */
+            pj_bool_t nominate = (c->nominated || ice->is_nominating);
+
             LOG5((ice->obj_name, "Performing triggered check for check %d",i));
-            perform_check(ice, &ice->clist, i);
+            perform_check(ice, &ice->clist, i, nominate);
 
         } else if (c->state == PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
@@ -2362 +2578 @@
 
         pj_ice_sess_check *c = &ice->clist.checks[ice->clist.count];
+        pj_bool_t nominate;
 
         c->lcand = lcand;
@@ -2370 +2587 @@
         c->err_code = PJ_SUCCESS;
 
+        nominate = (c->nominated || ice->is_nominating);
+
         LOG4((ice->obj_name, "New triggered check added: %d", 
              ice->clist.count));
-        perform_check(ice, &ice->clist, ice->clist.count++);
+        perform_check(ice, &ice->clist, ice->clist.count++, nominate);
 
     } else {