Add manual host candidates for ICE (#4618)

nanangizz · web-flow · commit e3cfd0eee6a5 · 2025-10-20T15:25:37.000+07:00
diff --git a/pjnath/include/pjnath/ice_strans.h b/pjnath/include/pjnath/ice_strans.h
@@ -247,6 +247,19 @@ typedef struct pj_ice_strans_stun_cfg
      */
     unsigned             max_host_cands;
 
+    /**
+     * Number of manual host candidates. This must be equal or less than
+     * \a max_host_cands.
+     */
+    unsigned             manual_host_cnt;
+
+    /**
+     * Optional configuration to manually specify host candidates.
+     * Each candidate will use the same port as the automatic/base host
+     * candidate.
+     */
+    pj_sockaddr          manual_host[PJ_ICE_ST_MAX_CAND];
+
     /**
      * Include loopback addresses in the host candidates.
      *
diff --git a/pjnath/src/pjnath/ice_strans.c b/pjnath/src/pjnath/ice_strans.c
@@ -653,6 +653,7 @@ static pj_status_t add_stun_and_host(pj_ice_strans *ice_st,
             pj_bool_t cand_duplicate = PJ_FALSE;
             char addrinfo[PJ_INET6_ADDRSTRLEN+10];
             const pj_sockaddr *addr = &stun_sock_info.aliases[i];
+            pj_bool_t manual_host_added = PJ_FALSE;
 
             if (max_cand_cnt==0) {
                 PJ_LOG(4,(ice_st->obj_name, "Too many host candidates"));
@@ -686,6 +687,68 @@ static pj_status_t add_stun_and_host(pj_ice_strans *ice_st,
                     continue;
             }
 
+            /* Add manual host candidates. */
+            if (!manual_host_added && stun_cfg->manual_host_cnt) {
+                manual_host_added = PJ_TRUE;
+
+                pj_assert(stun_cfg->manual_host_cnt < PJ_ARRAY_SIZE(
+                                                      stun_cfg->manual_host));
+                for (j=0; j<stun_cfg->manual_host_cnt &&
+                          max_cand_cnt && cand_cnt < stun_cfg->max_host_cands;
+                     j++)
+                {
+
+                    /* Only add the same address family */
+                    if (stun_cfg->manual_host[j].addr.sa_family !=
+                        stun_cfg->af ||
+                        !pj_sockaddr_has_addr(&stun_cfg->manual_host[j]))
+                    {
+                        continue;
+                    }
+
+                    cand = &comp->cand_list[comp->cand_cnt];
+
+                    cand->type = PJ_ICE_CAND_TYPE_HOST;
+                    cand->status = PJ_SUCCESS;
+                    cand->local_pref = (pj_uint16_t)(HOST_PREF - cand_cnt);
+                    cand->transport_id = CREATE_TP_ID(TP_STUN, idx);
+                    cand->comp_id = (pj_uint8_t) comp->comp_id;
+                    pj_sockaddr_cp(&cand->addr, &stun_cfg->manual_host[j]);
+                    pj_sockaddr_set_port(&cand->addr,
+                                         pj_sockaddr_get_port(addr));
+                    pj_sockaddr_cp(&cand->base_addr, addr);
+                    pj_bzero(&cand->rel_addr, sizeof(cand->rel_addr));
+
+                    comp->cand_cnt+=1;
+                    cand_cnt++;
+                    max_cand_cnt--;
+                    pj_ice_calc_foundation(ice_st->pool, &cand->foundation,
+                                           cand->type, &cand->base_addr);
+
+                    /* Set default candidate with the preferred default
+                     * address family
+                     */
+                    if (comp->ice_st->cfg.af != pj_AF_UNSPEC() &&
+                        cand->addr.addr.sa_family == comp->ice_st->cfg.af &&
+                        comp->cand_list[comp->default_cand].base_addr.addr.
+                                                sa_family != ice_st->cfg.af)
+                    {
+                        comp->default_cand = (unsigned)
+                                             (cand - comp->cand_list);
+                    }
+
+                    PJ_LOG(4,(ice_st->obj_name,
+                              "Comp %d/%d: host candidate %s (tpid=%d) added",
+                              comp->comp_id, comp->cand_cnt-1, 
+                              pj_sockaddr_print(&cand->addr, addrinfo,
+                                                sizeof(addrinfo), 3),
+                                                cand->transport_id));
+                }
+
+                if (max_cand_cnt == 0 || cand_cnt >= stun_cfg->max_host_cands)
+                    break;
+            }
+
             cand = &comp->cand_list[comp->cand_cnt];
 
             cand->type = PJ_ICE_CAND_TYPE_HOST;
diff --git a/pjsip/include/pjsua-lib/pjsua.h b/pjsip/include/pjsua-lib/pjsua.h
@@ -3911,6 +3911,19 @@ typedef struct pjsua_ice_config
      */
     int                 ice_max_host_cands;
 
+    /**
+     * Number of manual host candidates. This must be equal or less than
+     * \a ice_max_host_cands.
+     */
+    unsigned            ice_manual_host_cnt;
+
+    /**
+     * Optional configuration to manually specify host candidates.
+     * Each candidate will use the same port as the automatic/base host
+     * candidate.
+     */
+    pj_sockaddr         ice_manual_host[PJ_ICE_ST_MAX_CAND];
+
     /**
      * ICE session options.
      */
diff --git a/pjsip/include/pjsua2/account.hpp b/pjsip/include/pjsua2/account.hpp
@@ -584,6 +584,14 @@ struct AccountNatConfig : public PersistentObject
      */
     int                 iceMaxHostCands;
 
+    /**
+     * Optional configuration to manually specify host candidates.
+     * Each candidate will use the same port as the automatic/base host
+     * candidate. The number of entries in this array must be equal or less
+     * than \a iceMaxHostCands.
+     */
+    SocketAddressVector iceManualHost;
+
     /**
      * Specify whether to use aggressive nomination.
      *
diff --git a/pjsip/include/pjsua2/types.hpp b/pjsip/include/pjsua2/types.hpp
@@ -71,6 +71,9 @@ typedef void *Token;
  */
 typedef string SocketAddress;
 
+/** Array of socket address */
+typedef StringVector SocketAddressVector;
+
 /**
  * Transport ID is an integer.
  */
diff --git a/pjsip/src/pjsua-lib/pjsua_media.c b/pjsip/src/pjsua-lib/pjsua_media.c
@@ -1267,6 +1267,13 @@ static pj_status_t create_ice_media_transport(
 
             /* Configure max packet size */
             ice_cfg.stun_tp[i].cfg.max_pkt_size = PJMEDIA_MAX_MRU;
+
+            /* Configure manual host candidates */
+            ice_cfg.stun_tp[i].manual_host_cnt =
+                                        acc_cfg->ice_cfg.ice_manual_host_cnt;
+            pj_memcpy(&ice_cfg.stun_tp[i].manual_host,
+                      &acc_cfg->ice_cfg.ice_manual_host,
+                      sizeof(ice_cfg.stun_tp[i].manual_host));
         }
     }
 
