Fixed printf format warnings (#3813)
This commit is contained in:
parent
5601a20c1e
commit
033e4d7ae3
|
@ -163,7 +163,7 @@ static void on_data_read(pj_http_req *hreq, void *data, pj_size_t size)
|
|||
PJ_UNUSED_ARG(hreq);
|
||||
PJ_UNUSED_ARG(data);
|
||||
|
||||
PJ_LOG(5, (THIS_FILE, "\nData received: %ld bytes", size));
|
||||
PJ_LOG(5, (THIS_FILE, "\nData received: %lu bytes", (unsigned long)size));
|
||||
if (size > 0) {
|
||||
#ifdef VERBOSE
|
||||
printf("%.*s\n", (int)size, (char *)data);
|
||||
|
@ -190,8 +190,8 @@ static void on_send_data(pj_http_req *hreq,
|
|||
*data = sdata;
|
||||
*size = sendsz;
|
||||
|
||||
PJ_LOG(5, (THIS_FILE, "\nSending data progress: %ld out of %ld bytes",
|
||||
send_size, total_size));
|
||||
PJ_LOG(5, (THIS_FILE, "\nSending data progress: %lu out of %lu bytes",
|
||||
(unsigned long)send_size, (unsigned long)total_size));
|
||||
}
|
||||
|
||||
|
||||
|
@ -210,7 +210,8 @@ static void on_complete(pj_http_req *hreq, pj_status_t status,
|
|||
PJ_LOG(3, (THIS_FILE, "Error %d", status));
|
||||
return;
|
||||
}
|
||||
PJ_LOG(5, (THIS_FILE, "\nData completed: %ld bytes", resp->size));
|
||||
PJ_LOG(5, (THIS_FILE, "\nData completed: %lu bytes",
|
||||
(unsigned long)resp->size));
|
||||
if (resp->size > 0 && resp->data) {
|
||||
#ifdef VERBOSE
|
||||
printf("%.*s\n", (int)resp->size, (char *)resp->data);
|
||||
|
|
|
@ -1942,12 +1942,12 @@ PJ_DEF(void) pj_dns_resolver_dump(pj_dns_resolver *resolver,
|
|||
}
|
||||
}
|
||||
PJ_LOG(3,(resolver->name.ptr, " Nb. of pending query free nodes: %lu",
|
||||
pj_list_size(&resolver->query_free_nodes)));
|
||||
(unsigned long)pj_list_size(&resolver->query_free_nodes)));
|
||||
PJ_LOG(3,(resolver->name.ptr, " Nb. of timer entries: %lu",
|
||||
pj_timer_heap_count(resolver->timer)));
|
||||
(unsigned long)pj_timer_heap_count(resolver->timer)));
|
||||
PJ_LOG(3,(resolver->name.ptr, " Pool capacity: %lu, used size: %lu",
|
||||
pj_pool_get_capacity(resolver->pool),
|
||||
pj_pool_get_used_size(resolver->pool)));
|
||||
(unsigned long)pj_pool_get_capacity(resolver->pool),
|
||||
(unsigned long)pj_pool_get_used_size(resolver->pool)));
|
||||
|
||||
pj_grp_lock_release(resolver->grp_lock);
|
||||
#endif
|
||||
|
|
|
@ -76,7 +76,8 @@ PJ_DEF(pj_status_t) pjstun_parse_msg( void *buf, pj_size_t buf_len,
|
|||
msg_len = pj_ntohs(msg->hdr->length);
|
||||
if (msg_len != buf_len - sizeof(pjstun_msg_hdr)) {
|
||||
PJ_LOG(4,(THIS_FILE, "Error: invalid msg_len %d (expecting %lu)",
|
||||
msg_len, buf_len - sizeof(pjstun_msg_hdr)));
|
||||
msg_len, (unsigned long)
|
||||
(buf_len - sizeof(pjstun_msg_hdr))));
|
||||
return PJLIB_UTIL_ESTUNINMSGLEN;
|
||||
}
|
||||
|
||||
|
|
|
@ -345,8 +345,9 @@ PJ_DEF(pj_status_t) pjstun_get_mapped_addr2(pj_pool_factory *pf,
|
|||
}
|
||||
}
|
||||
|
||||
TRACE_((THIS_FILE, " Pool usage=%ld of %ld", pj_pool_get_used_size(pool),
|
||||
pj_pool_get_capacity(pool)));
|
||||
TRACE_((THIS_FILE, " Pool usage=%lu of %lu",
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)pj_pool_get_capacity(pool)));
|
||||
|
||||
pj_pool_release(pool);
|
||||
|
||||
|
|
|
@ -188,8 +188,8 @@ static pj_hash_entry **find_entry( pj_pool_t *pool, pj_hash_table_t *ht,
|
|||
entry = PJ_POOL_ALLOC_T(pool, pj_hash_entry);
|
||||
PJ_LOG(6, ("hashtbl",
|
||||
"%p: New p_entry %p created, pool used=%lu, cap=%lu",
|
||||
ht, entry, pj_pool_get_used_size(pool),
|
||||
pj_pool_get_capacity(pool)));
|
||||
ht, entry, (unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)pj_pool_get_capacity(pool)));
|
||||
}
|
||||
entry->next = NULL;
|
||||
entry->hash = hash;
|
||||
|
|
|
@ -53,7 +53,8 @@ static pj_pool_block *pj_pool_create_block( pj_pool_t *pool, pj_size_t size)
|
|||
pj_assert(size >= sizeof(pj_pool_block));
|
||||
|
||||
LOG((pool->obj_name, "create_block(sz=%lu), cur.cap=%lu, cur.used=%lu",
|
||||
size, pool->capacity, pj_pool_get_used_size(pool)));
|
||||
(unsigned long)size, (unsigned long)pool->capacity,
|
||||
(unsigned long)pj_pool_get_used_size(pool)));
|
||||
|
||||
/* Request memory from allocator. */
|
||||
block = (pj_pool_block*)
|
||||
|
@ -118,7 +119,8 @@ PJ_DEF(void*) pj_pool_allocate_find(pj_pool_t *pool, pj_size_t size)
|
|||
if (pool->increment_size == 0) {
|
||||
LOG((pool->obj_name, "Can't expand pool to allocate %lu bytes "
|
||||
"(used=%lu, cap=%lu)",
|
||||
size, pj_pool_get_used_size(pool), pool->capacity));
|
||||
(unsigned long)size, (unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)pool->capacity));
|
||||
(*pool->callback)(pool, size);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -143,7 +145,9 @@ PJ_DEF(void*) pj_pool_allocate_find(pj_pool_t *pool, pj_size_t size)
|
|||
|
||||
LOG((pool->obj_name,
|
||||
"%lu bytes requested, resizing pool by %lu bytes (used=%lu, cap=%lu)",
|
||||
size, block_size, pj_pool_get_used_size(pool), pool->capacity));
|
||||
(unsigned long)size, (unsigned long)block_size,
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)pool->capacity));
|
||||
|
||||
block = pj_pool_create_block(pool, block_size);
|
||||
if (!block)
|
||||
|
@ -233,7 +237,8 @@ PJ_DEF(pj_pool_t*) pj_pool_create_int( pj_pool_factory *f, const char *name,
|
|||
/* Pool initial capacity and used size */
|
||||
pool->capacity = initial_size;
|
||||
|
||||
LOG((pool->obj_name, "pool created, size=%lu", pool->capacity));
|
||||
LOG((pool->obj_name, "pool created, size=%lu",
|
||||
(unsigned long)pool->capacity));
|
||||
return pool;
|
||||
}
|
||||
|
||||
|
@ -278,9 +283,10 @@ static void reset_pool(pj_pool_t *pool)
|
|||
*/
|
||||
PJ_DEF(void) pj_pool_reset(pj_pool_t *pool)
|
||||
{
|
||||
LOG((pool->obj_name, "reset(): cap=%ld, used=%ld(%ld%%)",
|
||||
pool->capacity, pj_pool_get_used_size(pool),
|
||||
pj_pool_get_used_size(pool)*100/pool->capacity));
|
||||
LOG((pool->obj_name, "reset(): cap=%lu, used=%lu(%lu%%)",
|
||||
(unsigned long)pool->capacity,
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)(pj_pool_get_used_size(pool)*100/pool->capacity)));
|
||||
|
||||
reset_pool(pool);
|
||||
}
|
||||
|
@ -292,9 +298,10 @@ PJ_DEF(void) pj_pool_destroy_int(pj_pool_t *pool)
|
|||
{
|
||||
pj_size_t initial_size;
|
||||
|
||||
LOG((pool->obj_name, "destroy(): cap=%ld, used=%ld(%ld%%), block0=%p-%p",
|
||||
pool->capacity, pj_pool_get_used_size(pool),
|
||||
pj_pool_get_used_size(pool)*100/pool->capacity,
|
||||
LOG((pool->obj_name, "destroy(): cap=%lu, used=%lu(%lu%%), block0=%p-%p",
|
||||
(unsigned long)pool->capacity,
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)(pj_pool_get_used_size(pool)*100/pool->capacity),
|
||||
((pj_pool_block*)pool->block_list.next)->buf,
|
||||
((pj_pool_block*)pool->block_list.next)->end));
|
||||
|
||||
|
|
|
@ -188,7 +188,8 @@ static pj_pool_t* cpool_create_pool(pj_pool_factory *pf,
|
|||
cp->capacity = 0;
|
||||
}
|
||||
|
||||
PJ_LOG(6, (pool->obj_name, "pool reused, size=%lu", pool->capacity));
|
||||
PJ_LOG(6, (pool->obj_name, "pool reused, size=%lu",
|
||||
(unsigned long)pool->capacity));
|
||||
}
|
||||
|
||||
/* Put in used list. */
|
||||
|
@ -245,9 +246,11 @@ static void cpool_release_pool( pj_pool_factory *pf, pj_pool_t *pool)
|
|||
}
|
||||
|
||||
/* Reset pool. */
|
||||
PJ_LOG(6, (pool->obj_name, "recycle(): cap=%ld, used=%ld(%ld%%)",
|
||||
pool_capacity, pj_pool_get_used_size(pool),
|
||||
pj_pool_get_used_size(pool)*100/pool_capacity));
|
||||
PJ_LOG(6, (pool->obj_name, "recycle(): cap=%lu, used=%lu(%lu%%)",
|
||||
(unsigned long)pool_capacity,
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)(pj_pool_get_used_size(pool)*100/
|
||||
pool_capacity)));
|
||||
pj_pool_reset(pool);
|
||||
|
||||
pool_capacity = pj_pool_get_capacity(pool);
|
||||
|
@ -279,8 +282,9 @@ static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail )
|
|||
pj_lock_acquire(cp->lock);
|
||||
|
||||
PJ_LOG(3,("cachpool", " Dumping caching pool:"));
|
||||
PJ_LOG(3,("cachpool", " Capacity=%lu, max_capacity=%lu, used_cnt=%lu", \
|
||||
cp->capacity, cp->max_capacity, cp->used_count));
|
||||
PJ_LOG(3,("cachpool", " Capacity=%lu, max_capacity=%lu, used_cnt=%lu",
|
||||
(unsigned long)cp->capacity, (unsigned long)cp->max_capacity,
|
||||
(unsigned long)cp->used_count));
|
||||
if (detail) {
|
||||
pj_pool_t *pool = (pj_pool_t*) cp->used_list.next;
|
||||
pj_size_t total_used = 0, total_capacity = 0;
|
||||
|
@ -294,7 +298,7 @@ static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail )
|
|||
#if 0
|
||||
PJ_LOG(6, ("cachpool", " %16s block %u, size %ld",
|
||||
pj_pool_getobjname(pool), nblocks,
|
||||
block->end - block->buf + 1));
|
||||
(long)(block->end - block->buf + 1)));
|
||||
#endif
|
||||
nblocks++;
|
||||
block = block->next;
|
||||
|
@ -303,9 +307,10 @@ static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail )
|
|||
PJ_LOG(3,("cachpool", " %16s: %8lu of %8lu (%lu%%) used, "
|
||||
"nblocks: %d",
|
||||
pj_pool_getobjname(pool),
|
||||
pj_pool_get_used_size(pool),
|
||||
pool_capacity,
|
||||
pj_pool_get_used_size(pool)*100/pool_capacity,
|
||||
(unsigned long)pj_pool_get_used_size(pool),
|
||||
(unsigned long)pool_capacity,
|
||||
(unsigned long)(pj_pool_get_used_size(pool)*
|
||||
100/pool_capacity),
|
||||
nblocks));
|
||||
|
||||
#if PJ_POOL_MAX_SEARCH_BLOCK_COUNT == 0
|
||||
|
@ -323,8 +328,10 @@ static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail )
|
|||
}
|
||||
if (total_capacity) {
|
||||
PJ_LOG(3,("cachpool", " Total %9lu of %9lu (%lu %%) used!",
|
||||
total_used, total_capacity,
|
||||
total_used * 100 / total_capacity));
|
||||
(unsigned long)total_used,
|
||||
(unsigned long)total_capacity,
|
||||
(unsigned long)(total_used * 100 /
|
||||
total_capacity)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -381,8 +381,9 @@ static pj_status_t grow_heap(pj_timer_heap_t *ht)
|
|||
pj_timer_entry_dup *new_dup;
|
||||
#endif
|
||||
|
||||
PJ_LOG(6,(THIS_FILE, "Growing heap size from %ld to %ld",
|
||||
ht->max_size, new_size));
|
||||
PJ_LOG(6,(THIS_FILE, "Growing heap size from %lu to %lu",
|
||||
(unsigned long)ht->max_size,
|
||||
(unsigned long)new_size));
|
||||
|
||||
// First grow the heap itself.
|
||||
new_heap = (pj_timer_entry_dup**)
|
||||
|
|
|
@ -121,8 +121,8 @@ static void on_read_complete(pj_ioqueue_key_t *key,
|
|||
PJ_LOG(3,(THIS_FILE,
|
||||
".....additional info: type=%s, total read=%lu, "
|
||||
"total sent=%lu",
|
||||
item->type_name, item->bytes_recv,
|
||||
item->bytes_sent));
|
||||
item->type_name, (unsigned long)item->bytes_recv,
|
||||
(unsigned long)item->bytes_sent));
|
||||
}
|
||||
} else {
|
||||
last_error_counter++;
|
||||
|
@ -480,8 +480,10 @@ static int perform_test(const pj_ioqueue_cfg *cfg,
|
|||
if (display_report) {
|
||||
PJ_LOG(3,(THIS_FILE, " %s %d threads, %d pairs", type_name,
|
||||
thread_cnt, sockpair_cnt));
|
||||
PJ_LOG(3,(THIS_FILE, " Elapsed : %lu msec", total_elapsed_usec/1000));
|
||||
PJ_LOG(3,(THIS_FILE, " Bandwidth: %lu KB/s", *p_bandwidth));
|
||||
PJ_LOG(3,(THIS_FILE, " Elapsed : %lu msec",
|
||||
(unsigned long)(total_elapsed_usec/1000)));
|
||||
PJ_LOG(3,(THIS_FILE, " Bandwidth: %lu KB/s",
|
||||
(unsigned long)*p_bandwidth));
|
||||
PJ_LOG(3,(THIS_FILE, " Threads statistics:"));
|
||||
PJ_LOG(3,(THIS_FILE, " ============================="));
|
||||
PJ_LOG(3,(THIS_FILE, " Thread Loops Events Errors"));
|
||||
|
@ -506,7 +508,7 @@ static int perform_test(const pj_ioqueue_cfg *cfg,
|
|||
} else {
|
||||
PJ_LOG(3,(THIS_FILE, " %.4s %2d %2d %8lu KB/s",
|
||||
type_name, thread_cnt, sockpair_cnt,
|
||||
*p_bandwidth));
|
||||
(unsigned long)*p_bandwidth));
|
||||
}
|
||||
|
||||
/* Done. */
|
||||
|
@ -578,7 +580,7 @@ static int ioqueue_perf_test_imp(const pj_ioqueue_cfg *cfg)
|
|||
test_param[best_index].type_name,
|
||||
test_param[best_index].thread_cnt,
|
||||
test_param[best_index].sockpair_cnt,
|
||||
best_bandwidth));
|
||||
(unsigned long)best_bandwidth));
|
||||
PJ_LOG(3,(THIS_FILE, " (Note: packet size=%d, total errors=%u)",
|
||||
BUF_SIZE, last_error_counter));
|
||||
return 0;
|
||||
|
|
|
@ -69,7 +69,7 @@ static int capacity_test(void)
|
|||
|
||||
if (pj_pool_alloc(pool, freesize) == NULL) {
|
||||
PJ_LOG(3,("test", "...error: wrong freesize %lu reported",
|
||||
freesize));
|
||||
(unsigned long)freesize));
|
||||
pj_pool_release(pool);
|
||||
return -210;
|
||||
}
|
||||
|
@ -175,7 +175,8 @@ static int drain_test(pj_size_t size, pj_size_t increment)
|
|||
void *p;
|
||||
int status = 0;
|
||||
|
||||
PJ_LOG(3,("test", "...drain_test(%lu,%lu)", size, increment));
|
||||
PJ_LOG(3,("test", "...drain_test(%lu,%lu)", (unsigned long)size,
|
||||
(unsigned long)increment));
|
||||
|
||||
if (!pool)
|
||||
return -10;
|
||||
|
@ -208,7 +209,7 @@ static int drain_test(pj_size_t size, pj_size_t increment)
|
|||
/* Check that capacity is zero. */
|
||||
if (GET_FREE(pool) != 0) {
|
||||
PJ_LOG(3,("test", "....error: returned free=%lu (expecting 0)",
|
||||
GET_FREE(pool)));
|
||||
(unsigned long)(GET_FREE(pool))));
|
||||
status=-30; goto on_error;
|
||||
}
|
||||
|
||||
|
|
|
@ -541,14 +541,15 @@ static int send_recv_test(int sock_type,
|
|||
rc = -155; goto on_error;
|
||||
}
|
||||
if (received <= 0) {
|
||||
PJ_LOG(3,("", "...error: socket has closed! (received=%ld)",
|
||||
received));
|
||||
PJ_LOG(3,("", "...error: socket has closed! (received=%lu)",
|
||||
(unsigned long)received));
|
||||
rc = -156; goto on_error;
|
||||
}
|
||||
if (received != DATA_LEN-total_received) {
|
||||
if (sock_type != pj_SOCK_STREAM()) {
|
||||
PJ_LOG(3,("", "...error: expecting %lu bytes, got %lu bytes",
|
||||
DATA_LEN-total_received, received));
|
||||
(unsigned long)(DATA_LEN-total_received),
|
||||
(unsigned long)received));
|
||||
rc = -157; goto on_error;
|
||||
}
|
||||
}
|
||||
|
@ -599,14 +600,15 @@ static int send_recv_test(int sock_type,
|
|||
rc = -170; goto on_error;
|
||||
}
|
||||
if (received <= 0) {
|
||||
PJ_LOG(3,("", "...error: socket has closed! (received=%ld)",
|
||||
received));
|
||||
PJ_LOG(3,("", "...error: socket has closed! (received=%lu)",
|
||||
(unsigned long)received));
|
||||
rc = -173; goto on_error;
|
||||
}
|
||||
if (received != BIG_DATA_LEN-total_received) {
|
||||
if (sock_type != pj_SOCK_STREAM()) {
|
||||
PJ_LOG(3,("", "...error: expecting %lu bytes, got %lu bytes",
|
||||
BIG_DATA_LEN-total_received, received));
|
||||
(unsigned long)BIG_DATA_LEN-total_received,
|
||||
(unsigned long)received));
|
||||
rc = -176; goto on_error;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -350,7 +350,8 @@ static pj_bool_t ssl_on_data_read(pj_ssl_sock_t *ssock,
|
|||
}
|
||||
|
||||
pj_sockaddr_print((pj_sockaddr_t*)&info.local_addr, buf, sizeof(buf), 1);
|
||||
PJ_LOG(3, ("", "...%s successfully recv %lu bytes echo", buf, st->recv));
|
||||
PJ_LOG(3, ("", "...%s successfully recv %lu bytes echo", buf,
|
||||
(unsigned long)st->recv));
|
||||
st->done = PJ_TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -501,7 +502,8 @@ static int https_client_test(unsigned ms_timeout)
|
|||
}
|
||||
|
||||
PJ_LOG(3, ("", "...Done!"));
|
||||
PJ_LOG(3, ("", ".....Sent/recv: %lu/%lu bytes", state.sent, state.recv));
|
||||
PJ_LOG(3, ("", ".....Sent/recv: %lu/%lu bytes", (unsigned long)state.sent,
|
||||
(unsigned long)state.recv));
|
||||
|
||||
on_return:
|
||||
if (ssock && !state.err && !state.done)
|
||||
|
@ -755,7 +757,8 @@ static int echo_test(pj_ssl_sock_proto srv_proto, pj_ssl_sock_proto cli_proto,
|
|||
}
|
||||
|
||||
PJ_LOG(3, ("", "...Done!"));
|
||||
PJ_LOG(3, ("", ".....Sent/recv: %lu/%lu bytes", state_cli.sent, state_cli.recv));
|
||||
PJ_LOG(3, ("", ".....Sent/recv: %lu/%lu bytes", (unsigned long)state_cli.sent,
|
||||
(unsigned long)state_cli.recv));
|
||||
|
||||
on_return:
|
||||
#if (PJ_SSL_SOCK_IMP == PJ_SSL_SOCK_IMP_DARWIN) || \
|
||||
|
@ -1464,7 +1467,8 @@ static int perf_test(unsigned clients, unsigned ms_handshake_timeout)
|
|||
}
|
||||
|
||||
PJ_LOG(3, ("", ".....Clients: %d (%d errors)", clients, cli_err));
|
||||
PJ_LOG(3, ("", ".....Total sent/recv: %lu/%lu bytes", tot_sent, tot_recv));
|
||||
PJ_LOG(3, ("", ".....Total sent/recv: %lu/%lu bytes",
|
||||
(unsigned long)tot_sent, (unsigned long)tot_recv));
|
||||
|
||||
on_return:
|
||||
if (ssock_serv)
|
||||
|
|
|
@ -68,7 +68,7 @@ static int test_timer_heap(void)
|
|||
pool = pj_pool_create( mem, NULL, size, 4000, NULL);
|
||||
if (!pool) {
|
||||
PJ_LOG(3,("test", "...error: unable to create pool of %lu bytes",
|
||||
size));
|
||||
(unsigned long)size));
|
||||
return -10;
|
||||
}
|
||||
|
||||
|
@ -161,8 +161,8 @@ static int test_timer_heap(void)
|
|||
} while (PJ_TIME_VAL_LTE(now, expire)&&pj_timer_heap_count(timer) > 0);
|
||||
|
||||
if (pj_timer_heap_count(timer)) {
|
||||
PJ_LOG(3, (THIS_FILE, "ERROR: %ld timers left",
|
||||
pj_timer_heap_count(timer)));
|
||||
PJ_LOG(3, (THIS_FILE, "ERROR: %lu timers left",
|
||||
(unsigned long)pj_timer_heap_count(timer)));
|
||||
++err;
|
||||
}
|
||||
t_sched.u32.lo /= count;
|
||||
|
@ -715,8 +715,8 @@ on_return:
|
|||
if (timer)
|
||||
pj_timer_heap_destroy(timer);
|
||||
|
||||
PJ_LOG(3,("test", "Total memory of timer heap: %ld",
|
||||
pj_timer_heap_mem_size(ST_ENTRY_COUNT)));
|
||||
PJ_LOG(3,("test", "Total memory of timer heap: %lu",
|
||||
(unsigned long)pj_timer_heap_mem_size(ST_ENTRY_COUNT)));
|
||||
|
||||
if (tparam.idx)
|
||||
pj_atomic_destroy(tparam.idx);
|
||||
|
|
|
@ -1141,7 +1141,8 @@ static pj_status_t and_media_codec_encode(pjmedia_codec *codec,
|
|||
} else {
|
||||
PJ_LOG(4,(THIS_FILE, "Encoder getInputBuffer "
|
||||
"size: %lu, expecting %d.",
|
||||
output_size, input_size));
|
||||
(unsigned long)output_size,
|
||||
input_size));
|
||||
}
|
||||
goto on_return;
|
||||
}
|
||||
|
@ -1262,7 +1263,8 @@ static pj_status_t and_media_codec_decode(pjmedia_codec *codec,
|
|||
&input_size);
|
||||
if (input_buf == 0) {
|
||||
PJ_LOG(4,(THIS_FILE, "Decoder getInputBuffer failed "
|
||||
"return input_buf=%d, size=%lu", *input_buf, input_size));
|
||||
"return input_buf=%d, size=%lu", *input_buf,
|
||||
(unsigned long)input_size));
|
||||
goto on_return;
|
||||
}
|
||||
|
||||
|
|
|
@ -1033,7 +1033,8 @@ static pj_status_t and_media_codec_encode_begin(pjmedia_vid_codec *codec,
|
|||
} else {
|
||||
PJ_LOG(4,(THIS_FILE, "Encoder getInputBuffer "
|
||||
"size: %lu, expecting %lu.",
|
||||
output_size, input->size));
|
||||
(unsigned long)output_size,
|
||||
(unsigned long)input->size));
|
||||
}
|
||||
goto on_return;
|
||||
}
|
||||
|
|
|
@ -1182,7 +1182,7 @@ static pj_status_t oh264_codec_decode(pjmedia_vid_codec *codec,
|
|||
|
||||
PJ_LOG(5,(THIS_FILE, "Decode couldn't produce picture, "
|
||||
"input nframes=%lu, concatenated size=%d bytes, ret=%d",
|
||||
count, whole_len, ret));
|
||||
(unsigned long)count, whole_len, ret));
|
||||
}
|
||||
|
||||
return status;
|
||||
|
|
|
@ -931,7 +931,7 @@ static pj_status_t codec_parse( pjmedia_codec *codec,
|
|||
sizeof(tmp_buf));
|
||||
if (size < 0) {
|
||||
PJ_LOG(5, (THIS_FILE, "Parse failed! (pkt_size=%lu, err=%d)",
|
||||
pkt_size, size));
|
||||
(unsigned long)pkt_size, size));
|
||||
pj_mutex_unlock (opus_data->mutex);
|
||||
return PJMEDIA_CODEC_EFAILED;
|
||||
}
|
||||
|
|
|
@ -1404,8 +1404,8 @@ on_return:
|
|||
PJMEDIA_EVENT_PUBLISH_DEFAULT);
|
||||
|
||||
PJ_LOG(5,(THIS_FILE, "Decode couldn't produce picture, "
|
||||
"input nframes=%ld, concatenated size=%d bytes",
|
||||
count, whole_len));
|
||||
"input nframes=%lu, concatenated size=%d bytes",
|
||||
(unsigned long)count, whole_len));
|
||||
|
||||
output->type = PJMEDIA_FRAME_TYPE_NONE;
|
||||
output->size = 0;
|
||||
|
|
|
@ -830,7 +830,7 @@ on_return:
|
|||
|
||||
PJ_LOG(4,(THIS_FILE, "Decode couldn't produce picture, "
|
||||
"input nframes=%lu, concatenated size=%d bytes",
|
||||
count, whole_len));
|
||||
(unsigned long)count, whole_len));
|
||||
|
||||
output->type = PJMEDIA_FRAME_TYPE_NONE;
|
||||
output->size = 0;
|
||||
|
|
|
@ -745,7 +745,7 @@ static pj_status_t send_raw(dtls_srtp *ds, unsigned idx, const void *buf,
|
|||
{
|
||||
#if DTLS_DEBUG
|
||||
PJ_LOG(2,(ds->base.name, "DTLS-SRTP %s sending %lu bytes",
|
||||
CHANNEL_TO_STRING(idx), len));
|
||||
CHANNEL_TO_STRING(idx), (unsigned long)len));
|
||||
#endif
|
||||
|
||||
return (idx == RTP_CHANNEL?
|
||||
|
@ -1280,7 +1280,7 @@ static pj_status_t dtls_on_recv(pjmedia_transport *tp, unsigned idx,
|
|||
|
||||
#if DTLS_DEBUG
|
||||
PJ_LOG(2,(ds->base.name, "DTLS-SRTP %s receiving %lu bytes",
|
||||
CHANNEL_TO_STRING(idx), size));
|
||||
CHANNEL_TO_STRING(idx), (unsigned long)size));
|
||||
#endif
|
||||
|
||||
/* This is DTLS packet, let's process it. Note that if DTLS nego has
|
||||
|
|
|
@ -1398,7 +1398,8 @@ static pj_status_t vid_pasv_port_put_frame(struct pjmedia_port *this_port,
|
|||
if (frame->size != vp->src_size) {
|
||||
if (frame->size > 0) {
|
||||
PJ_LOG(4,(THIS_FILE, "Unexpected frame size %lu, expected %lu",
|
||||
frame->size, vp->src_size));
|
||||
(unsigned long)frame->size,
|
||||
(unsigned long)vp->src_size));
|
||||
}
|
||||
|
||||
pj_memcpy(&frame_, frame, sizeof(pjmedia_frame));
|
||||
|
|
|
@ -220,7 +220,7 @@ PJ_DEF(pj_status_t) pjmedia_wav_writer_port_create( pj_pool_t *pool,
|
|||
(int)fport->base.info.name.slen,
|
||||
fport->base.info.name.ptr,
|
||||
PJMEDIA_PIA_SRATE(&fport->base.info),
|
||||
fport->bufsize / 1000));
|
||||
(unsigned long)(fport->bufsize / 1000)));
|
||||
|
||||
|
||||
return PJ_SUCCESS;
|
||||
|
|
|
@ -178,7 +178,8 @@ static int codec_test_encode(pjmedia_codec_mgr *mgr,
|
|||
break;
|
||||
}
|
||||
|
||||
PJ_LOG(1,(THIS_FILE," failed: mismatch at pos %ld", pos+i));
|
||||
PJ_LOG(1,(THIS_FILE," failed: mismatch at pos %lu",
|
||||
(unsigned long)(pos+i)));
|
||||
rc = -200;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -1047,8 +1047,8 @@ static pj_bool_t alloc_on_data_recvfrom(pj_activesock_t *asock,
|
|||
}
|
||||
}
|
||||
if (i==alloc->perm_cnt) {
|
||||
PJ_LOG(5,("", "Client %s received %ld bytes unauthorized data from peer %s",
|
||||
client_info, size, peer_info));
|
||||
PJ_LOG(5,("", "Client %s received %lu bytes unauthorized data from peer %s",
|
||||
client_info, (unsigned long)size, peer_info));
|
||||
if (alloc->perm_cnt == 0)
|
||||
PJ_LOG(5,("", "Client %s has no permission", client_info));
|
||||
return PJ_TRUE;
|
||||
|
@ -1073,8 +1073,8 @@ static pj_bool_t alloc_on_data_recvfrom(pj_activesock_t *asock,
|
|||
|
||||
/* Send */
|
||||
sent = size;
|
||||
PJ_LOG(5,("", "Forwarding %ld bytes data from peer %s to client %s",
|
||||
sent, peer_info, client_info));
|
||||
PJ_LOG(5,("", "Forwarding %lu bytes data from peer %s to client %s",
|
||||
(unsigned long)sent, peer_info, client_info));
|
||||
|
||||
pj_activesock_sendto(alloc->test_srv->turn_sock, &alloc->send_key, buffer,
|
||||
&sent, 0, &alloc->client_addr,
|
||||
|
|
|
@ -2547,8 +2547,8 @@ PJ_DEF(pj_status_t) pj_stun_msg_decode(pj_pool_t *pool,
|
|||
if (pdu_len > 0) {
|
||||
/* Stray trailing bytes */
|
||||
PJ_LOG(4,(THIS_FILE,
|
||||
"Error decoding STUN message: unparsed trailing %ld bytes",
|
||||
pdu_len));
|
||||
"Error decoding STUN message: unparsed trailing %lu bytes",
|
||||
(unsigned long)pdu_len));
|
||||
return PJNATH_EINSTUNMSGLEN;
|
||||
}
|
||||
|
||||
|
|
|
@ -1034,8 +1034,8 @@ static void handle_peer_pkt(pj_turn_allocation *alloc,
|
|||
char peer_addr[80];
|
||||
pj_sockaddr_print(src_addr, peer_addr, sizeof(peer_addr), 3);
|
||||
PJ_LOG(4,(alloc->obj_name, "Client %s: discarded data from %s "
|
||||
"because it's too long (%ld bytes)",
|
||||
alloc->info, peer_addr, len));
|
||||
"because it's too long (%lu bytes)",
|
||||
alloc->info, peer_addr, (unsigned long)len));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -857,8 +857,9 @@ PJ_DEF(pj_status_t) pjsip_100rel_tx_response(pjsip_inv_session *inv,
|
|||
status = PJ_SUCCESS;
|
||||
|
||||
PJ_LOG(4,(dd->inv->dlg->obj_name,
|
||||
"Reliable %d response enqueued (%ld pending)",
|
||||
code, pj_list_size(&dd->uas_state->tx_data_list)));
|
||||
"Reliable %d response enqueued (%lu pending)",
|
||||
code, (unsigned long)
|
||||
pj_list_size(&dd->uas_state->tx_data_list)));
|
||||
|
||||
} else {
|
||||
pj_list_push_back(&dd->uas_state->tx_data_list, tl);
|
||||
|
|
|
@ -788,7 +788,8 @@ PJ_DEF(pj_status_t) pjsip_endpt_schedule_timer_dbg(pjsip_endpoint *endpt,
|
|||
int src_line)
|
||||
{
|
||||
PJ_LOG(6, (THIS_FILE, "pjsip_endpt_schedule_timer(entry=%p, delay=%lu.%lu)",
|
||||
entry, delay->sec, delay->msec));
|
||||
entry, (unsigned long)delay->sec,
|
||||
(unsigned long)delay->msec));
|
||||
return pj_timer_heap_schedule_dbg(endpt->timer_heap, entry, delay,
|
||||
src_file, src_line);
|
||||
}
|
||||
|
@ -797,8 +798,9 @@ PJ_DEF(pj_status_t) pjsip_endpt_schedule_timer( pjsip_endpoint *endpt,
|
|||
pj_timer_entry *entry,
|
||||
const pj_time_val *delay )
|
||||
{
|
||||
PJ_LOG(6, (THIS_FILE, "pjsip_endpt_schedule_timer(entry=%p, delay=%u.%u)",
|
||||
entry, delay->sec, delay->msec));
|
||||
PJ_LOG(6, (THIS_FILE, "pjsip_endpt_schedule_timer(entry=%p, delay=%lu.%lu)",
|
||||
entry, (unsigned long)delay->sec,
|
||||
(unsigned long)delay->msec));
|
||||
return pj_timer_heap_schedule( endpt->timer_heap, entry, delay );
|
||||
}
|
||||
#endif
|
||||
|
@ -817,8 +819,9 @@ PJ_DEF(pj_status_t) pjsip_endpt_schedule_timer_w_grp_lock_dbg(
|
|||
int src_line)
|
||||
{
|
||||
PJ_LOG(6, (THIS_FILE, "pjsip_endpt_schedule_timer_w_grp_lock"
|
||||
"(entry=%p, delay=%ld.%ld, grp_lock=%p)",
|
||||
entry, delay->sec, delay->msec, grp_lock));
|
||||
"(entry=%p, delay=%lu.%lu, grp_lock=%p)",
|
||||
entry, (unsigned long)delay->sec,
|
||||
(unsigned long)delay->msec, grp_lock));
|
||||
return pj_timer_heap_schedule_w_grp_lock_dbg(endpt->timer_heap, entry,
|
||||
delay, id_val, grp_lock,
|
||||
src_file, src_line);
|
||||
|
@ -832,8 +835,9 @@ PJ_DEF(pj_status_t) pjsip_endpt_schedule_timer_w_grp_lock(
|
|||
pj_grp_lock_t *grp_lock )
|
||||
{
|
||||
PJ_LOG(6, (THIS_FILE, "pjsip_endpt_schedule_timer_w_grp_lock"
|
||||
"(entry=%p, delay=%u.%u, grp_lock=%p)",
|
||||
entry, delay->sec, delay->msec, grp_lock));
|
||||
"(entry=%p, delay=%lu.%lu, grp_lock=%p)",
|
||||
entry, (unsigned long)delay->sec,
|
||||
(unsigned long)delay->msec, grp_lock));
|
||||
return pj_timer_heap_schedule_w_grp_lock( endpt->timer_heap, entry,
|
||||
delay, id_val, grp_lock );
|
||||
}
|
||||
|
@ -1314,8 +1318,8 @@ PJ_DEF(void) pjsip_endpt_dump( pjsip_endpoint *endpt, pj_bool_t detail )
|
|||
|
||||
/* Pool health. */
|
||||
PJ_LOG(3, (THIS_FILE," Endpoint pool capacity=%lu, used_size=%lu",
|
||||
pj_pool_get_capacity(endpt->pool),
|
||||
pj_pool_get_used_size(endpt->pool)));
|
||||
(unsigned long)pj_pool_get_capacity(endpt->pool),
|
||||
(unsigned long)pj_pool_get_used_size(endpt->pool)));
|
||||
|
||||
/* Resolver */
|
||||
#if PJSIP_HAS_RESOLVER
|
||||
|
@ -1333,7 +1337,7 @@ PJ_DEF(void) pjsip_endpt_dump( pjsip_endpoint *endpt, pj_bool_t detail )
|
|||
pj_timer_heap_dump(endpt->timer_heap);
|
||||
#else
|
||||
PJ_LOG(3,(THIS_FILE, " Timer heap has %lu entries",
|
||||
pj_timer_heap_count(endpt->timer_heap)));
|
||||
(unsigned long)pj_timer_heap_count(endpt->timer_heap)));
|
||||
#endif
|
||||
|
||||
/* Unlock mutex. */
|
||||
|
|
|
@ -2225,8 +2225,8 @@ PJ_DEF(pj_ssize_t) pjsip_tpmgr_receive_packet( pjsip_tpmgr *mgr,
|
|||
*/
|
||||
if (tmp.slen) {
|
||||
PJ_LOG(2, (THIS_FILE,
|
||||
"Dropping %ld bytes packet from %s %s:%d %.*s\n",
|
||||
msg_fragment_size,
|
||||
"Dropping %lu bytes packet from %s %s:%d %.*s\n",
|
||||
(unsigned long)msg_fragment_size,
|
||||
rdata->tp_info.transport->type_name,
|
||||
rdata->pkt_info.src_name,
|
||||
rdata->pkt_info.src_port,
|
||||
|
|
|
@ -503,7 +503,8 @@ on_return:
|
|||
|
||||
/* Dumping memory pool usage */
|
||||
PJ_LOG(3,(THIS_FILE, "Peak memory size=%lu MB",
|
||||
caching_pool.peak_used_size / 1000000));
|
||||
(unsigned long)
|
||||
(caching_pool.peak_used_size / 1000000)));
|
||||
|
||||
pjsip_endpt_destroy(endpt);
|
||||
pj_caching_pool_destroy(&caching_pool);
|
||||
|
|
Loading…
Reference in New Issue