Changeset 5513 for pjproject/branches/projects/uwp/pjsip/src/pjsua-lib/pjsua_core.c

Timestamp:

Dec 28, 2016 3:40:07 AM (8 years ago)

Author:

nanang

Message:

Re #1900: More merged from trunk (r5512 mistakenly contains merged changes in third-party dir only).

Location:

pjproject/branches/projects/uwp

Files:

• . (modified) (1 prop)
• pjsip/src/pjsua-lib/pjsua_core.c (modified) (39 diffs)

pjproject/branches/projects/uwp/pjsip/src/pjsua-lib/pjsua_core.c

@@ -278 +278 @@
 #if PJMEDIA_HAS_VIDEO
     pjmedia_vid_stream_rc_config_default(&cfg->vid_stream_rc_cfg);
+    pjmedia_vid_stream_sk_config_default(&cfg->vid_stream_sk_cfg);
 #endif
     pjsua_transport_config_default(&cfg->rtp_cfg);
@@ -303 +304 @@
     cfg->register_on_acc_add = PJ_TRUE;
     cfg->mwi_expires = PJSIP_MWI_DEFAULT_EXPIRES;
+
+    cfg->media_stun_use = PJSUA_STUN_RETRY_ON_FAILURE;
 }
 
@@ -1050 +1053 @@
 
     /* Start resolving STUN server */
-    status = resolve_stun_server(PJ_FALSE);
+    status = resolve_stun_server(PJ_FALSE, PJ_FALSE);
     if (status != PJ_SUCCESS && status != PJ_EPENDING) {
         pjsua_perror(THIS_FILE, "Error resolving STUN server", status);
@@ -1106 +1109 @@
 
         for (ii=0; ii<pjsua_var.ua_cfg.thread_cnt; ++ii) {
-            status = pj_thread_create(pjsua_var.pool, "pjsua", &worker_thread,
+            char thread_name[16];
+            pj_ansi_snprintf(thread_name, 16, "pjsua_%d", ii);
+            status = pj_thread_create(pjsua_var.pool, thread_name, &worker_thread,
                                       NULL, 0, 0, &pjsua_var.thread[ii]);
             if (status != PJ_SUCCESS)
@@ -1155 +1160 @@
 }
 
+
+static void destroy_stun_resolve_cb(pj_timer_heap_t *t, pj_timer_entry *e)
+{
+    pjsua_stun_resolve *sess = (pjsua_stun_resolve*)e->user_data;
+    PJ_UNUSED_ARG(t);
+
+    PJSUA_LOCK();
+    pj_list_erase(sess);
+    PJSUA_UNLOCK();
+
+    pj_assert(sess->stun_sock==NULL);
+    pj_pool_release(sess->pool);
+}
+
+
 static void destroy_stun_resolve(pjsua_stun_resolve *sess)
 {
+    pj_time_val timeout = {0, 0};
+
     sess->destroy_flag = PJ_TRUE;
-    if (sess->ref_cnt > 0)
+
+    /* If the STUN resolution session is blocking, only the waiting thread
+     * is allowed to destroy the session, otherwise it may cause deadlock.
+     */
+    if (sess->blocking) {
+        if (sess->waiter != pj_thread_this())
+            return;
+
+        /* Before destroying, make sure ref count is zero. */
+        while (sess->ref_cnt > 0)
+            pj_thread_sleep(10);
+
+    } else if (sess->ref_cnt > 0)
         return;
-
-    PJSUA_LOCK();
 
     if (sess->stun_sock) {
@@ -1174 +1206 @@
     }
     
-    pj_list_erase(sess);
-
-    PJSUA_UNLOCK();
-
-    pj_assert(sess->stun_sock==NULL);
-    pj_pool_release(sess->pool);
+    /* Schedule session clean up, it needs PJSUA lock and locking it here
+     * may cause deadlock as this function may be called by STUN socket
+     * while holding STUN socket lock, while application may wait for STUN
+     * resolution while holding PJSUA lock.
+     */
+    pj_timer_entry_init(&sess->timer, 0, (void*)sess,
+                        &destroy_stun_resolve_cb);
+    pjsua_schedule_timer(&sess->timer, &timeout);
 }
 
@@ -1204 +1238 @@
     result.status = sess->status;
     result.name = sess->srv[sess->idx];
+    result.index = sess->idx;
     pj_memcpy(&result.addr, &sess->addr, sizeof(result.addr));
     sess->has_result = PJ_TRUE;
@@ -1221 +1256 @@
     }
 
-    stun_resolve_add_ref(sess);
     sess->cb(&result);
-    stun_resolve_dec_ref(sess);
 
 on_return:
@@ -1252 +1285 @@
                   sess->srv[sess->idx].ptr, errmsg));
 
