Changeset 1094

Timestamp:

Mar 22, 2007 1:16:37 AM (17 years ago)

Author:

bennylp

Message:

Completed initial test for ICE

Location:

pjproject/trunk/pjnath/src

Files:

• pjnath-test/ice.c (modified) (12 diffs)
• pjnath-test/main.c (modified) (1 diff)
• pjnath-test/test.c (modified) (1 diff)
• pjnath/ice.c (modified) (20 diffs)
• pjnath/stun_msg.c (modified) (3 diffs)

pjproject/trunk/pjnath/src/pjnath-test/ice.c

@@ -24 +24 @@
 struct ice_data
 {
+    const char     *obj_name;
     pj_bool_t       complete;
     pj_status_t     err_code;
     unsigned        rx_rtp_cnt;
     unsigned        rx_rtcp_cnt;
+
+    char            rx_rtp_data[32];
+    char            rx_rtcp_data[32];
 };
 
@@ -38 +42 @@
     id->complete = PJ_TRUE;
     id->err_code = status;
+    PJ_LOG(3,(THIS_FILE, "    ICE %s complete %s", id->obj_name,
+              (status==PJ_SUCCESS ? "successfully" : "with failure")));
 }
 
@@ -47 +53 @@
 {
     struct ice_data *id = (struct ice_data*) icemt->user_data;
+
     id->rx_rtp_cnt++;
+    pj_memcpy(id->rx_rtp_data, pkt, size);
+
+    PJ_UNUSED_ARG(src_addr);
+    PJ_UNUSED_ARG(src_addr_len);
 }
 
@@ -57 +68 @@
 {
     struct ice_data *id = (struct ice_data*) icemt->user_data;
+
     id->rx_rtcp_cnt++;
+    pj_memcpy(id->rx_rtcp_data, pkt, size);
+
+    PJ_UNUSED_ARG(src_addr);
+    PJ_UNUSED_ARG(src_addr_len);
 }
 
