aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/common/crypto.c72
-rw-r--r--src/common/log.c3
-rw-r--r--src/common/torgzip.c8
-rw-r--r--src/common/tortls.c17
-rw-r--r--src/common/util.c76
5 files changed, 126 insertions, 50 deletions
diff --git a/src/common/crypto.c b/src/common/crypto.c
index 651822254..f896b27a5 100644
--- a/src/common/crypto.c
+++ b/src/common/crypto.c
@@ -325,7 +325,8 @@ static int crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
{
BIO *b;
- tor_assert(env && s);
+ tor_assert(env);
+ tor_assert(s);
/* Create a read-only memory BIO, backed by the nul-terminated string 's' */
b = BIO_new_mem_buf((char*)s, -1);
@@ -381,7 +382,9 @@ int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size
BUF_MEM *buf;
BIO *b;
- tor_assert(env && env->key && dest);
+ tor_assert(env);
+ tor_assert(env->key);
+ tor_assert(dest);
b = BIO_new(BIO_s_mem()); /* Create a memory BIO */
@@ -414,7 +417,8 @@ int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size
int crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src, size_t len) {
BIO *b;
- tor_assert(env && src);
+ tor_assert(env);
+ tor_assert(src);
b = BIO_new(BIO_s_mem()); /* Create a memory BIO */
@@ -479,7 +483,8 @@ int crypto_pk_DER64_encode_public_key(crypto_pk_env_t *env, char **out)
{
int len;
char buf[PK_BYTES*2]; /* Too long, but hey, stacks are big. */
- tor_assert(env && out);
+ tor_assert(env);
+ tor_assert(out);
len = crypto_pk_asn1_encode(env, buf, sizeof(buf));
if (len < 0) {
return -1;
@@ -563,7 +568,8 @@ int crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b) {
/** Return the size of the public key modulus in <b>env</b>, in bytes. */
int crypto_pk_keysize(crypto_pk_env_t *env)
{
- tor_assert(env && env->key);
+ tor_assert(env);
+ tor_assert(env->key);
return RSA_size(env->key);
}
@@ -571,7 +577,8 @@ int crypto_pk_keysize(crypto_pk_env_t *env)
/** Increase the reference count of <b>env</b>, and return it.
*/
crypto_pk_env_t *crypto_pk_dup_key(crypto_pk_env_t *env) {
- tor_assert(env && env->key);
+ tor_assert(env);
+ tor_assert(env->key);
env->refs++;
return env;
@@ -585,7 +592,9 @@ crypto_pk_env_t *crypto_pk_dup_key(crypto_pk_env_t *env) {
int crypto_pk_public_encrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding)
{
int r;
- tor_assert(env && from && to);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
r = RSA_public_encrypt(fromlen, (unsigned char*)from, to, env->key,
crypto_get_rsa_padding(padding));
@@ -604,7 +613,10 @@ int crypto_pk_public_encrypt(crypto_pk_env_t *env, const unsigned char *from, in
int crypto_pk_private_decrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding, int warnOnFailure)
{
int r;
- tor_assert(env && from && to && env->key);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
+ tor_assert(env->key);
if (!env->key->p)
/* Not a private key */
return -1;
@@ -627,7 +639,9 @@ int crypto_pk_private_decrypt(crypto_pk_env_t *env, const unsigned char *from, i
int crypto_pk_public_checksig(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to)
{
int r;
- tor_assert(env && from && to);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
r = RSA_public_decrypt(fromlen, (unsigned char*)from, to, env->key, RSA_PKCS1_PADDING);
if (r<0) {
@@ -645,7 +659,9 @@ int crypto_pk_public_checksig(crypto_pk_env_t *env, const unsigned char *from, i
int crypto_pk_private_sign(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to)
{
int r;
- tor_assert(env && from && to);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
if (!env->key->p)
/* Not a private key */
return -1;
@@ -669,7 +685,9 @@ int crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const unsigned char *
char buf[PK_BYTES+1];
int r;
- tor_assert(env && data && sig);
+ tor_assert(env);
+ tor_assert(data);
+ tor_assert(sig);
if (crypto_digest(data,datalen,digest)<0) {
log_fn(LOG_WARN, "couldn't compute digest");
@@ -728,7 +746,9 @@ int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
crypto_cipher_env_t *cipher = NULL;
char buf[PK_BYTES+1];
- tor_assert(env && from && to);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
overhead = crypto_get_rsa_padding_overhead(crypto_get_rsa_padding(padding));
pkeylen = crypto_pk_keysize(env);
@@ -964,7 +984,8 @@ int crypto_cipher_generate_key(crypto_cipher_env_t *env)
*/
int crypto_cipher_set_key(crypto_cipher_env_t *env, const unsigned char *key)
{
- tor_assert(env && key);
+ tor_assert(env);
+ tor_assert(key);
if (!env->key)
return -1;
@@ -1009,7 +1030,11 @@ int crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env)
*/
int crypto_cipher_encrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to)
{
- tor_assert(env && env->cipher && from && fromlen && to);
+ tor_assert(env);
+ tor_assert(env->cipher);
+ tor_assert(from);
+ tor_assert(fromlen);
+ tor_assert(to);
aes_crypt(env->cipher, from, fromlen, to);
return 0;
@@ -1021,7 +1046,9 @@ int crypto_cipher_encrypt(crypto_cipher_env_t *env, const unsigned char *from, u
*/
int crypto_cipher_decrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to)
{
- tor_assert(env && from && to);
+ tor_assert(env);
+ tor_assert(from);
+ tor_assert(to);
aes_crypt(env->cipher, from, fromlen, to);
return 0;
@@ -1054,7 +1081,8 @@ crypto_cipher_advance(crypto_cipher_env_t *env, long delta)
*/
int crypto_digest(const unsigned char *m, int len, unsigned char *digest)
{
- tor_assert(m && digest);
+ tor_assert(m);
+ tor_assert(digest);
return (SHA1(m,len,digest) == NULL);
}
@@ -1105,7 +1133,8 @@ void crypto_digest_get_digest(crypto_digest_env_t *digest,
{
static char r[DIGEST_LEN];
SHA_CTX tmpctx;
- tor_assert(digest && out);
+ tor_assert(digest);
+ tor_assert(out);
tor_assert(out_len <= DIGEST_LEN);
/* memcpy into a temporary ctx, since SHA1_Final clears the context */
memcpy(&tmpctx, &digest->d, sizeof(SHA_CTX));
@@ -1133,7 +1162,8 @@ void
crypto_digest_assign(crypto_digest_env_t *into,
const crypto_digest_env_t *from)
{
- tor_assert(into && from);
+ tor_assert(into);
+ tor_assert(from);
memcpy(into,from,sizeof(crypto_digest_env_t));
}
@@ -1154,7 +1184,8 @@ static void init_dh_param() {
p = BN_new();
g = BN_new();
- tor_assert(p && g);
+ tor_assert(p);
+ tor_assert(g);
#if 0
/* This is from draft-ietf-ipsec-ike-modp-groups-05.txt. It's a safe
@@ -1325,7 +1356,8 @@ int crypto_dh_compute_secret(crypto_dh_env_t *dh,
*/
void crypto_dh_free(crypto_dh_env_t *dh)
{
- tor_assert(dh && dh->dh);
+ tor_assert(dh);
+ tor_assert(dh->dh);
DH_free(dh->dh);
free(dh);
}
diff --git a/src/common/log.c b/src/common/log.c
index 1a91d072a..07a83e36f 100644
--- a/src/common/log.c
+++ b/src/common/log.c
@@ -233,7 +233,8 @@ static void delete_log(logfile_t *victim) {
logfiles = victim->next;
else {
for(tmpl = logfiles; tmpl && tmpl->next != victim; tmpl=tmpl->next) ;
- tor_assert(tmpl && tmpl->next == victim);
+ tor_assert(tmpl);
+ tor_assert(tmpl->next == victim);
tmpl->next = victim->next;
}
tor_free(victim->filename);
diff --git a/src/common/torgzip.c b/src/common/torgzip.c
index 4bd438197..660ab0e05 100644
--- a/src/common/torgzip.c
+++ b/src/common/torgzip.c
@@ -53,7 +53,9 @@ tor_gzip_compress(char **out, size_t *out_len,
size_t out_size;
off_t offset;
- tor_assert(out && out_len && in);
+ tor_assert(out);
+ tor_assert(out_len);
+ tor_assert(in);
if (method == GZIP_METHOD && !is_gzip_supported()) {
/* Old zlib version don't support gzip in deflateInit2 */
@@ -136,7 +138,9 @@ tor_gzip_uncompress(char **out, size_t *out_len,
size_t out_size;
off_t offset;
- tor_assert(out && out_len && in);
+ tor_assert(out);
+ tor_assert(out_len);
+ tor_assert(in);
if (method == GZIP_METHOD && !is_gzip_supported()) {
/* Old zlib version don't support gzip in inflateInit2 */
diff --git a/src/common/tortls.c b/src/common/tortls.c
index 306d9f55e..63924c26f 100644
--- a/src/common/tortls.c
+++ b/src/common/tortls.c
@@ -191,7 +191,10 @@ tor_tls_create_certificate(crypto_pk_env_t *rsa,
start_time = time(NULL);
- tor_assert(rsa && cname && rsa_sign && cname_sign);
+ tor_assert(rsa);
+ tor_assert(cname);
+ tor_assert(rsa_sign);
+ tor_assert(cname_sign);
if (!(sign_pkey = _crypto_pk_env_get_evp_pkey(rsa_sign,1)))
goto error;
if (!(pkey = _crypto_pk_env_get_evp_pkey(rsa,0)))
@@ -432,7 +435,8 @@ int
tor_tls_read(tor_tls *tls, char *cp, size_t len)
{
int r, err;
- tor_assert(tls && tls->ssl);
+ tor_assert(tls);
+ tor_assert(tls->ssl);
tor_assert(tls->state == TOR_TLS_ST_OPEN);
r = SSL_read(tls->ssl, cp, len);
if (r > 0)
@@ -457,7 +461,8 @@ int
tor_tls_write(tor_tls *tls, char *cp, size_t n)
{
int r, err;
- tor_assert(tls && tls->ssl);
+ tor_assert(tls);
+ tor_assert(tls->ssl);
tor_assert(tls->state == TOR_TLS_ST_OPEN);
if (n == 0)
return 0;
@@ -489,7 +494,8 @@ int
tor_tls_handshake(tor_tls *tls)
{
int r;
- tor_assert(tls && tls->ssl);
+ tor_assert(tls);
+ tor_assert(tls->ssl);
tor_assert(tls->state == TOR_TLS_ST_HANDSHAKE);
if (tls->isServer) {
r = SSL_accept(tls->ssl);
@@ -512,7 +518,8 @@ tor_tls_shutdown(tor_tls *tls)
{
int r, err;
char buf[128];
- tor_assert(tls && tls->ssl);
+ tor_assert(tls);
+ tor_assert(tls->ssl);
while (1) {
if (tls->state == TOR_TLS_ST_SENTCLOSE) {
diff --git a/src/common/util.c b/src/common/util.c
index 39c7311e6..601eea35e 100644
--- a/src/common/util.c
+++ b/src/common/util.c
@@ -234,7 +234,9 @@ int tor_strpartition(char *dest, size_t dest_len,
char *destp;
size_t len_in, len_out, len_ins;
int is_even, remaining;
- tor_assert(s && insert && n > 0);
+ tor_assert(s);
+ tor_assert(insert);
+ tor_assert(n > 0);
len_in = strlen(s);
len_ins = strlen(insert);
len_out = len_in + (len_in/n)*len_ins;
@@ -487,7 +489,9 @@ void *smartlist_choose(const smartlist_t *sl) {
*/
void *smartlist_get(const smartlist_t *sl, int idx)
{
- tor_assert(sl && idx>=0 && idx < sl->num_used);
+ tor_assert(sl);
+ tor_assert(idx>=0);
+ tor_assert(idx < sl->num_used);
return sl->list[idx];
}
/** Change the value of the <b>idx</b>th element of sl to <b>val</b>; return the old
@@ -496,7 +500,9 @@ void *smartlist_get(const smartlist_t *sl, int idx)
void *smartlist_set(smartlist_t *sl, int idx, void *val)
{
void *old;
- tor_assert(sl && idx>=0 && idx < sl->num_used);
+ tor_assert(sl);
+ tor_assert(idx>=0);
+ tor_assert(idx < sl->num_used);
old = sl->list[idx];
sl->list[idx] = val;
return old;
@@ -508,7 +514,9 @@ void *smartlist_set(smartlist_t *sl, int idx, void *val)
void *smartlist_del(smartlist_t *sl, int idx)
{
void *old;
- tor_assert(sl && idx>=0 && idx < sl->num_used);
+ tor_assert(sl);
+ tor_assert(idx>=0);
+ tor_assert(idx < sl->num_used);
old = sl->list[idx];
sl->list[idx] = sl->list[--sl->num_used];
return old;
@@ -520,7 +528,9 @@ void *smartlist_del(smartlist_t *sl, int idx)
void *smartlist_del_keeporder(smartlist_t *sl, int idx)
{
void *old;
- tor_assert(sl && idx>=0 && idx < sl->num_used);
+ tor_assert(sl);
+ tor_assert(idx>=0);
+ tor_assert(idx < sl->num_used);
old = sl->list[idx];
--sl->num_used;
if (idx < sl->num_used)
@@ -539,7 +549,9 @@ int smartlist_len(const smartlist_t *sl)
*/
void smartlist_insert(smartlist_t *sl, int idx, void *val)
{
- tor_assert(sl && idx >= 0 && idx <= sl->num_used);
+ tor_assert(sl);
+ tor_assert(idx>=0);
+ tor_assert(idx < sl->num_used);
if (idx == sl->num_used) {
smartlist_add(sl, val);
} else {
@@ -572,7 +584,9 @@ int smartlist_split_string(smartlist_t *sl, const char *str, const char *sep,
const char *cp, *end, *next;
int n = 0;
- tor_assert(sl && str && sep);
+ tor_assert(sl);
+ tor_assert(str);
+ tor_assert(sep);
cp = str;
while (1) {
@@ -619,8 +633,9 @@ char *smartlist_join_strings(smartlist_t *sl, const char *join, int terminate)
int i;
size_t n = 0, jlen;
char *r = NULL, *dst, *src;
-
- tor_assert(sl && join);
+
+ tor_assert(sl);
+ tor_assert(join);
jlen = strlen(join);
for (i = 0; i < sl->num_used; ++i) {
n += strlen(sl->list[i]);
@@ -681,7 +696,9 @@ void* strmap_set(strmap_t *map, const char *key, void *val)
strmap_entry_t *resolve;
strmap_entry_t search;
void *oldval;
- tor_assert(map && key && val);
+ tor_assert(map);
+ tor_assert(key);
+ tor_assert(val);
search.key = (char*)key;
resolve = SPLAY_FIND(strmap_tree, &map->head, &search);
if (resolve) {
@@ -704,7 +721,8 @@ void* strmap_get(strmap_t *map, const char *key)
{
strmap_entry_t *resolve;
strmap_entry_t search;
- tor_assert(map && key);
+ tor_assert(map);
+ tor_assert(key);
search.key = (char*)key;
resolve = SPLAY_FIND(strmap_tree, &map->head, &search);
if (resolve) {
@@ -725,7 +743,8 @@ void* strmap_remove(strmap_t *map, const char *key)
strmap_entry_t *resolve;
strmap_entry_t search;
void *oldval;
- tor_assert(map && key);
+ tor_assert(map);
+ tor_assert(key);
search.key = (char*)key;
resolve = SPLAY_FIND(strmap_tree, &map->head, &search);
if (resolve) {
@@ -804,7 +823,8 @@ void strmap_foreach(strmap_t *map,
void *data)
{
strmap_entry_t *ptr, *next;
- tor_assert(map && fn);
+ tor_assert(map);
+ tor_assert(fn);
for (ptr = SPLAY_MIN(strmap_tree, &map->head); ptr != NULL; ptr = next) {
/* This remove-in-place usage is specifically blessed in tree(3). */
next = SPLAY_NEXT(strmap_tree, &map->head, ptr);
@@ -852,7 +872,8 @@ strmap_iter_t *strmap_iter_init(strmap_t *map)
*/
strmap_iter_t *strmap_iter_next(strmap_t *map, strmap_iter_t *iter)
{
- tor_assert(map && iter);
+ tor_assert(map);
+ tor_assert(iter);
return SPLAY_NEXT(strmap_tree, &map->head, iter);
}
/** Advance the iterator <b>iter</b> a single step to the next entry, removing
@@ -861,7 +882,8 @@ strmap_iter_t *strmap_iter_next(strmap_t *map, strmap_iter_t *iter)
strmap_iter_t *strmap_iter_next_rmv(strmap_t *map, strmap_iter_t *iter)
{
strmap_iter_t *next;
- tor_assert(map && iter);
+ tor_assert(map);
+ tor_assert(iter);
next = SPLAY_NEXT(strmap_tree, &map->head, iter);
SPLAY_REMOVE(strmap_tree, &map->head, iter);
tor_free(iter->key);
@@ -872,7 +894,9 @@ strmap_iter_t *strmap_iter_next_rmv(strmap_t *map, strmap_iter_t *iter)
*/
void strmap_iter_get(strmap_iter_t *iter, const char **keyp, void **valp)
{
- tor_assert(iter && keyp && valp);
+ tor_assert(iter);
+ tor_assert(keyp);
+ tor_assert(valp);
*keyp = iter->key;
*valp = iter->val;
}
@@ -1069,7 +1093,8 @@ time_t tor_timegm (struct tm *tm) {
int i;
year = tm->tm_year + 1900;
tor_assert(year >= 1970);
- tor_assert(tm->tm_mon >= 0 && tm->tm_mon <= 11);
+ tor_assert(tm->tm_mon >= 0);
+ tor_assert(tm->tm_mon <= 11);
days = 365 * (year-1970) + n_leapdays(1970,year);
for (i = 0; i < tm->tm_mon; ++i)
days += days_per_month[i];
@@ -1094,9 +1119,11 @@ void format_rfc1123_time(char *buf, time_t t) {
struct tm *tm = gmtime(&t);
strftime(buf, RFC1123_TIME_LEN+1, "XXX, %d XXX %Y %H:%M:%S GMT", tm);
- tor_assert(tm->tm_wday >= 0 && tm->tm_wday <= 6);
+ tor_assert(tm->tm_wday >= 0);
+ tor_assert(tm->tm_wday <= 6);
memcpy(buf, WEEKDAY_NAMES[tm->tm_wday], 3);
- tor_assert(tm->tm_wday >= 0 && tm->tm_mon <= 11);
+ tor_assert(tm->tm_wday >= 0);
+ tor_assert(tm->tm_mon <= 11);
memcpy(buf+8, MONTH_NAMES[tm->tm_mon], 3);
}
@@ -2010,7 +2037,8 @@ int tor_inet_aton(const char *c, struct in_addr* addr)
return inet_aton(c, addr);
#else
uint32_t r;
- tor_assert(c && addr);
+ tor_assert(c);
+ tor_assert(addr);
if (strcmp(c, "255.255.255.255") == 0) {
addr->s_addr = 0xFFFFFFFFu;
return 1;
@@ -2132,8 +2160,12 @@ parse_addr_and_port_range(const char *s, uint32_t *addr_out,
struct in_addr in;
int bits;
- tor_assert(s && addr_out && mask_out && port_min_out && port_max_out);
-
+ tor_assert(s);
+ tor_assert(addr_out);
+ tor_assert(mask_out);
+ tor_assert(port_min_out);
+ tor_assert(port_max_out);
+
address = tor_strdup(s);
/* Break 'address' into separate strings.
*/
generated by cgit v1.2.3 (git 2.45.0) at 2024-12-28 20:31:35 +0000