+        if (op == PJ_STUN_SOCK_BINDING_OP && !sess->async_wait) {
+            /* Just return here, we will destroy the STUN socket and
+             * continue the STUN resolution later in resolve_stun_entry().
+             * For more details, please refer to ticket #1962.
+             */
+            return PJ_FALSE;
+        }
+
         pj_stun_sock_destroy(stun_sock);
         sess->stun_sock = NULL;
+
+        stun_resolve_add_ref(sess);
 
         ++sess->idx;
@@ -1261 +1304 @@
         resolve_stun_entry(sess);
 
+        stun_resolve_dec_ref(sess);
+
         return PJ_FALSE;
 
@@ -1268 +1313 @@
         pj_stun_sock_get_info(stun_sock, &ssi);
         pj_memcpy(&sess->addr, &ssi.srv_addr, sizeof(sess->addr));
+
+        stun_resolve_add_ref(sess);
 
         sess->status = PJ_SUCCESS;
@@ -1275 +1322 @@
         stun_resolve_complete(sess);
 
+        stun_resolve_dec_ref(sess);
+
         return PJ_FALSE;
 
@@ -1290 +1339 @@
     pj_status_t status = PJ_EUNKNOWN;
 
-    stun_resolve_add_ref(sess);
-
     /* Loop while we have entry to try */
     for (; sess->idx < sess->count; ++sess->idx) {
-        const int af = pj_AF_INET();
+        int af;
         char target[64];
         pj_str_t hostpart;
@@ -1307 +1354 @@
 
         /* Parse the server entry into host:port */
-        status = pj_sockaddr_parse2(af, 0, &sess->srv[sess->idx],
-                                          &hostpart, &port, NULL);
+        status = pj_sockaddr_parse2(pj_AF_UNSPEC(), 0, &sess->srv[sess->idx],
+                                    &hostpart, &port, &af);
         if (status != PJ_SUCCESS) {
             PJ_LOG(2,(THIS_FILE, "Invalid STUN server entry %s", target));
+            continue;
+        } else if (af != pj_AF_INET()) {
+            /* Ignore IPv6 STUN server for now */
+            status = PJ_EAFNOTSUP;
+            PJ_LOG(3,(THIS_FILE, "Ignored STUN server entry %s, currently "
+                                 "only IPv4 STUN server is supported (does "
+                                 "IPv6 still need a mapped address?)",
+                      target));
             continue;
         }
@@ -1326 +1381 @@
         pj_bzero(&stun_sock_cb, sizeof(stun_sock_cb));
         stun_sock_cb.on_status = &test_stun_on_status;
+        sess->async_wait = PJ_FALSE;
         status = pj_stun_sock_create(&pjsua_var.stun_cfg, "stunresolve",
-                                           pj_AF_INET(), &stun_sock_cb,
-                                           NULL, sess, &sess->stun_sock);
+                                     pj_AF_INET(), &stun_sock_cb,
+                                     NULL, sess, &sess->stun_sock);
         if (status != PJ_SUCCESS) {
             char errmsg[PJ_ERR_MSG_SIZE];
@@ -1339 +1395 @@
         }
 