@@ -129 +145 @@
 
 
-/* Direct agent to agent communication */
-static int ice_direct_test()
+/* Perform ICE test with the following parameters:
+ *
+ * - title:     The title of the test
+ * - ocand_cnt,
+ *   ocand      Additional candidates to be added to offerer
+ * - acand_cnt,
+ *   acand      Additional candidates to be added to answerer
+ *
+ * The additional candidates are invalid candidates, meaning they
+ * won't be reachable by the agents. They are used to "confuse"
+ * ICE processing.
+ */
+static int perform_ice_test(const char *title,
+                            unsigned ocand_cnt,
+                            const pj_ice_cand ocand[],
+                            unsigned acand_cnt,
+                            const pj_ice_cand acand[])
 {
     pj_icemt *im1, *im2;
     pj_icemt_cb icemt_cb;
     struct ice_data *id1, *id2;
+    pj_timestamp t_start, t_end;
+    pj_ice_cand *rcand;
+    unsigned i;
     pj_status_t status;
 
-    PJ_LOG(3,(THIS_FILE, "...direct communication"));
+    PJ_LOG(3,(THIS_FILE, "...%s", title));
 
     pj_bzero(&icemt_cb, sizeof(icemt_cb));
@@ -145 +179 @@
 
     /* Create first ICE */
-    status = pj_icemt_create(&stun_cfg, NULL, PJ_ICE_ROLE_CONTROLLING,
+    status = pj_icemt_create(&stun_cfg, "offerer", PJ_ICE_ROLE_CONTROLLING,
                              &icemt_cb, 0, PJ_FALSE, PJ_FALSE, NULL, &im1);
     if (status != PJ_SUCCESS)
@@ -151 +185 @@
 
     id1 = PJ_POOL_ZALLOC_T(im1->pool, struct ice_data);
+    id1->obj_name = "offerer";
     im1->user_data = id1;
 
+    /* Add additional candidates */
+    for (i=0; i<ocand_cnt; ++i) {
+        status = pj_ice_add_cand(im1->ice, 1, ocand[i].type, 65535,
+                                 &ocand[i].foundation, &ocand[i].addr,
+                                 &ocand[i].base_addr, &ocand[i].srv_addr,
+                                 sizeof(pj_sockaddr_in), NULL);
+        if (status != PJ_SUCCESS)
+            return -22;
+    }
+
     /* Create second ICE */
-    status = pj_icemt_create(&stun_cfg, NULL, PJ_ICE_ROLE_CONTROLLED,
+    status = pj_icemt_create(&stun_cfg, "answerer", PJ_ICE_ROLE_CONTROLLED,
                              &icemt_cb, 0, PJ_FALSE, PJ_FALSE, NULL, &im2);
     if (status != PJ_SUCCESS)
@@ -160 +205 @@
 
     id2 = PJ_POOL_ZALLOC_T(im2->pool, struct ice_data);
+    id2->obj_name = "answerer";
     im2->user_data = id2;
 
+    /* Add additional candidates */
+    for (i=0; i<acand_cnt; ++i) {
+        status = pj_ice_add_cand(im1->ice, 1, acand[i].type, 65535,
+                                 &acand[i].foundation, &acand[i].addr,
+                                 &acand[i].base_addr, &acand[i].srv_addr,
+                                 sizeof(pj_sockaddr_in), NULL);
+        if (status != PJ_SUCCESS)
+            return -22;
+    }
+
+    /* Set credentials */
     {
-        pj_str_t u1 = pj_str("uname1");
+        pj_str_t u1 = pj_str("offerer");
         pj_str_t p1 = pj_str("pass1");
-        pj_str_t u2 = pj_str("uname2");
+        pj_str_t u2 = pj_str("answerer");
         pj_str_t p2 = pj_str("pass2");
 
@@ -182 +239 @@
         return -35;
 
+    /* Mark start time */
+    pj_get_timestamp(&t_start);
+
     /* Both can start now */
     status = pj_ice_start_check(im1->ice);
@@ -187 +247 @@
         return -40;
 
-#if 0
+#if 1
     status = pj_ice_start_check(im2->ice);
     if (status != PJ_SUCCESS)
-        return -40;
+        return -45;
 #endif
 
     /* Just wait until both completes, or timed out */
-    while (!id1->complete || !id2->complete)
+    while (!id1->complete || !id2->complete) {
+        pj_timestamp t_now;
+
         handle_events(1);
 
+        pj_get_timestamp(&t_now);
+        if (pj_elapsed_msec(&t_start, &t_now) >= 10000) {
+            PJ_LOG(3,(THIS_FILE, "....error: timed-out"));
+            return -50;
+        }
+    }
+
+    /* Mark end-time */
+    pj_get_timestamp(&t_end);
+
+    /* Check status */
+    if (id1->err_code != PJ_SUCCESS)
+        return -53;
+    if (id2->err_code != PJ_SUCCESS)
+        return -56;
+
+    /* Verify that offerer gets answerer's transport address */
+    rcand = im1->ice->clist.checks[im1->ice->comp[0].nominated_check_id].rcand;
+    if (pj_memcmp(&rcand->addr, &im2->ice->lcand[0].addr, sizeof(pj_sockaddr_in))!=0) {
+        PJ_LOG(3,(THIS_FILE, "....error: address mismatch"));
+        return -60;
+    }
+
+    /* And the other way around */
+    rcand = im2->ice->clist.checks[im2->ice->comp[0].nominated_check_id].rcand;
+    if (pj_memcmp(&rcand->addr, &im1->ice->lcand[0].addr, sizeof(pj_sockaddr_in))!=0) {
+        PJ_LOG(3,(THIS_FILE, "....error: address mismatch"));
+        return -70;
+    }
+
+    /* Done */
+    PJ_LOG(3,(THIS_FILE, "....success: ICE completed in %d msec", 
+              pj_elapsed_msec(&t_start, &t_end)));
+
+    /* Wait for some more time */
+    PJ_LOG(3,(THIS_FILE, ".....waiting.."));
+    for (;;) {
+        pj_timestamp t_now;
+
+        pj_get_timestamp(&t_now);
+        if (pj_elapsed_msec(&t_end, &t_now) > 10000)
+            break;
+
+        handle_events(1);
+    }
+
+
+    pj_icemt_destroy(im1);
+    pj_icemt_destroy(im2);
     return 0;
-
 }
 
@@ -208 +318 @@
     pj_ioqueue_t *ioqueue;
     pj_timer_heap_t *timer_heap;
-    
+    pj_ice_cand ocand[PJ_ICE_MAX_CAND];
+    pj_ice_cand acand[PJ_ICE_MAX_CAND];
+    pj_str_t s;
+
     pool = pj_pool_create(mem, NULL, 4000, 4000, NULL);
     pj_ioqueue_create(pool, 12, &ioqueue);
@@ -217 +330 @@
     pj_log_set_level(5);
 
+    /* Basic create/destroy */
     rc = ice_basic_create_destroy_test();
     if (rc != 0)
         goto on_return;
 
-    rc = ice_direct_test();
+    /* Direct communication */
+    rc = perform_ice_test("Direct connection", 0, NULL, 0, NULL);
     if (rc != 0)
         goto on_return;
+
+    /* Direct communication with invalid address */
+    pj_bzero(ocand, sizeof(ocand));
+    pj_sockaddr_in_init(&ocand[0].addr.ipv4, pj_cstr(&s, "127.0.0.127"), 1234);
+    pj_sockaddr_in_init(&ocand[0].base_addr.ipv4, pj_cstr(&s, "127.0.0.128"), 1234);
+    ocand[0].comp_id = 1;
+    ocand[0].foundation = pj_str("H2");
+    ocand[0].type = PJ_ICE_CAND_TYPE_HOST;
+
+    rc = perform_ice_test("Direct connection with 1 invalid address", 1, ocand, 0, NULL);
+    if (rc != 0)
+        goto on_return;
+
 
 on_return:

pjproject/trunk/pjnath/src/pjnath-test/main.c

@@ -49 +49 @@
     rc = test_main();
 
+    if (argc == 2 && pj_ansi_strcmp(argv[1], "-i")==0) {
+        char buf[10];
+        fgets(buf, sizeof(buf), stdin);
+    }
+
     return rc;
 }

pjproject/trunk/pjnath/src/pjnath-test/test.c

@@ -50 +50 @@
     mem = &caching_pool.factory;
 
+#if 0
     pj_log_set_level(3);
     pj_log_set_decor(PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_TIME | 
                      PJ_LOG_HAS_MICRO_SEC);
+#endif
 
     rc = pj_init();

pjproject/trunk/pjnath/src/pjnath/ice.c

@@ -661 +661 @@
 
 static const char *dump_check(char *buffer, unsigned bufsize,
+                              const pj_ice *ice,
                               const pj_ice_check *check)
 {
@@ -672 +673 @@
     if (lcand->addr.addr.sa_family == PJ_AF_INET) {
         len = pj_ansi_snprintf(buffer, bufsize,
-                               "%s:%d-->%s:%d",
+                               "%d: %s:%d-->%s:%d",
+                               GET_CHECK_ID(check),
                                laddr, (int)pj_ntohs(lcand->addr.ipv4.sin_port),
                                pj_inet_ntoa(rcand->addr.ipv4.sin_addr),
@@ -700 +702 @@
     for (i=0; i<clist->count; ++i) {
         const pj_ice_check *c = &clist->checks[i];
-        LOG((ice->obj_name, " %d: %s (prio=0x%"PJ_INT64_FMT"x, state=%s)",
-             i, dump_check(buffer, sizeof(buffer), c),
-             c->prio, check_state_name[c->state]));
-    }
-}
+        LOG((ice->obj_name, " %s (%s, state=%s)",
+             dump_check(buffer, sizeof(buffer), ice, c),
+             (c->nominated ? "nominated" : "not nominated"), 
+             check_state_name[c->state]));
+    }
+}
+
+static void dump_valid_list(const char *title, const pj_ice *ice)
+{
+    unsigned i;
+    char buffer[CHECK_NAME_LEN];
+
+    LOG((ice->obj_name, "%s", title));
+    for (i=0; i<ice->valid_cnt; ++i) {
+        const pj_ice_check *c = &ice->clist.checks[ice->valid_list[i]];
+        LOG((ice->obj_name, " %s (%s, state=%s)",
+             dump_check(buffer, sizeof(buffer), ice, c),
+             (c->nominated ? "nominated" : "not nominated"), 
+             check_state_name[c->state]));
+    }
+}
+
 #else
 #define dump_checklist(ice, clist)
@@ -714 +733 @@
 {
     char buf[CHECK_NAME_LEN];
+
+    pj_assert(check->state < PJ_ICE_CHECK_STATE_SUCCEEDED);
+
     LOG((ice->obj_name, "Check %s: state changed from %s to %s",
-         dump_check(buf, sizeof(buf), check),
+         dump_check(buf, sizeof(buf), ice, check),
          check_state_name[check->state],
          check_state_name[st]));
@@ -725 +747 @@
                             pj_ice_checklist_state st)
 {
-    LOG((ice->obj_name, "Checklist: state changed from %s to %s",
-         clist_state_name[clist->state],
-         clist_state_name[st]));
-    clist->state = st;
+    if (clist->state != st) {
+        LOG((ice->obj_name, "Checklist: state changed from %s to %s",
+             clist_state_name[clist->state],
+             clist_state_name[st]));
+        clist->state = st;
+    }
 }
 
@@ -841 +865 @@
 
             if (ljcand->type == PJ_ICE_CAND_TYPE_SRFLX)
-                ljaddr = &licand->base_addr;
+                ljaddr = &ljcand->base_addr;
             else
-                ljaddr = &licand->addr;
+                ljaddr = &ljcand->addr;
 
             if (sockaddr_cmp(liaddr, ljaddr) == SOCKADDR_EQUAL &&
@@ -852 +876 @@
 
                 LOG((ice->obj_name, "Check %s pruned",
-                    dump_check(buf, sizeof(buf), &clist->checks[j])));
+                    dump_check(buf, sizeof(buf), ice, &clist->checks[j])));
 
                 pj_array_erase(clist->checks, sizeof(clist->checks[0]),
@@ -872 +896 @@
         ice->is_complete = PJ_TRUE;
         ice->ice_status = status;
+    
+        /* Log message */
+        LOG((ice->obj_name, "ICE process complete"));
+        dump_checklist("Dumping checklist", ice, &ice->clist);
+        dump_valid_list("Dumping valid list", ice);
 
         /* Call callback */
@@ -899 +928 @@
         pj_ice_comp *comp;
 
+        LOG((ice->obj_name, "Check %d is successful and nominated",
+             GET_CHECK_ID(check)));
+
         for (i=0; i<ice->clist.count; ++i) {
             pj_ice_check *c = &ice->clist.checks[i];
@@ -905 +937 @@
                  c->state==PJ_ICE_CHECK_STATE_WAITING))
             {
-                check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED,
+                LOG((ice->obj_name, 
+                     "Check %d to be failed because state is %s",
+                     i, check_state_name[c->state]));
+                check_set_state(ice, c, PJ_ICE_CHECK_STATE_FAILED,
                                 PJ_ECANCELLED);
             }
@@ -953 +988 @@
 
 
+#if 0
     /* For now, just see if we have a valid pair in component 1 and
      * just terminate ICE.
@@ -967 +1003 @@
         return PJ_TRUE;
     }
-
-    /* We don't have valid pair for component 1.
-     * See if we have performed all checks in the checklist. If we do,
+#else
+    /* See if all components have nominated pair. If they do, then mark
+     * ICE processing as success, otherwise wait.
+     */
+    for (i=0; i<ice->comp_cnt; ++i) {
+        if (ice->comp[i].nominated_check_id == -1)
+            break;
+    }
+    if (i == ice->comp_cnt) {
+        /* All components have nominated pair */
+        on_ice_complete(ice, PJ_SUCCESS);
+        return PJ_TRUE;
+    }
+#endif
+
+    /* 
+     * See if all checks in the checklist have completed. If we do,
      * then mark ICE processing as failed.
      */
@@ -1101 +1151 @@
 
     LOG((ice->obj_name, 
-         "Sending connectivity check for check %d: %s", 
-         check_id, dump_check(buffer, sizeof(buffer), check)));
+         "Sending connectivity check for check %s", 
+         dump_check(buffer, sizeof(buffer), ice, check)));
 
     /* Create request */
