Changeset 1096 for pjproject

Timestamp:

Mar 22, 2007 9:00:53 PM (18 years ago)

Author:

bennylp

Message:

Final ICE stream transport

Location:

pjproject/trunk/pjnath

Files:

• build/pjnath.dsp (modified) (2 diffs)
• include/pjnath.h (modified) (1 diff)
• include/pjnath/errno.h (modified) (1 diff)
• include/pjnath/ice.h (modified) (6 diffs)
• include/pjnath/ice_stream_transport.h (moved) (moved from pjproject/trunk/pjnath/include/pjnath/ice_mt.h) (5 diffs)
• src/pjnath-test/ice_test.c (modified) (11 diffs)
• src/pjnath/ice.c (modified) (27 diffs)
• src/pjnath/ice_stream_transport.c (moved) (moved from pjproject/trunk/pjnath/src/pjnath/ice_mt.c) (8 diffs)

pjproject/trunk/pjnath/build/pjnath.dsp

@@ -96 +96 @@
 # Begin Source File
 
-SOURCE=..\src\pjnath\ice_mt.c
+SOURCE=..\src\pjnath\ice_stream_transport.c
 # End Source File
 # Begin Source File
@@ -136 +136 @@
 # Begin Source File
 
-SOURCE=..\include\pjnath\ice_mt.h
+SOURCE=..\include\pjnath\ice_stream_transport.h
 # End Source File
 # Begin Source File

pjproject/trunk/pjnath/include/pjnath.h

@@ -21 +21 @@
 #include <pjnath/errno.h>
 #include <pjnath/ice.h>
-#include <pjnath/ice_mt.h>
+#include <pjnath/ice_stream_transport.h>
 #include <pjnath/stun_auth.h>
 #include <pjnath/stun_config.h>

pjproject/trunk/pjnath/include/pjnath/errno.h

@@ -156 +156 @@
 /**
  * @hideinitializer
+ * Invalid ICE candidate ID
+ */
+#define PJ_EICEINCANDID             -1
+/**
+ * @hideinitializer
+ * ICE session not available
+ */
+#define PJ_ENOICE                   -1
+
+ /**
+ * @hideinitializer
  * ICE check is in progress
  */

pjproject/trunk/pjnath/include/pjnath/ice.h

@@ -82 +82 @@
 {
     unsigned         comp_id;
-    pj_stun_session *stun_sess;
-    pj_sockaddr      local_addr;
     int              nominated_check_id;
 } pj_ice_comp;
@@ -100 +98 @@
     pj_sockaddr          base_addr;
     pj_sockaddr          srv_addr;
+    pj_stun_session     *stun_sess;
 } pj_ice_cand;
 