-        status = pj_stun_sock_start(sess->stun_sock, &hostpart,
-                                          port, pjsua_var.resolver);
+        status = pj_stun_sock_start(sess->stun_sock, &hostpart, port,
+                                    pjsua_var.resolver);
         if (status != PJ_SUCCESS) {
             char errmsg[PJ_ERR_MSG_SIZE];
@@ -1358 +1414 @@
          * stun_sock_cb()
          */
-        goto on_return;
+        sess->async_wait = PJ_TRUE;
+        return;
     }
 
     if (sess->idx >= sess->count) {
         /* No more entries to try */
+        stun_resolve_add_ref(sess);
         pj_assert(status != PJ_SUCCESS || sess->status != PJ_EPENDING);
         if (sess->status == PJ_EPENDING)
             sess->status = status;
         stun_resolve_complete(sess);
-    }
-
-on_return:
-    stun_resolve_dec_ref(sess);
+        stun_resolve_dec_ref(sess);
+    }
+}
+
+
+/*
+ * Update STUN servers.
+ */
+PJ_DEF(pj_status_t) pjsua_update_stun_servers(unsigned count, pj_str_t srv[],
+                                              pj_bool_t wait)
+{
+    unsigned i;
+    pj_status_t status;
+
+    PJ_ASSERT_RETURN(count && srv, PJ_EINVAL);
+    
+    PJSUA_LOCK();
+
+    pjsua_var.ua_cfg.stun_srv_cnt = count;
+    for (i = 0; i < count; i++) {
+        if (pj_strcmp(&pjsua_var.ua_cfg.stun_srv[i], &srv[i]))
+            pj_strdup(pjsua_var.pool, &pjsua_var.ua_cfg.stun_srv[i], &srv[i]);
+    }
+    pjsua_var.stun_status = PJ_EUNKNOWN;
+
+    PJSUA_UNLOCK();
+    
+    status = resolve_stun_server(wait, PJ_FALSE);
+    if (wait == PJ_FALSE && status == PJ_EPENDING)
+        status = PJ_SUCCESS;
+
+    return status;
 }
 
@@ -1386 +1472 @@
     pjsua_stun_resolve *sess;
     pj_status_t status;
-    unsigned i;
+    unsigned i, max_wait_ms;
+    pj_timestamp start, now;
 
     PJ_ASSERT_RETURN(count && srv && cb, PJ_EINVAL);
@@ -1400 +1487 @@
     sess->count = count;
     sess->blocking = wait;
+    sess->waiter = pj_thread_this();
     sess->status = PJ_EPENDING;
     sess->srv = (pj_str_t*) pj_pool_calloc(pool, count, sizeof(pj_str_t));
@@ -1414 +1502 @@
     if (!wait)
         return PJ_SUCCESS;
+
+    /* Should limit the wait time to avoid deadlock. For example,
+     * if app holds dlg/tsx lock, pjsua worker thread will block on
+     * any dlg/tsx state change.
+     */
+    max_wait_ms = count * pjsua_var.stun_cfg.rto_msec * (1 << 7);
+    pj_get_timestamp(&start);
 
     while (sess->status == PJ_EPENDING) {
@@ -1428 +1523 @@
             pj_thread_sleep(20);
         }
+
+        pj_get_timestamp(&now);
+        if (pj_elapsed_msec(&start, &now) > max_wait_ms)
+            sess->status = PJ_ETIMEDOUT;
     }
 