diff --git a/pjsip/src/pjsua2/account.cpp b/pjsip/src/pjsua2/account.cpp
@@ -497,6 +497,7 @@ void AccountNatConfig::readObject(const ContainerNode &node)
     NODE_READ_UNSIGNED( this_node, udpKaIntervalSec);
     NODE_READ_STRING  ( this_node, udpKaData);
     NODE_READ_INT     ( this_node, contactUseSrcPort);
+    NODE_READ_STRINGV ( this_node, iceManualHost);
 }
 
 void AccountNatConfig::writeObject(ContainerNode &node) const
@@ -534,6 +535,7 @@ void AccountNatConfig::writeObject(ContainerNode &node) const
     NODE_WRITE_UNSIGNED( this_node, udpKaIntervalSec);
     NODE_WRITE_STRING  ( this_node, udpKaData);
     NODE_WRITE_INT     ( this_node, contactUseSrcPort);
+    NODE_WRITE_STRINGV  (this_node, iceManualHost);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -758,6 +760,25 @@ void AccountConfig::toPj(pjsua_acc_config &ret) const
     ret.ice_cfg.enable_ice      = natConfig.iceEnabled;
     ret.ice_cfg.ice_opt.trickle = natConfig.iceTrickle;
     ret.ice_cfg.ice_max_host_cands = natConfig.iceMaxHostCands;