@@ -1316 +1366 @@
 
     LOG((ice->obj_name, 
-         "Connectivity check %s for check %s",
-         (status==PJ_SUCCESS ? "SUCCESS" : "FAILED"), 
-         dump_check(buffer, sizeof(buffer), check)));
+         "Check %s%s: connectivity check %s",
+         dump_check(buffer, sizeof(buffer), ice, check),
+         (check->nominated ? " (nominated)" : " (not nominated)"),
+         (status==PJ_SUCCESS ? "SUCCESS" : "FAILED")));
 
     if (status != PJ_SUCCESS) {
         check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, status);
+        on_check_complete(ice, check);
         pj_mutex_unlock(ice->mutex);
         return;
@@ -1340 +1392 @@
         check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, 
                         PJNATH_ESTUNNOXORMAP);
+        on_check_complete(ice, check);
         pj_mutex_unlock(ice->mutex);
         return;
@@ -1366 +1419 @@
         if (status != PJ_SUCCESS) {
             check_set_state(ice, check, PJ_ICE_CHECK_STATE_FAILED, status);
+            on_check_complete(ice, check);
             pj_mutex_unlock(ice->mutex);
             return;
@@ -1548 +1602 @@
                                                   "f%p", 
                                                   rcand->foundation.ptr);
+
+        LOG((ice->obj_name, 
+             "Added new remote candidate from the request: %s:%d",
+             pj_inet_ntoa(rcand->addr.ipv4.sin_addr),
+             (int)pj_ntohs(rcand->addr.ipv4.sin_port)));
+
     } else {
         /* Remote candidate found */
@@ -1607 +1667 @@
         pj_ice_check *c = &ice->clist.checks[i];
 
-        /* If USE-CANDIDATE is present, set nominated flag */
-        c->nominated = (uc != NULL);
+        /* If USE-CANDIDATE is present, set nominated flag 
+         * Note: DO NOT overwrite nominated flag if one is already set.
+         */
+        c->nominated = ((uc != NULL) || c->nominated);
 
         if (c->state == PJ_ICE_CHECK_STATE_FROZEN ||
@@ -1620 +1682 @@
              * TODO
              */
+            LOG((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) {
             /* Check complete for this component.
@@ -1625 +1689 @@
              */
             pj_bool_t complete;
+
+            LOG((ice->obj_name, "Triggered check for check %d not performed "
+                                "because it's completed", i));
 
             complete = on_check_complete(ice, c);

pjproject/trunk/pjnath/src/pjnath/stun_msg.c

@@ -866 +866 @@
 
     attr = PJ_POOL_ZALLOC_T(pool, pj_stun_empty_attr);
-    INIT_ATTR(attr, attr_type, sizeof(pj_stun_empty_attr));
+    INIT_ATTR(attr, attr_type, 0);
 
     *p_attr = attr;
@@ -909 +909 @@
 
     /* Check that the attribute length is valid */
-    if (attr->hdr.length != ATTR_HDR_LEN)
+    if (attr->hdr.length != 0)
         return PJNATH_ESTUNINATTRLEN;
 
@@ -931 +931 @@
     attr = (pj_stun_empty_attr*) buf;
     attr->hdr.type = pj_htons(attr->hdr.type);
-    pj_assert(attr->hdr.length == ATTR_HDR_LEN);
-    attr->hdr.length = pj_htons(ATTR_HDR_LEN);
+    attr->hdr.length = 0;
 
     /* Done */