@@ -1477 +1576 @@
     if ((result->status == PJ_SUCCESS) && (pjsua_var.ua_cfg.stun_srv_cnt>0)) {
         pj_memcpy(&pjsua_var.stun_srv, &result->addr, sizeof(result->addr));
+        pjsua_var.stun_srv_idx = result->index;
 
         /* Perform NAT type detection if not yet */
         if (pjsua_var.nat_type == PJ_STUN_NAT_TYPE_UNKNOWN &&
+            !pjsua_var.nat_in_progress &&
             pjsua_var.ua_cfg.nat_type_in_sdp)
         {
@@ -1493 +1594 @@
  * Resolve STUN server.
  */
-pj_status_t resolve_stun_server(pj_bool_t wait)
-{
+pj_status_t resolve_stun_server(pj_bool_t wait, pj_bool_t retry_if_cur_error)
+{
+    /* Retry resolving if currently the STUN status is error */
+    if (pjsua_var.stun_status != PJ_EPENDING &&
+        pjsua_var.stun_status != PJ_SUCCESS &&
+        retry_if_cur_error)
+    {
+        pjsua_var.stun_status = PJ_EUNKNOWN;
+    }
+
     if (pjsua_var.stun_status == PJ_EUNKNOWN) {
         pj_status_t status;
@@ -1522 +1631 @@
          */
         if (wait) {
-            while (pjsua_var.stun_status == PJ_EPENDING) {
+            unsigned max_wait_ms;
+            pj_timestamp start, now;
+
+            /* Should limit the wait time to avoid deadlock. For example,
+             * if app holds dlg/tsx lock, pjsua worker thread will block on
+             * any dlg/tsx state change.
+             */
+            max_wait_ms = pjsua_var.ua_cfg.stun_srv_cnt *
+                          pjsua_var.stun_cfg.rto_msec * (1 << 7);
+            pj_get_timestamp(&start);
+
+            while (pjsua_var.stun_status == PJ_EPENDING) {              
                 /* If there is no worker thread or
                  * the function is called from the only worker thread,
@@ -1535 +1655 @@
                     pj_thread_sleep(10);
                 }
+
+                pj_get_timestamp(&now);
+                if (pj_elapsed_msec(&start, &now) > max_wait_ms)
+                    return PJ_ETIMEDOUT;
             }
         }
@@ -1545 +1669 @@
         PJ_LOG(2,(THIS_FILE, 
                   "Ignoring STUN resolution failure (by setting)"));
-        pjsua_var.stun_status = PJ_SUCCESS;
+        //pjsua_var.stun_status = PJ_SUCCESS;
+        return PJ_SUCCESS;
     }
 
@@ -1956 +2081 @@
 
     /* Make sure STUN server resolution has completed */
-    status = resolve_stun_server(PJ_TRUE);
+    status = resolve_stun_server(PJ_TRUE, PJ_TRUE);
     if (status != PJ_SUCCESS) {
         pjsua_perror(THIS_FILE, "Error resolving STUN server", status);
@@ -2015 +2140 @@
 
     if (pjsua_var.stun_srv.addr.sa_family != 0) {
-        pj_ansi_strcpy(stun_ip_addr,pj_inet_ntoa(pjsua_var.stun_srv.ipv4.sin_addr));
+        pj_sockaddr_print(&pjsua_var.stun_srv,
+                          stun_ip_addr, sizeof(stun_ip_addr), 0);
         stun_srv = pj_str(stun_ip_addr);
     } else {
@@ -2032 +2158 @@
             pj_sockaddr_set_port(p_pub_addr, (pj_uint16_t)port);
 
-    } else if (stun_srv.slen) {
+    } else if (stun_srv.slen && af == pj_AF_INET()) {
         pjstun_setting stun_opt;
 
         /*
          * STUN is specified, resolve the address with STUN.
+         * Currently, this is available for IPv4 address only.
          */
-        if (af != pj_AF_INET()) {
-            pjsua_perror(THIS_FILE, "Cannot use STUN", PJ_EAFNOTSUP);
-            pj_sock_close(sock);
-            return PJ_EAFNOTSUP;
-        }
-
         pj_bzero(&stun_opt, sizeof(stun_opt));
         stun_opt.use_stun2 = pjsua_var.ua_cfg.stun_map_use_stun2;
@@ -2052 +2173 @@
                                          1, &sock, &p_pub_addr->ipv4);
         if (status != PJ_SUCCESS) {
+            /* Failed getting mapped address via STUN */
             pjsua_perror(THIS_FILE, "Error contacting STUN server", status);
-            pj_sock_close(sock);
-            return status;
+            
+            /* Return error if configured to not ignore STUN failure */
+            if (!pjsua_var.ua_cfg.stun_ignore_failure) {
+                pj_sock_close(sock);
+                return status;
+            }
+
+            /* Otherwise, just use host IP */
+            pj_sockaddr_init(af, p_pub_addr, NULL, (pj_uint16_t)port);
+            status = pj_gethostip(af, p_pub_addr);
+            if (status != PJ_SUCCESS) {
+                pjsua_perror(THIS_FILE, "Unable to get local host IP", status);
+                pj_sock_close(sock);
+                return status;
+            }
         }
 
     } else {
+
         pj_bzero(p_pub_addr, sizeof(pj_sockaddr));
 
@@ -2073 +2209 @@
         p_pub_addr->addr.sa_family = (pj_uint16_t)af;
         pj_sockaddr_set_port(p_pub_addr, (pj_uint16_t)port);
+
+        if (stun_srv.slen && af != pj_AF_INET()) {
+            /* STUN is specified, but it is not IPv4, just print warning */
+            PJ_PERROR(2, (THIS_FILE, PJ_EAFNOTSUP,
+                          "Cannot use STUN for SIP UDP socket %s:%d",
+                          addr_string(p_pub_addr),
+                          (int)pj_sockaddr_get_port(p_pub_addr)));
+        }
+
     }
 
@@ -2406 +2551 @@
     PJSUA_LOCK();
 
-    if (t->type == PJSIP_TRANSPORT_UDP) {
+    if ((t->type & ~PJSIP_TRANSPORT_IPV6) == PJSIP_TRANSPORT_UDP) {
 
         pjsip_transport *tp = t->data.tp;
@@ -2427 +2572 @@
         status = PJ_SUCCESS;
 
-    } else if (t->type == PJSIP_TRANSPORT_TCP ||
-               t->type == PJSIP_TRANSPORT_TLS)
+    } else if ((t->type & ~PJSIP_TRANSPORT_IPV6) == PJSIP_TRANSPORT_TCP ||
+               (t->type & ~PJSIP_TRANSPORT_IPV6) == PJSIP_TRANSPORT_TLS)
     {
 
@@ -2440 +2585 @@
         info->id = id;
         info->type = t->type;
-        info->type_name = (t->type==PJSIP_TRANSPORT_TCP)? pj_str("TCP"):
-                                                          pj_str("TLS");
-        info->info = (t->type==PJSIP_TRANSPORT_TCP)? pj_str("TCP transport"):
-                                                     pj_str("TLS transport");
+        info->type_name = pj_str(factory->type_name);
+        info->info = pj_str(factory->info);
         info->flag = factory->flag;
         info->addr_len = sizeof(factory->local_addr);
@@ -2493 +2636 @@
 {
     pj_status_t status;
+    pjsip_transport_type_e tp_type;
 
     /* Make sure id is in range. */
@@ -2500 +2644 @@
     /* Make sure that transport exists */
     PJ_ASSERT_RETURN(pjsua_var.tpdata[id].data.ptr != NULL, PJ_EINVAL);
+
+    tp_type = pjsua_var.tpdata[id].type & ~PJSIP_TRANSPORT_IPV6;
 
     /* Note: destroy() may not work if there are objects still referencing
@@ -2505 +2651 @@
      */
     if (force) {
-        switch (pjsua_var.tpdata[id].type) {
+        switch (tp_type) {
         case PJSIP_TRANSPORT_UDP:
             status = pjsip_transport_shutdown(pjsua_var.tpdata[id].data.tp);
@@ -2538 +2684 @@
          * descriptor.
          */
-        switch (pjsua_var.tpdata[id].type) {
+        switch (tp_type) {
         case PJSIP_TRANSPORT_UDP:
             return pjsip_transport_shutdown(pjsua_var.tpdata[id].data.tp);
@@ -2741 +2887 @@
 
     /* Make sure STUN server resolution has completed */
-    status = resolve_stun_server(PJ_TRUE);
+    status = resolve_stun_server(PJ_TRUE, PJ_TRUE);
     if (status != PJ_SUCCESS) {
         pjsua_var.nat_status = status;