@@ -146 +145 @@
 {
     void        (*on_ice_complete)(pj_ice *ice, pj_status_t status);
-    pj_status_t (*on_tx_pkt)(pj_ice *ice, unsigned comp_id,
+    pj_status_t (*on_tx_pkt)(pj_ice *ice, unsigned comp_id, 
+                             unsigned cand_id,
                              const void *pkt, pj_size_t size,
                              const pj_sockaddr_t *dst_addr,
                              unsigned dst_addr_len);
-    pj_status_t (*on_rx_data)(pj_ice *ice, unsigned comp_id,
+    void        (*on_rx_data)(pj_ice *ice, unsigned comp_id,
+                              unsigned cand_id,
                               void *pkt, pj_size_t size,
                               const pj_sockaddr_t *src_addr,
@@ -213 +214 @@
                                    pj_ice_role role,
                                    const pj_ice_cb *cb,
+                                   const pj_str_t *local_ufrag,
+                                   const pj_str_t *local_passwd,
                                    pj_ice **p_ice);
 PJ_DECL(pj_status_t) pj_ice_destroy(pj_ice *ice);
-PJ_DECL(pj_status_t) pj_ice_add_comp(pj_ice *ice,
-                                     unsigned comp_id,
-                                     const pj_sockaddr_t *local_addr,
-                                     unsigned addr_len);
-PJ_DECL(pj_status_t) pj_ice_set_credentials(pj_ice *ice,
-                                            const pj_str_t *local_ufrag,
-                                            const pj_str_t *local_pass,
-                                            const pj_str_t *remote_ufrag,
-                                            const pj_str_t *remote_pass);
+PJ_DECL(pj_status_t) pj_ice_add_comp(pj_ice *ice, unsigned comp_id);
 PJ_DECL(pj_status_t) pj_ice_add_cand(pj_ice *ice,
                                      unsigned comp_id,
@@ -247 +242 @@
 
 PJ_DECL(pj_status_t) pj_ice_create_check_list(pj_ice *ice,
+                                              const pj_str_t *rem_ufrag,
+                                              const pj_str_t *rem_passwd,
                                               unsigned rem_cand_cnt,
                                               const pj_ice_cand rem_cand[]);
@@ -257 +254 @@
 PJ_DECL(pj_status_t) pj_ice_on_rx_pkt(pj_ice *ice,
                                       unsigned comp_id,
+                                      unsigned cand_id,
                                       void *pkt,
                                       pj_size_t pkt_size,

pjproject/trunk/pjnath/include/pjnath/ice_stream_transport.h

@@ -17 +17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  */
-#ifndef __PJNATH_ICE_MT_H__
-#define __PJNATH_ICE_MT_H__
+#ifndef __PJNATH_ICE_STREAM_TRANSPORT_H__
+#define __PJNATH_ICE_STREAM_TRANSPORT_H__
 
 
@@ -26 +26 @@
  */
 #include <pjnath/ice.h>
+#include <pjlib-util/resolver.h>
 #include <pj/ioqueue.h>
 
@@ -33 +34 @@
 
 /**
- * @defgroup PJNATH_ICE_MEDIA_TRANSPORT ICE Media Transport
- * @brief ICE Media Transport
+ * @defgroup PJNATH_ICE_STREAM_TRANSPORT ICE Stream Transport
+ * @brief Transport for media stream using ICE
  * @ingroup PJNATH_ICE
  * @{
  */
 
-typedef struct pj_icemt pj_icemt;
+typedef struct pj_ice_st pj_ice_st;
 
-typedef struct pj_icemt_cb
+typedef struct pj_ice_st_cb
 {
-    void        (*on_ice_complete)(pj_icemt *icemt, 
-                                   pj_status_t status);
-    void        (*on_rx_rtp)(pj_icemt *icemt,
-                             void *pkt, pj_size_t size,
-                             const pj_sockaddr_t *src_addr,
-                             unsigned src_addr_len);
-    void        (*on_rx_rtcp)(pj_icemt *icemt,
-                              void *pkt, pj_size_t size,
-                              const pj_sockaddr_t *src_addr,
-                              unsigned src_addr_len);
+    void    (*on_rx_data)(pj_ice_st *ice_st,
+                          unsigned comp_id, unsigned cand_id,
+                          void *pkt, pj_size_t size,
+                          const pj_sockaddr_t *src_addr,
+                          unsigned src_addr_len);
 
-} pj_icemt_cb;
+    void    (*on_stun_srv_resolved)(pj_ice_st *ice_st,
+                                    pj_status_t status);
+    void    (*on_interface_status)(pj_ice_st *ice_st,
+                                   void *notify_data,
+                                   pj_status_t status,
+                                   int itf_id);
+    void    (*on_ice_complete)(pj_ice_st *ice_st, 
+                               pj_status_t status);
+
+} pj_ice_st_cb;
 
 
-typedef struct pj_icemt_sock
+typedef struct pj_ice_st_comp
 {
-    pj_icemt            *icemt;
     unsigned             comp_id;
+} pj_ice_st_comp;
+
+
+typedef struct pj_ice_st_interface
+{
+    pj_ice_st           *ice_st;
+    pj_ice_cand_type     type;
+    unsigned             comp_id;
+    int                  cand_id;
+    pj_str_t             foundation;
+    pj_uint16_t          local_pref;
     pj_sock_t            sock;
     pj_sockaddr          addr;
@@ -70 +85 @@
     pj_sockaddr          src_addr;
     int                  src_addr_len;
-} pj_icemt_sock;
+} pj_ice_st_interface;
 
 
-struct pj_icemt
+struct pj_ice_st
 {
-    pj_pool_t       *pool;
-    pj_ice          *ice;
-    void            *user_data;
+    char                     obj_name[PJ_MAX_OBJ_NAME];
+    pj_pool_t               *pool;
+    void                    *user_data;
+    pj_stun_config           stun_cfg;
+    pj_ice_st_cb             cb;
 
-    pj_icemt_cb      cb;
+    pj_ice                  *ice;
 
-    pj_icemt_sock    rtp;
-    pj_icemt_sock    rtcp;
+    unsigned                 comp_cnt;
+    unsigned                 comps[PJ_ICE_MAX_COMP];
 
-    pj_bool_t        has_turn;
-    pj_sockaddr      stun_srv;
+    unsigned                 itf_cnt;
+    pj_ice_st_interface     *itfs[PJ_ICE_MAX_CAND];
+
+    pj_dns_resolver         *resolver;
+    pj_bool_t                relay_enabled;
+    pj_str_t                 stun_domain;
+    pj_sockaddr_in           stun_srv;
 };
 
 
-PJ_DECL(pj_status_t) pj_icemt_create(pj_stun_config *stun_cfg,
-                                     const char *name,
-                                     pj_ice_role role,
-                                     const pj_icemt_cb *cb,
-                                     unsigned rtp_port,
-                                     pj_bool_t has_rtcp,
-                                     pj_bool_t has_turn,
-                                     const pj_sockaddr *srv,
-                                     pj_icemt **p_icemt);
-PJ_DECL(pj_status_t) pj_icemt_destroy(pj_icemt *icemt);
+PJ_DECL(pj_status_t) pj_ice_st_create(pj_stun_config *stun_cfg,
+                                      const char *name,
+                                      void *user_data,
+                                      const pj_ice_st_cb *cb,
+                                      pj_ice_st **p_ice_st);
+PJ_DECL(pj_status_t) pj_ice_st_destroy(pj_ice_st *ice_st);
 
+PJ_DECL(pj_status_t) pj_ice_st_set_stun(pj_ice_st *ice_st,
+                                        pj_dns_resolver *resolver,
+                                        pj_bool_t enable_relay,
+                                        const pj_str_t *domain);
+PJ_DECL(pj_status_t) pj_ice_st_set_stun_addr(pj_ice_st *ice_st,
+                                             pj_bool_t enable_relay,
+                                             const pj_sockaddr_in *srv_addr);
+
+PJ_DECL(pj_status_t) pj_ice_st_add_comp(pj_ice_st *ice_st,
+                                        unsigned comp_id);
+
+PJ_DECL(pj_status_t) pj_ice_st_add_host_interface(pj_ice_st *ice_st,
+                                                  unsigned comp_id,
+                                                  pj_uint16_t local_pref,
+                                                  const pj_sockaddr_in *addr,
+                                                  unsigned *p_itf_id,
+                                                  pj_bool_t notify,
+                                                  void *notify_data);
+PJ_DECL(pj_status_t) pj_ice_st_add_all_host_interfaces(pj_ice_st *ice_st,
+                                                       unsigned comp_id,
+                                                       unsigned port,
+                                                       pj_bool_t notify,
+                                                       void *notify_data);
+PJ_DECL(pj_status_t) pj_ice_st_add_stun_interface(pj_ice_st *ice_st,
+                                                  unsigned comp_id,
+                                                  unsigned local_port,
+                                                  pj_bool_t notify,
+                                                  void *notify_data);
+PJ_DECL(pj_status_t) pj_ice_st_add_relay_interface(pj_ice_st *ice_st,
+                                                   unsigned comp_id,
+                                                   unsigned local_port,
+                                                   pj_bool_t notify,
+                                                   void *notify_data);
+
+
+PJ_DECL(pj_status_t) pj_ice_st_init_ice(pj_ice_st *ice_st,
+                                        pj_ice_role role,
+                                        const pj_str_t *local_ufrag,
+                                        const pj_str_t *local_passwd);
+PJ_DECL(pj_status_t) pj_ice_st_enum_cands(pj_ice_st *ice_st,
+                                          unsigned *count,
+                                          pj_ice_cand cand[]);
+PJ_DECL(pj_status_t) pj_ice_st_start_ice(pj_ice_st *ice_st,
+                                         const pj_str_t *rem_ufrag,
+                                         const pj_str_t *rem_passwd,
+                                         unsigned rem_cand_cnt,
+                                         const pj_ice_cand rem_cand[]);
+PJ_DECL(pj_status_t) pj_ice_st_stop_ice(pj_ice_st *ice_st);
+
+PJ_DECL(pj_status_t) pj_ice_st_send_data(pj_ice_st *ice_st,
+                                         unsigned comp_id,
+                                         const void *data,
+                                         pj_size_t data_len);
 
 
@@ -111 +182 @@
 
 
-#endif  /* __PJNATH_ICE_MT_H__ */
+#endif  /* __PJNATH_ICE_STREAM_TRANSPORT_H__ */
 

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

@@ -38 +38 @@
 static pj_stun_config stun_cfg;
 
-static void on_ice_complete(pj_icemt *icemt, 
+static void on_ice_complete(pj_ice_st *icest, 
                             pj_status_t status)
 {
-    struct ice_data *id = (struct ice_data*) icemt->user_data;
+    struct ice_data *id = (struct ice_data*) icest->user_data;
     id->complete = PJ_TRUE;
     id->err_code = status;
@@ -49 +49 @@
 
 
-static void on_rx_rtp(pj_icemt *icemt,
-                      void *pkt, pj_size_t size,
-                      const pj_sockaddr_t *src_addr,
-                      unsigned src_addr_len)
-{
-    struct ice_data *id = (struct ice_data*) icemt->user_data;
-
-    id->rx_rtp_cnt++;
-    pj_memcpy(id->last_rx_rtp_data, pkt, size);
-    id->last_rx_rtp_data[size] = '\0';
-
-    PJ_UNUSED_ARG(src_addr);
-    PJ_UNUSED_ARG(src_addr_len);
-}
-
-
-static void on_rx_rtcp(pj_icemt *icemt,
+static void on_rx_data(pj_ice_st *icest,
+                       unsigned comp_id, unsigned cand_id,
                        void *pkt, pj_size_t size,
                        const pj_sockaddr_t *src_addr,
                        unsigned src_addr_len)
 {
-    struct ice_data *id = (struct ice_data*) icemt->user_data;
-
-    id->rx_rtcp_cnt++;
-    pj_memcpy(id->last_rx_rtcp_data, pkt, size);
-    id->last_rx_rtcp_data[size] = '\0';
-
+    struct ice_data *id = (struct ice_data*) icest->user_data;
+
+    if (comp_id == 1) {
+        id->rx_rtp_cnt++;
+        pj_memcpy(id->last_rx_rtp_data, pkt, size);
+        id->last_rx_rtp_data[size] = '\0';
+    } else if (comp_id == 2) {
+        id->rx_rtcp_cnt++;
+        pj_memcpy(id->last_rx_rtcp_data, pkt, size);
+        id->last_rx_rtcp_data[size] = '\0';
+    } else {
+        pj_assert(!"Invalid component ID");
+    }
+
+    PJ_UNUSED_ARG(cand_id);
     PJ_UNUSED_ARG(src_addr);
     PJ_UNUSED_ARG(src_addr_len);
@@ -98 +92 @@
 static int ice_basic_create_destroy_test()
 {
-    pj_icemt *im;
-    pj_ice *ice;
-    pj_icemt_cb icemt_cb;
+    pj_ice_st *im;
+    pj_ice_st_cb icest_cb;
     pj_status_t status;
 
     PJ_LOG(3,(THIS_FILE, "...basic create/destroy"));
 
-    pj_bzero(&icemt_cb, sizeof(icemt_cb));
-    icemt_cb.on_ice_complete = &on_ice_complete;
-    icemt_cb.on_rx_rtp = &on_rx_rtp;
-    icemt_cb.on_rx_rtcp = &on_rx_rtcp;
-
-    status = pj_icemt_create(&stun_cfg, NULL, PJ_ICE_ROLE_CONTROLLING,
-                             &icemt_cb, 0, PJ_FALSE, PJ_FALSE, NULL, &im);
+    pj_bzero(&icest_cb, sizeof(icest_cb));
+    icest_cb.on_ice_complete = &on_ice_complete;
+    icest_cb.on_rx_data = &on_rx_data;
+
+    status = pj_ice_st_create(&stun_cfg, NULL, NULL, &icest_cb, &im);
     if (status != PJ_SUCCESS)
         return -10;
 
-    ice = im->ice;
-
-    pj_icemt_destroy(im);
+    pj_ice_st_destroy(im);
 
     return 0;
@@ -123 +112 @@
 
 
-static pj_status_t set_remote_list(pj_icemt *src, pj_icemt *dst)
-{
-    unsigned i, count;
-    unsigned cand_id[PJ_ICE_MAX_CAND];
+static pj_status_t start_ice(pj_ice_st *ist, pj_ice_st *remote)
+{
+    unsigned count;
     pj_ice_cand cand[PJ_ICE_MAX_CAND];
     pj_status_t status;
 
-    count = PJ_ARRAY_SIZE(cand_id);
-    status = pj_ice_enum_cands(src->ice, &count, cand_id);
+    count = PJ_ARRAY_SIZE(cand);
+    status = pj_ice_st_enum_cands(remote, &count, cand);
     if (status != PJ_SUCCESS)
         return status;
 
-    for (i=0; i<count; ++i) {
-        pj_ice_cand *p_cand;
-        status = pj_ice_get_cand(src->ice, cand_id[i], &p_cand);
-        if (status != PJ_SUCCESS)
-            return status;
-
-        pj_memcpy(&cand[i], p_cand, sizeof(pj_ice_cand));
-    }
-
-    status = pj_ice_create_check_list(dst->ice, count, cand);
-    return status;
-}
+    return pj_ice_st_start_ice(ist, &remote->ice->rx_ufrag, &remote->ice->rx_pass,
+                               count, cand);
+}
+
 
 
@@ -163 +143 @@
 static int perform_ice_test(const char *title,
                             unsigned wait_before_send,
-                            unsigned max_total_time,
-                            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;
+                            unsigned max_total_time)
+{
+    pj_ice_st *im1, *im2;
+    pj_ice_st_cb icest_cb;
     struct ice_data *id1, *id2;
     pj_timestamp t_start, t_end;
     pj_ice_cand *rcand;
     pj_str_t data_from_offerer, data_from_answerer;
-    unsigned i;
     pj_status_t status;
 
     PJ_LOG(3,(THIS_FILE, "...%s", title));
 
-    pj_bzero(&icemt_cb, sizeof(icemt_cb));
-    icemt_cb.on_ice_complete = &on_ice_complete;
-    icemt_cb.on_rx_rtp = &on_rx_rtp;
-    icemt_cb.on_rx_rtcp = &on_rx_rtcp;
+    pj_bzero(&icest_cb, sizeof(icest_cb));
+    icest_cb.on_ice_complete = &on_ice_complete;
+    icest_cb.on_rx_data = &on_rx_data;
 
     /* Create first ICE */
-    status = pj_icemt_create(&stun_cfg, "offerer", PJ_ICE_ROLE_CONTROLLING,
-                             &icemt_cb, 0, PJ_FALSE, PJ_FALSE, NULL, &im1);
+    status = pj_ice_st_create(&stun_cfg, "offerer", NULL, &icest_cb, &im1);
     if (status != PJ_SUCCESS)
         return -20;
@@ -195 +168 @@
     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;
-    }
+    /* Add first component */
+    status = pj_ice_st_add_comp(im1, 1);
+    if (status != PJ_SUCCESS)
+        return -21;
+
+    /* Add host candidate */
+    status = pj_ice_st_add_host_interface(im1, 1, 65535, NULL, NULL, PJ_FALSE, NULL);
+    if (status != PJ_SUCCESS)
+        return -21;
 
     /* Create second ICE */
-    status = pj_icemt_create(&stun_cfg, "answerer", PJ_ICE_ROLE_CONTROLLED,
-                             &icemt_cb, 0, PJ_FALSE, PJ_FALSE, NULL, &im2);
+    status = pj_ice_st_create(&stun_cfg, "answerer", NULL, &icest_cb, &im2);
     if (status != PJ_SUCCESS)
         return -25;
@@ -215 +187 @@
     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("offerer");
-        pj_str_t p1 = pj_str("pass1");
-        pj_str_t u2 = pj_str("answerer");
-        pj_str_t p2 = pj_str("pass2");
-
-        pj_ice_set_credentials(im1->ice, &u1, &p1, &u2, &p2);
-        pj_ice_set_credentials(im2->ice, &u2, &p2, &u1, &p1);
-    }
-
-    /* Send offer to im2 */
-    status = set_remote_list(im1, im2);
+    /* Add first component */
+    status = pj_ice_st_add_comp(im2, 1);
+    if (status != PJ_SUCCESS)
+        return -26;
+
+    /* Add host candidate */
+    status = pj_ice_st_add_host_interface(im2, 1, 65535, NULL, NULL, PJ_FALSE, NULL);
+    if (status != PJ_SUCCESS)
+        return -27;
+
+    /* Init ICE on im1 */
+    status = pj_ice_st_init_ice(im1, PJ_ICE_ROLE_CONTROLLING, NULL, NULL);
+    if (status != PJ_SUCCESS)
+        return -29;
+
+    /* Init ICE on im2 */
+    status = pj_ice_st_init_ice(im2, PJ_ICE_ROLE_CONTROLLED, NULL, NULL);
+    if (status != PJ_SUCCESS)
+        return -29;
+
+    /* Start ICE on im2 */
+    status = start_ice(im2, im1);
     if (status != PJ_SUCCESS)
         return -30;
 
-    /* Send answer to im1 */
-    status = set_remote_list(im2, im1);
+    /* Start ICE on im1 */
+    status = start_ice(im1, im2);
     if (status != PJ_SUCCESS)
         return -35;
@@ -248 +219 @@
     /* Mark start time */
     pj_get_timestamp(&t_start);
-
-    /* Both can start now */
-    status = pj_ice_start_check(im1->ice);
-    if (status != PJ_SUCCESS)
-        return -40;
-
-#if 1
-    status = pj_ice_start_check(im2->ice);
-    if (status != PJ_SUCCESS)
-        return -45;
-#endif
 
     /* Poll for wait_before_send msecs before we send the first data */
@@ -366 +326 @@
 
 
-    pj_icemt_destroy(im1);
-    pj_icemt_destroy(im2);
+    pj_ice_st_destroy(im1);
+    pj_ice_st_destroy(im2);
     return 0;
 }
@@ -378 +338 @@
     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);
@@ -396 +353 @@
 
     /* Direct communication */
-    rc = perform_ice_test("Direct connection", 500, 1000, 0, NULL, 0, NULL);
+    rc = perform_ice_test("Direct connection", 500, 1000);
     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", 500, 1000, 1, ocand, 0, NULL);
+    rc = perform_ice_test("Direct connection with 1 invalid address", 500, 1000);
     if (rc != 0)
         goto on_return;
 
     /* Direct communication with two components */
-    rc = perform_ice_test("Direct connection with two components", 500, 1000, 0, NULL, 0, NULL);
+    rc = perform_ice_test("Direct connection with two components", 500, 1000);
     if (rc != 0)
         goto on_return;

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

@@ -22 +22 @@
 #include <pj/array.h>
 #include <pj/assert.h>
+#include <pj/guid.h>
 #include <pj/log.h>
 #include <pj/os.h>
@@ -69 +70 @@
 {
     pj_ice      *ice;
-    unsigned     comp_id;
-    pj_ice_comp *comp;
+    unsigned     lcand_id;
+    pj_ice_cand *lcand;
 } stun_data;
 
@@ -133 +134 @@
 
 
+/*
+ * Create ICE stream session.
+ */
 PJ_DEF(pj_status_t) pj_ice_create(pj_stun_config *stun_cfg,
                                   const char *name,
                                   pj_ice_role role,
                                   const pj_ice_cb *cb,
+                                  const pj_str_t *local_ufrag,
+                                  const pj_str_t *local_passwd,
                                   pj_ice **p_ice)
 {
     pj_pool_t *pool;
     pj_ice *ice;
+    char tmp[32];
+    pj_str_t s;
     unsigned i;
     pj_status_t status;
@@ -146 +154 @@
     PJ_ASSERT_RETURN(stun_cfg && cb && p_ice, PJ_EINVAL);
 
-    if (!name)
+    if (name == NULL)
         name = "ice%p";
 
@@ -171 +179 @@
     }
 
+    if (local_ufrag == NULL) {
+        pj_ansi_snprintf(tmp, sizeof(tmp), "%x", pj_rand());
+        s = pj_str(tmp);
+        local_ufrag = &s;
+    }
+    pj_strdup(ice->pool, &ice->rx_ufrag, local_ufrag);
+
+    if (local_passwd == NULL) {
+        pj_ansi_snprintf(tmp, sizeof(tmp), "%x", pj_rand());
+        s = pj_str(tmp);
+        local_passwd = &s;
+    }
+    pj_strdup(ice->pool, &ice->rx_pass, local_passwd);
+
+
     /* Done */
     *p_ice = ice;
 
-    LOG((ice->obj_name, "ICE media stream created"));
+    LOG((ice->obj_name, "ICE stream session created, role is %s agent",
+        (ice->role==PJ_ICE_ROLE_CONTROLLING ? "controlling" : "controlled")));
 
     return PJ_SUCCESS;
@@ -180 +204 @@
 
 
+/*
+ * Destroy
+ */
 static void destroy_ice(pj_ice *ice,
                         pj_status_t reason)
@@ -190 +217 @@
 
     for (i=0; i<ice->comp_cnt; ++i) {
-        pj_ice_comp *comp = &ice->comp[i];
-
-        if (comp->stun_sess) {
-            pj_stun_session_destroy(comp->stun_sess);
-            comp->stun_sess = NULL;
+        /* Nothing to do */
+    }
+
+    for (i=0; i<ice->lcand_cnt; ++i) {
+        if (ice->lcand[i].stun_sess) {
+            pj_stun_session_destroy(ice->lcand[i].stun_sess);
+            ice->lcand[i].stun_sess = NULL;
         }
     }
@@ -223 +252 @@
 
 
+/* Find component by ID */
 static pj_ice_comp *find_comp(const pj_ice *ice, unsigned comp_id)
 {
@@ -228 +258 @@
     for (i=0; i<ice->comp_cnt; ++i) {
         if (ice->comp[i].comp_id == comp_id)
-            return (pj_ice_comp*) &ice->comp[i];
+            return (pj_ice_comp *) &ice->comp[i];
     }
 
@@ -235 +265 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_add_comp(pj_ice *ice,
-                                    unsigned comp_id,
-                                    const pj_sockaddr_t *local_addr,
-                                    unsigned addr_len)
-{
-    pj_stun_session_cb sess_cb;
+/* Add a new component */
+PJ_DEF(pj_status_t) pj_ice_add_comp(pj_ice *ice, unsigned comp_id)
+{
     pj_ice_comp *comp;
-    pj_stun_auth_cred auth_cred;
-    stun_data *sd;
-    pj_status_t status;
-
-    PJ_ASSERT_RETURN(ice && local_addr && addr_len, PJ_EINVAL);
+
+    PJ_ASSERT_RETURN(ice && comp_id, PJ_EINVAL);
     PJ_ASSERT_RETURN(ice->comp_cnt < PJ_ARRAY_SIZE(ice->comp), PJ_ETOOMANY);
+    PJ_ASSERT_RETURN(comp_id==ice->comp_cnt+1, PJ_EICEINCOMPID);
     PJ_ASSERT_RETURN(find_comp(ice, comp_id) == NULL, PJ_EEXISTS);
 
@@ -255 +280 @@
     comp->comp_id = comp_id;
     comp->nominated_check_id = -1;
-    pj_memcpy(&comp->local_addr, local_addr, addr_len);
-
-    /* Init STUN callbacks */
-    pj_bzero(&sess_cb, sizeof(sess_cb));
-    sess_cb.on_request_complete = &on_stun_request_complete;
-    sess_cb.on_rx_indication = &on_stun_rx_indication;
-    sess_cb.on_rx_request = &on_stun_rx_request;
-    sess_cb.on_send_msg = &on_stun_send_msg;
-
-    /* Create STUN session for this component */
-    status = pj_stun_session_create(&ice->stun_cfg, ice->obj_name, 
-                                    &sess_cb, PJ_FALSE,
-                                    &comp->stun_sess);
-    if (status != PJ_SUCCESS) {
-        pj_mutex_unlock(ice->mutex);
-        return status;
-    }
-
-    /* Associate data with this STUN session */
-    sd = PJ_POOL_ZALLOC_T(ice->pool, struct stun_data);
-    sd->ice = ice;
-    sd->comp_id = comp_id;
-    sd->comp = comp;
-    pj_stun_session_set_user_data(comp->stun_sess, sd);
-
-    /* Init STUN authentication credential */
-    pj_bzero(&auth_cred, sizeof(auth_cred));
-    auth_cred.type = PJ_STUN_AUTH_CRED_DYNAMIC;
-    auth_cred.data.dyn_cred.get_auth = &stun_auth_get_auth;
-    auth_cred.data.dyn_cred.get_cred = &stun_auth_get_cred;
-    auth_cred.data.dyn_cred.get_password = &stun_auth_get_password;
-    auth_cred.data.dyn_cred.verify_nonce = &stun_auth_verify_nonce;
-    auth_cred.data.dyn_cred.user_data = comp->stun_sess;
-    pj_stun_session_set_credential(comp->stun_sess, &auth_cred);
 
     /* Done */
@@ -409 +400 @@
 
 
-PJ_DEF(pj_status_t) pj_ice_set_credentials(pj_ice *ice,
-                                           const pj_str_t *local_ufrag,
-                                           const pj_str_t *local_pass,
-                                           const pj_str_t *remote_ufrag,
-                                           const pj_str_t *remote_pass)
-{
-    char buf[128];
-    pj_str_t username;
-
-    username.ptr = buf;
-
-    PJ_ASSERT_RETURN(ice && local_ufrag && local_pass &&
-                     remote_ufrag && remote_pass, PJ_EINVAL);
-    PJ_ASSERT_RETURN(local_ufrag->slen + remote_ufrag->slen <
-                     sizeof(buf), PJ_ENAMETOOLONG);
-
-    pj_strcpy(&username, remote_ufrag);
-    pj_strcat2(&username, ":");
-    pj_strcat(&username, local_ufrag);
-
-    pj_strdup(ice->pool, &ice->tx_uname, &username);
-    pj_strdup(ice->pool, &ice->tx_ufrag, remote_ufrag);
-    pj_strdup(ice->pool, &ice->tx_pass, remote_pass);
-
-    pj_strcpy(&username, local_ufrag);
-    pj_strcat2(&username, ":");
-    pj_strcat(&username, remote_ufrag);
-
-    pj_strdup(ice->pool, &ice->rx_uname, &username);
-    pj_strdup(ice->pool, &ice->rx_ufrag, local_ufrag);
-    pj_strdup(ice->pool, &ice->rx_pass, local_pass);
-
-    return PJ_SUCCESS;
-}
-
-
 static pj_uint32_t CALC_CAND_PRIO(pj_ice_cand_type type,
                                   pj_uint32_t local_pref,
@@ -463 +418 @@
 
 
+/*
+ * Add ICE candidate
+ */
 PJ_DEF(pj_status_t) pj_ice_add_cand(pj_ice *ice,
                                     unsigned comp_id,
@@ -475 +433 @@
 {
     pj_ice_cand *lcand;
+    pj_stun_session_cb sess_cb;
+    pj_stun_auth_cred auth_cred;
+    stun_data *sd;
     pj_status_t status = PJ_SUCCESS;
     char tmp[128];
@@ -501 +462 @@
         pj_bzero(&lcand->srv_addr, sizeof(lcand->srv_addr));
 
-    if (p_cand_id)
-        *p_cand_id = ice->lcand_cnt;
+    /* Init STUN callbacks */
+    pj_bzero(&sess_cb, sizeof(sess_cb));
+    sess_cb.on_request_complete = &on_stun_request_complete;
+    sess_cb.on_rx_indication = &on_stun_rx_indication;
+    sess_cb.on_rx_request = &on_stun_rx_request;
+    sess_cb.on_send_msg = &on_stun_send_msg;
+
+    /* Create STUN session for this candidate */
+    status = pj_stun_session_create(&ice->stun_cfg, ice->obj_name, 
+                                    &sess_cb, PJ_FALSE,
+                                    &lcand->stun_sess);
+    if (status != PJ_SUCCESS) {
+        pj_mutex_unlock(ice->mutex);
+        return status;
+    }
+
+    /* Associate data with this STUN session */
+    sd = PJ_POOL_ZALLOC_T(ice->pool, struct stun_data);
+    sd->ice = ice;
+    sd->lcand_id = GET_LCAND_ID(lcand);
+    sd->lcand = lcand;
+    pj_stun_session_set_user_data(lcand->stun_sess, sd);
+
+    /* Init STUN authentication credential */
+    pj_bzero(&auth_cred, sizeof(auth_cred));
+    auth_cred.type = PJ_STUN_AUTH_CRED_DYNAMIC;
+    auth_cred.data.dyn_cred.get_auth = &stun_auth_get_auth;
+    auth_cred.data.dyn_cred.get_cred = &stun_auth_get_cred;
+    auth_cred.data.dyn_cred.get_password = &stun_auth_get_password;
+    auth_cred.data.dyn_cred.verify_nonce = &stun_auth_verify_nonce;
+    auth_cred.data.dyn_cred.user_data = lcand->stun_sess;
+    pj_stun_session_set_credential(lcand->stun_sess, &auth_cred);
+
 
     pj_ansi_strcpy(tmp, pj_inet_ntoa(lcand->addr.ipv4.sin_addr));
@@ -518 +510 @@
          (int)pj_htons(lcand->base_addr.ipv4.sin_port),
          lcand->prio, lcand->prio));
+
+    if (p_cand_id)
+        *p_cand_id = ice->lcand_cnt;
 
     ++ice->lcand_cnt;
@@ -1042 +1037 @@
 
 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;
+    char buf[128];
+    pj_str_t username;
     timer_data *td;
     unsigned i, j;
 
-    PJ_ASSERT_RETURN(ice && rcand_cnt && rcand, PJ_EINVAL);
+    PJ_ASSERT_RETURN(ice && rem_ufrag && rem_passwd && rcand_cnt && rcand,
+                     PJ_EINVAL);
     PJ_ASSERT_RETURN(rcand_cnt + ice->rcand_cnt <= PJ_ICE_MAX_CAND, 
                      PJ_ETOOMANY);
 
     pj_mutex_lock(ice->mutex);
+
+    /* Save credentials */
+    username.ptr = buf;
+
+    pj_strcpy(&username, rem_ufrag);
+    pj_strcat2(&username, ":");
+    pj_strcat(&username, &ice->rx_ufrag);
+
+    pj_strdup(ice->pool, &ice->tx_uname, &username);
+    pj_strdup(ice->pool, &ice->tx_ufrag, rem_ufrag);
+    pj_strdup(ice->pool, &ice->tx_pass, rem_passwd);
+
+    pj_strcpy(&username, &ice->rx_ufrag);
+    pj_strcat2(&username, ":");
+    pj_strcat(&username, rem_ufrag);
+
+    pj_strdup(ice->pool, &ice->rx_uname, &username);
+
 
     /* Save remote candidates */
@@ -1155 +1173 @@
 
     /* Create request */
-    status = pj_stun_session_create_req(comp->stun_sess, 
+    status = pj_stun_session_create_req(lcand->stun_sess, 
                                         PJ_STUN_BINDING_REQUEST, &tdata);
     if (status != PJ_SUCCESS)
@@ -1187 +1205 @@
 
     /* Initiate STUN transaction to send the request */
-    status = pj_stun_session_send_msg(comp->stun_sess, PJ_FALSE, 
+    status = pj_stun_session_send_msg(lcand->stun_sess, PJ_FALSE, 
                                       &rcand->addr, 
                                       sizeof(pj_sockaddr_in), tdata);
@@ -1332 +1350 @@
 {
     stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
-    return (*sd->ice->cb.on_tx_pkt)(sd->ice, sd->comp_id, 
+    return (*sd->ice->cb.on_tx_pkt)(sd->ice, sd->lcand->comp_id, sd->lcand_id,
                                     pkt, pkt_size, 
                                     dst_addr, addr_len);
@@ -1535 +1553 @@
     sd = (stun_data*) pj_stun_session_get_user_data(sess);
     ice = sd->ice;
-    comp = sd->comp;
+    lcand = sd->lcand;
+    comp = find_comp(ice, lcand->comp_id);
 
     pj_mutex_lock(ice->mutex);
@@ -1621 +1640 @@
     PJ_TODO(DETERMINE_IF_REQUEST_COMES_FROM_RELAYED_CANDIDATE);
     is_relayed = PJ_FALSE;
-
-    /* Next find local candidate, by first finding a check in the checklist
-     * which base address is equal to the local address.
-     */
-    for (i=0; i<ice->clist.count; ++i) {
-        pj_ice_check *c = &ice->clist.checks[i];
-        if (sockaddr_cmp(&c->lcand->base_addr, &comp->local_addr)==0)
-            break;
-    }
-
-    /* MUST find a local candidate! */
-    pj_assert(i != ice->clist.count);
-    if (i == ice->clist.count) {
-        pj_mutex_unlock(ice->mutex);
-        LOG((ice->obj_name, "Error: unable to find local candidate for "
-             "incoming request"));
-        return PJ_SUCCESS;
-    }
-
-    lcand = ice->clist.checks[i].lcand;
 
     /* Now that we have local and remote candidate, check if we already
@@ -1759 +1758 @@
     pj_status_t status = PJ_SUCCESS;
     pj_ice_comp *comp;
+    unsigned cand_id;
     pj_ice_check *check;
 
@@ -1777 +1777 @@
 
     check = &ice->clist.checks[comp->nominated_check_id];
-
-    status = (*ice->cb.on_tx_pkt)(ice, comp_id, data, data_len, 
+    cand_id = GET_LCAND_ID(check->lcand);
+
+    status = (*ice->cb.on_tx_pkt)(ice, comp_id, cand_id, data, data_len, 
                                   &check->rcand->addr, 
                                   sizeof(pj_sockaddr_in));
@@ -1790 +1791 @@
 PJ_DEF(pj_status_t) pj_ice_on_rx_pkt( pj_ice *ice,
                                       unsigned comp_id,
+                                      unsigned cand_id,
                                       void *pkt,
                                       pj_size_t pkt_size,
@@ -1797 +1799 @@
     pj_status_t status = PJ_SUCCESS;
     pj_ice_comp *comp;
+    pj_ice_cand *lcand;
     pj_status_t stun_status;
 
@@ -1809 +1812 @@
     }
 
+    lcand = &ice->lcand[cand_id];
+
     stun_status = pj_stun_msg_check(pkt, pkt_size, PJ_STUN_IS_DATAGRAM);
     if (stun_status == PJ_SUCCESS) {
-        status = pj_stun_session_on_rx_pkt(comp->stun_sess, pkt, pkt_size,
+        status = pj_stun_session_on_rx_pkt(lcand->stun_sess, pkt, pkt_size,
                                            PJ_STUN_IS_DATAGRAM,
                                            NULL, src_addr, src_addr_len);
     } else {
-        status = (*ice->cb.on_rx_data)(ice, comp_id, pkt, pkt_size, 
-                                       src_addr, src_addr_len);
+        (*ice->cb.on_rx_data)(ice, comp_id, cand_id, pkt, pkt_size, 
+                              src_addr, src_addr_len);
     }
     

pjproject/trunk/pjnath/src/pjnath/ice_stream_transport.c

@@ -17 +17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  */
-#include <pjnath/ice_mt.h>
+#include <pjnath/ice_stream_transport.h>
 #include <pjnath/errno.h>
 #include <pj/addr_resolv.h>
 #include <pj/assert.h>
+#include <pj/log.h>
 #include <pj/pool.h>
 #include <pj/string.h>
 
 
-#define RTP_COMP_ID     1
-#define RTCP_COMP_ID    2
-
-
 
 /* ICE callbacks */
 static void        on_ice_complete(pj_ice *ice, pj_status_t status);
-static pj_status_t on_tx_pkt(pj_ice *ice, unsigned comp_id,
+static pj_status_t on_tx_pkt(pj_ice *ice, 
+                             unsigned comp_id, unsigned cand_id,
                              const void *pkt, pj_size_t size,
                              const pj_sockaddr_t *dst_addr,
                              unsigned dst_addr_len);
-static pj_status_t on_rx_data(pj_ice *ice, unsigned comp_id,
+static void        on_rx_data(pj_ice *ice, 
+                              unsigned comp_id, unsigned cand_id,
                               void *pkt, pj_size_t size,
                               const pj_sockaddr_t *src_addr,
@@ -46 +45 @@
                              pj_ssize_t bytes_read);
 
-static void destroy_ice_sock(pj_icemt_sock *is);
-
-static pj_status_t create_ice_sock(pj_icemt *icemt,
-                                   pj_ioqueue_t *ioqueue,
-                                   unsigned comp_id,
-                                   unsigned port,
-                                   pj_icemt_sock *is)
+static void destroy_ice_interface(pj_ice_st_interface *is);
+static void destroy_ice_st(pj_ice_st *ice_st, pj_status_t reason);
+
+static void ice_st_perror(pj_ice_st *ice_st, const char *title, 
+                          pj_status_t status)
+{
+    char errmsg[PJ_ERR_MSG_SIZE];
+
+    pj_strerror(status, errmsg, sizeof(errmsg));
+    PJ_LOG(1,(ice_st->obj_name, "%s: %s", title, errmsg));
+}
+
+
+/* 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';
+    }
+}
+
+
+/* 
+ * Create new interface (i.e. socket) 
+ */
+static pj_status_t create_ice_interface(pj_ice_st *ice_st,
+                                        pj_ice_cand_type type,
+                                        unsigned comp_id,
+                                        pj_uint16_t local_pref,
+                                        const pj_sockaddr_in *addr,
+                                        pj_ice_st_interface **p_is)
 {
     pj_ioqueue_callback ioqueue_cb;
-    const pj_str_t H1 = { "H1", 2 };
+    pj_ice_st_interface *is;
+    char foundation[32];
     int addr_len;
     pj_status_t status;
 
-    pj_bzero(is, sizeof(*is));
+    is = PJ_POOL_ZALLOC_T(ice_st->pool, pj_ice_st_interface);
+    is->type = type;
+    is->comp_id = comp_id;
+    is->cand_id = -1;
     is->sock = PJ_INVALID_SOCKET;
-    is->comp_id = comp_id;
-    is->icemt = icemt;
+    is->ice_st = ice_st;
+    is->local_pref = local_pref;
 
     status = pj_sock_socket(PJ_AF_INET, PJ_SOCK_DGRAM, 0, &is->sock);
@@ -69 +102 @@
 
     /* Bind and get the local IP address */
-    pj_sockaddr_in_init(&is->base_addr.ipv4, NULL, (pj_uint16_t)port);
+    if (addr) 
+        pj_memcpy(&is->base_addr, addr, sizeof(pj_sockaddr_in));
+    else 
+        pj_sockaddr_in_init(&is->base_addr.ipv4, NULL, 0);
+
     status = pj_sock_bind(is->sock, &is->base_addr, sizeof(pj_sockaddr_in));
     if (status != PJ_SUCCESS)
@@ -85 +122 @@
     }
 
+    /* Assign foundation */
+    pj_ansi_snprintf(foundation, sizeof(foundation), "%c%x", 
+                     get_type_prefix(type),
+                     (int)pj_ntohl(is->base_addr.ipv4.sin_addr.s_addr));
+    pj_strdup2(ice_st->pool, &is->foundation, foundation);
+
+
     /* Register to ioqueue */
     pj_bzero(&ioqueue_cb, sizeof(ioqueue_cb));
     ioqueue_cb.on_read_complete = &on_read_complete;
-    status = pj_ioqueue_register_sock(icemt->pool, ioqueue, is->sock, is,
-                                      &ioqueue_cb, &is->key);
+    status = pj_ioqueue_register_sock(ice_st->pool, ice_st->stun_cfg.ioqueue, 
+                                      is->sock, is, &ioqueue_cb, &is->key);
     if (status != PJ_SUCCESS)
         goto on_error;
@@ -96 +140 @@
     pj_ioqueue_op_key_init(&is->write_op, sizeof(is->write_op));
 
+    /* Kick start reading the socket */
     on_read_complete(is->key, &is->read_op, 0);
 
-    /* Add new ICE component */
-    status = pj_ice_add_comp(icemt->ice, comp_id, &is->base_addr,
-                             sizeof(pj_sockaddr_in));
-    if (status != PJ_SUCCESS)
-        goto on_error;
-
-    /* Add host candidate */
-    status = pj_ice_add_cand(icemt->ice, comp_id, PJ_ICE_CAND_TYPE_HOST,
-                             65535, &H1, &is->base_addr, &is->base_addr,
-                             NULL, sizeof(pj_sockaddr_in), NULL);
-    if (status != PJ_SUCCESS)
-        goto on_error;
-    
+    /* Done */
+    *p_is = is;
     return PJ_SUCCESS;
 
 on_error:
-    destroy_ice_sock(is);
+    destroy_ice_interface(is);
     return status;
 }
 
 
+/* 
+ * This is callback called by ioqueue on incoming packet 
+ */
 static void on_read_complete(pj_ioqueue_key_t *key, 
                              pj_ioqueue_op_key_t *op_key, 
                              pj_ssize_t bytes_read)
 {
-    pj_icemt_sock *is = (pj_icemt_sock*) pj_ioqueue_get_user_data(key);
+    pj_ice_st_interface *is = (pj_ice_st_interface*) 
+                              pj_ioqueue_get_user_data(key);
     pj_ssize_t pkt_size;
     pj_status_t status;
 
     if (bytes_read > 0) {
-        status = pj_ice_on_rx_pkt(is->icemt->ice, is->comp_id, 
-                                  is->pkt, bytes_read,
-                                  &is->src_addr, is->src_addr_len);
-    }
-
+
+        /* If we have an active ICE session, hand over all incoming
+         * packets to the ICE session. Otherwise just drop the packet.
+         */
+        if (is->ice_st->ice) {
+            status = pj_ice_on_rx_pkt(is->ice_st->ice, 
+                                      is->comp_id, is->cand_id,
+                                      is->pkt, bytes_read,
+                                      &is->src_addr, is->src_addr_len);
+        }
+
+    } else if (bytes_read < 0) {
+        ice_st_perror(is->ice_st, "ioqueue read callback error", -bytes_read);
+    }
+
+    /* Read next packet */
     pkt_size = sizeof(is->pkt);
     is->src_addr_len = sizeof(is->src_addr);
@@ -138 +187 @@
                                  PJ_IOQUEUE_ALWAYS_ASYNC,
                                  &is->src_addr, &is->src_addr_len);
-    pj_assert(status == PJ_SUCCESS || status == PJ_EPENDING);
-}
-
-
-static void destroy_ice_sock(pj_icemt_sock *is)
+    if (status != PJ_SUCCESS && status != PJ_EPENDING) {
+        ice_st_perror(is->ice_st, "ioqueue recvfrom() error", status);
+    }
+}
+
+
+/* 
+ * Destroy an interface 
+ */
+static void destroy_ice_interface(pj_ice_st_interface *is)
 {
     if (is->key) {
@@ -155 +209 @@
 
 
-PJ_DEF(pj_status_t) pj_icemt_create( pj_stun_config *stun_cfg,
-                                     const char *name,
-                                     pj_ice_role role,
-                                     const pj_icemt_cb *cb,
-                                     unsigned rtp_port,
-                                     pj_bool_t has_rtcp,
-                                     pj_bool_t has_turn,
-                                     const pj_sockaddr *srv,
-                                     pj_icemt **p_icemt)
+/* 
+ * Create ICE stream transport 
+ */
+PJ_DECL(pj_status_t) pj_ice_st_create(pj_stun_config *stun_cfg,
+                                      const char *name,
+                                      void *user_data,
+                                      const pj_ice_st_cb *cb,
+                                      pj_ice_st **p_ice_st)
 {
     pj_pool_t *pool;
-    pj_icemt *icemt;
+    pj_ice_st *ice_st;
+
+    PJ_ASSERT_RETURN(stun_cfg && cb && p_ice_st, PJ_EINVAL);
+    PJ_ASSERT_RETURN(stun_cfg->ioqueue && stun_cfg->timer_heap, PJ_EINVAL);
+
+    if (name == NULL)
+        name = "icest%p";
+
+    pool = pj_pool_create(stun_cfg->pf, name, 4000, 4000, NULL);
+    ice_st = PJ_POOL_ZALLOC_T(pool, pj_ice_st);
+    ice_st->pool = pool;
+    pj_memcpy(ice_st->obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
+    ice_st->user_data = user_data;
+    
+    pj_memcpy(&ice_st->cb, cb, sizeof(*cb));
+    pj_memcpy(&ice_st->stun_cfg, stun_cfg, sizeof(*stun_cfg));
+
+    PJ_LOG(4,(ice_st->obj_name, "ICE stream transport created"));
+
+    *p_ice_st = ice_st;
+    return PJ_SUCCESS;
+}
+
+
+static void destroy_ice_st(pj_ice_st *ice_st, pj_status_t reason)
+{
+    unsigned i;
+    char obj_name[PJ_MAX_OBJ_NAME];
+
+    if (reason == PJ_SUCCESS) {
+        pj_memcpy(obj_name, ice_st->obj_name, PJ_MAX_OBJ_NAME);
+        PJ_LOG(4,(obj_name, "ICE stream transport shutting down"));
+    }
+
+    /* Destroy ICE if we have ICE */
+    if (ice_st->ice) {
+        pj_ice_destroy(ice_st->ice);
+        ice_st->ice = NULL;
+    }
+
+    /* Destroy all interfaces */
+    for (i=0; i<ice_st->itf_cnt; ++i) {
+        destroy_ice_interface(ice_st->itfs[i]);
+        ice_st->itfs[i] = NULL;
+    }
+    ice_st->itf_cnt = 0;
+
+    /* Done */
+    pj_pool_release(ice_st->pool);
+
+    if (reason == PJ_SUCCESS) {
+        PJ_LOG(4,(obj_name, "ICE stream transport destroyed"));
+    }
+}
+
+
+/*
+ * Destroy ICE stream transport.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_destroy(pj_ice_st *ice_st)
+{
+    destroy_ice_st(ice_st, PJ_SUCCESS);
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Resolve STUN server
+ */
+PJ_DEF(pj_status_t) pj_ice_st_set_stun( pj_ice_st *ice_st,
+                                        pj_dns_resolver *resolver,
+                                        pj_bool_t enable_relay,
+                                        const pj_str_t *domain)
+{
+    /* Yeah, TODO */
+    PJ_UNUSED_ARG(ice_st);
+    PJ_UNUSED_ARG(resolver);
+    PJ_UNUSED_ARG(enable_relay);
+    PJ_UNUSED_ARG(domain);
+    return -1;
+}
+
+
+/*
+ * Set STUN server address.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_set_stun_addr( pj_ice_st *ice_st,
+                                             pj_bool_t enable_relay,
+                                             const pj_sockaddr_in *srv_addr)
+{
+
+    PJ_ASSERT_RETURN(ice_st && srv_addr, PJ_EINVAL);
+    
+    ice_st->relay_enabled = enable_relay;
+    pj_strdup2(ice_st->pool, &ice_st->stun_domain,
+               pj_inet_ntoa(srv_addr->sin_addr));
+    pj_memcpy(&ice_st->stun_srv, srv_addr, sizeof(pj_sockaddr_in));
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Add new component.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_add_comp(pj_ice_st *ice_st,
+                                       unsigned comp_id)
+{
+    /* Verify arguments */
+    PJ_ASSERT_RETURN(ice_st && comp_id, PJ_EINVAL);
+
+    /* Can only add component when we don't have active ICE session */
+    PJ_ASSERT_RETURN(ice_st->ice == NULL, PJ_EBUSY);
+
+    /* Check that we don't have too many components */
+    PJ_ASSERT_RETURN(ice_st->comp_cnt < PJ_ICE_MAX_COMP, PJ_ETOOMANY);
+
+    /* Component ID must be valid */
+    PJ_ASSERT_RETURN(comp_id <= PJ_ICE_MAX_COMP, PJ_EICEINCOMPID);
+
+    /* First component ID must be 1, second must be 2, etc., and 
+     * they must be registered in order.
+     */
+    PJ_ASSERT_RETURN(ice_st->comps[comp_id-1] == ice_st->comp_cnt, 
+                     PJ_EICEINCOMPID);
+
+    /* All in order, add the component. */
+    ice_st->comps[ice_st->comp_cnt++] = comp_id;
+
+    return PJ_SUCCESS;
+}
+
+
+/* Add interface */
+static void add_interface(pj_ice_st *ice_st, pj_ice_st_interface *is,
+                          unsigned *p_itf_id, pj_bool_t notify,
+                          void *notify_data)
+{
+    unsigned itf_id;
+
+    itf_id = ice_st->itf_cnt++;
+    ice_st->itfs[itf_id] = is;
+
+    if (p_itf_id)
+        *p_itf_id = itf_id;
+
+    if (notify && ice_st->cb.on_interface_status) {
+        (*ice_st->cb.on_interface_status)(ice_st, notify_data, 
+                                          PJ_SUCCESS, itf_id);
+    }
+}
+
+/*
+ * Add new host interface.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_add_host_interface(pj_ice_st *ice_st,
+                                                 unsigned comp_id,
+                                                 pj_uint16_t local_pref,
+                                                 const pj_sockaddr_in *addr,
+                                                 unsigned *p_itf_id,
+                                                 pj_bool_t notify,
+                                                 void *notify_data)
+{
+    pj_ice_st_interface *is;
+    pj_status_t status;
+
+    /* Verify arguments */
+    PJ_ASSERT_RETURN(ice_st && comp_id, PJ_EINVAL);
+
+    /* Check that component ID present */
+    PJ_ASSERT_RETURN(comp_id <= ice_st->comp_cnt, PJ_EICEINCOMPID);
+
+    /* Can't add new interface while ICE is running */
+    PJ_ASSERT_RETURN(ice_st->ice == NULL, PJ_EBUSY);
+
+    /* Create interface */
+    status = create_ice_interface(ice_st, PJ_ICE_CAND_TYPE_HOST, comp_id,
+                                  local_pref, addr, &is);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    /* For host interface, the address is the base address */
+    pj_memcpy(&is->addr, &is->base_addr, sizeof(is->addr));
+
+    /* Store this interface */
+    add_interface(ice_st, is, p_itf_id, notify, notify_data);
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Enumerate and add all host interfaces.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_add_all_host_interfaces(pj_ice_st *ice_st,
+                                                      unsigned comp_id,
+                                                      unsigned port,
+                                                      pj_bool_t notify,
+                                                      void *notify_data)
+{
+    pj_sockaddr_in addr;
+    pj_status_t status;
+
+    /* Yeah, TODO.
+     * For now just add the default interface.
+     */
+    pj_sockaddr_in_init(&addr, NULL, (pj_uint16_t)port);
+    
+    status = pj_gethostip(&addr.sin_addr);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    return pj_ice_st_add_host_interface(ice_st, comp_id, 65535, &addr, 
+                                        NULL, notify, notify_data);
+}
+
+
+/*
+ * Add STUN mapping interface.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_add_stun_interface(pj_ice_st *ice_st,
+                                                 unsigned comp_id,
+                                                 unsigned local_port,
+                                                 pj_bool_t notify,
+                                                 void *notify_data)
+{
+    /* Yeah, TODO */
+    PJ_UNUSED_ARG(ice_st);
+    PJ_UNUSED_ARG(comp_id);
+    PJ_UNUSED_ARG(local_port);
+    PJ_UNUSED_ARG(notify);
+    PJ_UNUSED_ARG(notify_data);
+    return -1;
+}
+
+
+/*
+ * Add TURN mapping interface.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_add_relay_interface(pj_ice_st *ice_st,
+                                                  unsigned comp_id,
+                                                  unsigned local_port,
+                                                  pj_bool_t notify,
+                                                  void *notify_data)
+{
+    /* Yeah, TODO */
+    PJ_UNUSED_ARG(ice_st);
+    PJ_UNUSED_ARG(comp_id);
+    PJ_UNUSED_ARG(local_port);
+    PJ_UNUSED_ARG(notify);
+    PJ_UNUSED_ARG(notify_data);
+    return -1;
+}
+
+
+/*
+ * Create ICE!
+ */
+PJ_DEF(pj_status_t) pj_ice_st_init_ice(pj_ice_st *ice_st,
+                                       pj_ice_role role,
+                                       const pj_str_t *local_ufrag,
+                                       const pj_str_t *local_passwd)
+{
+    pj_status_t status;
+    unsigned i;
     pj_ice_cb ice_cb;
-    pj_status_t status;
-
-    pool = pj_pool_create(stun_cfg->pf, name, 512, 512, NULL);
-    icemt = PJ_POOL_ZALLOC_T(pool, struct pj_icemt);
-    icemt->pool = pool;
-
-
+
+    /* Check arguments */
+    PJ_ASSERT_RETURN(ice_st, PJ_EINVAL);
+    /* Must not have ICE */
+    PJ_ASSERT_RETURN(ice_st->ice == NULL, PJ_EINVALIDOP);
+
+    /* Init callback */
     pj_bzero(&ice_cb, sizeof(ice_cb));
     ice_cb.on_ice_complete = &on_ice_complete;
+    ice_cb.on_rx_data = &on_rx_data;
     ice_cb.on_tx_pkt = &on_tx_pkt;
-    ice_cb.on_rx_data = &on_rx_data;
-
-    pj_memcpy(&icemt->cb, cb, sizeof(*cb));
-
-    status = pj_ice_create(stun_cfg, name, role, &ice_cb, &icemt->ice);
-    if (status != PJ_SUCCESS)
-        goto on_error;
-
-    icemt->ice->user_data = (void*)icemt;
-
-    icemt->has_turn = has_turn;
-    if (srv)
-        pj_memcpy(&icemt->stun_srv, srv, sizeof(pj_sockaddr));
-
-    status = create_ice_sock(icemt, stun_cfg->ioqueue, RTP_COMP_ID,
-                             rtp_port, &icemt->rtp);
-    if (status != PJ_SUCCESS)
-        goto on_error;
-
-    if (has_rtcp) {
-        if (rtp_port) ++rtp_port;
-
-        status = create_ice_sock(icemt, stun_cfg->ioqueue, RTCP_COMP_ID,
-                                 rtp_port, &icemt->rtcp);
+
+    /* Create! */
+    status = pj_ice_create(&ice_st->stun_cfg, ice_st->obj_name, role, 
+                           &ice_cb, local_ufrag, local_passwd, &ice_st->ice);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    /* Associate user data */
+    ice_st->ice->user_data = (void*)ice_st;
+
+    /* Add components */
+    for (i=0; i<ice_st->comp_cnt; ++i) {
+        status = pj_ice_add_comp(ice_st->ice, ice_st->comps[i]);
         if (status != PJ_SUCCESS)
             goto on_error;
     }
 
-    *p_icemt = icemt;
+    /* Add candidates */
+    for (i=0; i<ice_st->itf_cnt; ++i) {
+        pj_ice_st_interface *is= ice_st->itfs[i];
+        status = pj_ice_add_cand(ice_st->ice, is->comp_id, is->type, 
+                                 is->local_pref, &is->foundation,
+                                 &is->addr, &is->base_addr, NULL, 
+                                 sizeof(pj_sockaddr_in), 
+                                 (unsigned*)&is->cand_id);
+        if (status != PJ_SUCCESS)
+            goto on_error;
+    }
+
     return PJ_SUCCESS;
 
 on_error:
-    if (icemt->ice)
-        pj_ice_destroy(icemt->ice);
-    pj_pool_release(pool);
+    for (i=0; i<ice_st->itf_cnt; ++i) {
+        ice_st->itfs[i]->cand_id = -1;
+    }
+    if (ice_st->ice) {
+        pj_ice_destroy(ice_st->ice);
+        ice_st->ice = NULL;
+    }
     return status;
 }
 
 
-PJ_DEF(pj_status_t) pj_icemt_destroy(pj_icemt *icemt)
-{
-    destroy_ice_sock(&icemt->rtp);
-    destroy_ice_sock(&icemt->rtcp);
-
-    pj_ice_destroy(icemt->ice);
-    pj_pool_release(icemt->pool);
-
-    return PJ_SUCCESS;
-}
-
-
+/*
+ * Enum candidates
+ */
+PJ_DEF(pj_status_t) pj_ice_st_enum_cands(pj_ice_st *ice_st,
+                                         unsigned *count,
+                                         pj_ice_cand cand[])
+{
+    unsigned i, cnt;
+    pj_ice_cand *pcand;
+    pj_status_t status;
+
+    PJ_ASSERT_RETURN(ice_st && count && cand, PJ_EINVAL);
+    PJ_ASSERT_RETURN(ice_st->ice, PJ_EINVALIDOP);
+
+    cnt = pj_ice_get_cand_cnt(ice_st->ice);
+    cnt = (cnt > *count) ? *count : cnt;
+    *count = 0;
+
+    for (i=0; i<cnt; ++i) {
+        status = pj_ice_get_cand(ice_st->ice, i, &pcand);
+        if (status != PJ_SUCCESS)
+            return status;
+
+        pj_memcpy(&cand[i], pcand, sizeof(pj_ice_cand));
+    }
+
+    *count = cnt;
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Start ICE processing !
+ */
+PJ_DEF(pj_status_t) pj_ice_st_start_ice( pj_ice_st *ice_st,
+                                         const pj_str_t *rem_ufrag,
+                                         const pj_str_t *rem_passwd,
+                                         unsigned rem_cand_cnt,
+                                         const pj_ice_cand rem_cand[])
+{
+    pj_status_t status;
+
+    status = pj_ice_create_check_list(ice_st->ice, rem_ufrag, rem_passwd,
+                                      rem_cand_cnt, rem_cand);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    return pj_ice_start_check(ice_st->ice);
+}
+
+
+/*
+ * Stop ICE!
+ */
+PJ_DECL(pj_status_t) pj_ice_st_stop_ice(pj_ice_st *ice_st)
+{
+    if (ice_st->ice) {
+        pj_ice_destroy(ice_st->ice);
+        ice_st->ice = NULL;
+    }
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Send data to peer agent.
+ */
+PJ_DEF(pj_status_t) pj_ice_st_send_data( pj_ice_st *ice_st,
+                                         unsigned comp_id,
+                                         const void *data,
+                                         pj_size_t data_len)
+{
+    if (!ice_st->ice)
+        return PJ_ENOICE;
+
+    return pj_ice_send_data(ice_st->ice, comp_id, data, data_len);
+}
+
+
+
+/*
+ * Callback called by ICE session when ICE processing is complete, either
+ * successfully or with failure.
+ */
 static void on_ice_complete(pj_ice *ice, pj_status_t status)
 {
-    pj_icemt *icemt = (pj_icemt*)ice->user_data;
-    (*icemt->cb.on_ice_complete)(icemt, status);
-}
-
-
-static pj_status_t on_tx_pkt(pj_ice *ice, unsigned comp_id,
+    pj_ice_st *ice_st = (pj_ice_st*)ice->user_data;
+    if (ice_st->cb.on_ice_complete) {
+        (*ice_st->cb.on_ice_complete)(ice_st, status);
+    }
+}
+
+
+/*
+ * Callback called by ICE session when it wants to send outgoing packet.
+ */
+static pj_status_t on_tx_pkt(pj_ice *ice, 
+                             unsigned comp_id, unsigned cand_id,
                              const void *pkt, pj_size_t size,
                              const pj_sockaddr_t *dst_addr,
                              unsigned dst_addr_len)
 {
-    pj_icemt *icemt = (pj_icemt*)ice->user_data;
-    pj_icemt_sock *is;
+    pj_ice_st *ice_st = (pj_ice_st*)ice->user_data;
+    pj_ice_st_interface *is = NULL;
+    unsigned i;
     pj_ssize_t pkt_size;
     pj_status_t status;
 
-    if (comp_id == RTP_COMP_ID)
-        is = &icemt->rtp;
-    else if (comp_id == RTCP_COMP_ID)
-        is = &icemt->rtcp;
-    else {
-        pj_assert(!"Invalid comp_id");
-        return -1;
+    PJ_UNUSED_ARG(comp_id);
+
+    for (i=0; i<ice_st->itf_cnt; ++i) {
+        if (ice_st->itfs[i]->cand_id == (int)cand_id) {
+            is = ice_st->itfs[i];
+            break;
+        }
+    }
+    if (is == NULL) {
+        return PJ_EICEINCANDID;
     }
 
@@ -264 +669 @@
 
 
-static pj_status_t on_rx_data(pj_ice *ice, unsigned comp_id,
-                              void *pkt, pj_size_t size,
-                              const pj_sockaddr_t *src_addr,
-                              unsigned src_addr_len)
-{
-    pj_icemt *icemt = (pj_icemt*)ice->user_data;
-
-    if (comp_id == RTP_COMP_ID && icemt->cb.on_rx_rtp) {
-        (*icemt->cb.on_rx_rtp)(icemt, pkt, size, src_addr, src_addr_len);
-    } else if (comp_id == RTCP_COMP_ID && icemt->cb.on_rx_rtcp) {
-        (*icemt->cb.on_rx_rtcp)(icemt, pkt, size, src_addr, src_addr_len);
-    }
-    return PJ_SUCCESS;
-}
-
-
+/*
+ * Callback called by ICE session when it receives application data.
+ */
+static void on_rx_data(pj_ice *ice, 
+                       unsigned comp_id, unsigned cand_id,
+                       void *pkt, pj_size_t size,
+                       const pj_sockaddr_t *src_addr,
+                       unsigned src_addr_len)
+{
+    pj_ice_st *ice_st = (pj_ice_st*)ice->user_data;
+
+    if (ice_st->cb.on_rx_data) {
+        (*ice_st->cb.on_rx_data)(ice_st, comp_id, cand_id, 
+                                 pkt, size, src_addr, src_addr_len);
+    }
+}
+
+