diff options
author | Benny Prijono <bennylp@teluu.com> | 2007-03-18 17:39:27 +0000 |
---|---|---|
committer | Benny Prijono <bennylp@teluu.com> | 2007-03-18 17:39:27 +0000 |
commit | 25c436a6432ebac429285c81f990653a4c52dd3c (patch) | |
tree | 8f145c79bd09aa7bd7390100f809ca72bf2f069b /pjnath/src | |
parent | 331af12f95e6c79555ce45e5ea9c387fd70915dc (diff) |
Changed pj_sockaddr structure and added pjnath project for ICE/STUN stuffs
git-svn-id: http://svn.pjsip.org/repos/pjproject/trunk@1080 74dad513-b988-da41-8d7b-12977e46ad98
Diffstat (limited to 'pjnath/src')
-rw-r--r-- | pjnath/src/pjnath/errno.c | 121 | ||||
-rw-r--r-- | pjnath/src/pjnath/ice.c | 566 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_auth.c | 22 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_endpoint.c | 20 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_msg.c | 84 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_msg_dump.c | 12 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_session.c | 49 | ||||
-rw-r--r-- | pjnath/src/pjnath/stun_transaction.c | 28 | ||||
-rw-r--r-- | pjnath/src/pjstun-client/client_main.c | 1 | ||||
-rw-r--r-- | pjnath/src/pjstun-srv-test/bind_usage.c | 2 | ||||
-rw-r--r-- | pjnath/src/pjstun-srv-test/server.c | 6 | ||||
-rw-r--r-- | pjnath/src/pjstun-srv-test/server.h | 3 | ||||
-rw-r--r-- | pjnath/src/pjstun-srv-test/turn_usage.c | 10 |
13 files changed, 808 insertions, 116 deletions
diff --git a/pjnath/src/pjnath/errno.c b/pjnath/src/pjnath/errno.c new file mode 100644 index 00000000..bfde1bc0 --- /dev/null +++ b/pjnath/src/pjnath/errno.c @@ -0,0 +1,121 @@ +/* $Id$ */ +/* + * Copyright (C) 2003-2007 Benny Prijono <benny@prijono.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include <pjnath/errno.h> +#include <pj/string.h> + + + +/* PJNATH's own error codes/messages + * MUST KEEP THIS ARRAY SORTED!! + * Message must be limited to 64 chars! + */ +#if defined(PJ_HAS_ERROR_STRING) && PJ_HAS_ERROR_STRING!=0 +static const struct +{ + int code; + const char *msg; +} err_str[] = +{ + /* STUN */ + PJ_BUILD_ERR( PJNATH_ESTUNTOOMANYATTR, "Too many STUN attributes"), + PJ_BUILD_ERR( PJNATH_ESTUNUNKNOWNATTR, "Unknown STUN attribute"), + PJ_BUILD_ERR( PJNATH_ESTUNINADDRLEN, "Invalid STUN socket address length"), + PJ_BUILD_ERR( PJNATH_ESTUNIPV6NOTSUPP, "STUN IPv6 attribute not supported"), + PJ_BUILD_ERR( PJNATH_ESTUNNOTRESPONSE, "Expecting STUN response message"), + PJ_BUILD_ERR( PJNATH_ESTUNINVALIDID, "STUN transaction ID mismatch"), + PJ_BUILD_ERR( PJNATH_ESTUNNOHANDLER, "Unable to find STUN handler for the request"), + PJ_BUILD_ERR( PJNATH_ESTUNMSGINTPOS, "Found non-FINGERPRINT attr. after MESSAGE-INTEGRITY"), + PJ_BUILD_ERR( PJNATH_ESTUNFINGERPOS, "Found STUN attribute after FINGERPRINT"), + PJ_BUILD_ERR( PJNATH_ESTUNNOUSERNAME, "Missing STUN USERNAME attribute"), + PJ_BUILD_ERR( PJNATH_ESTUNMSGINT, "Missing/invalid STUN MESSAGE-INTEGRITY attribute"), + PJ_BUILD_ERR( PJNATH_ESTUNDUPATTR, "Found duplicate STUN attribute"), + PJ_BUILD_ERR( PJNATH_ESTUNNOREALM, "Missing STUN REALM attribute"), + PJ_BUILD_ERR( PJNATH_ESTUNNONCE, "Missing/stale STUN NONCE attribute value"), + PJ_BUILD_ERR( PJNATH_ESTUNTSXFAILED, "STUN transaction terminates with failure"), +}; +#endif /* PJ_HAS_ERROR_STRING */ + + +/* + * pjnath_strerror() + */ +PJ_DEF(pj_str_t) pjnath_strerror( pj_status_t statcode, + char *buf, pj_size_t bufsize ) +{ + pj_str_t errstr; + +#if defined(PJ_HAS_ERROR_STRING) && (PJ_HAS_ERROR_STRING != 0) + + if (statcode >= PJNATH_ERRNO_START && + statcode < PJNATH_ERRNO_START + PJ_ERRNO_SPACE_SIZE) + { + /* Find the error in the table. + * Use binary search! + */ + int first = 0; + int n = PJ_ARRAY_SIZE(err_str); + + while (n > 0) { + int half = n/2; + int mid = first + half; + + if (err_str[mid].code < statcode) { + first = mid+1; + n -= (half+1); + } else if (err_str[mid].code > statcode) { + n = half; + } else { + first = mid; + break; + } + } + + + if (PJ_ARRAY_SIZE(err_str) && err_str[first].code == statcode) { + pj_str_t msg; + + msg.ptr = (char*)err_str[first].msg; + msg.slen = pj_ansi_strlen(err_str[first].msg); + + errstr.ptr = buf; + pj_strncpy_with_null(&errstr, &msg, bufsize); + return errstr; + + } + } + +#endif /* PJ_HAS_ERROR_STRING */ + + + /* Error not found. */ + errstr.ptr = buf; + errstr.slen = pj_ansi_snprintf(buf, bufsize, + "Unknown pjlib-util error %d", + statcode); + + return errstr; +} + + +PJ_DEF(pj_status_t) pjnath_init(void) +{ + return pj_register_strerror(PJNATH_ERRNO_START, + PJ_ERRNO_SPACE_SIZE, + &pjnath_strerror); +} diff --git a/pjnath/src/pjnath/ice.c b/pjnath/src/pjnath/ice.c new file mode 100644 index 00000000..c92ceb5a --- /dev/null +++ b/pjnath/src/pjnath/ice.c @@ -0,0 +1,566 @@ +/* $Id$ */ +/* + * Copyright (C) 2003-2005 Benny Prijono <benny@prijono.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include <pjnath/ice.h> +#include <pjnath/errno.h> +#include <pj/assert.h> +#include <pj/os.h> +#include <pj/pool.h> +#include <pj/string.h> + + +static void destroy_ice(pj_ice *ice, + pj_status_t reason); +static void ice_set_state(pj_ice *ice, + pj_ice_state new_state); + + +PJ_DEF(pj_status_t) pj_ice_create(pj_stun_config *cfg, + const char *name, + int af, + int sock_type, + pj_ice **p_ice) +{ + pj_pool_t *pool; + pj_ice *ice; + pj_status_t status; + + PJ_ASSERT_RETURN(cfg && p_ice, PJ_EINVAL); + PJ_ASSERT_RETURN(sock_type==PJ_SOCK_DGRAM || sock_type==PJ_SOCK_STREAM, + PJ_EINVAL); + + if (!name) + name = "ice%p"; + + pool = pj_pool_create(cfg->pf, name, 4000, 4000, NULL); + ice = PJ_POOL_ZALLOC_T(pool, pj_ice); + ice->pool = pool; + ice->af = af; + ice->sock_type = sock_type; + + pj_ansi_snprintf(ice->obj_name, sizeof(ice->obj_name), + name, ice); + + status = pj_mutex_create_recursive(pool, ice->obj_name, + &ice->mutex); + if (status != PJ_SUCCESS) { + destroy_ice(ice, status); + return status; + } + + *p_ice = ice; + + return PJ_SUCCESS; +} + + +static void destroy_ice(pj_ice *ice, + pj_status_t reason) +{ + if (ice->resv_q) { + pj_dns_resolver_cancel_query(ice->resv_q, PJ_FALSE); + ice->resv_q = NULL; + } + + if (ice->mutex) { + pj_mutex_destroy(ice->mutex); + ice->mutex = NULL; + } + + if (ice->pool) { + pj_pool_t *pool = ice->pool; + ice->pool = NULL; + pj_pool_release(pool); + } +} + + +PJ_DEF(pj_status_t) pj_ice_destroy(pj_ice *ice) +{ + destroy_ice(ice, PJ_SUCCESS); + return PJ_SUCCESS; +} + + +static void ice_set_state(pj_ice *ice, + pj_ice_state new_state) +{ + ice->state = new_state; +} + +static void resolver_cb(void *user_data, + pj_status_t status, + pj_dns_parsed_packet *response) +{ + pj_assert(!"Not implemented yet!"); +} + +PJ_DEF(pj_status_t) pj_ice_set_srv(pj_ice *ice, + pj_bool_t enable_relay, + pj_dns_resolver *resolver, + const pj_str_t *domain) +{ + char namebuf[128]; + char *tp_name; + pj_str_t name; + pj_status_t status; + + + /* Not implemented yet! */ + return PJ_ENOTSUP; + + + PJ_ASSERT_RETURN(ice && resolver && domain, PJ_EINVAL); + + /* Must not have a running resolver. This is because we couldn't + * safely cancel the query (there is a race condition situation + * between the callback acquiring the mutex and this function + * acquiring the mutex) + */ + PJ_ASSERT_RETURN(ice->resv_q==NULL, PJ_EBUSY); + + pj_mutex_lock(ice->mutex); + + /* Reset resolver and server addresses */ + ice->relay_enabled = enable_relay; + ice->resv = resolver; + pj_bzero(&ice->stun_srv, sizeof(ice->stun_srv)); + + /* Build SRV record name */ + if (ice->sock_type == PJ_SOCK_DGRAM) { + tp_name = "_udp"; + } else if (ice->sock_type == PJ_SOCK_STREAM) { + tp_name = "_tcp"; + } else { + pj_assert(!"Invalid sock_type"); + pj_mutex_unlock(ice->mutex); + return PJ_EBUG; + } + + if (enable_relay) { + name.ptr = namebuf; + name.slen = pj_ansi_snprintf(namebuf, sizeof(namebuf), + "_stun-relay.%s.%.*s", + tp_name, + (int)domain->slen, + domain->ptr); + } else { + name.ptr = namebuf; + name.slen = pj_ansi_snprintf(namebuf, sizeof(namebuf), + "_stun.%s.%.*s", + tp_name, + (int)domain->slen, + domain->ptr); + } + + if (name.slen < 1 || name.slen >= sizeof(namebuf)) { + pj_mutex_unlock(ice->mutex); + return PJ_ENAMETOOLONG; + } + + /* Start DNS query */ + status = pj_dns_resolver_start_query(ice->resv, &name, + PJ_DNS_TYPE_SRV, 0, + &resolver_cb, + ice, &ice->resv_q); + if (status != PJ_SUCCESS) { + pj_mutex_unlock(ice->mutex); + return status; + } + + pj_mutex_unlock(ice->mutex); + + return PJ_SUCCESS; +} + + +PJ_DEF(pj_status_t) pj_ice_set_srv_addr(pj_ice *ice, + pj_bool_t enable_relay, + const pj_sockaddr_t *srv_addr, + unsigned addr_len) +{ + PJ_ASSERT_RETURN(ice && srv_addr, PJ_EINVAL); + /* Must not have a running resolver. This is because we couldn't + * safely cancel the query (there is a race condition situation + * between the callback acquiring the mutex and this function + * acquiring the mutex) + */ + PJ_ASSERT_RETURN(ice->resv_q==NULL, PJ_EBUSY); + + pj_mutex_lock(ice->mutex); + + ice->relay_enabled = enable_relay; + pj_memcpy(&ice->stun_srv, srv_addr, addr_len); + + pj_mutex_unlock(ice->mutex); + + return PJ_SUCCESS; + +} + + +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_status_t status; + pj_sock_t sock; + + PJ_ASSERT_RETURN(ice && local_addr && addr_len, PJ_EINVAL); + + status = pj_sock_socket(ice->af, ice->sock_type, 0, &sock); + if (status != PJ_SUCCESS) + return status; + + status = pj_sock_bind(sock, local_addr, addr_len); + if (status != PJ_SUCCESS) + return status; + + status = pj_ice_add_sock_comp(ice, comp_id, sock); + if (status != PJ_SUCCESS) { + pj_sock_close(sock); + return status; + } + + return PJ_SUCCESS; +} + + +PJ_DEF(pj_status_t) pj_ice_add_sock_comp( pj_ice *ice, + unsigned comp_id, + pj_sock_t sock) +{ + PJ_ASSERT_RETURN(ice && sock != PJ_INVALID_SOCKET, PJ_EINVAL); + PJ_ASSERT_RETURN(ice->comp_cnt < PJ_ARRAY_SIZE(ice->comp), PJ_ETOOMANY); + + pj_mutex_lock(ice->mutex); + ice->comp[ice->comp_cnt].comp_id = comp_id; + ice->comp[ice->comp_cnt].sock = sock; + ++ice->comp_cnt; + pj_mutex_unlock(ice->mutex); + + return PJ_SUCCESS; +} + + +static pj_status_t gather_host_cands(pj_ice *ice) +{ + unsigned i; + pj_status_t status; + + for (i=0; i<ice->comp_cnt; ++i) { + pj_ice_comp *comp = &ice->comp[i]; + pj_sockaddr addr; + int addr_len; + + addr_len = sizeof(addr); + status = pj_sock_getsockname(comp->sock, &addr, &addr_len); + if (status != PJ_SUCCESS) + return status; + + if (addr.ipv4.sin_addr.s_addr == 0) { + status = pj_gethostip(&addr.ipv4.sin_addr); + if (status != PJ_SUCCESS) + return status; + } + + status = pj_ice_add_cand(ice, i, PJ_ICE_CAND_TYPE_HOST, 65535, + NULL, &addr, &addr, NULL, + sizeof(pj_sockaddr_in), NULL); + if (status != PJ_SUCCESS) + return status; + } + + return PJ_SUCCESS; +} + +static pj_status_t gather_mapped_cands(pj_ice *ice) +{ + return PJ_ENOTSUP; +} + +static pj_status_t gather_relayed_cands(pj_ice *ice) +{ + return PJ_ENOTSUP; +} + +PJ_DEF(pj_status_t) pj_ice_start_gather(pj_ice *ice, + unsigned flags) +{ + pj_status_t status; + + /* Gather host candidate */ + status = gather_host_cands(ice); + if (status != PJ_SUCCESS) + return status; + + PJ_TODO(GATHER_MAPPED_AND_RELAYED_CANDIDATES); + + ice_set_state(ice, PJ_ICE_STATE_CAND_COMPLETE); + + return PJ_SUCCESS; +} + + +static pj_uint32_t CALC_CAND_PRIO(pj_ice_cand_type type, + pj_uint32_t local_pref, + pj_uint32_t comp_id) +{ + static pj_uint32_t type_pref[] = + { + PJ_ICE_HOST_PREF, + PJ_ICE_MAPPED_PREF, + PJ_ICE_PEER_MAPPED_PREF, + PJ_ICE_RELAYED_PREF + }; + + return ((1 << 24) * type_pref[type]) + + ((1 << 8) * local_pref) + + (256 - comp_id); +} + + +PJ_DEF(pj_status_t) pj_ice_add_cand(pj_ice *ice, + unsigned comp_id, + pj_ice_cand_type type, + pj_uint16_t local_pref, + const pj_str_t *foundation, + const pj_sockaddr_t *addr, + const pj_sockaddr_t *base_addr, + const pj_sockaddr_t *srv_addr, + int addr_len, + unsigned *p_cand_id) +{ + pj_ice_cand *cand; + pj_status_t status = PJ_SUCCESS; + + pj_mutex_lock(ice->mutex); + + if (ice->cand_cnt >= PJ_ARRAY_SIZE(ice->cand)) { + status = PJ_ETOOMANY; + goto on_error; + } + + cand = &ice->cand[ice->cand_cnt]; + cand->comp_id = comp_id; + cand->type = type; + pj_strdup(ice->pool, &cand->foundation, foundation); + cand->prio = CALC_CAND_PRIO(type, local_pref, cand->comp_id); + pj_memcpy(&cand->addr, addr, addr_len); + pj_memcpy(&cand->base_addr, base_addr, addr_len); + if (srv_addr) + pj_memcpy(&cand->srv_addr, srv_addr, addr_len); + else + pj_bzero(&cand->srv_addr, sizeof(cand->srv_addr)); + + if (p_cand_id) + *p_cand_id = ice->cand_cnt; + + ++ice->cand_cnt; + +on_error: + pj_mutex_unlock(ice->mutex); + return status; +} + + +PJ_DEF(unsigned) pj_ice_get_cand_cnt(pj_ice *ice) +{ + return ice->cand_cnt; +} + + +PJ_DEF(pj_status_t) pj_ice_enum_cands(pj_ice *ice, + unsigned sort_by, + unsigned *p_count, + unsigned cand_ids[]) +{ + unsigned i, count; + + pj_mutex_lock(ice->mutex); + + count = (*p_count < ice->cand_cnt) ? *p_count : ice->cand_cnt; + for (i=0; i<count; ++i) + cand_ids[i] = i; + + *p_count = count; + pj_mutex_unlock(ice->mutex); + + return PJ_SUCCESS; +} + + +PJ_DEF(pj_status_t) pj_ice_get_cand(pj_ice *ice, + unsigned cand_id, + pj_ice_cand **p_cand) +{ + PJ_ASSERT_RETURN(ice && p_cand, PJ_EINVAL); + PJ_ASSERT_RETURN(cand_id <= ice->cand_cnt, PJ_EINVAL); + + *p_cand = &ice->cand[cand_id]; + + return PJ_SUCCESS; +} + +#ifndef MIN +# define MIN(a,b) (a < b ? a : b) +#endif + +#ifndef MAX +# define MAX(a,b) (a > b ? a : b) +#endif + +static pj_uint64_t CALC_CHECK_PRIO(pj_uint32_t O, pj_uint32_t A) +{ + return ((pj_uint64_t)1 << 32) * MIN(O, A) + + (pj_uint64_t)2 * MAX(O, A) + (O>A ? 1 : 0); +} + + +PJ_DEF(pj_status_t) pj_ice_create_check_list(pj_ice *ice, + pj_bool_t is_remote_offer, + unsigned rem_cand_cnt, + const pj_ice_cand rem_cand[]) +{ + pj_ice_checklist *clist; + unsigned i, j, count; + + PJ_ASSERT_RETURN(ice && rem_cand_cnt && rem_cand, PJ_EINVAL); + + pj_mutex_lock(ice->mutex); + + /* Create checklist */ + clist = &ice->cklist; + clist->checks = pj_pool_calloc(ice->pool, + ice->cand_cnt * rem_cand_cnt, + sizeof(pj_ice_check)); + for (i=0, count=0; i<ice->cand_cnt; ++i) { + for (j=0; j<rem_cand_cnt; ++j) { + + pj_ice_check *c = &clist->checks[count++]; + + /* A local candidate is paired with a remote candidate if + * and only if the two candidates have the same component ID + * and have the same IP address version. + */ + if (ice->cand[i].comp_id != rem_cand[j].comp_id || + pj_strcmp(&ice->cand[i].foundation,&rem_cand[j].foundation)==0) + { + continue; + } + + c->local_cand_id = i; + + if (is_remote_offer) { + c->check_prio = CALC_CHECK_PRIO(rem_cand[j].prio, + ice->cand[i].prio); + } else { + c->check_prio = CALC_CHECK_PRIO(ice->cand[i].prio, + rem_cand[j].prio); + } + + c->rem_type = rem_cand[j].type; + pj_strdup(ice->pool, &c->rem_foundation, &rem_cand[j].foundation); + c->rem_prio = rem_cand[j].prio; + pj_memcpy(&c->rem_addr, &rem_cand[j].addr, + sizeof(rem_cand[j].addr)); + pj_memcpy(&c->rem_base_addr, &rem_cand[j].base_addr, + sizeof(rem_cand[j].addr)); + } + } + + clist->count = count; + + /* Sort checklist based on priority */ + for (i=0; i<clist->count-1; ++i) { + unsigned highest = i; + for (j=i+1; j<clist->count; ++j) { + if (clist->checks[j].check_prio > + clist->checks[highest].check_prio) + { + highest = j; + } + } + + if (highest != i) { + pj_ice_check tmp; + + pj_memcpy(&tmp, &clist->checks[i], sizeof(pj_ice_check)); + pj_memcpy(&clist->checks[i], &clist->checks[highest], + sizeof(pj_ice_check)); + pj_memcpy(&clist->checks[highest], &tmp, sizeof(pj_ice_check)); + } + } + + /* Prune the checklist */ + for (i=0; i<clist->count; ++i) { + PJ_TODO(PRUNE_CHECKLIST); + } + + pj_mutex_lock(ice->mutex); + + return PJ_SUCCESS; +} + + +/* Start periodic check for the specified checklist */ +static pj_status_t start_periodic_check(pj_ice *ice, pj_ice_checklist *clist) +{ +} + + +/* Start ICE check */ +PJ_DEF(pj_status_t) pj_ice_start_check(pj_ice *ice) +{ + pj_ice_checklist *clist; + unsigned i, comp_id; + pj_str_t fnd; + + PJ_ASSERT_RETURN(ice, PJ_EINVAL); + + clist = &ice->cklist; + + if (clist->count == 0) + return PJ_EICENOCHECKLIST; + + /* Pickup the first pair and set the state to Waiting */ + clist->checks[0].check_state = PJ_ICE_CHECK_STATE_WAITING; + + /* Find all of the other pairs in that check list with the same + * component ID, but different foundations, and sets all of their + * states to Waiting as well. + */ + comp_id = ice->cand[clist->checks[0].local_cand_id].comp_id; + fnd = ice->cand[clist->checks[0].local_cand_id].foundation; + + for (i=1; i<clist->count; ++i) { + pj_ice_check *cki = &clist->checks[i]; + + if (ice->cand[cki->local_cand_id].comp_id != comp_id) + continue; + + if (pj_strcmp(&ice->cand[cki->local_cand_id].foundation, &fnd)==0) + continue; + + clist->checks[i].check_state = PJ_ICE_CHECK_STATE_WAITING; + } + + /* Start periodic check */ + return start_periodic_check(ice, clist); +} diff --git a/pjnath/src/pjnath/stun_auth.c b/pjnath/src/pjnath/stun_auth.c index 9a94fe0d..071019b8 100644 --- a/pjnath/src/pjnath/stun_auth.c +++ b/pjnath/src/pjnath/stun_auth.c @@ -16,8 +16,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_auth.h> -#include <pjlib-util/errno.h> +#include <pjnath/stun_auth.h> +#include <pjnath/errno.h> #include <pjlib-util/hmac_sha1.h> #include <pjlib-util/sha1.h> #include <pj/assert.h> @@ -159,7 +159,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_UNAUTHORIZED, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNMSGINT; + return PJNATH_ESTUNMSGINT; } /* Next check that USERNAME is present */ @@ -170,7 +170,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_MISSING_USERNAME, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNOUSERNAME; + return PJNATH_ESTUNNOUSERNAME; } /* Get REALM, if any */ @@ -201,7 +201,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_UNKNOWN_USERNAME, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNUSERNAME; + return PJNATH_ESTUNUSERNAME; } @@ -216,7 +216,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_MISSING_REALM, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNOREALM; + return PJNATH_ESTUNNOREALM; } else if (realm.slen != 0 && arealm != NULL) { /* We want long term, and REALM is present */ @@ -227,7 +227,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_MISSING_NONCE, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNONCE; + return PJNATH_ESTUNNONCE; } /* Verify REALM matches */ @@ -237,7 +237,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_MISSING_REALM, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNOREALM; + return PJNATH_ESTUNNOREALM; } /* Valid case, will validate the message integrity later */ @@ -260,7 +260,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_MISSING_NONCE, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNONCE; + return PJNATH_ESTUNNONCE; } } @@ -286,7 +286,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_STALE_NONCE, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNNONCE; + return PJNATH_ESTUNNONCE; } } @@ -331,7 +331,7 @@ PJ_DEF(pj_status_t) pj_stun_verify_credential( const pj_uint8_t *pkt, create_challenge(pool, msg, PJ_STUN_SC_INTEGRITY_CHECK_FAILURE, NULL, &realm, &nonce, p_response); } - return PJLIB_UTIL_ESTUNMSGINT; + return PJNATH_ESTUNMSGINT; } /* Everything looks okay! */ diff --git a/pjnath/src/pjnath/stun_endpoint.c b/pjnath/src/pjnath/stun_endpoint.c index 277e385e..3be6407d 100644 --- a/pjnath/src/pjnath/stun_endpoint.c +++ b/pjnath/src/pjnath/stun_endpoint.c @@ -16,8 +16,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_endpoint.h> -#include <pjlib-util/errno.h> +#include <pjnath/stun_endpoint.h> +#include <pjnath/errno.h> #include <pj/assert.h> #include <pj/pool.h> @@ -25,14 +25,14 @@ /* * Create a STUN endpoint instance. */ -PJ_DEF(pj_status_t) pj_stun_endpoint_create( pj_pool_factory *factory, - unsigned options, - pj_ioqueue_t *ioqueue, - pj_timer_heap_t *timer_heap, - pj_stun_endpoint **p_endpt) +PJ_DEF(pj_status_t) pj_stun_config_create( pj_pool_factory *factory, + unsigned options, + pj_ioqueue_t *ioqueue, + pj_timer_heap_t *timer_heap, + pj_stun_config **p_endpt) { pj_pool_t *pool; - pj_stun_endpoint *endpt; + pj_stun_config *endpt; PJ_ASSERT_RETURN(factory && p_endpt, PJ_EINVAL); @@ -40,7 +40,7 @@ PJ_DEF(pj_status_t) pj_stun_endpoint_create( pj_pool_factory *factory, if (!pool) return PJ_ENOMEM; - endpt = PJ_POOL_ZALLOC_T(pool, pj_stun_endpoint); + endpt = PJ_POOL_ZALLOC_T(pool, pj_stun_config); endpt->pool = pool; endpt->pf = factory; endpt->options = options; @@ -58,7 +58,7 @@ PJ_DEF(pj_status_t) pj_stun_endpoint_create( pj_pool_factory *factory, /* * Destroy STUN endpoint instance. */ -PJ_DEF(pj_status_t) pj_stun_endpoint_destroy(pj_stun_endpoint *endpt) +PJ_DEF(pj_status_t) pj_stun_config_destroy(pj_stun_config *endpt) { PJ_ASSERT_RETURN(endpt, PJ_EINVAL); diff --git a/pjnath/src/pjnath/stun_msg.c b/pjnath/src/pjnath/stun_msg.c index 1c750d8e..b361898f 100644 --- a/pjnath/src/pjnath/stun_msg.c +++ b/pjnath/src/pjnath/stun_msg.c @@ -16,9 +16,9 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_msg.h> +#include <pjnath/stun_msg.h> +#include <pjnath/errno.h> #include <pjlib-util/crc32.h> -#include <pjlib-util/errno.h> #include <pjlib-util/hmac_sha1.h> #include <pjlib-util/md5.h> #include <pj/assert.h> @@ -558,7 +558,7 @@ pj_stun_sockaddr_attr_create(pj_pool_t *pool, attr = PJ_POOL_ZALLOC_T(pool, pj_stun_sockaddr_attr); INIT_ATTR(attr, attr_type, STUN_GENERIC_IP_ADDR_LEN); - pj_memcpy(&attr->addr, addr, addr_len); + pj_memcpy(&attr->sockaddr, addr, addr_len); attr->xor_ed = xor_ed; *p_attr = attr; @@ -606,19 +606,19 @@ static pj_status_t decode_sockaddr_attr(pj_pool_t *pool, /* Check that the attribute length is valid */ if (attr->hdr.length != STUN_GENERIC_IP_ADDR_LEN) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; /* Check address family */ val = *(pj_uint8_t*)(buf + ATTR_HDR_LEN + 1); /* Check address family is valid (only supports ipv4 for now) */ if (val != 1) - return PJLIB_UTIL_ESTUNIPV6NOTSUPP; + return PJNATH_ESTUNIPV6NOTSUPP; /* Get port and address */ - pj_sockaddr_in_init(&attr->addr.ipv4, NULL, 0); - pj_memcpy(&attr->addr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); - pj_memcpy(&attr->addr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); + pj_sockaddr_in_init(&attr->sockaddr.ipv4, NULL, 0); + pj_memcpy(&attr->sockaddr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); + pj_memcpy(&attr->sockaddr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); /* Done */ *p_attr = attr; @@ -644,22 +644,22 @@ static pj_status_t decode_xored_sockaddr_attr(pj_pool_t *pool, /* Check that the attribute length is valid */ if (attr->hdr.length != STUN_GENERIC_IP_ADDR_LEN) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; /* Check address family */ val = *(pj_uint8_t*)(buf + ATTR_HDR_LEN + 1); /* Check address family is valid (only supports ipv4 for now) */ if (val != 1) - return PJLIB_UTIL_ESTUNIPV6NOTSUPP; + return PJNATH_ESTUNIPV6NOTSUPP; /* Get port and address */ - pj_sockaddr_in_init(&attr->addr.ipv4, NULL, 0); - pj_memcpy(&attr->addr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); - pj_memcpy(&attr->addr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); + pj_sockaddr_in_init(&attr->sockaddr.ipv4, NULL, 0); + pj_memcpy(&attr->sockaddr.ipv4.sin_port, buf+ATTR_HDR_LEN+2, 2); + pj_memcpy(&attr->sockaddr.ipv4.sin_addr, buf+ATTR_HDR_LEN+4, 4); - attr->addr.ipv4.sin_port ^= 0x2112; - attr->addr.ipv4.sin_addr.s_addr ^= pj_htonl(0x2112A442); + attr->sockaddr.ipv4.sin_port ^= pj_htons(0x2112); + attr->sockaddr.ipv4.sin_addr.s_addr ^= pj_htonl(0x2112A442); /* Done */ *p_attr = attr; @@ -693,17 +693,17 @@ static pj_status_t encode_sockaddr_attr(const void *a, pj_uint8_t *buf, *buf++ = '\0'; /* Family (IPv4 only for now) */ - PJ_ASSERT_RETURN(ca->addr.addr.sa_family == PJ_AF_INET, PJ_EINVAL); + PJ_ASSERT_RETURN(ca->sockaddr.addr.sa_family == PJ_AF_INET, PJ_EINVAL); *buf++ = 1; if (ca->xor_ed) { pj_uint32_t addr; pj_uint16_t port; - addr = ca->addr.ipv4.sin_addr.s_addr; - port = ca->addr.ipv4.sin_port; + addr = ca->sockaddr.ipv4.sin_addr.s_addr; + port = ca->sockaddr.ipv4.sin_port; - port ^= 0x2112; + port ^= pj_htons(0x2112); addr ^= pj_htonl(0x2112A442); /* Port */ @@ -716,11 +716,11 @@ static pj_status_t encode_sockaddr_attr(const void *a, pj_uint8_t *buf, } else { /* Port */ - pj_memcpy(buf, &ca->addr.ipv4.sin_port, 2); + pj_memcpy(buf, &ca->sockaddr.ipv4.sin_port, 2); buf += 2; /* Address */ - pj_memcpy(buf, &ca->addr.ipv4.sin_addr, 4); + pj_memcpy(buf, &ca->sockaddr.ipv4.sin_addr, 4); buf += 4; } @@ -892,7 +892,7 @@ static pj_status_t decode_empty_attr(pj_pool_t *pool, /* Check that the attribute length is valid */ if (attr->hdr.length != ATTR_HDR_LEN) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; /* Done */ *p_attr = attr; @@ -992,7 +992,7 @@ static pj_status_t decode_uint_attr(pj_pool_t *pool, /* Check that the attribute length is valid */ if (attr->hdr.length != STUN_UINT_LEN) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; /* Done */ *p_attr = attr; @@ -1088,7 +1088,7 @@ static pj_status_t decode_msgint_attr(pj_pool_t *pool, /* Check that the attribute length is valid */ if (attr->hdr.length != STUN_MSG_INTEGRITY_LEN) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; /* Done */ *p_attr = attr; @@ -1563,18 +1563,18 @@ PJ_DEF(pj_status_t) pj_stun_msg_check(const pj_uint8_t *pdu, unsigned pdu_len, PJ_ASSERT_RETURN(pdu, PJ_EINVAL); if (pdu_len < sizeof(pj_stun_msg_hdr)) - return PJLIB_UTIL_ESTUNINMSGLEN; + return PJNATH_ESTUNINMSGLEN; /* First byte of STUN message is always 0x00 or 0x01. */ if (*pdu != 0x00 && *pdu != 0x01) - return PJLIB_UTIL_ESTUNINMSGTYPE; + return PJNATH_ESTUNINMSGTYPE; /* Check the PDU length */ msg_len = GET_VAL16(pdu, 2); if ((msg_len + 20 > pdu_len) || ((options & PJ_STUN_IS_DATAGRAM) && msg_len + 20 != pdu_len)) { - return PJLIB_UTIL_ESTUNINMSGLEN; + return PJNATH_ESTUNINMSGLEN; } /* If magic is set, then there is great possibility that this is @@ -1589,13 +1589,13 @@ PJ_DEF(pj_status_t) pj_stun_msg_check(const pj_uint8_t *pdu, unsigned pdu_len, pj_uint32_t crc; if (attr_len != 4) - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; crc = pj_crc32_calc(pdu, msg_len + 20); crc ^= STUN_XOR_FINGERPRINT; if (crc != fingerprint) - return PJLIB_UTIL_ESTUNFINGERPRINT; + return PJNATH_ESTUNFINGERPRINT; } } @@ -1618,7 +1618,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_create_response(pj_pool_t *pool, PJ_ASSERT_RETURN(pool && p_response, PJ_EINVAL); PJ_ASSERT_RETURN(PJ_STUN_IS_REQUEST(msg_type), - PJLIB_UTIL_ESTUNINMSGTYPE); + PJNATH_ESTUNINMSGTYPE); /* Create response or error response */ if (err_code) @@ -1728,7 +1728,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, PJ_STUN_SC_BAD_REQUEST, &err_msg, p_response); } - return PJLIB_UTIL_ESTUNINATTRLEN; + return PJNATH_ESTUNINATTRLEN; } /* Get the attribute descriptor */ @@ -1757,7 +1757,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, } } - return PJLIB_UTIL_ESTUNUNKNOWNATTR; + return PJNATH_ESTUNUNKNOWNATTR; } } else { @@ -1805,7 +1805,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, PJ_STUN_SC_BAD_REQUEST, NULL, p_response); } - return PJLIB_UTIL_ESTUNDUPATTR; + return PJNATH_ESTUNDUPATTR; } has_msg_int = PJ_TRUE; @@ -1819,7 +1819,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, PJ_STUN_SC_BAD_REQUEST, NULL, p_response); } - return PJLIB_UTIL_ESTUNDUPATTR; + return PJNATH_ESTUNDUPATTR; } has_fingerprint = PJ_TRUE; } else { @@ -1833,8 +1833,8 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, PJ_STUN_SC_BAD_REQUEST, NULL, p_response); } - return has_fingerprint ? PJLIB_UTIL_ESTUNFINGERPOS : - PJLIB_UTIL_ESTUNMSGINTPOS; + return has_fingerprint ? PJNATH_ESTUNFINGERPOS : + PJNATH_ESTUNMSGINTPOS; } } @@ -1848,7 +1848,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool, PJ_STUN_SC_BAD_REQUEST, &e, p_response); } - return PJLIB_UTIL_ESTUNTOOMANYATTR; + return PJNATH_ESTUNTOOMANYATTR; } /* Add the attribute */ @@ -2027,12 +2027,12 @@ PJ_DEF(pj_status_t) pj_stun_msg_encode(pj_stun_msg *msg, const pj_stun_attr_hdr *attr_hdr = msg->attr[i]; /* There mustn't any attribute after FINGERPRINT */ - PJ_ASSERT_RETURN(afingerprint == NULL, PJLIB_UTIL_ESTUNFINGERPOS); + PJ_ASSERT_RETURN(afingerprint == NULL, PJNATH_ESTUNFINGERPOS); if (attr_hdr->type == PJ_STUN_ATTR_MESSAGE_INTEGRITY) { /* There mustn't be MESSAGE-INTEGRITY before */ PJ_ASSERT_RETURN(amsgint == NULL, - PJLIB_UTIL_ESTUNMSGINTPOS); + PJNATH_ESTUNMSGINTPOS); amsgint = (pj_stun_msgint_attr*) attr_hdr; } else if (attr_hdr->type == PJ_STUN_ATTR_FINGERPRINT) { @@ -2070,13 +2070,13 @@ PJ_DEF(pj_status_t) pj_stun_msg_encode(pj_stun_msg *msg, if (i < msg->attr_count-2) { /* Should not happen for message generated by us */ pj_assert(PJ_FALSE); - return PJLIB_UTIL_ESTUNMSGINTPOS; + return PJNATH_ESTUNMSGINTPOS; } else if (i == msg->attr_count-2) { if (msg->attr[i+1]->type != PJ_STUN_ATTR_FINGERPRINT) { /* Should not happen for message generated by us */ pj_assert(PJ_FALSE); - return PJLIB_UTIL_ESTUNMSGINTPOS; + return PJNATH_ESTUNMSGINTPOS; } else { afingerprint = (pj_stun_fingerprint_attr*) msg->attr[i+1]; } @@ -2086,7 +2086,7 @@ PJ_DEF(pj_status_t) pj_stun_msg_encode(pj_stun_msg *msg, if (auname == NULL) { /* Should not happen for message generated by us */ pj_assert(PJ_FALSE); - return PJLIB_UTIL_ESTUNNOUSERNAME; + return PJNATH_ESTUNNOUSERNAME; } /* Password must be specified */ diff --git a/pjnath/src/pjnath/stun_msg_dump.c b/pjnath/src/pjnath/stun_msg_dump.c index 0ee0ebe4..5e83958e 100644 --- a/pjnath/src/pjnath/stun_msg_dump.c +++ b/pjnath/src/pjnath/stun_msg_dump.c @@ -16,8 +16,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_msg.h> -#include <pjlib-util/errno.h> +#include <pjnath/stun_msg.h> +#include <pjnath/errno.h> #include <pj/assert.h> #include <pj/string.h> @@ -80,13 +80,13 @@ static int print_attr(char *buffer, unsigned length, attr = (const pj_stun_sockaddr_attr*)ahdr; - if (attr->addr.addr.sa_family == PJ_AF_INET) { + if (attr->sockaddr.addr.sa_family == PJ_AF_INET) { len = pj_ansi_snprintf(p, end-p, ", IPv4 addr=%s:%d\n", - pj_inet_ntoa(attr->addr.ipv4.sin_addr), - pj_ntohs(attr->addr.ipv4.sin_port)); + pj_inet_ntoa(attr->sockaddr.ipv4.sin_addr), + pj_ntohs(attr->sockaddr.ipv4.sin_port)); - } else if (attr->addr.addr.sa_family == PJ_AF_INET6) { + } else if (attr->sockaddr.addr.sa_family == PJ_AF_INET6) { len = pj_ansi_snprintf(p, end-p, ", IPv6 addr present\n"); } else { diff --git a/pjnath/src/pjnath/stun_session.c b/pjnath/src/pjnath/stun_session.c index b4e7356c..9bcff549 100644 --- a/pjnath/src/pjnath/stun_session.c +++ b/pjnath/src/pjnath/stun_session.c @@ -16,12 +16,12 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_session.h> +#include <pjnath/stun_session.h> #include <pjlib.h> struct pj_stun_session { - pj_stun_endpoint *endpt; + pj_stun_config *cfg; pj_pool_t *pool; pj_mutex_t *mutex; pj_stun_session_cb cb; @@ -119,7 +119,7 @@ static pj_status_t create_tdata(pj_stun_session *sess, pj_stun_tx_data *tdata; /* Create pool and initialize basic tdata attributes */ - pool = pj_pool_create(sess->endpt->pf, "tdata%p", + pool = pj_pool_create(sess->cfg->pf, "tdata%p", TDATA_POOL_SIZE, TDATA_POOL_INC, NULL); PJ_ASSERT_RETURN(pool, PJ_ENOMEM); @@ -170,7 +170,7 @@ static void destroy_tdata(pj_stun_tx_data *tdata) tdata->client_tsx = NULL; } if (tdata->res_timer.id != PJ_FALSE) { - pj_timer_heap_cancel(tdata->sess->endpt->timer_heap, + pj_timer_heap_cancel(tdata->sess->cfg->timer_heap, &tdata->res_timer); tdata->res_timer.id = PJ_FALSE; pj_list_erase(tdata); @@ -223,8 +223,8 @@ static pj_status_t apply_msg_options(pj_stun_session *sess, pj_status_t status = 0; /* The server SHOULD include a SERVER attribute in all responses */ - if (PJ_STUN_IS_RESPONSE(msg->hdr.type) || - PJ_STUN_IS_ERROR_RESPONSE(msg->hdr.type)) + if (sess->srv_name.slen && (PJ_STUN_IS_RESPONSE(msg->hdr.type) || + PJ_STUN_IS_ERROR_RESPONSE(msg->hdr.type))) { pj_stun_msg_add_string_attr(pool, msg, PJ_STUN_ATTR_SERVER, &sess->srv_name); @@ -300,7 +300,7 @@ static pj_status_t tsx_on_send_msg(pj_stun_client_tsx *tsx, /* **************************************************************************/ -PJ_DEF(pj_status_t) pj_stun_session_create( pj_stun_endpoint *endpt, +PJ_DEF(pj_status_t) pj_stun_session_create( pj_stun_config *cfg, const char *name, const pj_stun_session_cb *cb, pj_bool_t fingerprint, @@ -310,16 +310,16 @@ PJ_DEF(pj_status_t) pj_stun_session_create( pj_stun_endpoint *endpt, pj_stun_session *sess; pj_status_t status; - PJ_ASSERT_RETURN(endpt && cb && p_sess, PJ_EINVAL); + PJ_ASSERT_RETURN(cfg && cb && p_sess, PJ_EINVAL); if (name==NULL) name = "sess%p"; - pool = pj_pool_create(endpt->pf, name, 4000, 4000, NULL); + pool = pj_pool_create(cfg->pf, name, 4000, 4000, NULL); PJ_ASSERT_RETURN(pool, PJ_ENOMEM); sess = PJ_POOL_ZALLOC_T(pool, pj_stun_session); - sess->endpt = endpt; + sess->cfg = cfg; sess->pool = pool; pj_memcpy(&sess->cb, cb, sizeof(*cb)); sess->use_fingerprint = fingerprint; @@ -383,8 +383,11 @@ PJ_DEF(void*) pj_stun_session_get_user_data(pj_stun_session *sess) PJ_DEF(pj_status_t) pj_stun_session_set_server_name(pj_stun_session *sess, const pj_str_t *srv_name) { - PJ_ASSERT_RETURN(sess && srv_name, PJ_EINVAL); - pj_strdup(sess->pool, &sess->srv_name, srv_name); + PJ_ASSERT_RETURN(sess, PJ_EINVAL); + if (srv_name) + pj_strdup(sess->pool, &sess->srv_name, srv_name); + else + sess->srv_name.slen = 0; return PJ_SUCCESS; } @@ -489,14 +492,12 @@ static void dump_tx_msg(pj_stun_session *sess, const pj_stun_msg *msg, const pj_sockaddr *dst = (const pj_sockaddr*)addr; char buf[512]; - if (dst->sa_family == PJ_AF_INET) { - const pj_sockaddr_in *dst4 = (const pj_sockaddr_in*)dst; - dst_name = pj_inet_ntoa(dst4->sin_addr); - dst_port = pj_ntohs(dst4->sin_port); - } else if (dst->sa_family == PJ_AF_INET6) { - const pj_sockaddr_in6 *dst6 = (const pj_sockaddr_in6*)dst; + if (dst->addr.sa_family == PJ_AF_INET) { + dst_name = pj_inet_ntoa(dst->ipv4.sin_addr); + dst_port = pj_ntohs(dst->ipv4.sin_port); + } else if (dst->addr.sa_family == PJ_AF_INET6) { dst_name = "IPv6"; - dst_port = pj_ntohs(dst6->sin6_port); + dst_port = pj_ntohs(dst->ipv6.sin6_port); } else { LOG_ERR_(sess, "Invalid address family", PJ_EINVAL); return; @@ -558,7 +559,7 @@ PJ_DEF(pj_status_t) pj_stun_session_send_msg( pj_stun_session *sess, if (PJ_STUN_IS_REQUEST(tdata->msg->hdr.type)) { /* Create STUN client transaction */ - status = pj_stun_client_tsx_create(sess->endpt, tdata->pool, + status = pj_stun_client_tsx_create(sess->cfg, tdata->pool, &tsx_cb, &tdata->client_tsx); PJ_ASSERT_RETURN(status==PJ_SUCCESS, status); pj_stun_client_tsx_set_data(tdata->client_tsx, (void*)tdata); @@ -592,10 +593,10 @@ PJ_DEF(pj_status_t) pj_stun_session_send_msg( pj_stun_session *sess, pj_timer_entry_init(&tdata->res_timer, PJ_TRUE, tdata, &on_cache_timeout); - timeout.sec = sess->endpt->res_cache_msec / 1000; - timeout.msec = sess->endpt->res_cache_msec % 1000; + timeout.sec = sess->cfg->res_cache_msec / 1000; + timeout.msec = sess->cfg->res_cache_msec % 1000; - status = pj_timer_heap_schedule(sess->endpt->timer_heap, + status = pj_timer_heap_schedule(sess->cfg->timer_heap, &tdata->res_timer, &timeout); if (status != PJ_SUCCESS) { @@ -829,7 +830,7 @@ PJ_DEF(pj_status_t) pj_stun_session_on_rx_pkt(pj_stun_session *sess, PJ_ASSERT_RETURN(sess && packet && pkt_size, PJ_EINVAL); - tmp_pool = pj_pool_create(sess->endpt->pf, "tmpstun", 1024, 1024, NULL); + tmp_pool = pj_pool_create(sess->cfg->pf, "tmpstun", 1024, 1024, NULL); if (!tmp_pool) return PJ_ENOMEM; diff --git a/pjnath/src/pjnath/stun_transaction.c b/pjnath/src/pjnath/stun_transaction.c index 0000e3a6..2813f7ef 100644 --- a/pjnath/src/pjnath/stun_transaction.c +++ b/pjnath/src/pjnath/stun_transaction.c @@ -16,8 +16,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <pjlib-util/stun_transaction.h> -#include <pjlib-util/errno.h> +#include <pjnath/stun_transaction.h> +#include <pjnath/errno.h> #include <pj/assert.h> #include <pj/log.h> #include <pj/pool.h> @@ -31,7 +31,7 @@ struct pj_stun_client_tsx { char obj_name[PJ_MAX_OBJ_NAME]; - pj_stun_endpoint *endpt; + pj_stun_config *cfg; pj_stun_tsx_cb cb; void *user_data; @@ -63,18 +63,18 @@ static void stun_perror(pj_stun_client_tsx *tsx, const char *title, /* * Create a STUN client transaction. */ -PJ_DEF(pj_status_t) pj_stun_client_tsx_create(pj_stun_endpoint *endpt, +PJ_DEF(pj_status_t) pj_stun_client_tsx_create(pj_stun_config *cfg, pj_pool_t *pool, const pj_stun_tsx_cb *cb, pj_stun_client_tsx **p_tsx) { pj_stun_client_tsx *tsx; - PJ_ASSERT_RETURN(endpt && cb && p_tsx, PJ_EINVAL); + PJ_ASSERT_RETURN(cfg && cb && p_tsx, PJ_EINVAL); PJ_ASSERT_RETURN(cb->on_send_msg, PJ_EINVAL); tsx = PJ_POOL_ZALLOC_T(pool, pj_stun_client_tsx); - tsx->endpt = endpt; + tsx->cfg = cfg; pj_memcpy(&tsx->cb, cb, sizeof(*cb)); tsx->timer.cb = &retransmit_timer_callback; @@ -97,7 +97,7 @@ PJ_DEF(pj_status_t) pj_stun_client_tsx_destroy(pj_stun_client_tsx *tsx) PJ_ASSERT_RETURN(tsx, PJ_EINVAL); if (tsx->timer.id != 0) { - pj_timer_heap_cancel(tsx->endpt->timer_heap, &tsx->timer); + pj_timer_heap_cancel(tsx->cfg->timer_heap, &tsx->timer); tsx->timer.id = 0; } return PJ_SUCCESS; @@ -149,7 +149,7 @@ static pj_status_t tsx_transmit_msg(pj_stun_client_tsx *tsx) /* Calculate retransmit/timeout delay */ if (tsx->transmit_count == 0) { tsx->retransmit_time.sec = 0; - tsx->retransmit_time.msec = tsx->endpt->rto_msec; + tsx->retransmit_time.msec = tsx->cfg->rto_msec; } else if (tsx->transmit_count < PJ_STUN_MAX_RETRANSMIT_COUNT-1) { unsigned msec; @@ -168,7 +168,7 @@ static pj_status_t tsx_transmit_msg(pj_stun_client_tsx *tsx) * cancel it (as opposed to when schedule_timer() failed we cannot * cancel transmission). */; - status = pj_timer_heap_schedule(tsx->endpt->timer_heap, &tsx->timer, + status = pj_timer_heap_schedule(tsx->cfg->timer_heap, &tsx->timer, &tsx->retransmit_time); if (status != PJ_SUCCESS) { tsx->timer.id = 0; @@ -182,7 +182,7 @@ static pj_status_t tsx_transmit_msg(pj_stun_client_tsx *tsx) status = tsx->cb.on_send_msg(tsx, tsx->last_pkt, tsx->last_pkt_size); if (status != PJ_SUCCESS) { if (tsx->timer.id != 0) { - pj_timer_heap_cancel(tsx->endpt->timer_heap, &tsx->timer); + pj_timer_heap_cancel(tsx->cfg->timer_heap, &tsx->timer); tsx->timer.id = 0; } stun_perror(tsx, "STUN error sending message", status); @@ -235,7 +235,7 @@ static void retransmit_timer_callback(pj_timer_heap_t *timer_heap, PJ_LOG(4,(tsx->obj_name, "STUN timeout waiting for response")); tsx->complete = PJ_TRUE; if (tsx->cb.on_complete) { - tsx->cb.on_complete(tsx, PJLIB_UTIL_ESTUNNOTRESPOND, NULL); + tsx->cb.on_complete(tsx, PJNATH_ESTUNNOTRESPOND, NULL); } return; } @@ -268,7 +268,7 @@ PJ_DEF(pj_status_t) pj_stun_client_tsx_on_rx_msg(pj_stun_client_tsx *tsx, { PJ_LOG(4,(tsx->obj_name, "STUN rx_msg() error: not response message")); - return PJLIB_UTIL_ESTUNNOTRESPONSE; + return PJNATH_ESTUNNOTRESPONSE; } @@ -276,7 +276,7 @@ PJ_DEF(pj_status_t) pj_stun_client_tsx_on_rx_msg(pj_stun_client_tsx *tsx, * We can cancel retransmit timer now. */ if (tsx->timer.id) { - pj_timer_heap_cancel(tsx->endpt->timer_heap, &tsx->timer); + pj_timer_heap_cancel(tsx->cfg->timer_heap, &tsx->timer); tsx->timer.id = 0; } @@ -300,7 +300,7 @@ PJ_DEF(pj_status_t) pj_stun_client_tsx_on_rx_msg(pj_stun_client_tsx *tsx, if (err_attr == NULL) { status = PJ_SUCCESS; } else { - status = PJLIB_UTIL_ESTUNTSXFAILED; + status = PJNATH_ESTUNTSXFAILED; } /* Call callback */ diff --git a/pjnath/src/pjstun-client/client_main.c b/pjnath/src/pjstun-client/client_main.c index be65b516..9bb249f1 100644 --- a/pjnath/src/pjstun-client/client_main.c +++ b/pjnath/src/pjstun-client/client_main.c @@ -16,6 +16,7 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include <pjnath.h> #include <pjlib-util.h> #include <pjlib.h> diff --git a/pjnath/src/pjstun-srv-test/bind_usage.c b/pjnath/src/pjstun-srv-test/bind_usage.c index fc10fb91..3c1825f9 100644 --- a/pjnath/src/pjstun-srv-test/bind_usage.c +++ b/pjnath/src/pjstun-srv-test/bind_usage.c @@ -85,7 +85,7 @@ PJ_DEF(pj_status_t) pj_stun_bind_usage_create(pj_stun_server *srv, pj_bzero(&sess_cb, sizeof(sess_cb)); sess_cb.on_send_msg = &sess_on_send_msg; sess_cb.on_rx_request = &sess_on_rx_request; - status = pj_stun_session_create(si->endpt, "bind%p", &sess_cb, PJ_FALSE, + status = pj_stun_session_create(si->cfg, "bind%p", &sess_cb, PJ_FALSE, &bu->session); if (status != PJ_SUCCESS) { pj_stun_usage_destroy(bu->usage); diff --git a/pjnath/src/pjstun-srv-test/server.c b/pjnath/src/pjstun-srv-test/server.c index 5fdb233e..d0fe426d 100644 --- a/pjnath/src/pjstun-srv-test/server.c +++ b/pjnath/src/pjstun-srv-test/server.c @@ -83,8 +83,8 @@ PJ_DEF(pj_status_t) pj_stun_server_create(pj_pool_factory *pf, if (status != PJ_SUCCESS) goto on_error; - status = pj_stun_endpoint_create(srv->si.pf, 0, srv->si.ioqueue, - srv->si.timer_heap, &srv->si.endpt); + status = pj_stun_config_create(srv->si.pf, 0, srv->si.ioqueue, + srv->si.timer_heap, &srv->si.cfg); if (status != PJ_SUCCESS) goto on_error; @@ -174,7 +174,7 @@ PJ_DEF(pj_status_t) pj_stun_server_destroy(pj_stun_server *srv) srv->threads[i] = NULL; } - pj_stun_endpoint_destroy(srv->si.endpt); + pj_stun_config_destroy(srv->si.cfg); pj_timer_heap_destroy(srv->si.timer_heap); pj_ioqueue_destroy(srv->si.ioqueue); pj_pool_release(srv->pool); diff --git a/pjnath/src/pjstun-srv-test/server.h b/pjnath/src/pjstun-srv-test/server.h index a88d87c2..6c61da39 100644 --- a/pjnath/src/pjstun-srv-test/server.h +++ b/pjnath/src/pjstun-srv-test/server.h @@ -19,6 +19,7 @@ #ifndef __STUN_SERVER_H__ #define __STUN_SERVER_H__ +#include <pjnath.h> #include <pjlib-util.h> #include <pjlib.h> @@ -30,7 +31,7 @@ typedef struct pj_stun_server pj_stun_server; typedef struct pj_stun_server_info { pj_pool_factory *pf; - pj_stun_endpoint *endpt; + pj_stun_config *cfg; pj_ioqueue_t *ioqueue; pj_timer_heap_t *timer_heap; unsigned thread_cnt; diff --git a/pjnath/src/pjstun-srv-test/turn_usage.c b/pjnath/src/pjstun-srv-test/turn_usage.c index e3d2e595..c1f83d15 100644 --- a/pjnath/src/pjstun-srv-test/turn_usage.c +++ b/pjnath/src/pjstun-srv-test/turn_usage.c @@ -69,7 +69,7 @@ static pj_status_t client_handle_stun_msg(struct turn_client *client, struct turn_usage { pj_pool_factory *pf; - pj_stun_endpoint *endpt; + pj_stun_config *cfg; pj_ioqueue_t *ioqueue; pj_timer_heap_t *timer_heap; pj_pool_t *pool; @@ -165,7 +165,7 @@ PJ_DEF(pj_status_t) pj_stun_turn_usage_create(pj_stun_server *srv, tu->pool = pool; tu->type = type; tu->pf = si->pf; - tu->endpt = si->endpt; + tu->cfg = si->cfg; tu->ioqueue = si->ioqueue; tu->timer_heap = si->timer_heap; tu->next_port = START_PORT; @@ -197,7 +197,7 @@ PJ_DEF(pj_status_t) pj_stun_turn_usage_create(pj_stun_server *srv, pj_bzero(&sess_cb, sizeof(sess_cb)); sess_cb.on_send_msg = &tu_sess_on_send_msg; sess_cb.on_rx_request = &tu_sess_on_rx_request; - status = pj_stun_session_create(si->endpt, "turns%p", &sess_cb, PJ_FALSE, + status = pj_stun_session_create(si->cfg, "turns%p", &sess_cb, PJ_FALSE, &tu->default_session); if (status != PJ_SUCCESS) { pj_stun_usage_destroy(tu->usage); @@ -208,6 +208,8 @@ PJ_DEF(pj_status_t) pj_stun_turn_usage_create(pj_stun_server *srv, sd->tu = tu; pj_stun_session_set_user_data(tu->default_session, sd); + pj_stun_session_set_server_name(tu->default_session, NULL); + /* Create mutex */ status = pj_mutex_create_recursive(pool, "turn%p", &tu->mutex); if (status != PJ_SUCCESS) { @@ -620,7 +622,7 @@ static pj_status_t client_create(struct turn_usage *tu, sess_cb.on_send_msg = &client_sess_on_send_msg; sess_cb.on_rx_request = &client_sess_on_rx_msg; sess_cb.on_rx_indication = &client_sess_on_rx_msg; - status = pj_stun_session_create(tu->endpt, client->obj_name, + status = pj_stun_session_create(tu->cfg, client->obj_name, &sess_cb, PJ_FALSE, &client->session); if (status != PJ_SUCCESS) { |