sysmocom
/
pjproject
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Ported PJLIB-UTIL and PJNATH to Symbian 

git-svn-id: https://svn.pjsip.org/repos/pjproject/trunk@1239 74dad513-b988-da41-8d7b-12977e46ad98
This commit is contained in:
Benny Prijono 2007-05-01 12:25:01 +00:00
parent aeeb1d1116
commit 727f2030fc
13 changed files with 210 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
build.symbian/pjlib_util.mmp Normal file
View File

@ -0,0 +1,41 @@
TARGET pjlib_util.lib
TARGETTYPE lib
UID 0x100039CE 0x10004299
VENDORID 0x70000001
SOURCEPATH ..\pjlib-util\src\pjlib-util
MACRO PJ_M_I386=1
MACRO PJ_SYMBIAN=1
MACRO PJ_IMPORTING
OPTION CW -lang c++
// PJLIB-UTIL files
SOURCE crc32.c
SOURCE dns.c
SOURCE dns_dump.c
SOURCE errno.c
SOURCE getopt.c
SOURCE hmac_md5.c
SOURCE hmac_sha1.c
SOURCE md5.c
SOURCE resolver.c
SOURCE scanner.c
SOURCE sha1.c
SOURCE srv_resolver.c
SOURCE string.c
SOURCE stun_simple.c
SOURCE stun_simple_client.c
SOURCE xml.c
SYSTEMINCLUDE ..\pjlib\include
SYSTEMINCLUDE ..\pjlib-util\include
SYSTEMINCLUDE \epoc32\include
SYSTEMINCLUDE \epoc32\include\libc
LIBRARY pjlib.lib
CAPABILITY None

35
build.symbian/pjnath.mmp Normal file
View File

@ -0,0 +1,35 @@
TARGET pjnath.lib
TARGETTYPE lib
UID 0x100039CE 0x10004299
VENDORID 0x70000001
SOURCEPATH ..\pjnath\src\pjnath
MACRO PJ_M_I386=1
MACRO PJ_SYMBIAN=1
MACRO PJ_IMPORTING
OPTION CW -lang c++
// PJNATH files
SOURCE errno.c
SOURCE ice_session.c
SOURCE ice_strans.c
SOURCE stun_auth.c
SOURCE stun_msg.c
SOURCE stun_msg_dump.c
SOURCE stun_session.c
SOURCE stun_transaction.c
SYSTEMINCLUDE ..\pjlib\include
SYSTEMINCLUDE ..\pjlib-util\include
SYSTEMINCLUDE ..\pjnath\include
SYSTEMINCLUDE \epoc32\include
SYSTEMINCLUDE \epoc32\include\libc
LIBRARY pjlib.lib
LIBRARY pjlib_util.lib
CAPABILITY None

31
build.symbian/pjstun_client.mmp Normal file
View File

@ -0,0 +1,31 @@
TARGET pjstun_client.exe
TARGETTYPE exe
UID 0x100039CE 0x10004299
VENDORID 0x70000001
SOURCEPATH ..\pjnath\src\pjstun-client
MACRO PJ_M_I386=1
MACRO PJ_SYMBIAN=1
MACRO PJ_IMPORTING
OPTION CW -lang c++
// PJSTUN-CLIENT files
SOURCE client_main.c
//SOURCE main_symbian.cpp
SYSTEMINCLUDE ..\pjlib\include
SYSTEMINCLUDE ..\pjlib-util\include
SYSTEMINCLUDE ..\pjnath\include
SYSTEMINCLUDE \epoc32\include
SYSTEMINCLUDE \epoc32\include\libc
LIBRARY pjnath.lib pjlib_util.lib pjlib.lib esock.lib insock.lib charconv.lib euser.lib estlib.lib eexe.lib
STATICLIBRARY ecrt0.lib
CAPABILITY None

84
pjlib-util/src/pjlib-util/dns.c
View File

