sipwise
/
rtpengine
mirror of https://github.com/sipwise/rtpengine.git
1
0
Fork 0
Code Issues Releases Wiki Activity

TT#111150 convert str.len to size_t

Browse Source 
This makes the type in line with string(3) functions and eliminates some
compiler warnings.

Also update the related bencode data type.

Change-Id: I7ef4024f4b5a0f737b3dbe03bcd078032395bce6
pull/1252/head
Richard Fuchs 4 years ago
parent 61a852fa71
commit d5d0a3a994
16 changed files with 102 additions and 93 deletions

58
daemon/bencode.c
Unescape View File

@ -201,7 +201,7 @@ static void __bencode_container_add(bencode_item_t *parent, bencode_item_t *chil
} }
static bencode_item_t *__bencode_string_alloc(bencode_buffer_t *buf, const void *base, static bencode_item_t *__bencode_string_alloc(bencode_buffer_t *buf, const void *base,
int str_len, int iov_len, int iov_cnt, bencode_type_t type) size_t str_len, size_t iov_len, unsigned int iov_cnt, bencode_type_t type)
{ {
bencode_item_t *ret; bencode_item_t *ret;
int len_len; int len_len;
@ -210,7 +210,7 @@ static bencode_item_t *__bencode_string_alloc(bencode_buffer_t *buf, const void
ret = __bencode_item_alloc(buf, 7); ret = __bencode_item_alloc(buf, 7);
if (!ret) if (!ret)
return NULL; return NULL;
len_len = sprintf(ret->__buf, "%d:", str_len); len_len = sprintf(ret->__buf, "%zu:", str_len);
ret->type = type; ret->type = type;
ret->iov[0].iov_base = ret->__buf; ret->iov[0].iov_base = ret->__buf;
@ -223,7 +223,7 @@ static bencode_item_t *__bencode_string_alloc(bencode_buffer_t *buf, const void
return ret; return ret;
} }
bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, int len) { bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, size_t len) {
char *sd = bencode_buffer_alloc(buf, len); char *sd = bencode_buffer_alloc(buf, len);
if (!sd) if (!sd)
return NULL; return NULL;
@ -231,11 +231,13 @@ bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, int
return bencode_string_len(buf, sd, len); return bencode_string_len(buf, sd, len);
} }
bencode_item_t *bencode_string_len(bencode_buffer_t *buf, const char *s, int len) { bencode_item_t *bencode_string_len(bencode_buffer_t *buf, const char *s, size_t len) {
return __bencode_string_alloc(buf, s, len, len, 1, BENCODE_STRING); return __bencode_string_alloc(buf, s, len, len, 1, BENCODE_STRING);
} }
bencode_item_t *bencode_string_iovec(bencode_buffer_t *buf, const struct iovec *iov, int iov_cnt, int str_len) { bencode_item_t *bencode_string_iovec(bencode_buffer_t *buf, const struct iovec *iov, unsigned int iov_cnt,
size_t str_len)
{
int i; int i;
if (iov_cnt < 0) if (iov_cnt < 0)
@ -275,7 +277,7 @@ bencode_item_t *bencode_integer(bencode_buffer_t *buf, long long int i) {
return ret; return ret;
} }
bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, int keylen, bencode_item_t *val) { bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, size_t keylen, bencode_item_t *val) {
bencode_item_t *str; bencode_item_t *str;
if (!dict || !val) if (!dict || !val)
@ -337,7 +339,7 @@ static int __bencode_iovec_dump(struct iovec *out, bencode_item_t *item) {
return item->iov_cnt; return item->iov_cnt;
} }
static int __bencode_str_dump(char *out, bencode_item_t *item) { static size_t __bencode_str_dump(char *out, bencode_item_t *item) {
char *orig = out; char *orig = out;
bencode_item_t *child; bencode_item_t *child;
@ -376,9 +378,9 @@ struct iovec *bencode_iovec(bencode_item_t *root, int *cnt, unsigned int head, u
return ret; return ret;
} }
char *bencode_collapse(bencode_item_t *root, int *len) { char *bencode_collapse(bencode_item_t *root, size_t *len) {
char *ret; char *ret;
int l; size_t l;
if (!root) if (!root)
return NULL; return NULL;
@ -393,7 +395,7 @@ char *bencode_collapse(bencode_item_t *root, int *len) {
return ret; return ret;
} }
char *bencode_collapse_dup(bencode_item_t *root, int *len) { char *bencode_collapse_dup(bencode_item_t *root, size_t *len) {
char *ret; char *ret;
int l; int l;
@ -641,13 +643,13 @@ static bencode_item_t *__bencode_decode(bencode_buffer_t *buf, const char *s, co
} }
} }
bencode_item_t *bencode_decode(bencode_buffer_t *buf, const char *s, int len) { bencode_item_t *bencode_decode(bencode_buffer_t *buf, const char *s, size_t len) {
assert(s != NULL); assert(s != NULL);
return __bencode_decode(buf, s, s + len); return __bencode_decode(buf, s, s + len);
} }
static int __bencode_dictionary_key_match(bencode_item_t *key, const char *keystr, int keylen) { static int __bencode_dictionary_key_match(bencode_item_t *key, const char *keystr, size_t keylen) {
assert(key->type == BENCODE_STRING); assert(key->type == BENCODE_STRING);
if (keylen != key->iov[1].iov_len) if (keylen != key->iov[1].iov_len)
@ -658,7 +660,7 @@ static int __bencode_dictionary_key_match(bencode_item_t *key, const char *keyst
return 1; return 1;
} }
bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *keystr, int keylen) { bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *keystr, size_t keylen) {
bencode_item_t *key; bencode_item_t *key;
unsigned int bucket, i; unsigned int bucket, i;
struct __bencode_hash *hash; struct __bencode_hash *hash;
@ -710,17 +712,17 @@ void bencode_buffer_destroy_add(bencode_buffer_t *buf, free_func_t func, void *p
buf->free_list = li; buf->free_list = li;
} }
static int __bencode_string(const char *s, int offset, int len) { static int __bencode_string(const char *s, size_t offset, size_t len) {
int pos; size_t pos;
unsigned long long sl; unsigned long sl;
char *end; char *end;
for (pos = offset + 1; s[pos] != ':' && isdigit(s[pos]) && pos < len; ++pos); for (pos = offset; s[pos] != ':' && isdigit(s[pos]) && pos < len; ++pos);
if (pos == len) if (pos == len)
return -1; return -1;
sl = strtoul(s + offset + 1, &end, 10); sl = strtoul(s + offset, &end, 10);
if (s + offset + 1 == end || end != s + pos) if (s + offset == end || end != s + pos)
return -2; return -2;
if (pos + sl > len) if (pos + sl > len)
@ -729,8 +731,8 @@ static int __bencode_string(const char *s, int offset, int len) {
return pos + sl + 1; return pos + sl + 1;
} }
static int __bencode_integer(const char *s, int offset, int len) { static int __bencode_integer(const char *s, size_t offset, size_t len) {
int pos; size_t pos;
if (s[offset + 1] == '-') { if (s[offset + 1] == '-') {
if (offset + 3 < len && s[offset + 2] == '0' && s[offset + 3] == 'e') { if (offset + 3 < len && s[offset + 2] == '0' && s[offset + 3] == 'e') {
@ -759,9 +761,9 @@ static int __bencode_integer(const char *s, int offset, int len) {
return pos + 1; return pos + 1;
} }
static int __bencode_next(const char *s, int offset, int len); static int __bencode_next(const char *s, size_t offset, size_t len);
static int __bencode_list(const char *s, int offset, int len) { static int __bencode_list(const char *s, size_t offset, size_t len) {
for (++offset; s[offset] != 'e' && offset < len;) { for (++offset; s[offset] != 'e' && offset < len;) {
offset = __bencode_next(s, offset, len); offset = __bencode_next(s, offset, len);
if (offset < 0) if (offset < 0)
@ -774,9 +776,9 @@ static int __bencode_list(const char *s, int offset, int len) {
return offset + 1; return offset + 1;
} }
static int __bencode_dictionary(const char *s, int offset, int len) { static int __bencode_dictionary(const char *s, size_t offset, size_t len) {
for (++offset; s[offset] != 'e' && offset < len;) { for (++offset; s[offset] != 'e' && offset < len;) {
offset = __bencode_string(s, offset - 1, len); offset = __bencode_string(s, offset, len);
if (offset < 0) if (offset < 0)
return offset; return offset;
offset = __bencode_next(s, offset, len); offset = __bencode_next(s, offset, len);
@ -790,7 +792,7 @@ static int __bencode_dictionary(const char *s, int offset, int len) {
return offset + 1; return offset + 1;
} }
static int __bencode_next(const char *s, int offset, int len) { static int __bencode_next(const char *s, size_t offset, size_t len) {
if (offset >= len) if (offset >= len)
return -1; return -1;
switch(s[offset]) { switch(s[offset]) {
@ -810,11 +812,11 @@ static int __bencode_next(const char *s, int offset, int len) {
case '7': case '7':
case '8': case '8':
case '9': case '9':
return __bencode_string(s, offset - 1, len); return __bencode_string(s, offset, len);
} }
return -2; return -2;
} }
int bencode_valid(const char *s, int len) { int bencode_valid(const char *s, size_t len) {
return __bencode_next(s, 0, len); return __bencode_next(s, 0, len);
} }

2
daemon/call.c
Unescape View File

@ -2558,7 +2558,7 @@ void call_destroy(struct call *c) {
(unsigned int) (rtpe_now.tv_sec - ml->created) % 60, (unsigned int) (rtpe_now.tv_sec - ml->created) % 60,
STR_FMT_M(&ml->viabranch), STR_FMT_M(&ml->viabranch),
ml->active_dialogue ? rtpe_common_config_ptr->log_mark_prefix : "", ml->active_dialogue ? rtpe_common_config_ptr->log_mark_prefix : "",
ml->active_dialogue ? ml->active_dialogue->tag.len : 6, ml->active_dialogue ? (int) ml->active_dialogue->tag.len : 6,
ml->active_dialogue ? ml->active_dialogue->tag.s : "(none)", ml->active_dialogue ? ml->active_dialogue->tag.s : "(none)",
ml->active_dialogue ? rtpe_common_config_ptr->log_mark_suffix : ""); ml->active_dialogue ? rtpe_common_config_ptr->log_mark_suffix : "");

2
daemon/cli.c
Unescape View File

@ -577,7 +577,7 @@ static void cli_incoming_list_callid(str *instr, struct cli_writer *cw) {
STR_FMT(&ml->viabranch), STR_FMT(&ml->viabranch),
tim_result_duration.tv_sec, tim_result_duration.tv_sec,
tim_result_duration.tv_usec, tim_result_duration.tv_usec,
ml->active_dialogue ? ml->active_dialogue->tag.len : 6, ml->active_dialogue ? (int) ml->active_dialogue->tag.len : 6,
ml->active_dialogue ? ml->active_dialogue->tag.s : "(none)"); ml->active_dialogue ? ml->active_dialogue->tag.s : "(none)");
for (k = ml->medias.head; k; k = k->next) { for (k = ml->medias.head; k; k = k->next) {

6
daemon/codec.c
Unescape View File

@ -2132,7 +2132,7 @@ static int __handler_func_supplemental(struct codec_handler *h, struct media_pac
// create new packet and insert it into sequencer queue // create new packet and insert it into sequencer queue
ilogs(transcoding, LOG_DEBUG, "Received %s RTP packet: SSRC %" PRIx32 ", PT %u, seq %u, TS %u, len %i", ilogs(transcoding, LOG_DEBUG, "Received %s RTP packet: SSRC %" PRIx32 ", PT %u, seq %u, TS %u, len %zu",
h->source_pt.codec_def->rtpname, h->source_pt.codec_def->rtpname,
ntohl(mp->rtp->ssrc), mp->rtp->m_pt, ntohs(mp->rtp->seq_num), ntohl(mp->rtp->ssrc), mp->rtp->m_pt, ntohs(mp->rtp->seq_num),
ntohl(mp->rtp->timestamp), mp->payload.len); ntohl(mp->rtp->timestamp), mp->payload.len);
@ -2903,7 +2903,7 @@ static int packet_encoded_rtp(encoder_t *enc, void *u1, void *u2) {
break; break;
} }
ilogs(transcoding, LOG_DEBUG, "Received packet of %i bytes from packetizer", inout.len); ilogs(transcoding, LOG_DEBUG, "Received packet of %zu bytes from packetizer", inout.len);
// check special payloads // check special payloads
@ -3145,7 +3145,7 @@ static int handler_func_transcode(struct codec_handler *h, struct media_packet *
// create new packet and insert it into sequencer queue // create new packet and insert it into sequencer queue
ilogs(transcoding, LOG_DEBUG, "Received RTP packet: SSRC %" PRIx32 ", PT %u, seq %u, TS %u, len %i", ilogs(transcoding, LOG_DEBUG, "Received RTP packet: SSRC %" PRIx32 ", PT %u, seq %u, TS %u, len %zu",
ntohl(mp->rtp->ssrc), mp->rtp->m_pt, ntohs(mp->rtp->seq_num), ntohl(mp->rtp->ssrc), mp->rtp->m_pt, ntohs(mp->rtp->seq_num),
ntohl(mp->rtp->timestamp), mp->payload.len); ntohl(mp->rtp->timestamp), mp->payload.len);

2
daemon/crypto.c
Unescape View File

@ -495,7 +495,7 @@ int crypto_gen_session_key(struct crypto_context *c, str *out, unsigned char lab
"%02x%02x%02x%02x..., " "%02x%02x%02x%02x..., "
"master salt " "master salt "
"%02x%02x%02x%02x..., " "%02x%02x%02x%02x..., "
"label %02x, length %i, result " "label %02x, length %zu, result "
"%02x%02x%02x%02x...", "%02x%02x%02x%02x...",
c->params.master_key[0], c->params.master_key[0],
c->params.master_key[1], c->params.master_key[1],

2
daemon/dtls.c
Unescape View File

@ -701,7 +701,7 @@ int dtls(struct stream_fd *sfd, const str *s, const endpoint_t *fsin) {
return 0; return 0;
if (s) if (s)
__DBG("dtls packet input: len %u %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", __DBG("dtls packet input: len %zu %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
s->len, s->len,
(unsigned char) s->s[0], (unsigned char) s->s[1], (unsigned char) s->s[2], (unsigned char) s->s[3], (unsigned char) s->s[0], (unsigned char) s->s[1], (unsigned char) s->s[2], (unsigned char) s->s[3],
(unsigned char) s->s[4], (unsigned char) s->s[5], (unsigned char) s->s[6], (unsigned char) s->s[7], (unsigned char) s->s[4], (unsigned char) s->s[5], (unsigned char) s->s[6], (unsigned char) s->s[7],

2
daemon/dtmf.c
Unescape View File

@ -114,7 +114,7 @@ int dtmf_do_logging(void) {
int dtmf_event(struct media_packet *mp, str *payload, int clockrate) { int dtmf_event(struct media_packet *mp, str *payload, int clockrate) {
struct telephone_event_payload *dtmf; struct telephone_event_payload *dtmf;
if (payload->len < sizeof(*dtmf)) { if (payload->len < sizeof(*dtmf)) {
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Short DTMF event packet (len %u)", payload->len); ilog(LOG_WARN | LOG_FLAG_LIMIT, "Short DTMF event packet (len %zu)", payload->len);
return -1; return -1;
} }
dtmf = (void *) payload->s; dtmf = (void *) payload->s;

4
daemon/main.c
Unescape View File

@ -550,9 +550,9 @@ static void options(int *argc, char ***argv) {
if ((errno == ERANGE && (uint_keyspace_db == ULONG_MAX)) || if ((errno == ERANGE && (uint_keyspace_db == ULONG_MAX)) ||
(errno != 0 && uint_keyspace_db == 0)) { (errno != 0 && uint_keyspace_db == 0)) {
ilog(LOG_ERR, "Fail adding keyspace '%.*s' to redis notifications; errono=%d\n", str_keyspace_db.len, str_keyspace_db.s, errno); ilog(LOG_ERR, "Fail adding keyspace '" STR_FORMAT "' to redis notifications; errono=%d\n", STR_FMT(&str_keyspace_db), errno);
} else if (endptr == str_keyspace_db.s) { } else if (endptr == str_keyspace_db.s) {
ilog(LOG_ERR, "Fail adding keyspace '%.*s' to redis notifications; no digits found\n", str_keyspace_db.len, str_keyspace_db.s); ilog(LOG_ERR, "Fail adding keyspace '" STR_FORMAT "' to redis notifications; no digits found\n", STR_FMT(&str_keyspace_db));
} else { } else {
g_queue_push_tail(&rtpe_config.redis_subscribed_keyspaces, GUINT_TO_POINTER(uint_keyspace_db)); g_queue_push_tail(&rtpe_config.redis_subscribed_keyspaces, GUINT_TO_POINTER(uint_keyspace_db));
} }

2
daemon/recording.c
Unescape View File

@ -425,7 +425,7 @@ static void sdp_after_pcap(struct recording *recording, GString *str, struct cal
// descriptor does not. Make sure to flush any unwritten contents // descriptor does not. Make sure to flush any unwritten contents
// so the file contents appear in order. // so the file contents appear in order.
if (ml->label.len) { if (ml->label.len) {
fprintf(meta_fp, "\nLabel: %*s", ml->label.len, ml->label.s); fprintf(meta_fp, "\nLabel: " STR_FORMAT, STR_FMT(&ml->label));
} }
fprintf(meta_fp, "\nTimestamp started ms: "); fprintf(meta_fp, "\nTimestamp started ms: ");
fprintf(meta_fp, "%.3lf", ml->started.tv_sec*1000.0+ml->started.tv_usec/1000.0); fprintf(meta_fp, "%.3lf", ml->started.tv_sec*1000.0+ml->started.tv_usec/1000.0);

2
daemon/redis.c
Unescape View File

@ -920,7 +920,7 @@ static void redis_delete_async_call_json(struct call *c, struct redis *r) {
redis_command = g_strdup_printf("SELECT %i", c->redis_hosted_db); redis_command = g_strdup_printf("SELECT %i", c->redis_hosted_db);
g_queue_push_tail(&r->async_queue, redis_command); g_queue_push_tail(&r->async_queue, redis_command);
redis_command = g_strdup_printf("DEL %.*s", c->callid.len, c->callid.s); redis_command = g_strdup_printf("DEL " STR_FORMAT, STR_FMT(&c->callid));
g_queue_push_tail(&r->async_queue, redis_command); g_queue_push_tail(&r->async_queue, redis_command);
} }

10
daemon/t38.c
Unescape View File

@ -568,11 +568,11 @@ int t38_gateway_input_udptl(struct t38_gateway *tg, const str *buf) {
return 0; return 0;
if (buf->len < 4) { if (buf->len < 4) {
ilog(LOG_INFO | LOG_FLAG_LIMIT, "Ignoring short UDPTL packet (%i bytes)", buf->len); ilog(LOG_INFO | LOG_FLAG_LIMIT, "Ignoring short UDPTL packet (%zu bytes)", buf->len);
return 0; return 0;
} }
ilog(LOG_DEBUG, "Processing %i UDPTL bytes", buf->len); ilog(LOG_DEBUG, "Processing %zu UDPTL bytes", buf->len);
str s = *buf; str s = *buf;
str piece; str piece;
@ -587,7 +587,7 @@ int t38_gateway_input_udptl(struct t38_gateway *tg, const str *buf) {
if (__get_udptl(&piece, &s)) if (__get_udptl(&piece, &s))
goto err; goto err;
ilog(LOG_DEBUG, "Received primary IFP packet, len %i, seq %i", piece.len, seq); ilog(LOG_DEBUG, "Received primary IFP packet, len %zu, seq %i", piece.len, seq);
str primary = piece; str primary = piece;
up = __make_udptl_packet(&primary, seq); up = __make_udptl_packet(&primary, seq);
@ -636,7 +636,7 @@ int t38_gateway_input_udptl(struct t38_gateway *tg, const str *buf) {
// ignore zero-length packets // ignore zero-length packets
if (!piece.len) if (!piece.len)
continue; continue;
ilog(LOG_DEBUG, "Received secondary IFP packet, len %i, seq %i", piece.len, ilog(LOG_DEBUG, "Received secondary IFP packet, len %zu, seq %i", piece.len,
seq - 1 - i); seq - 1 - i);
up = __make_udptl_packet(&piece, seq - 1 - i); up = __make_udptl_packet(&piece, seq - 1 - i);
packet_sequencer_insert(&tg->sequencer, &up->p); packet_sequencer_insert(&tg->sequencer, &up->p);
@ -744,7 +744,7 @@ seq_ok:;
if (!up) if (!up)
break; break;
ilog(LOG_DEBUG, "Processing %i IFP bytes, seq %i", up->s->len, up->p.seq); ilog(LOG_DEBUG, "Processing %zu IFP bytes, seq %i", up->s->len, up->p.seq);
t38_core_rx_ifp_packet(t38, (uint8_t *) up->s->s, up->s->len, up->p.seq); t38_core_rx_ifp_packet(t38, (uint8_t *) up->s->s, up->s->len, up->p.seq);

40
include/bencode.h
Unescape View File

@ -31,7 +31,7 @@ struct bencode_item {
bencode_type_t type; bencode_type_t type;
struct iovec iov[2]; /* when decoding, iov[1] contains the contents of a string object */ struct iovec iov[2]; /* when decoding, iov[1] contains the contents of a string object */
unsigned int iov_cnt; unsigned int iov_cnt;
unsigned int str_len; /* length of the whole ENCODED object. NOT the length of a byte string */ size_t str_len; /* length of the whole ENCODED object. NOT the length of a byte string */
long long int value; /* when decoding an integer, contains the value; otherwise used internally */ long long int value; /* when decoding an integer, contains the value; otherwise used internally */
bencode_item_t *parent, *child, *last_child, *sibling; bencode_item_t *parent, *child, *last_child, *sibling;
bencode_buffer_t *buffer; bencode_buffer_t *buffer;
@ -106,13 +106,13 @@ INLINE bencode_item_t *bencode_dictionary_add(bencode_item_t *dict, const char *
INLINE bencode_item_t *bencode_dictionary_str_add(bencode_item_t *dict, const str *key, bencode_item_t *val); INLINE bencode_item_t *bencode_dictionary_str_add(bencode_item_t *dict, const str *key, bencode_item_t *val);
/* Identical to bencode_dictionary_add() but doesn't require the key string to be null-terminated */ /* Identical to bencode_dictionary_add() but doesn't require the key string to be null-terminated */
bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, int keylen, bencode_item_t *val); bencode_item_t *bencode_dictionary_add_len(bencode_item_t *dict, const char *key, size_t keylen, bencode_item_t *val);
/* Convenience function to add a string value to a dictionary, possibly duplicated into the /* Convenience function to add a string value to a dictionary, possibly duplicated into the
* bencode_buffer_t object. */ * bencode_buffer_t object. */
INLINE bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val); INLINE bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const char *key, const char *val);
INLINE bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val); INLINE bencode_item_t *bencode_dictionary_add_string_dup(bencode_item_t *dict, const char *key, const char *val);
INLINE bencode_item_t *bencode_dictionary_add_string_len(bencode_item_t *dict, const char *key, const char *val, int len); INLINE bencode_item_t *bencode_dictionary_add_string_len(bencode_item_t *dict, const char *key, const char *val, size_t len);
/* Ditto, but for a "str" object */ /* Ditto, but for a "str" object */
INLINE bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val); INLINE bencode_item_t *bencode_dictionary_add_str(bencode_item_t *dict, const char *key, const str *val);
@ -122,7 +122,7 @@ INLINE bencode_item_t *bencode_dictionary_add_str_dup(bencode_item_t *dict, cons
/* Ditto, but adds a string created through an iovec array to the dictionary. See /* Ditto, but adds a string created through an iovec array to the dictionary. See
* bencode_string_iovec(). */ * bencode_string_iovec(). */
INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key, INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key,
const struct iovec *iov, int iov_cnt, int str_len); const struct iovec *iov, unsigned int iov_cnt, size_t str_len);
/* Convenience functions to add the respective (newly created) objects to a dictionary */ /* Convenience functions to add the respective (newly created) objects to a dictionary */
INLINE bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val); INLINE bencode_item_t *bencode_dictionary_add_integer(bencode_item_t *dict, const char *key, long long int val);
@ -158,7 +158,7 @@ INLINE bencode_item_t *bencode_list_add_dictionary(bencode_item_t *list);
* be allocated. * be allocated.
* Strings are not copied or duplicated, so the string pointed to by "s" must remain valid until * Strings are not copied or duplicated, so the string pointed to by "s" must remain valid until
* the complete document is finally encoded or sent out. */ * the complete document is finally encoded or sent out. */
bencode_item_t *bencode_string_len(bencode_buffer_t *buf, const char *s, int len); bencode_item_t *bencode_string_len(bencode_buffer_t *buf, const char *s, size_t len);
/* Creates a new byte-string object. The given string must be null-terminated. Otherwise identical /* Creates a new byte-string object. The given string must be null-terminated. Otherwise identical
* to bencode_string_len(). */ * to bencode_string_len(). */
@ -170,7 +170,7 @@ INLINE bencode_item_t *bencode_str(bencode_buffer_t *buf, const str *s);
/* Identical to the above three functions, but copies the string into the bencode_buffer_t object. /* Identical to the above three functions, but copies the string into the bencode_buffer_t object.
* Thus, the given string doesn't have to remain valid and accessible afterwards. */ * Thus, the given string doesn't have to remain valid and accessible afterwards. */
bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, int len); bencode_item_t *bencode_string_len_dup(bencode_buffer_t *buf, const char *s, size_t len);
INLINE bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s); INLINE bencode_item_t *bencode_string_dup(bencode_buffer_t *buf, const char *s);
INLINE bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s); INLINE bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s);
@ -180,7 +180,7 @@ INLINE bencode_item_t *bencode_str_dup(bencode_buffer_t *buf, const str *s);
* document is encoded. The full length of the string composed of the iovec array is given in the * document is encoded. The full length of the string composed of the iovec array is given in the
* "str_len" parameter, which can be negative, in which case the array is iterated to calculate the * "str_len" parameter, which can be negative, in which case the array is iterated to calculate the
* length. */ * length. */
bencode_item_t *bencode_string_iovec(bencode_buffer_t *buf, const struct iovec *iov, int iov_cnt, int str_len); bencode_item_t *bencode_string_iovec(bencode_buffer_t *buf, const struct iovec *iov, unsigned int iov_cnt, size_t str_len);
/* Convenience function to compare a string object to a regular C string. Returns 2 if object /* Convenience function to compare a string object to a regular C string. Returns 2 if object
* isn't a string object, otherwise returns according to strcmp(). */ * isn't a string object, otherwise returns according to strcmp(). */
@ -230,7 +230,7 @@ struct iovec *bencode_iovec(bencode_item_t *root, int *cnt, unsigned int head, u
* in *len. This is important if the encoded document contains binary data, in which case null * in *len. This is important if the encoded document contains binary data, in which case null
* termination cannot be trusted. The returned string is freed when the corresponding * termination cannot be trusted. The returned string is freed when the corresponding
* bencode_buffer_t object is destroyed. */ * bencode_buffer_t object is destroyed. */
char *bencode_collapse(bencode_item_t *root, int *len); char *bencode_collapse(bencode_item_t *root, size_t *len);
/* Identical to bencode_collapse() but fills in a "str" object. Returns "out". */ /* Identical to bencode_collapse() but fills in a "str" object. Returns "out". */
static str *bencode_collapse_str(bencode_item_t *root, str *out); static str *bencode_collapse_str(bencode_item_t *root, str *out);
@ -239,7 +239,7 @@ static str *bencode_collapse_str(bencode_item_t *root, str *out);
* a bencode_buffer_t object, but instead using the function defined as BENCODE_MALLOC (normally * a bencode_buffer_t object, but instead using the function defined as BENCODE_MALLOC (normally
* malloc() or pkg_malloc()), similar to strdup(). Using this function, the bencode_buffer_t * malloc() or pkg_malloc()), similar to strdup(). Using this function, the bencode_buffer_t
* object can be destroyed, but the returned string remains valid and usable. */ * object can be destroyed, but the returned string remains valid and usable. */
char *bencode_collapse_dup(bencode_item_t *root, int *len); char *bencode_collapse_dup(bencode_item_t *root, size_t *len);
@ -292,17 +292,17 @@ char *bencode_collapse_dup(bencode_item_t *root, int *len);
* *
* All memory is freed when the bencode_buffer_t object is destroyed. * All memory is freed when the bencode_buffer_t object is destroyed.
*/ */
bencode_item_t *bencode_decode(bencode_buffer_t *buf, const char *s, int len); bencode_item_t *bencode_decode(bencode_buffer_t *buf, const char *s, size_t len);
/* Identical to bencode_decode(), but returns successfully only if the type of the decoded object match /* Identical to bencode_decode(), but returns successfully only if the type of the decoded object match
* "expect". */ * "expect". */
INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect); INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, size_t len, bencode_type_t expect);
/* Identical to bencode_decode_expect() but takes a "str" argument. */ /* Identical to bencode_decode_expect() but takes a "str" argument. */
INLINE bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect); INLINE bencode_item_t *bencode_decode_expect_str(bencode_buffer_t *buf, const str *s, bencode_type_t expect);
/* Returns the number of bytes that could successfully be decoded from 's', -1 if more bytes are needed or -2 on error */ /* Returns the number of bytes that could successfully be decoded from 's', -1 if more bytes are needed or -2 on error */
int bencode_valid(const char *s, int len); int bencode_valid(const char *s, size_t len);
/*** DICTIONARY LOOKUP & EXTRACTION ***/ /*** DICTIONARY LOOKUP & EXTRACTION ***/
@ -313,13 +313,13 @@ int bencode_valid(const char *s, int len);
INLINE bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key); INLINE bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *key);
/* Identical to bencode_dictionary_get() but doesn't require the key to be null-terminated. */ /* Identical to bencode_dictionary_get() but doesn't require the key to be null-terminated. */
bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *key, int key_len); bencode_item_t *bencode_dictionary_get_len(bencode_item_t *dict, const char *key, size_t key_len);
/* Identical to bencode_dictionary_get() but returns the value only if its type is a string, and /* Identical to bencode_dictionary_get() but returns the value only if its type is a string, and
* returns it as a pointer to the string itself. Returns NULL if the value is of some other type. The * returns it as a pointer to the string itself. Returns NULL if the value is of some other type. The
* returned string is NOT null-terminated. Length of the string is returned in *len, which must be a * returned string is NOT null-terminated. Length of the string is returned in *len, which must be a
* valid pointer. The returned string will be valid until dict's bencode_buffer_t object is destroyed. */ * valid pointer. The returned string will be valid until dict's bencode_buffer_t object is destroyed. */
INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len); INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, size_t *len);
/* Identical to bencode_dictionary_get_string() but fills in a "str" struct. Returns str->s, which /* Identical to bencode_dictionary_get_string() but fills in a "str" struct. Returns str->s, which
* may be NULL. */ * may be NULL. */
@ -332,7 +332,7 @@ INLINE int bencode_dictionary_get_strcmp(bencode_item_t *dict, const char *key,
/* Identical to bencode_dictionary_get() but returns the string in a newly allocated buffer (using the /* Identical to bencode_dictionary_get() but returns the string in a newly allocated buffer (using the
* BENCODE_MALLOC function), which remains valid even after bencode_buffer_t is destroyed. */ * BENCODE_MALLOC function), which remains valid even after bencode_buffer_t is destroyed. */
INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len); INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, size_t *len);
/* Combines bencode_dictionary_get_str() and bencode_dictionary_get_string_dup(). Fills in a "str" /* Combines bencode_dictionary_get_str() and bencode_dictionary_get_string_dup(). Fills in a "str"
* struct, but copies the string into a newly allocated buffer. Returns str->s. */ * struct, but copies the string into a newly allocated buffer. Returns str->s. */
@ -400,7 +400,7 @@ INLINE bencode_item_t *bencode_dictionary_add_string(bencode_item_t *dict, const
return bencode_dictionary_add(dict, key, bencode_string(bencode_item_buffer(dict), val)); return bencode_dictionary_add(dict, key, bencode_string(bencode_item_buffer(dict), val));
} }
INLINE bencode_item_t *bencode_dictionary_add_string_len(bencode_item_t *dict, const char *key, const char *val, int len) { INLINE bencode_item_t *bencode_dictionary_add_string_len(bencode_item_t *dict, const char *key, const char *val, size_t len) {
if (!val) if (!val)
return NULL; return NULL;
return bencode_dictionary_add(dict, key, bencode_string_len(bencode_item_buffer(dict), val, len)); return bencode_dictionary_add(dict, key, bencode_string_len(bencode_item_buffer(dict), val, len));
@ -476,7 +476,7 @@ INLINE bencode_item_t *bencode_dictionary_get(bencode_item_t *dict, const char *
return bencode_dictionary_get_len(dict, key, strlen(key)); return bencode_dictionary_get_len(dict, key, strlen(key));
} }
INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, int *len) { INLINE char *bencode_dictionary_get_string(bencode_item_t *dict, const char *key, size_t *len) {
bencode_item_t *val; bencode_item_t *val;
val = bencode_dictionary_get(dict, key); val = bencode_dictionary_get(dict, key);
if (!val || val->type != BENCODE_STRING) if (!val || val->type != BENCODE_STRING)
@ -492,7 +492,7 @@ INLINE char *bencode_dictionary_get_str(bencode_item_t *dict, const char *key, s
return str->s; return str->s;
} }
INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, int *len) { INLINE char *bencode_dictionary_get_string_dup(bencode_item_t *dict, const char *key, size_t *len) {
const char *s; const char *s;
char *ret; char *ret;
s = bencode_dictionary_get_string(dict, key, len); s = bencode_dictionary_get_string(dict, key, len);
@ -542,7 +542,7 @@ INLINE long long int bencode_dictionary_get_int_str(bencode_item_t *dict, const
return ret; return ret;
} }
INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, int len, bencode_type_t expect) { INLINE bencode_item_t *bencode_decode_expect(bencode_buffer_t *buf, const char *s, size_t len, bencode_type_t expect) {
bencode_item_t *ret; bencode_item_t *ret;
ret = bencode_decode(buf, s, len); ret = bencode_decode(buf, s, len);
if (!ret || ret->type != expect) if (!ret || ret->type != expect)
@ -593,7 +593,7 @@ INLINE str *bencode_get_str(bencode_item_t *in, str *out) {
} }
INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key, INLINE bencode_item_t *bencode_dictionary_add_iovec(bencode_item_t *dict, const char *key,
const struct iovec *iov, int iov_cnt, int str_len) const struct iovec *iov, unsigned int iov_cnt, size_t str_len)
{ {
return bencode_dictionary_add(dict, key, bencode_string_iovec(bencode_item_buffer(dict), iov, iov_cnt, str_len)); return bencode_dictionary_add(dict, key, bencode_string_iovec(bencode_item_buffer(dict), iov, iov_cnt, str_len));
} }

4
lib/codeclib.c
Unescape View File

@ -1928,7 +1928,7 @@ static int amr_decoder_input(decoder_t *dec, const str *data, GQueue *out) {
goto err; goto err;
// add TOC byte // add TOC byte
str_shift(&frame, -1); str_unshift(&frame, 1);
frame.s[0] = toc_byte & 0x7c; // strip F bit, keep FT and Q, zero padding (01111100) frame.s[0] = toc_byte & 0x7c; // strip F bit, keep FT and Q, zero padding (01111100)
if (dec->codec_options.amr.octet_aligned && (bits % 8) != 0) { if (dec->codec_options.amr.octet_aligned && (bits % 8) != 0) {
@ -2284,7 +2284,7 @@ static const char *dtmf_decoder_init(decoder_t *dec, const str *fmtp, const str
static int dtmf_decoder_input(decoder_t *dec, const str *data, GQueue *out) { static int dtmf_decoder_input(decoder_t *dec, const str *data, GQueue *out) {
struct telephone_event_payload *dtmf; struct telephone_event_payload *dtmf;
if (data->len < sizeof(*dtmf)) { if (data->len < sizeof(*dtmf)) {
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Short DTMF event packet (len %u)", data->len); ilog(LOG_WARN | LOG_FLAG_LIMIT, "Short DTMF event packet (len %zu)", data->len);
return -1; return -1;
} }
dtmf = (void *) data->s; dtmf = (void *) data->s;

4
lib/str.c
Unescape View File

@ -69,7 +69,7 @@ char *rand_hex_str(char *rand_str, int num_bytes) {
static const char *hex_chars = "0123456789abcdef"; static const char *hex_chars = "0123456789abcdef";
int str_uri_encode_len(char *out, const char *in, int len) { size_t str_uri_encode_len(char *out, const char *in, size_t len) {
const char *end = in + len; const char *end = in + len;
char *ori_out = out; char *ori_out = out;
@ -89,7 +89,7 @@ int str_uri_encode_len(char *out, const char *in, int len) {
return out - ori_out; return out - ori_out;
} }
str *str_uri_decode_len(const char *in, int in_len) { str *str_uri_decode_len(const char *in, size_t in_len) {
const char *end = in + in_len; const char *end = in + in_len;
str *ret = str_alloc(in_len); str *ret = str_alloc(in_len);
char *outp = ret->s; char *outp = ret->s;

53
lib/str.h
Unescape View File

@ -13,7 +13,7 @@
struct _str { struct _str {
char *s; char *s;
int len; size_t len;
}; };
typedef struct _str str; typedef struct _str str;
@ -22,9 +22,9 @@ typedef struct _str str;
#define STR_FORMAT "%.*s" #define STR_FORMAT "%.*s"
#define STR_FORMAT_M "%s%.*s%s" #define STR_FORMAT_M "%s%.*s%s"
#define STR_FMT(str) (str)->len, (str)->s #define STR_FMT(str) (int) (str)->len, (str)->s
#define STR_FMT_M(str) FMT_M(STR_FMT(str)) #define STR_FMT_M(str) FMT_M(STR_FMT(str))
#define STR_FMT0(str) ((str) ? (str)->len : 6), ((str) ? (str)->s : "(NULL)") #define STR_FMT0(str) ((str) ? (int) (str)->len : 6), ((str) ? (str)->s : "(NULL)")
#define STR_FMT0_M(str) FMT_M(STR_FMT0(str)) #define STR_FMT0_M(str) FMT_M(STR_FMT0(str))
#define G_STR_FMT(gstr) (int) (gstr)->len, (gstr)->str // for glib GString #define G_STR_FMT(gstr) (int) (gstr)->len, (gstr)->str // for glib GString
@ -48,7 +48,7 @@ INLINE char *str_chr_str(str *out, const str *s, int c);
/* compares a str to a regular string */ /* compares a str to a regular string */
INLINE int str_cmp(const str *a, const char *b); INLINE int str_cmp(const str *a, const char *b);
/* compares a str to a non-null-terminated string */ /* compares a str to a non-null-terminated string */
INLINE int str_cmp_len(const str *a, const char *b, int len); INLINE int str_cmp_len(const str *a, const char *b, size_t len);
/* compares two str objects */ /* compares two str objects */
INLINE int str_cmp_str(const str *a, const str *b); INLINE int str_cmp_str(const str *a, const str *b);
INLINE int str_casecmp_str(const str *a, const str *b); INLINE int str_casecmp_str(const str *a, const str *b);
@ -57,23 +57,25 @@ INLINE int str_cmp_str0(const str *a, const str *b);
/* inits a str object from a regular string. returns out */ /* inits a str object from a regular string. returns out */
INLINE str *str_init(str *out, char *s); INLINE str *str_init(str *out, char *s);
/* inits a str object from any binary string. returns out */ /* inits a str object from any binary string. returns out */
INLINE str *str_init_len(str *out, char *s, int len); INLINE str *str_init_len(str *out, char *s, size_t len);
INLINE str *str_init_len_assert_len(str *out, char *s, int buflen, int len); INLINE str *str_init_len_assert_len(str *out, char *s, size_t buflen, size_t len);
#define str_init_len_assert(out, s, len) str_init_len_assert_len(out, s, sizeof(s), len) #define str_init_len_assert(out, s, len) str_init_len_assert_len(out, s, sizeof(s), len)
/* inits a str object from a regular string and duplicates the contents. returns out */ /* inits a str object from a regular string and duplicates the contents. returns out */
INLINE str *str_init_dup(str *out, char *s); INLINE str *str_init_dup(str *out, char *s);
INLINE str *str_init_dup_str(str *out, const str *s); INLINE str *str_init_dup_str(str *out, const str *s);
INLINE void str_free_dup(str *out); INLINE void str_free_dup(str *out);
/* returns new str object with uninitialized buffer large enough to hold `len` characters (+1 for null byte) */ /* returns new str object with uninitialized buffer large enough to hold `len` characters (+1 for null byte) */
INLINE str *str_alloc(int len); INLINE str *str_alloc(size_t len);
/* returns new str object allocated with malloc, including buffer */ /* returns new str object allocated with malloc, including buffer */
INLINE str *str_dup(const str *s); INLINE str *str_dup(const str *s);
/* shifts pointer by len chars and decrements len. returns -1 if buffer too short, 0 otherwise */ /* shifts pointer by len chars and decrements len. returns -1 if buffer too short, 0 otherwise */
INLINE int str_shift(str *s, int len); INLINE int str_shift(str *s, size_t len);
/* to revert a previously successful str_shift(). no error checking */
INLINE void str_unshift(str *s, size_t len);
/* eats the supplied string from the beginning of s. returns -1 if string head doesn't match */ /* eats the supplied string from the beginning of s. returns -1 if string head doesn't match */
INLINE int str_shift_cmp(str *s, const char *); INLINE int str_shift_cmp(str *s, const char *);
/* shifts the string by given length and returns the shifted part. returns -1 if string is too short */ /* shifts the string by given length and returns the shifted part. returns -1 if string is too short */
INLINE int str_shift_ret(str *s, int len, str *ret); INLINE int str_shift_ret(str *s, size_t len, str *ret);
/* binary compares str object with memory chunk of equal size */ /* binary compares str object with memory chunk of equal size */
INLINE int str_memcmp(const str *s, void *m); INLINE int str_memcmp(const str *s, void *m);
/* locate a substring within a string, returns character index or -1 */ /* locate a substring within a string, returns character index or -1 */
@ -112,10 +114,10 @@ INLINE str *str_slice_dup(const str *);
void str_slice_free(void *); void str_slice_free(void *);
/* saves "in" into "out" pseudo-URI encoded. "out" point to a buffer with sufficient length. returns length */ /* saves "in" into "out" pseudo-URI encoded. "out" point to a buffer with sufficient length. returns length */
int str_uri_encode_len(char *out, const char *in, int in_len); size_t str_uri_encode_len(char *out, const char *in, size_t in_len);
INLINE int str_uri_encode(char *out, const str *in); INLINE size_t str_uri_encode(char *out, const str *in);
/* reverse of the above. returns newly allocated str + buffer as per str_alloc (must be free'd) */ /* reverse of the above. returns newly allocated str + buffer as per str_alloc (must be free'd) */
str *str_uri_decode_len(const char *in, int in_len); str *str_uri_decode_len(const char *in, size_t in_len);
@ -124,10 +126,10 @@ str *str_uri_decode_len(const char *in, int in_len);
INLINE char *str_end(const str *s) { INLINE char *str_end(const str *s) {
return s->s + s->len; return s->s + s->len;
} }
INLINE int str_shift(str *s, int len) { INLINE int str_shift(str *s, size_t len) {
return str_shift_ret(s, len, NULL); return str_shift_ret(s, len, NULL);
} }
INLINE int str_shift_ret(str *s, int len, str *ret) { INLINE int str_shift_ret(str *s, size_t len, str *ret) {
if (s->len < len) if (s->len < len)
return -1; return -1;
if (ret) if (ret)
@ -136,8 +138,12 @@ INLINE int str_shift_ret(str *s, int len, str *ret) {
s->len -= len; s->len -= len;
return 0; return 0;
} }
INLINE void str_unshift(str *s, size_t len) {
s->s -= len;
s->len += len;
}
INLINE int str_shift_cmp(str *s, const char *t) { INLINE int str_shift_cmp(str *s, const char *t) {
int len = strlen(t); size_t len = strlen(t);
if (s->len < len) if (s->len < len)
return -1; return -1;
if (memcmp(s->s, t, len)) if (memcmp(s->s, t, len))
@ -162,7 +168,7 @@ INLINE char *str_chr_str(str *out, const str *s, int c) {
str_shift(out, p - out->s); str_shift(out, p - out->s);
return out->s; return out->s;
} }
INLINE int str_cmp_len(const str *a, const char *b, int l) { INLINE int str_cmp_len(const str *a, const char *b, size_t l) {
if (a->len < l) if (a->len < l)
return -1; return -1;
if (a->len > l) if (a->len > l)
@ -217,12 +223,12 @@ INLINE str *str_init(str *out, char *s) {
out->len = s ? strlen(s) : 0; out->len = s ? strlen(s) : 0;
return out; return out;
} }
INLINE str *str_init_len(str *out, char *s, int len) { INLINE str *str_init_len(str *out, char *s, size_t len) {
out->s = s; out->s = s;
out->len = len; out->len = len;
return out; return out;
} }
INLINE str *str_init_len_assert_len(str *out, char *s, int buflen, int len) { INLINE str *str_init_len_assert_len(str *out, char *s, size_t buflen, size_t len) {
assert(buflen >= len); assert(buflen >= len);
return str_init_len(out, s, len); return str_init_len(out, s, len);
} }
@ -252,7 +258,7 @@ INLINE void str_free_dup(str *out) {
out->s = NULL; out->s = NULL;
out->len = 0; out->len = 0;
} }
INLINE str *str_alloc(int len) { INLINE str *str_alloc(size_t len) {
str *r; str *r;
r = malloc(sizeof(*r) + len + 1); r = malloc(sizeof(*r) + len + 1);
r->s = ((char *) r) + sizeof(*r); r->s = ((char *) r) + sizeof(*r);
@ -278,7 +284,8 @@ INLINE str *str_slice_dup(const str *s) {
#define STR_MALLOC_PADDING "xxxxxxxxxxxxxxxx" #define STR_MALLOC_PADDING "xxxxxxxxxxxxxxxx"
INLINE str *__str_vsprintf(const char *fmt, va_list ap) { INLINE str *__str_vsprintf(const char *fmt, va_list ap) {
char *r; char *r;
int l, pl; int l;
size_t pl;
str *ret; str *ret;
l = vasprintf(&r, fmt, ap); l = vasprintf(&r, fmt, ap);
@ -294,7 +301,7 @@ INLINE str *__str_vsprintf(const char *fmt, va_list ap) {
str *__str_sprintf(const char *fmt, ...) __attribute__((format(printf,1,2))); str *__str_sprintf(const char *fmt, ...) __attribute__((format(printf,1,2)));
INLINE GString *g_string_new_str(void) { INLINE GString *g_string_new_str(void) {
int pl; size_t pl;
GString *ret; GString *ret;
ret = g_string_new(""); ret = g_string_new("");
@ -305,7 +312,7 @@ INLINE GString *g_string_new_str(void) {
} }
INLINE str *g_string_free_str(GString *gs) { INLINE str *g_string_free_str(GString *gs) {
str *ret; str *ret;
int pl; size_t pl;
pl = strlen(STR_MALLOC_PADDING); pl = strlen(STR_MALLOC_PADDING);
assert(gs->len >= pl); assert(gs->len >= pl);
@ -385,7 +392,7 @@ INLINE int str_token_sep(str *new_token, str *ori_and_remainder, int sep) {
return 0; return 0;
} }
INLINE int str_uri_encode(char *out, const str *in) { INLINE size_t str_uri_encode(char *out, const str *in) {
return str_uri_encode_len(out, in->s, in->len); return str_uri_encode_len(out, in->s, in->len);
} }

2
t/test-bitstr.c
Unescape View File

@ -70,7 +70,7 @@ int do_test(const char *input, unsigned int input_len,
ret, result, file, line, argc); ret, result, file, line, argc);
if (ret == 0 && output) { if (ret == 0 && output) {
if (outp.len != output_len) if (outp.len != output_len)
err("ERROR output len %i instead of %i (%s:%i arg %i)\n", err("ERROR output len %zu instead of %u (%s:%i arg %i)\n",
outp.len, output_len, file, line, argc); outp.len, output_len, file, line, argc);
if (memcmp(outp.s, output, output_len)) if (memcmp(outp.s, output, output_len))
err("ERROR output string mismatch (%s:%i arg %i)\n", err("ERROR output string mismatch (%s:%i arg %i)\n",

Write Preview
Loading…
Cancel
Save