+    ret.ice_cfg.ice_manual_host_cnt = 0;
+    if (natConfig.iceManualHost.size() >
+                            PJ_ARRAY_SIZE(ret.ice_cfg.ice_manual_host))
+    {
+        PJSUA2_RAISE_ERROR(PJ_ETOOMANY);
+    }
+    for (i=0; i<natConfig.iceManualHost.size(); ++i) {
+        pj_str_t tmp = pj_str(const_cast<char*>
+                              (natConfig.iceManualHost[i].c_str()));
+        pj_sockaddr* addr =
+                &ret.ice_cfg.ice_manual_host[ret.ice_cfg.ice_manual_host_cnt];
+        if (pj_sockaddr_set_str_addr(pj_AF_INET(),  addr, &tmp)==PJ_SUCCESS ||
+            pj_sockaddr_set_str_addr(pj_AF_INET6(), addr, &tmp)==PJ_SUCCESS)
+        {
+            ret.ice_cfg.ice_manual_host_cnt++;
+        } else {
+            PJSUA2_RAISE_ERROR(PJ_EINVAL);
+        }
+    }
     ret.ice_cfg.ice_opt.aggressive = natConfig.iceAggressiveNomination;
     ret.ice_cfg.ice_opt.nominated_check_delay =
                             natConfig.iceNominatedCheckDelayMsec;
@@ -933,6 +954,14 @@ void AccountConfig::fromPj(const pjsua_acc_config &prm,
         natConfig.iceEnabled = PJ2BOOL(prm.ice_cfg.enable_ice);
         natConfig.iceTrickle = prm.ice_cfg.ice_opt.trickle;
         natConfig.iceMaxHostCands = prm.ice_cfg.ice_max_host_cands;
+        natConfig.iceManualHost.clear();
+        for (i=0; i<prm.ice_cfg.ice_manual_host_cnt; ++i) {
+            char buf[PJ_INET6_ADDRSTRLEN];
+            const pj_sockaddr *addr = &prm.ice_cfg.ice_manual_host[i];
+            if (pj_sockaddr_print(addr, buf, sizeof(buf), 0) != NULL) {
+                natConfig.iceManualHost.push_back(std::string(buf));
+            }
+        }
         natConfig.iceAggressiveNomination =
                         PJ2BOOL(prm.ice_cfg.ice_opt.aggressive);
         natConfig.iceNominatedCheckDelayMsec =

Original file line number	Diff line number	Diff line change
`@@ -1267,6 +1267,13 @@ static pj_status_t create_ice_media_transport(`
`1267`	`1267`
`1268`	`1268`	`/* Configure max packet size */`
`1269`	`1269`	`ice_cfg.stun_tp[i].cfg.max_pkt_size = PJMEDIA_MAX_MRU;`
	`1270`	`+`
	`1271`	`+ /* Configure manual host candidates */`
	`1272`	`+ ice_cfg.stun_tp[i].manual_host_cnt =`
	`1273`	`+ acc_cfg->ice_cfg.ice_manual_host_cnt;`
	`1274`	`+ pj_memcpy(&ice_cfg.stun_tp[i].manual_host,`
	`1275`	`+ &acc_cfg->ice_cfg.ice_manual_host,`
	`1276`	`+ sizeof(ice_cfg.stun_tp[i].manual_host));`
`1270`	`1277`	`}`
`1271`	`1278`	`}`
`1272`	`1279`