@ -66,7 +66,7 @@ PJ_DEF(pj_status_t) pj_dns_make_query( void *packet,
PJ_ASSERT_RETURN(*size >= d, PJLIB_UTIL_EDNSQRYTOOSMALL);
/* Initialize header */
hdr = packet;
hdr = (pj_dns_hdr*) packet;
pj_bzero(hdr, sizeof(struct pj_dns_hdr));
hdr->id = pj_htons(id);
hdr->flags = pj_htons(PJ_DNS_SET_RD(1));
@ -110,11 +110,11 @@ PJ_DEF(pj_status_t) pj_dns_make_query( void *packet,
/* Get a name length (note: name consists of multiple labels and
* it may contain pointers when name compression is applied)
*/
static pj_status_t get_name_len(int rec_counter, const char *pkt,
const char *start, const char *max,
static pj_status_t get_name_len(int rec_counter, const pj_uint8_t *pkt,
const pj_uint8_t *start, const pj_uint8_t *max,
int *parsed_len, int *name_len)
{
const char *p;
const pj_uint8_t *p;
pj_status_t status;
/* Limit the number of recursion */
@ -180,11 +180,11 @@ static pj_status_t get_name_len(int rec_counter, const char *pkt,
/* Parse and copy name (note: name consists of multiple labels and
* it may contain pointers when compression is applied).
*/
static pj_status_t get_name(int rec_counter, const char *pkt,
const char *start, const char *max,
static pj_status_t get_name(int rec_counter, const pj_uint8_t *pkt,
const pj_uint8_t *start, const pj_uint8_t *max,
pj_str_t *name)
{
const char *p;
const pj_uint8_t *p;
pj_status_t status;
/* Limit the number of recursion */
@ -241,10 +241,10 @@ static pj_status_t get_name(int rec_counter, const char *pkt,
/* Skip query records. */
static pj_status_t parse_query(pj_dns_parsed_query *q, pj_pool_t *pool,
const char *pkt, const char *start,
const char *max, int *parsed_len)
const pj_uint8_t *pkt, const pj_uint8_t *start,
const pj_uint8_t *max, int *parsed_len)
{
const char *p = start;
const pj_uint8_t *p = start;
int name_len, name_part_len;
pj_status_t status;
@ -254,7 +254,7 @@ static pj_status_t parse_query(pj_dns_parsed_query *q, pj_pool_t *pool,
return status;
/* Allocate memory for the name */
q->name.ptr = pj_pool_alloc(pool, name_len+4);
q->name.ptr = (char*) pj_pool_alloc(pool, name_len+4);
q->name.slen = 0;
/* Get the name */
@ -282,11 +282,11 @@ static pj_status_t parse_query(pj_dns_parsed_query *q, pj_pool_t *pool,
/* Parse RR records */
static pj_status_t parse_rr(pj_dns_parsed_rr *rr, pj_pool_t *pool,
const char *pkt,
const char *start, const char *max,
const pj_uint8_t *pkt,
const pj_uint8_t *start, const pj_uint8_t *max,
int *parsed_len)
{
const char *p = start;
const pj_uint8_t *p = start;
int name_len, name_part_len;
pj_status_t status;
@ -296,7 +296,7 @@ static pj_status_t parse_rr(pj_dns_parsed_rr *rr, pj_pool_t *pool,
return status;
/* Allocate memory for the name */
rr->name.ptr = pj_pool_alloc(pool, name_len+4);
rr->name.ptr = (char*) pj_pool_alloc(pool, name_len+4);
rr->name.slen = 0;
/* Get the name */
@ -354,7 +354,7 @@ static pj_status_t parse_rr(pj_dns_parsed_rr *rr, pj_pool_t *pool,
return status;
/* Allocate memory for the name */
rr->rdata.cname.name.ptr = pj_pool_alloc(pool, name_len);
rr->rdata.cname.name.ptr = (char*) pj_pool_alloc(pool, name_len);
rr->rdata.cname.name.slen = 0;
/* Get the name */
@ -387,7 +387,7 @@ static pj_status_t parse_rr(pj_dns_parsed_rr *rr, pj_pool_t *pool,
return status;
/* Allocate memory for the name */
rr->rdata.srv.target.ptr = pj_pool_alloc(pool, name_len);
rr->rdata.srv.target.ptr = (char*) pj_pool_alloc(pool, name_len);
rr->rdata.srv.target.slen = 0;
/* Get the name */
@ -418,7 +418,7 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
pj_dns_parsed_packet **p_res)
{
pj_dns_parsed_packet *res;
char *start, *end;
const pj_uint8_t *start, *end;
pj_status_t status;
unsigned i;
@ -430,7 +430,7 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
return PJLIB_UTIL_EDNSINSIZE;
/* Create the structure */
res = pj_pool_zalloc(pool, sizeof(pj_dns_parsed_packet));
res = PJ_POOL_ZALLOC_T(pool, pj_dns_parsed_packet);
/* Copy the DNS header, and convert endianness to host byte order */
pj_memcpy(&res->hdr, packet, sizeof(pj_dns_hdr));
@ -442,19 +442,20 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
res->hdr.arcount = pj_ntohs(res->hdr.arcount);
/* Mark start and end of payload */
start = ((char*)packet) + sizeof(pj_dns_hdr);
end = ((char*)packet) + size;
start = ((const pj_uint8_t*)packet) + sizeof(pj_dns_hdr);
end = ((const pj_uint8_t*)packet) + size;
/* Parse query records (if any).
*/
if (res->hdr.qdcount) {
res->q = pj_pool_zalloc(pool, res->hdr.qdcount *
res->q = (pj_dns_parsed_query*)
pj_pool_zalloc(pool, res->hdr.qdcount *
sizeof(pj_dns_parsed_query));
for (i=0; i<res->hdr.qdcount; ++i) {
int parsed_len = 0;
status = parse_query(&res->q[i], pool, packet, start, end,
&parsed_len);
status = parse_query(&res->q[i], pool, (const pj_uint8_t*)packet,
start, end, &parsed_len);
if (status != PJ_SUCCESS)
return status;
@ -464,14 +465,15 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
/* Parse answer, if any */
if (res->hdr.anscount) {
res->ans = pj_pool_zalloc(pool, res->hdr.anscount *
res->ans = (pj_dns_parsed_rr*)
pj_pool_zalloc(pool, res->hdr.anscount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<res->hdr.anscount; ++i) {
int parsed_len;
status = parse_rr(&res->ans[i], pool, packet, start, end,
&parsed_len);
status = parse_rr(&res->ans[i], pool, (const pj_uint8_t*)packet,
start, end, &parsed_len);
if (status != PJ_SUCCESS)
return status;
@ -481,14 +483,15 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
/* Parse authoritative NS records, if any */
if (res->hdr.nscount) {
res->ns = pj_pool_zalloc(pool, res->hdr.nscount *
res->ns = (pj_dns_parsed_rr*)
pj_pool_zalloc(pool, res->hdr.nscount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<res->hdr.nscount; ++i) {
int parsed_len;
status = parse_rr(&res->ns[i], pool, packet, start, end,
&parsed_len);
status = parse_rr(&res->ns[i], pool, (const pj_uint8_t*)packet,
start, end, &parsed_len);
if (status != PJ_SUCCESS)
return status;
@ -498,14 +501,15 @@ PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,
/* Parse additional RR answer, if any */
if (res->hdr.arcount) {
res->arr = pj_pool_zalloc(pool, res->hdr.arcount *
res->arr = (pj_dns_parsed_rr*)
pj_pool_zalloc(pool, res->hdr.arcount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<res->hdr.arcount; ++i) {
int parsed_len;
status = parse_rr(&res->arr[i], pool, packet, start, end,
&parsed_len);
status = parse_rr(&res->arr[i], pool, (const pj_uint8_t*)packet,
start, end, &parsed_len);
if (status != PJ_SUCCESS)
return status;
@ -613,7 +617,7 @@ PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,
PJ_ASSERT_ON_FAIL(pool && p && p_dst, return);
/* Create packet and copy header */
*p_dst = dst = pj_pool_zalloc(pool, sizeof(pj_dns_parsed_packet));
*p_dst = dst = PJ_POOL_ZALLOC_T(pool, pj_dns_parsed_packet);
pj_memcpy(&dst->hdr, &p->hdr, sizeof(p->hdr));
/* Initialize section counts in the target packet to zero.
@ -628,7 +632,8 @@ PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,
/* Copy query section */
if (p->hdr.qdcount && (options & PJ_DNS_NO_QD)==0) {
dst->q = pj_pool_alloc(pool, p->hdr.qdcount *
dst->q = (pj_dns_parsed_query*)
pj_pool_alloc(pool, p->hdr.qdcount *
sizeof(pj_dns_parsed_query));
for (i=0; i<p->hdr.qdcount; ++i) {
copy_query(pool, &dst->q[i], &p->q[i],
@ -639,7 +644,8 @@ PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,
/* Copy answer section */
if (p->hdr.anscount && (options & PJ_DNS_NO_ANS)==0) {
dst->ans = pj_pool_alloc(pool, p->hdr.anscount *
dst->ans = (pj_dns_parsed_rr*)
pj_pool_alloc(pool, p->hdr.anscount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<p->hdr.anscount; ++i) {
copy_rr(pool, &dst->ans[i], &p->ans[i],
@ -650,7 +656,8 @@ PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,
/* Copy NS section */
if (p->hdr.nscount && (options & PJ_DNS_NO_NS)==0) {
dst->ns = pj_pool_alloc(pool, p->hdr.nscount *
dst->ns = (pj_dns_parsed_rr*)
pj_pool_alloc(pool, p->hdr.nscount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<p->hdr.nscount; ++i) {
copy_rr(pool, &dst->ns[i], &p->ns[i],
@ -661,7 +668,8 @@ PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,
/* Copy additional info section */
if (p->hdr.arcount && (options & PJ_DNS_NO_AR)==0) {
dst->arr = pj_pool_alloc(pool, p->hdr.arcount *
dst->arr = (pj_dns_parsed_rr*)
pj_pool_alloc(pool, p->hdr.arcount *
sizeof(pj_dns_parsed_rr));
for (i=0; i<p->hdr.arcount; ++i) {
copy_rr(pool, &dst->arr[i], &p->arr[i],

36
pjlib-util/src/pjlib-util/resolver.c
View File

@ -243,7 +243,7 @@ PJ_DEF(pj_status_t) pj_dns_resolver_create( pj_pool_factory *pf,
return PJ_ENOMEM;
/* Create pool and name */
resv = pj_pool_zalloc(pool, sizeof(struct pj_dns_resolver));
resv = PJ_POOL_ZALLOC_T(pool, struct pj_dns_resolver);
resv->pool = pool;
resv->udp_sock = PJ_INVALID_SOCKET;
pj_strdup2_with_null(pool, &resv->name, name);
@ -337,7 +337,8 @@ PJ_DEF(pj_status_t) pj_dns_resolver_destroy( pj_dns_resolver *resolver,
it = pj_hash_first(resolver->hquerybyid, &it_buf);
while (it) {
pj_dns_async_query *q = pj_hash_this(resolver->hquerybyid, it);
pj_dns_async_query *q = (pj_dns_async_query *)
pj_hash_this(resolver->hquerybyid, it);
pj_dns_async_query *cq;
if (q->cb)
(*q->cb)(q->user_data, PJ_ECANCELLED, NULL);
@ -497,7 +498,7 @@ static pj_dns_async_query *alloc_qnode(pj_dns_resolver *resolver,
pj_list_erase(q);
pj_bzero(q, sizeof(*q));
} else {
q = pj_pool_zalloc(resolver->pool, sizeof(*q));
q = PJ_POOL_ZALLOC_T(resolver->pool, pj_dns_async_query);
}
/* Init query */
@ -657,7 +658,8 @@ PJ_DEF(pj_status_t) pj_dns_resolver_start_query( pj_dns_resolver *resolver,
* and the cached entry has not expired.
*/
hval = 0;
cache = pj_hash_get(resolver->hrescache, &key, sizeof(key), &hval);
cache = (struct cached_res *) pj_hash_get(resolver->hrescache, &key,
sizeof(key), &hval);
if (cache) {
/* We've found a cached entry. */
@ -702,7 +704,8 @@ PJ_DEF(pj_status_t) pj_dns_resolver_start_query( pj_dns_resolver *resolver,
}
/* Next, check if we have pending query on the same resource */
q = pj_hash_get(resolver->hquerybyres, &key, sizeof(key), NULL);
q = (pj_dns_async_query *) pj_hash_get(resolver->hquerybyres, &key,
sizeof(key), NULL);
if (q) {
/* Yes, there's another pending query to the same key.
* Just create a new child query and add this query to
@ -941,7 +944,8 @@ static void update_res_cache(pj_dns_resolver *resolver,
/* If status is unsuccessful, clear the same entry from the cache */
if (status != PJ_SUCCESS) {
cache = pj_hash_get(resolver->hrescache, key, sizeof(*key), &hval);
cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key,
sizeof(*key), &hval);
if (cache)
pj_list_push_back(&resolver->res_free_nodes, cache);
pj_hash_set(NULL, resolver->hrescache, key, sizeof(*key), hval, NULL);
@ -976,7 +980,8 @@ static void update_res_cache(pj_dns_resolver *resolver,
/* If TTL is zero, clear the same entry in the hash table */
if (ttl == 0) {
cache = pj_hash_get(resolver->hrescache, key, sizeof(*key), &hval);
cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key,
sizeof(*key), &hval);
if (cache)
pj_list_push_back(&resolver->res_free_nodes, cache);
pj_hash_set(NULL, resolver->hrescache, key, sizeof(*key), hval, NULL);
@ -984,13 +989,14 @@ static void update_res_cache(pj_dns_resolver *resolver,
}
/* Get a cache response entry */
cache = pj_hash_get(resolver->hrescache, key, sizeof(*key), &hval);
cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key,
sizeof(*key), &hval);
if (cache == NULL) {
if (!pj_list_empty(&resolver->res_free_nodes)) {
cache = resolver->res_free_nodes.next;
pj_list_erase(cache);
} else {
cache = pj_pool_zalloc(resolver->pool, sizeof(*cache));
cache = PJ_POOL_ZALLOC_T(resolver->pool, struct cached_res);
}
}
@ -1040,7 +1046,7 @@ static void on_timeout( pj_timer_heap_t *timer_heap,
PJ_UNUSED_ARG(timer_heap);
q = entry->user_data;
q = (pj_dns_async_query *) entry->user_data;
resolver = q->resolver;
pj_mutex_lock(resolver->mutex);
@ -1124,7 +1130,7 @@ static void on_read_complete(pj_ioqueue_key_t *key,
PJ_USE_EXCEPTION;
resolver = pj_ioqueue_get_user_data(key);
resolver = (pj_dns_resolver *) pj_ioqueue_get_user_data(key);
pj_mutex_lock(resolver->mutex);
@ -1187,7 +1193,8 @@ static void on_read_complete(pj_ioqueue_key_t *key,
}
/* Find the query based on the transaction ID */
q = pj_hash_get(resolver->hquerybyid, &dns_pkt->hdr.id,
q = (pj_dns_async_query*)
pj_hash_get(resolver->hquerybyid, &dns_pkt->hdr.id,
sizeof(dns_pkt->hdr.id), NULL);
if (!q) {
PJ_LOG(5,(resolver->name.ptr,
@ -1371,7 +1378,8 @@ PJ_DEF(void) pj_dns_resolver_dump(pj_dns_resolver *resolver,
pj_hash_iterator_t itbuf, *it;
it = pj_hash_first(resolver->hrescache, &itbuf);
while (it) {
struct cached_res *cache = pj_hash_this(resolver->hrescache, it);
struct cached_res *cache;
cache = (struct cached_res*)pj_hash_this(resolver->hrescache, it);
PJ_LOG(3,(resolver->name.ptr,
" Type %s: %s",
pj_dns_get_type_name(cache->key.qtype),
@ -1389,7 +1397,7 @@ PJ_DEF(void) pj_dns_resolver_dump(pj_dns_resolver *resolver,
it = pj_hash_first(resolver->hquerybyid, &itbuf);
while (it) {
struct pj_dns_async_query *q;
q = pj_hash_this(resolver->hquerybyid, it);
q = (pj_dns_async_query*) pj_hash_this(resolver->hquerybyid, it);
PJ_LOG(3,(resolver->name.ptr,
" Type %s: %s",
pj_dns_get_type_name(q->key.qtype),

2
pjlib-util/src/pjlib-util/srv_resolver.c
View File

@ -381,7 +381,7 @@ static void dns_callback(void *user_data,
pj_status_t status,
pj_dns_parsed_packet *pkt)
{
pj_dns_srv_resolver_job *query_job = user_data;
pj_dns_srv_resolver_job *query_job = (pj_dns_srv_resolver_job*) user_data;
unsigned i;
/* Proceed to next stage */

2
pjlib-util/src/pjlib-util/string.c
View File

@ -31,7 +31,7 @@ PJ_DEF(pj_str_t) pj_str_unescape( pj_pool_t *pool, const pj_str_t *src_str)
if (pj_strchr(src_str, '%')==NULL)
return *src_str;
dst = dst_str.ptr = pj_pool_alloc(pool, src_str->slen);
dst = dst_str.ptr = (char*) pj_pool_alloc(pool, src_str->slen);
while (src != end) {
if (*src == '%' && src < end-2 && pj_isxdigit(*(src+1)) &&

2
pjlib-util/src/pjlib-util/stun_simple.c
View File

@ -35,7 +35,7 @@ PJ_DEF(pj_status_t) pjstun_create_bind_req( pj_pool_t *pool,
PJ_CHECK_STACK();
hdr = pj_pool_calloc(pool, 1, sizeof(pjstun_msg_hdr));
hdr = PJ_POOL_ZALLOC_T(pool, pjstun_msg_hdr);
if (!hdr)
return PJ_ENOMEM;

9
pjlib-util/src/pjlib-util/stun_simple_client.c
View File

@ -41,7 +41,7 @@ PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf,
pj_sockaddr_in srv_addr[2];
int i, j, send_cnt = 0;
pj_pool_t *pool;
struct {
struct query_rec {
struct {
pj_uint32_t mapped_addr;
pj_uint32_t mapped_port;
@ -61,7 +61,7 @@ PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf,
/* Allocate client records */
rec = pj_pool_calloc(pool, sock_cnt, sizeof(*rec));
rec = (struct query_rec*) pj_pool_calloc(pool, sock_cnt, sizeof(*rec));
if (!rec) {
status = PJ_ENOMEM;
goto on_error;
@ -97,7 +97,7 @@ PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf,
/* Send messages to servers that has not given us response. */
for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) {
for (j=0; j<2 && status==PJ_SUCCESS; ++j) {
pjstun_msg_hdr *msg_hdr = out_msg;
pjstun_msg_hdr *msg_hdr = (pjstun_msg_hdr*) out_msg;
pj_ssize_t sent_len;
if (rec[i].srv[j].mapped_port != 0)
@ -194,7 +194,8 @@ PJ_DECL(pj_status_t) pjstun_get_mapped_addr( pj_pool_factory *pf,
continue;
}
attr = (void*)pjstun_msg_find_attr(&msg, PJSTUN_ATTR_MAPPED_ADDR);
attr = (pjstun_mapped_addr_attr*)
pjstun_msg_find_attr(&msg, PJSTUN_ATTR_MAPPED_ADDR);
if (!attr) {
status = PJLIB_UTIL_ESTUNNOMAP;
continue;

6
pjlib-util/src/pjlib-util/xml.c
View File

@ -37,7 +37,7 @@ static pj_xml_node *alloc_node( pj_pool_t *pool )
{
pj_xml_node *node;
node = pj_pool_zalloc(pool, sizeof(pj_xml_node));
node = PJ_POOL_ZALLOC_T(pool, pj_xml_node);
pj_list_init( &node->attr_head );
pj_list_init( &node->node_head );
@ -46,7 +46,7 @@ static pj_xml_node *alloc_node( pj_pool_t *pool )
static pj_xml_attr *alloc_attr( pj_pool_t *pool )
{
return pj_pool_zalloc(pool, sizeof(pj_xml_attr));
return PJ_POOL_ZALLOC_T(pool, pj_xml_attr);
}
/* This is a recursive function! */
@ -393,7 +393,7 @@ PJ_DEF(pj_xml_node*) pj_xml_find( pj_xml_node *parent, const pj_str_t *name,
const void *data,
pj_bool_t (*match)(pj_xml_node *, const void*))
{
pj_xml_node *head = (void*)&parent->node_head, *node = head->next;
pj_xml_node *head = (pj_xml_node*) &parent->node_head, *node = head->next;
while (node != (void*)head) {
if (name && pj_stricmp(&node->name, name)==0) {

15
pjnath/src/pjnath/ice_session.c
View File

@ -296,7 +296,7 @@ PJ_DEF(pj_status_t) pj_ice_sess_create(pj_stun_config *stun_cfg,
}
if (local_ufrag == NULL) {
ice->rx_ufrag.ptr = pj_pool_alloc(ice->pool, 16);
ice->rx_ufrag.ptr = (char*) pj_pool_alloc(ice->pool, 16);
pj_create_random_string(ice->rx_ufrag.ptr, 16);
ice->rx_ufrag.slen = 16;
} else {
@ -304,7 +304,7 @@ PJ_DEF(pj_status_t) pj_ice_sess_create(pj_stun_config *stun_cfg,
}
if (local_passwd == NULL) {
ice->rx_pass.ptr = pj_pool_alloc(ice->pool, 16);
ice->rx_pass.ptr = (char*) pj_pool_alloc(ice->pool, 16);
pj_create_random_string(ice->rx_pass.ptr, 16);
ice->rx_pass.slen = 16;
} else {
@ -396,8 +396,8 @@ PJ_DEF(pj_status_t) pj_ice_sess_set_prefs(pj_ice_sess *ice,
const pj_uint8_t prefs[4])
{
PJ_ASSERT_RETURN(ice && prefs, PJ_EINVAL);
ice->prefs = pj_pool_calloc(ice->pool, PJ_ARRAY_SIZE(prefs),
sizeof(pj_uint8_t));
ice->prefs = (pj_uint8_t*) pj_pool_calloc(ice->pool, PJ_ARRAY_SIZE(prefs),
sizeof(pj_uint8_t));
pj_memcpy(ice->prefs, prefs, sizeof(prefs));
return PJ_SUCCESS;
}
@ -1708,7 +1708,7 @@ static void on_stun_request_complete(pj_stun_session *stun_sess,
* the response match the source IP address and port that the Binding
* Request was sent from.
*/
if (sockaddr_cmp(&check->rcand->addr, src_addr) != 0) {
if (sockaddr_cmp(&check->rcand->addr, (const pj_sockaddr*)src_addr) != 0) {
status = PJNATH_EICEINSRCADDR;
LOG4((ice->obj_name,
"Check %s%s: connectivity check FAILED: source address mismatch",
@ -2063,7 +2063,7 @@ static void handle_incoming_check(pj_ice_sess *ice,
pj_memcpy(&rcand->addr, &rcheck->src_addr, rcheck->src_addr_len);
/* Foundation is random, unique from other foundation */
rcand->foundation.ptr = pj_pool_alloc(ice->pool, 36);
rcand->foundation.ptr = (char*) pj_pool_alloc(ice->pool, 36);
rcand->foundation.slen = pj_ansi_snprintf(rcand->foundation.ptr, 36,
"f%p",
rcand->foundation.ptr);
@ -2302,7 +2302,8 @@ PJ_DEF(pj_status_t) pj_ice_sess_on_rx_pkt(pj_ice_sess *ice,
goto on_return;
}
stun_status = pj_stun_msg_check(pkt, pkt_size, PJ_STUN_IS_DATAGRAM);
stun_status = pj_stun_msg_check((const pj_uint8_t*)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,
PJ_STUN_IS_DATAGRAM,

4
pjnath/src/pjnath/stun_msg.c
View File

@ -1494,7 +1494,7 @@ pj_stun_binary_attr_create(pj_pool_t *pool,
if (data && length) {
attr->length = length;
attr->data = pj_pool_alloc(pool, length);
attr->data = (pj_uint8_t*) pj_pool_alloc(pool, length);
pj_memcpy(attr->data, data, length);
}
@ -1536,7 +1536,7 @@ static pj_status_t decode_binary_attr(pj_pool_t *pool,
/* Copy the data to the attribute */
attr->length = attr->hdr.length;
attr->data = pj_pool_alloc(pool, attr->length);
attr->data = (pj_uint8_t*) pj_pool_alloc(pool, attr->length);
pj_memcpy(attr->data, buf+ATTR_HDR_LEN, attr->length);
/* Done */

25
pjnath/src/pjnath/stun_session.c
View File

@ -380,7 +380,7 @@ PJ_DEF(pj_status_t) pj_stun_session_create( pj_stun_config *cfg,
pj_memcpy(&sess->cb, cb, sizeof(*cb));
sess->use_fingerprint = fingerprint;
sess->srv_name.ptr = pj_pool_alloc(pool, 32);
sess->srv_name.ptr = (char*) pj_pool_alloc(pool, 32);
sess->srv_name.slen = pj_ansi_snprintf(sess->srv_name.ptr, 32,
"pj_stun-%s", PJ_VERSION);
@ -453,7 +453,7 @@ PJ_DEF(void) pj_stun_session_set_credential(pj_stun_session *sess,
PJ_ASSERT_ON_FAIL(sess, return);
if (cred) {
if (!sess->cred)
sess->cred = pj_pool_alloc(sess->pool, sizeof(pj_stun_auth_cred));
sess->cred = PJ_POOL_ALLOC_T(sess->pool, pj_stun_auth_cred);
pj_stun_auth_cred_dup(sess->pool, sess->cred, cred);
} else {
sess->cred = NULL;
@ -598,8 +598,9 @@ PJ_DEF(pj_status_t) pj_stun_session_send_msg( pj_stun_session *sess,
}
/* Encode message */
status = pj_stun_msg_encode(tdata->msg, tdata->pkt, tdata->max_len,
0, get_passwd(sess, tdata->pool, tdata->msg),
status = pj_stun_msg_encode(tdata->msg, (pj_uint8_t*)tdata->pkt,
tdata->max_len, 0,
get_passwd(sess, tdata->pool, tdata->msg),
&tdata->pkt_size);
if (status != PJ_SUCCESS) {
pj_stun_msg_destroy_tdata(sess, tdata);
@ -752,7 +753,7 @@ static pj_status_t send_response(pj_stun_session *sess,
/* Alloc packet buffer */
out_max_len = PJ_STUN_MAX_PKT_LEN;
out_pkt = pj_pool_alloc(pool, out_max_len);
out_pkt = (pj_uint8_t*) pj_pool_alloc(pool, out_max_len);
/* Encode */
status = pj_stun_msg_encode(response, out_pkt, out_max_len, 0,
@ -958,7 +959,7 @@ PJ_DEF(pj_status_t) pj_stun_session_on_rx_pkt(pj_stun_session *sess,
return status;
}
dump = pj_pool_alloc(tmp_pool, PJ_STUN_MAX_PKT_LEN);
dump = (char*) pj_pool_alloc(tmp_pool, PJ_STUN_MAX_PKT_LEN);
PJ_LOG(5,(SNAME(sess),
"RX STUN message:\n"
@ -980,8 +981,8 @@ PJ_DEF(pj_status_t) pj_stun_session_on_rx_pkt(pj_stun_session *sess,
* is specified in the option.
*/
if ((options & PJ_STUN_NO_AUTHENTICATE) == 0) {
status = authenticate_msg(sess, packet, pkt_size, msg, tmp_pool,
src_addr, src_addr_len);
status = authenticate_msg(sess, (const pj_uint8_t*) packet, pkt_size,
msg, tmp_pool, src_addr, src_addr_len);
if (status != PJ_SUCCESS) {
goto on_return;
}
@ -995,12 +996,14 @@ PJ_DEF(pj_status_t) pj_stun_session_on_rx_pkt(pj_stun_session *sess,
} else if (PJ_STUN_IS_REQUEST(msg->hdr.type)) {
status = on_incoming_request(sess, tmp_pool, packet, pkt_size, msg,
src_addr, src_addr_len);
status = on_incoming_request(sess, tmp_pool,
(const pj_uint8_t*) packet, pkt_size,
msg, src_addr, src_addr_len);
} else if (PJ_STUN_IS_INDICATION(msg->hdr.type)) {
status = on_incoming_indication(sess, tmp_pool, packet, pkt_size,
status = on_incoming_indication(sess, tmp_pool,
(const pj_uint8_t*) packet, pkt_size,
msg, src_addr, src_addr_len);
} else {