nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-10 21:23:58 +01:00
Code Issues Packages Projects Releases Wiki Activity

Reformat inconsistent function declarations.

Browse Source 
svn:r5160
This commit is contained in:
Nick Mathewson 2005-09-30 01:09:52 +00:00
parent 6ce1add8da
commit 92451f74a8
20 changed files with 368 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/common/aes.c
View File

@ -608,7 +608,9 @@ static const u32 rcon[] = {
*
* @return the number of rounds for the given cipher key size.
*/
int rijndaelKeySetupEnc(u32 rk[/*4*(Nr + 1)*/], const u8 cipherKey[], int keyBits) {
int
rijndaelKeySetupEnc(u32 rk[/*4*(Nr + 1)*/], const u8 cipherKey[], int keyBits)
{
int i = 0;
u32 temp;
@ -689,7 +691,9 @@ int rijndaelKeySetupEnc(u32 rk[/*4*(Nr + 1)*/], const u8 cipherKey[], int keyBit
return 0;
}
void rijndaelEncrypt(const u32 rk[/*4*(Nr + 1)*/], int Nr, const u8 pt[16], u8 ct[16]) {
void
rijndaelEncrypt(const u32 rk[/*4*(Nr + 1)*/], int Nr, const u8 pt[16], u8 ct[16])
{
u32 s0, s1, s2, s3, t0, t1, t2, t3;
#ifndef FULL_UNROLL
int r;

9
src/common/compat.c
View File

@ -440,7 +440,8 @@ tor_socketpair(int family, int type, int protocol, int fd[2])
* have a low soft limit.) Make sure we set it to at least
* <b>limit</b>. Return a new limit if we can, or -1 if we fail. */
int
set_max_file_descriptors(unsigned long limit, unsigned long cap) {
set_max_file_descriptors(unsigned long limit, unsigned long cap)
{
#ifndef HAVE_GETRLIMIT
log_fn(LOG_INFO,"This platform is missing getrlimit(). Proceeding.");
if (limit > cap) {
@ -488,7 +489,8 @@ set_max_file_descriptors(unsigned long limit, unsigned long cap) {
* success. On failure, log and return -1.
*/
int
switch_id(char *user, char *group) {
switch_id(char *user, char *group)
{
#ifndef MS_WINDOWS
struct passwd *pw = NULL;
struct group *gr = NULL;
@ -1041,7 +1043,8 @@ struct tor_mutex_t {
* socket to get the error.
*/
#ifdef MS_WINDOWS
int tor_socket_errno(int sock)
int
tor_socket_errno(int sock)
{
int optval, optvallen=sizeof(optval);
int err = WSAGetLastError();

16
src/common/container.c
View File

@ -43,7 +43,8 @@ struct smartlist_t {
/** Allocate and return an empty smartlist.
*/
smartlist_t *
smartlist_create(void) {
smartlist_create(void)
{
smartlist_t *sl = tor_malloc(sizeof(smartlist_t));
sl->num_used = 0;
sl->capacity = SMARTLIST_DEFAULT_CAPACITY;
@ -55,7 +56,8 @@ smartlist_create(void) {
* list's elements.
*/
void
smartlist_free(smartlist_t *sl) {
smartlist_free(smartlist_t *sl)
{
free(sl->list);
free(sl);
}
@ -66,7 +68,9 @@ smartlist_free(smartlist_t *sl) {
* currently in the list, reduce the list's capacity as much as
* possible without losing elements.
*/
void smartlist_set_capacity(smartlist_t *sl, int n) {
void
smartlist_set_capacity(smartlist_t *sl, int n)
{
if (n < sl->num_used)
n = sl->num_used;
if (sl->capacity != n) {
@ -78,7 +82,8 @@ void smartlist_set_capacity(smartlist_t *sl, int n) {
/** Remove all elements from the list.
*/
void
smartlist_clear(smartlist_t *sl) {
smartlist_clear(smartlist_t *sl)
{
sl->num_used = 0;
}
@ -95,7 +100,8 @@ smartlist_truncate(smartlist_t *sl, int len)
/** Append element to the end of the list. */
void
smartlist_add(smartlist_t *sl, void *element) {
smartlist_add(smartlist_t *sl, void *element)
{
if (sl->num_used >= sl->capacity) {
int higher = sl->capacity * 2;
tor_assert(higher > sl->capacity); /* detect overflow */

164
src/common/crypto.c
View File

@ -119,7 +119,8 @@ static int tor_check_dh_key(BIGNUM *bn);
/** Return the number of bytes added by padding method <b>padding</b>.
*/
static INLINE int
crypto_get_rsa_padding_overhead(int padding) {
crypto_get_rsa_padding_overhead(int padding)
{
switch (padding)
{
case RSA_NO_PADDING: return 0;
@ -132,7 +133,8 @@ crypto_get_rsa_padding_overhead(int padding) {
/** Given a padding method <b>padding</b>, return the correct OpenSSL constant.
*/
static INLINE int
crypto_get_rsa_padding(int padding) {
crypto_get_rsa_padding(int padding)
{
switch (padding)
{
case PK_NO_PADDING: return RSA_NO_PADDING;
@ -216,7 +218,8 @@ crypto_global_init(int useAccel)
/** Uninitialize the crypto library. Return 0 on success, -1 on failure.
*/
int crypto_global_cleanup(void)
int
crypto_global_cleanup(void)
{
ERR_free_strings();
#ifndef NO_ENGINES
@ -304,7 +307,8 @@ crypto_pk_env_t *crypto_new_pk_env(void)
/** Release a reference to an asymmetric key; when all the references
* are released, free the key.
*/
void crypto_free_pk_env(crypto_pk_env_t *env)
void
crypto_free_pk_env(crypto_pk_env_t *env)
{
tor_assert(env);
@ -365,7 +369,8 @@ crypto_cipher_env_t *crypto_new_cipher_env(void)
/** Free a symmetric cipher.
*/
void crypto_free_cipher_env(crypto_cipher_env_t *env)
void
crypto_free_cipher_env(crypto_cipher_env_t *env)
{
tor_assert(env);
@ -379,7 +384,8 @@ void crypto_free_cipher_env(crypto_cipher_env_t *env)
/** Generate a new public/private keypair in <b>env</b>. Return 0 on
* success, -1 on failure.
*/
int crypto_pk_generate_key(crypto_pk_env_t *env)
int
crypto_pk_generate_key(crypto_pk_env_t *env)
{
tor_assert(env);
@ -397,8 +403,9 @@ int crypto_pk_generate_key(crypto_pk_env_t *env)
/** Read a PEM-encoded private key from the string <b>s</b> into <b>env</b>.
* Return 0 on success, -1 on failure.
*/
static int crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
const char *s)
static int
crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
const char *s)
{
BIO *b;
@ -425,7 +432,8 @@ static int crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
/** Read a PEM-encoded private key from the file named by
* <b>keyfile</b> into <b>env</b>. Return 0 on success, -1 on failure.
*/
int crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, const char *keyfile)
int
crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, const char *keyfile)
{
char *contents;
int r;
@ -455,7 +463,9 @@ int crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, const char *k
* string, *<b>len</b> to the string's length, and return 0. On
* failure, return -1.
*/
int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size_t *len) {
int
crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size_t *len)
{
BUF_MEM *buf;
BIO *b;
@ -491,7 +501,9 @@ int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size
* <b>src</b>, and store the result in <b>env</b>. Return 0 on success, -1 on
* failure.
*/
int crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src, size_t len) {
int
crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src, size_t len)
{
BIO *b;
tor_assert(env);
@ -556,7 +568,8 @@ crypto_pk_write_private_key_to_filename(crypto_pk_env_t *env,
* directories containing "opt keyword\n-----BEGIN OBJECT----" entries
* in versions of Tor up to 0.0.9pre2.</i>
*/
int crypto_pk_DER64_encode_public_key(crypto_pk_env_t *env, char **out)
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. */
@ -585,7 +598,8 @@ int crypto_pk_DER64_encode_public_key(crypto_pk_env_t *env, char **out)
* directories containing "opt keyword\n-----BEGIN OBJECT----" entries
* in versions of Tor up to 0.0.9pre2.</i>
*/
crypto_pk_env_t *crypto_pk_DER64_decode_public_key(const char *in)
crypto_pk_env_t *
crypto_pk_DER64_decode_public_key(const char *in)
{
char partitioned[PK_BYTES*2 + 16];
char buf[PK_BYTES*2];
@ -611,7 +625,8 @@ crypto_pk_env_t *crypto_pk_DER64_decode_public_key(const char *in)
/** Return true iff <b>env</b> has a valid key.
*/
int crypto_pk_check_key(crypto_pk_env_t *env)
int
crypto_pk_check_key(crypto_pk_env_t *env)
{
int r;
tor_assert(env);
@ -625,7 +640,9 @@ int crypto_pk_check_key(crypto_pk_env_t *env)
/** Compare the public-key components of a and b. Return -1 if a\<b, 0
* if a==b, and 1 if a\>b.
*/
int crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b) {
int
crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b)
{
int result;
if (!a || !b)
@ -643,7 +660,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. */
size_t crypto_pk_keysize(crypto_pk_env_t *env)
size_t
crypto_pk_keysize(crypto_pk_env_t *env)
{
tor_assert(env);
tor_assert(env->key);
@ -653,7 +671,9 @@ size_t 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) {
crypto_pk_env_t *
crypto_pk_dup_key(crypto_pk_env_t *env)
{
tor_assert(env);
tor_assert(env->key);
@ -827,11 +847,12 @@ crypto_pk_private_sign_digest(crypto_pk_env_t *env, char *to,
* padded and encrypted with the public key; followed by the rest of
* the source data encrypted in AES-CTR mode with the symmetric key.
*/
int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
char *to,
const char *from,
size_t fromlen,
int padding, int force)
int
crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
char *to,
const char *from,
size_t fromlen,
int padding, int force)
{
int overhead, outlen, r, symlen;
size_t pkeylen;
@ -890,11 +911,12 @@ int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
}
/** Invert crypto_pk_public_hybrid_encrypt. */
int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
char *to,
const char *from,
size_t fromlen,
int padding, int warnOnFailure)
int
crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
char *to,
const char *from,
size_t fromlen,
int padding, int warnOnFailure)
{
int overhead, outlen, r;
size_t pkeylen;
@ -937,7 +959,8 @@ int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
/** ASN.1-encode the public portion of <b>pk</b> into <b>dest</b>.
* Return -1 on error, or the number of characters used on success.
*/
int crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, int dest_len)
int
crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, int dest_len)
{
int len;
unsigned char *buf, *cp;
@ -962,7 +985,8 @@ int crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, int dest_len)
/** Decode an ASN.1-encoded public key from <b>str</b>; return the result on
* success and NULL on failure.
*/
crypto_pk_env_t *crypto_pk_asn1_decode(const char *str, size_t len)
crypto_pk_env_t *
crypto_pk_asn1_decode(const char *str, size_t len)
{
RSA *rsa;
unsigned char *buf;
@ -989,7 +1013,8 @@ crypto_pk_env_t *crypto_pk_asn1_decode(const char *str, size_t len)
* public key into <b>digest_out</b> (must have DIGEST_LEN bytes of space).
* Return 0 on success, -1 on failure.
*/
int crypto_pk_get_digest(crypto_pk_env_t *pk, char *digest_out)
int
crypto_pk_get_digest(crypto_pk_env_t *pk, char *digest_out)
{
unsigned char *buf, *bufp;
int len;
@ -1063,7 +1088,8 @@ crypto_pk_check_fingerprint_syntax(const char *s)
/** Generate a new random key for the symmetric cipher in <b>env</b>.
* Return 0 on success, -1 on failure. Does not initialize the cipher.
*/
int crypto_cipher_generate_key(crypto_cipher_env_t *env)
int
crypto_cipher_generate_key(crypto_cipher_env_t *env)
{
tor_assert(env);
@ -1074,7 +1100,8 @@ int crypto_cipher_generate_key(crypto_cipher_env_t *env)
* CIPHER_KEY_LEN bytes of <b>key</b>. Does not initialize the cipher.
* Return 0 on success, -1 on failure.
*/
int crypto_cipher_set_key(crypto_cipher_env_t *env, const char *key)
int
crypto_cipher_set_key(crypto_cipher_env_t *env, const char *key)
{
tor_assert(env);
tor_assert(key);
@ -1089,7 +1116,8 @@ int crypto_cipher_set_key(crypto_cipher_env_t *env, const char *key)
/** Return a pointer to the key set for the cipher in <b>env</b>.
*/
const char *crypto_cipher_get_key(crypto_cipher_env_t *env)
const char *
crypto_cipher_get_key(crypto_cipher_env_t *env)
{
return env->key;
}
@ -1097,7 +1125,8 @@ const char *crypto_cipher_get_key(crypto_cipher_env_t *env)
/** Initialize the cipher in <b>env</b> for encryption. Return 0 on
* success, -1 on failure.
*/
int crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env)
int
crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env)
{
tor_assert(env);
@ -1108,7 +1137,8 @@ int crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env)
/** Initialize the cipher in <b>env</b> for decryption. Return 0 on
* success, -1 on failure.
*/
int crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env)
int
crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env)
{
tor_assert(env);
@ -1175,7 +1205,8 @@ crypto_cipher_advance(crypto_cipher_env_t *env, long delta)
* <b>m</b>. Write the DIGEST_LEN byte result into <b>digest</b>.
* Return 0 on success, -1 on failure.
*/
int crypto_digest(char *digest, const char *m, size_t len)
int
crypto_digest(char *digest, const char *m, size_t len)
{
tor_assert(m);
tor_assert(digest);
@ -1200,7 +1231,8 @@ crypto_new_digest_env(void)
/** Deallocate a digest object.
*/
void
crypto_free_digest_env(crypto_digest_env_t *digest) {
crypto_free_digest_env(crypto_digest_env_t *digest)
{
tor_free(digest);
}
@ -1224,8 +1256,9 @@ crypto_digest_add_bytes(crypto_digest_env_t *digest, const char *data,
* object; write the first out_len bytes of the result to <b>out</b>.
* <b>out_len</b> must be \<= DIGEST_LEN.
*/
void crypto_digest_get_digest(crypto_digest_env_t *digest,
char *out, size_t out_len)
void
crypto_digest_get_digest(crypto_digest_env_t *digest,
char *out, size_t out_len)
{
static unsigned char r[DIGEST_LEN];
SHA_CTX tmpctx;
@ -1272,7 +1305,9 @@ static BIGNUM *dh_param_g = NULL;
/** Initialize dh_param_p and dh_param_g if they are not already
* set. */
static void init_dh_param(void) {
static void
init_dh_param(void)
{
BIGNUM *p, *g;
int r;
if (dh_param_p && dh_param_g)
@ -1303,7 +1338,8 @@ static void init_dh_param(void) {
/** Allocate and return a new DH object for a key exchange.
*/
crypto_dh_env_t *crypto_dh_new(void)
crypto_dh_env_t *
crypto_dh_new(void)
{
crypto_dh_env_t *res = NULL;
@ -1331,7 +1367,8 @@ crypto_dh_env_t *crypto_dh_new(void)
/** Return the length of the DH key in <b>dh</b>, in bytes.
*/
int crypto_dh_get_bytes(crypto_dh_env_t *dh)
int
crypto_dh_get_bytes(crypto_dh_env_t *dh)
{
tor_assert(dh);
return DH_size(dh->dh);
@ -1340,7 +1377,8 @@ int crypto_dh_get_bytes(crypto_dh_env_t *dh)
/** Generate \<x,g^x\> for our part of the key exchange. Return 0 on
* success, -1 on failure.
*/
int crypto_dh_generate_public(crypto_dh_env_t *dh)
int
crypto_dh_generate_public(crypto_dh_env_t *dh)
{
again:
if (!DH_generate_key(dh->dh)) {
@ -1362,7 +1400,8 @@ int crypto_dh_generate_public(crypto_dh_env_t *dh)
* as a <b>pubkey_len</b>-byte value into <b>pubkey</b>. Return 0 on
* success, -1 on failure. <b>pubkey_len</b> must be \>= DH_BYTES.
*/
int crypto_dh_get_public(crypto_dh_env_t *dh, char *pubkey, size_t pubkey_len)
int
crypto_dh_get_public(crypto_dh_env_t *dh, char *pubkey, size_t pubkey_len)
{
int bytes;
tor_assert(dh);
@ -1454,9 +1493,10 @@ tor_check_dh_key(BIGNUM *bn)
* SHA1( g^xy || "\x00" ) || SHA1( g^xy || "\x01" ) || ...
* where || is concatenation.)
*/
int crypto_dh_compute_secret(crypto_dh_env_t *dh,
const char *pubkey, size_t pubkey_len,
char *secret_out, size_t secret_bytes_out)
int
crypto_dh_compute_secret(crypto_dh_env_t *dh,
const char *pubkey, size_t pubkey_len,
char *secret_out, size_t secret_bytes_out)
{
char hash[DIGEST_LEN];
char *secret_tmp = NULL;
@ -1512,7 +1552,8 @@ int crypto_dh_compute_secret(crypto_dh_env_t *dh,
/** Free a DH key exchange object.
*/
void crypto_dh_free(crypto_dh_env_t *dh)
void
crypto_dh_free(crypto_dh_env_t *dh)
{
tor_assert(dh);
tor_assert(dh->dh);
@ -1525,7 +1566,8 @@ void crypto_dh_free(crypto_dh_env_t *dh)
/** Seed OpenSSL's random number generator with DIGEST_LEN bytes from the
* operating system. Return 0 on success, -1 on failure.
*/
int crypto_seed_rng(void)
int
crypto_seed_rng(void)
{
#ifdef MS_WINDOWS
static int provider_set = 0;
@ -1580,7 +1622,8 @@ int crypto_seed_rng(void)
/** Write n bytes of strong random data to <b>to</b>. Return 0 on
* success, -1 on failure.
*/
int crypto_rand(char *to, size_t n)
int
crypto_rand(char *to, size_t n)
{
int r;
tor_assert(to);
@ -1593,7 +1636,8 @@ int crypto_rand(char *to, size_t n)
/** Write n bytes of pseudorandom data to <b>to</b>. Return 0 on
* success, -1 on failure.
*/
void crypto_pseudo_rand(char *to, size_t n)
void
crypto_pseudo_rand(char *to, size_t n)
{
tor_assert(to);
if (RAND_pseudo_bytes((unsigned char*)to, n) == -1) {
@ -1605,7 +1649,9 @@ void crypto_pseudo_rand(char *to, size_t n)
/** Return a pseudorandom integer, chosen uniformly from the values
* between 0 and max-1. */
int crypto_pseudo_rand_int(unsigned int max) {
int
crypto_pseudo_rand_int(unsigned int max)
{
unsigned int val;
unsigned int cutoff;
tor_assert(max < UINT_MAX);
@ -1625,7 +1671,9 @@ int crypto_pseudo_rand_int(unsigned int max) {
/** Return a randomly chosen element of sl; or NULL if sl is empty.
*/
void *smartlist_choose(const smartlist_t *sl) {
void *
smartlist_choose(const smartlist_t *sl)
{
size_t len;
len = smartlist_len(sl);
if (len)
@ -1793,8 +1841,10 @@ _openssl_locking_cb(int mode, int n, const char *file, int line)
else
tor_mutex_release(_openssl_mutexes[n]);
}
static int
setup_openssl_threading(void) {
setup_openssl_threading(void)
{
int i;
int n = CRYPTO_num_locks();
_n_openssl_mutexes = n;
@ -1806,6 +1856,10 @@ setup_openssl_threading(void) {
return 0;
}
#else
static int setup_openssl_threading(void) { return 0; }
static int
setup_openssl_threading(void)
{
return 0;
}
#endif

94
src/common/log.c
View File

@ -46,7 +46,9 @@ typedef struct logfile_t {
} logfile_t;
/** Helper: map a log severity to descriptive string. */
static INLINE const char *sev_to_string(int severity) {
static INLINE const char *
sev_to_string(int severity)
{
switch (severity) {
case LOG_DEBUG: return "debug";
case LOG_INFO: return "info";
@ -97,7 +99,8 @@ _log_prefix(char *buf, size_t buf_len, int severity)
*
* Return -1 if the log is broken and needs to be deleted, else return 0.
*/
static int log_tor_version(logfile_t *lf, int reset)
static int
log_tor_version(logfile_t *lf, int reset)
{
char buf[256];
size_t n;
@ -132,9 +135,10 @@ static int log_tor_version(logfile_t *lf, int reset)
* than once.) Return a pointer to the first character of the message
* portion of the formatted string.
*/
static INLINE char *format_msg(char *buf, size_t buf_len,
int severity, const char *funcname,
const char *format, va_list ap)
static INLINE char *
format_msg(char *buf, size_t buf_len,
int severity, const char *funcname,
const char *format, va_list ap)
{
size_t n;
int r;
@ -228,7 +232,8 @@ logv(int severity, const char *funcname, const char *format, va_list ap)
}
/** Output a message to the log. */
void _log(int severity, const char *format, ...)
void
_log(int severity, const char *format, ...)
{
va_list ap;
va_start(ap,format);
@ -238,7 +243,8 @@ void _log(int severity, const char *format, ...)
/** Output a message to the log, prefixed with a function name <b>fn</b>. */
#ifdef __GNUC__
void _log_fn(int severity, const char *fn, const char *format, ...)
void
_log_fn(int severity, const char *fn, const char *format, ...)
{
va_list ap;
va_start(ap,format);
@ -247,7 +253,8 @@ void _log_fn(int severity, const char *fn, const char *format, ...)
}
#else
const char *_log_fn_function_name=NULL;
void _log_fn(int severity, const char *format, ...)
void
_log_fn(int severity, const char *format, ...)
{
va_list ap;
va_start(ap,format);
@ -258,7 +265,8 @@ void _log_fn(int severity, const char *format, ...)
#endif
/** Close all open log files. */
void close_logs(void)
void
close_logs(void)
{
logfile_t *victim;
while (logfiles) {
@ -271,7 +279,8 @@ void close_logs(void)
}
/** Close and re-open all log files; used to rotate logs on SIGHUP. */
void reset_logs(void)
void
reset_logs(void)
{
logfile_t *lf = logfiles;
while (lf) {
@ -291,7 +300,9 @@ void reset_logs(void)
* called). After this function is called, the caller shouldn't refer
* to <b>victim</b> anymore.
*/
static void delete_log(logfile_t *victim) {
static void
delete_log(logfile_t *victim)
{
logfile_t *tmpl;
if (victim == logfiles)
logfiles = victim->next;
@ -307,7 +318,8 @@ static void delete_log(logfile_t *victim) {
/** Helper: release system resources (but not memory) held by a single
* logfile_t. */
static void close_log(logfile_t *victim)
static void
close_log(logfile_t *victim)
{
if (victim->needs_close && victim->file) {
fclose(victim->file);
@ -324,7 +336,8 @@ static void close_log(logfile_t *victim)
/** Helper: reset a single logfile_t. For a file log, this involves
* closing and reopening the log, and maybe writing the version. For
* other log types, do nothing. */
static int reset_log(logfile_t *lf)
static int
reset_log(logfile_t *lf)
{
if (lf->needs_close) {
if (fclose(lf->file)==EOF ||
@ -340,7 +353,8 @@ static int reset_log(logfile_t *lf)
/** Add a log handler to send all messages of severity <b>loglevel</b>
* or higher to <b>stream</b>. */
void add_stream_log(int loglevelMin, int loglevelMax, const char *name, FILE *stream)
void
add_stream_log(int loglevelMin, int loglevelMax, const char *name, FILE *stream)
{
logfile_t *lf;
lf = tor_malloc_zero(sizeof(logfile_t));
@ -355,7 +369,8 @@ void add_stream_log(int loglevelMin, int loglevelMax, const char *name, FILE *st
/** Add a log handler to receive messages during startup (before the real
* logs are initialized).
*/
void add_temp_log(void)
void
add_temp_log(void)
{
add_stream_log(LOG_NOTICE, LOG_ERR, "<temp>", stdout);
logfiles->is_temporary = 1;
@ -366,7 +381,8 @@ void add_temp_log(void)
* <b>logLevelmin</b> and <b>logLevelMax</b> to the function
* <b>cb</b>.
*/
int add_callback_log(int loglevelMin, int loglevelMax, log_callback cb)
int
add_callback_log(int loglevelMin, int loglevelMax, log_callback cb)
{
logfile_t *lf;
lf = tor_malloc_zero(sizeof(logfile_t));
@ -379,8 +395,9 @@ int add_callback_log(int loglevelMin, int loglevelMax, log_callback cb)
return 0;
}
void change_callback_log_severity(int loglevelMin, int loglevelMax,
log_callback cb)
void
change_callback_log_severity(int loglevelMin, int loglevelMax,
log_callback cb)
{
logfile_t *lf;
for (lf = logfiles; lf; lf = lf->next) {
@ -392,7 +409,8 @@ void change_callback_log_severity(int loglevelMin, int loglevelMax,
}
/** Close any log handlers added by add_temp_log or marked by mark_logs_temp */
void close_temp_logs(void)
void
close_temp_logs(void)
{
logfile_t *lf, **p;
for (p = &logfiles; *p; ) {
@ -410,7 +428,8 @@ void close_temp_logs(void)
}
/** Configure all log handles to be closed by close_temp_logs */
void mark_logs_temp(void)
void
mark_logs_temp(void)
{
logfile_t *lf;
for (lf = logfiles; lf; lf = lf->next)
@ -422,7 +441,8 @@ void mark_logs_temp(void)
* the logfile fails, -1 is returned and errno is set appropriately
* (by fopen).
*/
int add_file_log(int loglevelMin, int loglevelMax, const char *filename)
int
add_file_log(int loglevelMin, int loglevelMax, const char *filename)
{
FILE *f;
f = fopen(filename, "a");
@ -439,7 +459,8 @@ int add_file_log(int loglevelMin, int loglevelMax, const char *filename)
/**
* Add a log handler to send messages to they system log facility.
*/
int add_syslog_log(int loglevelMin, int loglevelMax)
int
add_syslog_log(int loglevelMin, int loglevelMax)
{
logfile_t *lf;
if (syslog_count++ == 0)
@ -459,7 +480,9 @@ int add_syslog_log(int loglevelMin, int loglevelMax)
/** If <b>level</b> is a valid log severity, return the corresponding
* numeric value. Otherwise, return -1. */
int parse_log_level(const char *level) {
int
parse_log_level(const char *level)
{
if (!strcasecmp(level, "err"))
return LOG_ERR;
if (!strcasecmp(level, "warn"))
@ -474,13 +497,15 @@ int parse_log_level(const char *level) {
}
/** Return the string equivalent of a given log level. */
const char *log_level_to_string(int level)
const char *
log_level_to_string(int level)
{
return sev_to_string(level);
}
/** Return the least severe log level that any current log is interested in. */
int get_min_log_level(void)
int
get_min_log_level(void)
{
logfile_t *lf;
int min = LOG_ERR;
@ -492,7 +517,8 @@ int get_min_log_level(void)
}
/** Switch all logs to output at most verbose level. */
void switch_logs_debug(void)
void
switch_logs_debug(void)
{
logfile_t *lf;
for (lf = logfiles; lf; lf=lf->next) {
@ -531,16 +557,24 @@ libevent_logging_callback(int severity, const char *msg)
break;
}
}
void configure_libevent_logging(void)
void
configure_libevent_logging(void)
{
event_set_log_callback(libevent_logging_callback);
}
void suppress_libevent_log_msg(const char *msg)
void
suppress_libevent_log_msg(const char *msg)
{
suppress_msg = msg;
}
#else
void configure_libevent_logging(void) {}
void suppress_libevent_log_msg(const char *msg) {}
void
configure_libevent_logging(void)
{
}
void
suppress_libevent_log_msg(const char *msg)
{
}
#endif

3
src/common/torgzip.c
View File

@ -253,7 +253,8 @@ tor_gzip_uncompress(char **out, size_t *out_len,
* to be compressed or not. If it is, return the likeliest compression method.
* Otherwise, return 0.
*/
int detect_compression_method(const char *in, size_t in_len)
int
detect_compression_method(const char *in, size_t in_len)
{
if (in_len > 2 && !memcmp(in, "\x1f\x8b", 2)) {
return GZIP_METHOD;

17
src/common/tortls.c
View File

@ -174,8 +174,9 @@ tor_tls_free_all(void)
* it: We always accept peer certs and complete the handshake. We
* don't validate them until later.
*/
static int always_accept_verify_cb(int preverify_ok,
X509_STORE_CTX *x509_ctx)
static int
always_accept_verify_cb(int preverify_ok,
X509_STORE_CTX *x509_ctx)
{
/* avoid "unused parameter" warning. */
preverify_ok = 0;
@ -672,7 +673,8 @@ tor_tls_get_peer_cert_nickname(tor_tls *tls, char *buf, size_t buflen)
return r;
}
static void log_cert_lifetime(X509 *cert, const char *problem)
static void
log_cert_lifetime(X509 *cert, const char *problem)
{
BIO *bio = NULL;
BUF_MEM *buf;
@ -842,13 +844,15 @@ tor_tls_get_pending_bytes(tor_tls *tls)
}
/** Return the number of bytes read across the underlying socket. */
unsigned long tor_tls_get_n_bytes_read(tor_tls *tls)
unsigned long
tor_tls_get_n_bytes_read(tor_tls *tls)
{
tor_assert(tls);
return BIO_number_read(SSL_get_rbio(tls->ssl));
}
/** Return the number of bytes written across the underlying socket. */
unsigned long tor_tls_get_n_bytes_written(tor_tls *tls)
unsigned long
tor_tls_get_n_bytes_written(tor_tls *tls)
{
tor_assert(tls);
return BIO_number_written(SSL_get_wbio(tls->ssl));
@ -856,7 +860,8 @@ unsigned long tor_tls_get_n_bytes_written(tor_tls *tls)
/** Implement check_no_tls_errors: If there are any pending OpenSSL
* errors, log an error message and assert(0). */
void _check_no_tls_errors(const char *fname, int line)
void
_check_no_tls_errors(const char *fname, int line)
{
if (ERR_peek_error() == 0)
return;

155
src/common/util.c
View File

@ -139,7 +139,9 @@ void *_tor_malloc(DMALLOC_PARAMS size_t size)
* zero bytes, and return a pointer to the result. Log and terminate
* the process on error. (Same as calloc(size,1), but never returns NULL.)
*/
void *_tor_malloc_zero(DMALLOC_PARAMS size_t size) {
void *
_tor_malloc_zero(DMALLOC_PARAMS size_t size)
{
void *result = _tor_malloc(DMALLOC_FN_ARGS size);
memset(result, 0, size);
return result;
@ -149,7 +151,9 @@ void *_tor_malloc_zero(DMALLOC_PARAMS size_t size) {
* bytes long; return the new memory block. On error, log and
* terminate. (Like realloc(ptr,size), but never returns NULL.)
*/
void *_tor_realloc(DMALLOC_PARAMS void *ptr, size_t size) {
void *
_tor_realloc(DMALLOC_PARAMS void *ptr, size_t size)
{
void *result;
result = dmalloc_realloc(file, line, ptr, size, DMALLOC_FUNC_REALLOC, 0);
@ -164,7 +168,9 @@ void *_tor_realloc(DMALLOC_PARAMS void *ptr, size_t size) {
* error, log and terminate. (Like strdup(s), but never returns
* NULL.)
*/
char *_tor_strdup(DMALLOC_PARAMS const char *s) {
char *
_tor_strdup(DMALLOC_PARAMS const char *s)
{
char *dup;
tor_assert(s);
@ -182,7 +188,9 @@ char *_tor_strdup(DMALLOC_PARAMS const char *s) {
* always NUL-terminated. (Like strndup(s,n), but never returns
* NULL.)
*/
char *_tor_strndup(DMALLOC_PARAMS const char *s, size_t n) {
char *
_tor_strndup(DMALLOC_PARAMS const char *s, size_t n)
{
char *dup;
tor_assert(s);
dup = _tor_malloc(DMALLOC_FN_ARGS n+1);
@ -201,7 +209,8 @@ char *_tor_strndup(DMALLOC_PARAMS const char *s, size_t n) {
/** Remove from the string <b>s</b> every character which appears in
* <b>strip</b>. Return the number of characters removed. */
int tor_strstrip(char *s, const char *strip)
int
tor_strstrip(char *s, const char *strip)
{
char *read = s;
while (*read) {
@ -226,9 +235,10 @@ int tor_strstrip(char *s, const char *strip)
* If <b>rule</b> is TERMINATE_IF_EVEN, then end the string with <b>insert</b>
* exactly when its length <i>is</i> a multiple of <b>n</b>.
*/
int tor_strpartition(char *dest, size_t dest_len,
const char *s, const char *insert, size_t n,
part_finish_rule_t rule)
int
tor_strpartition(char *dest, size_t dest_len,
const char *s, const char *insert, size_t n,
part_finish_rule_t rule)
{
char *destp;
size_t len_in, len_out, len_ins;
@ -283,7 +293,8 @@ int tor_strpartition(char *dest, size_t dest_len,
* result does not need to be deallocated, but repeated calls to
* hex_str will trash old results.
*/
const char *hex_str(const char *from, size_t fromlen)
const char *
hex_str(const char *from, size_t fromlen)
{
static char buf[65];
if (fromlen>(sizeof(buf)-1)/2)
@ -294,7 +305,8 @@ const char *hex_str(const char *from, size_t fromlen)
/** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
* lowercase. */
void tor_strlower(char *s)
void
tor_strlower(char *s)
{
while (*s) {
*s = tolower(*s);
@ -304,7 +316,8 @@ void tor_strlower(char *s)
/** Convert all alphabetic characters in the nul-terminated string <b>s</b> to
* lowercase. */
void tor_strupper(char *s)
void
tor_strupper(char *s)
{
while (*s) {
*s = toupper(*s);
@ -315,7 +328,8 @@ void tor_strupper(char *s)
/* Compares the first strlen(s2) characters of s1 with s2. Returns as for
* strcmp.
*/
int strcmpstart(const char *s1, const char *s2)
int
strcmpstart(const char *s1, const char *s2)
{
size_t n = strlen(s2);
return strncmp(s1, s2, n);
@ -324,7 +338,8 @@ int strcmpstart(const char *s1, const char *s2)
/* Compares the first strlen(s2) characters of s1 with s2. Returns as for
* strcasecmp.
*/
int strcasecmpstart(const char *s1, const char *s2)
int
strcasecmpstart(const char *s1, const char *s2)
{
size_t n = strlen(s2);
return strncasecmp(s1, s2, n);
@ -333,7 +348,8 @@ int strcasecmpstart(const char *s1, const char *s2)
/* Compares the last strlen(s2) characters of s1 with s2. Returns as for
* strcmp.
*/
int strcmpend(const char *s1, const char *s2)
int
strcmpend(const char *s1, const char *s2)
{
size_t n1 = strlen(s1), n2 = strlen(s2);
if (n2>n1)
@ -345,7 +361,8 @@ int strcmpend(const char *s1, const char *s2)
/* Compares the last strlen(s2) characters of s1 with s2. Returns as for
* strcasecmp.
*/
int strcasecmpend(const char *s1, const char *s2)
int
strcasecmpend(const char *s1, const char *s2)
{
size_t n1 = strlen(s1), n2 = strlen(s2);
if (n2>n1) /* then they can't be the same; figure out which is bigger */
@ -357,7 +374,9 @@ int strcasecmpend(const char *s1, const char *s2)
/** Return a pointer to the first char of s that is not whitespace and
* not a comment, or to the terminating NUL if no such character exists.
*/
const char *eat_whitespace(const char *s) {
const char *
eat_whitespace(const char *s)
{
tor_assert(s);
while (TOR_ISSPACE(*s) || *s == '#') {
@ -375,7 +394,9 @@ const char *eat_whitespace(const char *s) {
/** Return a pointer to the first char of s that is not a space or a tab,
* or to the terminating NUL if no such character exists. */
const char *eat_whitespace_no_nl(const char *s) {
const char *
eat_whitespace_no_nl(const char *s)
{
while (*s == ' ' || *s == '\t')
++s;
return s;
@ -384,7 +405,9 @@ const char *eat_whitespace_no_nl(const char *s) {
/** Return a pointer to the first char of s that is whitespace or <b>#</b>,
* or to the terminating NUL if no such character exists.
*/
const char *find_whitespace(const char *s) {
const char *
find_whitespace(const char *s)
{
tor_assert(s);
while (*s && !TOR_ISSPACE(*s) && *s != '#')
@ -470,7 +493,8 @@ tor_parse_uint64(const char *s, int base, uint64_t min,
CHECK_STRTOX_RESULT();
}
void base16_encode(char *dest, size_t destlen, const char *src, size_t srclen)
void
base16_encode(char *dest, size_t destlen, const char *src, size_t srclen)
{
const char *end;
char *cp;
@ -490,7 +514,8 @@ void base16_encode(char *dest, size_t destlen, const char *src, size_t srclen)
static const char HEX_DIGITS[] = "0123456789ABCDEFabcdef";
static INLINE int hex_decode_digit(char c)
static INLINE int
hex_decode_digit(char c)
{
const char *cp;
int n;
@ -504,7 +529,8 @@ static INLINE int hex_decode_digit(char c)
return n-6; /* lowercase */
}
int base16_decode(char *dest, size_t destlen, const char *src, size_t srclen)
int
base16_decode(char *dest, size_t destlen, const char *src, size_t srclen)
{
const char *end;
int v1,v2;
@ -548,7 +574,9 @@ tv_udiff(struct timeval *start, struct timeval *end)
/** Return -1 if *a \< *b, 0 if *a==*b, and 1 if *a \> *b.
*/
int tv_cmp(struct timeval *a, struct timeval *b) {
int
tv_cmp(struct timeval *a, struct timeval *b)
{
if (a->tv_sec > b->tv_sec)
return 1;
if (a->tv_sec < b->tv_sec)
@ -562,7 +590,9 @@ int tv_cmp(struct timeval *a, struct timeval *b) {
/** Increment *a by the number of seconds and microseconds in *b.
*/
void tv_add(struct timeval *a, struct timeval *b) {
void
tv_add(struct timeval *a, struct timeval *b)
{
a->tv_usec += b->tv_usec;
a->tv_sec += b->tv_sec + (a->tv_usec / 1000000);
a->tv_usec %= 1000000;
@ -570,14 +600,18 @@ void tv_add(struct timeval *a, struct timeval *b) {
/** Increment *a by <b>ms</b> milliseconds.
*/
void tv_addms(struct timeval *a, long ms) {
void
tv_addms(struct timeval *a, long ms)
{
a->tv_usec += (ms * 1000) % 1000000;
a->tv_sec += ((ms * 1000) / 1000000) + (a->tv_usec / 1000000);
a->tv_usec %= 1000000;
}
#define IS_LEAPYEAR(y) (!(y % 4) && ((y % 100) || !(y % 400)))
static int n_leapdays(int y1, int y2) {
static int
n_leapdays(int y1, int y2)
{
--y1;
--y2;
return (y2/4 - y1/4) - (y2/100 - y1/100) + (y2/400 - y1/400);
@ -590,7 +624,8 @@ static const int days_per_month[] =
* does not account for leap seconds.
*/
time_t
tor_timegm(struct tm *tm) {
tor_timegm(struct tm *tm)
{
/* This is a pretty ironclad timegm implementation, snarfed from Python2.2.
* It's way more brute-force than fiddling with tzset().
*/
@ -621,7 +656,9 @@ static const char *MONTH_NAMES[] =
{ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
void format_rfc1123_time(char *buf, time_t t) {
void
format_rfc1123_time(char *buf, time_t t)
{
struct tm tm;
tor_gmtime_r(&t, &tm);
@ -635,7 +672,9 @@ void format_rfc1123_time(char *buf, time_t t) {
memcpy(buf+8, MONTH_NAMES[tm.tm_mon], 3);
}
int parse_rfc1123_time(const char *buf, time_t *t) {
int
parse_rfc1123_time(const char *buf, time_t *t)
{
struct tm tm;
char month[4];
char weekday[4];
@ -669,17 +708,23 @@ int parse_rfc1123_time(const char *buf, time_t *t) {
return 0;
}
void format_local_iso_time(char *buf, time_t t) {
void
format_local_iso_time(char *buf, time_t t)
{
struct tm tm;
strftime(buf, ISO_TIME_LEN+1, "%Y-%m-%d %H:%M:%S", tor_localtime_r(&t, &tm));
}
void format_iso_time(char *buf, time_t t) {
void
format_iso_time(char *buf, time_t t)
{
struct tm tm;
strftime(buf, ISO_TIME_LEN+1, "%Y-%m-%d %H:%M:%S", tor_gmtime_r(&t, &tm));
}
int parse_iso_time(const char *cp, time_t *t) {
int
parse_iso_time(const char *cp, time_t *t)
{
struct tm st_tm;
#ifdef HAVE_STRPTIME
if (!strptime(cp, "%Y-%m-%d %H:%M:%S", &st_tm)) {
@ -715,7 +760,8 @@ int parse_iso_time(const char *cp, time_t *t) {
* was returned by open(). Return the number of bytes written, or -1
* on error. Only use if fd is a blocking fd. */
int
write_all(int fd, const char *buf, size_t count, int isSocket) {
write_all(int fd, const char *buf, size_t count, int isSocket)
{
size_t written = 0;
int result;
@ -737,7 +783,8 @@ write_all(int fd, const char *buf, size_t count, int isSocket) {
* open(). Return the number of bytes read, or -1 on error. Only use
* if fd is a blocking fd. */
int
read_all(int fd, char *buf, size_t count, int isSocket) {
read_all(int fd, char *buf, size_t count, int isSocket)
{
size_t numread = 0;
int result;
@ -783,7 +830,8 @@ clean_name_for_stat(char *name)
/** Return FN_ERROR if filename can't be read, FN_NOENT if it doesn't
* exist, FN_FILE if it is a regular file, or FN_DIR if it's a
* directory. */
file_status_t file_status(const char *fname)
file_status_t
file_status(const char *fname)
{
struct stat st;
char *f;
@ -811,7 +859,8 @@ file_status_t file_status(const char *fname)
* and return 0 on success. If it does not exist, and
* check==CPD_CHECK, and we think we can create it, return 0. Else
* return -1. */
int check_private_dir(const char *dirname, cpd_check_t check)
int
check_private_dir(const char *dirname, cpd_check_t check)
{
int r;
struct stat st;
@ -988,7 +1037,9 @@ append_bytes_to_file(const char *fname, const char *str, size_t len,
* the call to stat and the call to read_all: the resulting string will
* be truncated.
*/
char *read_file_to_str(const char *filename, int bin) {
char *
read_file_to_str(const char *filename, int bin)
{
int fd; /* router file */
struct stat statbuf;
char *string, *f;
@ -1117,7 +1168,8 @@ parse_line_from_str(char *line, char **key_out, char **value_out)
/** Expand any homedir prefix on 'filename'; return a newly allocated
* string. */
char *expand_filename(const char *filename)
char *
expand_filename(const char *filename)
{
tor_assert(filename);
if (*filename == '~') {
@ -1225,8 +1277,9 @@ tor_listdir(const char *dirname)
/** Return true iff <b>ip</b> (in host order) is an IP reserved to localhost,
* or reserved for local networks by RFC 1918.
*/
int is_internal_IP(uint32_t ip) {
int
is_internal_IP(uint32_t ip)
{
if (((ip & 0xff000000) == 0x0a000000) || /* 10/8 */
((ip & 0xff000000) == 0x00000000) || /* 0/8 */
((ip & 0xff000000) == 0x7f000000) || /* 127/8 */
@ -1242,7 +1295,9 @@ int is_internal_IP(uint32_t ip) {
*
* XXX Also check if it's on the same class C network as our public IP.
*/
int is_local_IP(uint32_t ip) {
int
is_local_IP(uint32_t ip)
{
return is_internal_IP(ip);
}
@ -1523,7 +1578,8 @@ static int daemon_filedes[2];
* until finish_daemon is called. (Note: it's safe to call this more
* than once: calls after the first are ignored.)
*/
void start_daemon(void)
void
start_daemon(void)
{
pid_t pid;
@ -1574,7 +1630,8 @@ void start_daemon(void)
* calls after the first are ignored. Calls start_daemon first if it hasn't
* been called already.)
*/
void finish_daemon(const char *desired_cwd)
void
finish_daemon(const char *desired_cwd)
{
int nullfd;
char c = '.';
@ -1615,13 +1672,21 @@ void finish_daemon(const char *desired_cwd)
}
#else
/* defined(MS_WINDOWS) */
void start_daemon(void) {}
void finish_daemon(const char *cp) {}
void
start_daemon(void)
{
}
void
finish_daemon(const char *cp)
{
}
#endif
/** Write the current process ID, followed by NL, into <b>filename</b>.
*/
void write_pidfile(char *filename) {
void
write_pidfile(char *filename)
{
#ifndef MS_WINDOWS
FILE *pidfile;

12
src/or/buffers.c
View File

@ -289,7 +289,8 @@ buf_shrink(buf_t *buf)
/** Remove the first <b>n</b> bytes from buf. */
static INLINE void
buf_remove_from_front(buf_t *buf, size_t n) {
buf_remove_from_front(buf_t *buf, size_t n)
{
tor_assert(buf->datalen >= n);
buf->datalen -= n;
buf_total_used -= n;
@ -313,7 +314,8 @@ buf_nul_terminate(buf_t *buf)
/** Create and return a new buf with capacity <b>size</b>. */
buf_t *
buf_new_with_capacity(size_t size) {
buf_new_with_capacity(size_t size)
{
buf_t *buf;
buf = tor_malloc_zero(sizeof(buf_t));
buf->magic = BUFFER_MAGIC;
@ -646,7 +648,8 @@ flush_buf_tls_impl(tor_tls *tls, buf_t *buf, size_t sz, size_t *buf_flushlen)
/** As flush_buf(), but writes data to a TLS connection.
*/
int flush_buf_tls(tor_tls *tls, buf_t *buf, size_t *buf_flushlen)
int
flush_buf_tls(tor_tls *tls, buf_t *buf, size_t *buf_flushlen)
{
int r;
size_t flushed=0;
@ -1198,7 +1201,8 @@ fetch_from_buf_line(buf_t *buf, char *data_out, size_t *data_len)
/** Log an error and exit if <b>buf</b> is corrupted.
*/
void assert_buf_ok(buf_t *buf)
void
assert_buf_ok(buf_t *buf)
{
tor_assert(buf);
tor_assert(buf->magic == BUFFER_MAGIC);

3
src/or/circuitlist.c
View File

@ -178,7 +178,8 @@ _circuit_get_global_list(void)
/** Function to make circ-\>state human-readable */
const char *
circuit_state_to_string(int state) {
circuit_state_to_string(int state)
{
static char buf[64];
switch (state) {
case CIRCUIT_STATE_BUILDING: return "doing handshakes";

3
src/or/circuituse.c
View File

@ -585,7 +585,8 @@ circuit_testing_opened(circuit_t *circ)
/** A testing circuit has failed to build. Take whatever stats we want. */
static void
circuit_testing_failed(circuit_t *circ, int at_last_hop) {
circuit_testing_failed(circuit_t *circ, int at_last_hop)
{
#if 0
routerinfo_t *me = router_get_my_routerinfo();

6
src/or/config.c
View File

@ -3154,7 +3154,8 @@ config_parse_units(const char *val, struct unit_table_t *u, int *ok)
* and return the number of bytes specified. Otherwise, set
* *<b>ok</b> to false and return 0. */
static uint64_t
config_parse_memunit(const char *s, int *ok) {
config_parse_memunit(const char *s, int *ok)
{
return config_parse_units(s, memory_units, ok);
}
@ -3163,7 +3164,8 @@ config_parse_memunit(const char *s, int *ok) {
* the provided interval. Otherwise, set *<b>ok</b> to 0 and return -1.
*/
static int
config_parse_interval(const char *s, int *ok) {
config_parse_interval(const char *s, int *ok)
{
uint64_t r;
r = config_parse_units(s, time_units, ok);
if (!ok)

3
src/or/connection.c
View File

@ -1637,7 +1637,8 @@ connection_get_by_type_state_lastwritten(int type, int state)
* is non-zero, conn must be of that state too.
*/
connection_t *
connection_get_by_type_state_rendquery(int type, int state, const char *rendquery) {
connection_get_by_type_state_rendquery(int type, int state, const char *rendquery)
{
int i, n;
connection_t *conn;
connection_t **carray;

3
src/or/directory.c
View File

@ -1122,7 +1122,8 @@ connection_dir_reached_eof(connection_t *conn)
/** Read handler for directory connections. (That's connections <em>to</em>
* directory servers and connections <em>at</em> directory servers.)
*/
int connection_dir_process_inbuf(connection_t *conn)
int
connection_dir_process_inbuf(connection_t *conn)
{
tor_assert(conn);
tor_assert(conn->type == CONN_TYPE_DIR);

3
src/or/dirserv.c
View File

@ -50,7 +50,8 @@ static addr_policy_t *authdir_invalid_policy = NULL;
/** Parse authdir policy strings from the configuration.
*/
void
parse_authdir_policy(void) {
parse_authdir_policy(void)
{
addr_policy_t *n;
if (authdir_reject_policy) {
addr_policy_free(authdir_reject_policy);

6
src/or/dns.c
View File

@ -81,8 +81,10 @@ static SPLAY_HEAD(cache_tree, cached_resolve_t) cache_root;
/** Function to compare hashed resolves on their addresses; used to
* implement splay trees. */
static int compare_cached_resolves(cached_resolve_t *a,
cached_resolve_t *b) {
static int
compare_cached_resolves(cached_resolve_t *a,
cached_resolve_t *b)
{
/* make this smarter one day? */
return strncmp(a->address, b->address, MAX_ADDRESSLEN);
}

6
src/or/main.c
View File

@ -1377,7 +1377,8 @@ tor_free_all(int postfork)
/** Do whatever cleanup is necessary before shutting Tor down. */
void
tor_cleanup(void) {
tor_cleanup(void)
{
or_options_t *options = get_options();
/* Remove our pid file. We don't care if there was an error when we
* unlink, nothing we could do about it anyways. */
@ -1442,7 +1443,8 @@ do_hash_password(void)
/** Checks if torrc is present in the same directory
* as the service executable.
* Return 1 if it is, 0 if it is not present. */
static int nt_torrc_is_present()
static int
nt_torrc_is_present()
{
HANDLE hFile;
TCHAR szPath[_MAX_PATH];

7
src/or/rendcommon.c
View File

@ -12,13 +12,16 @@ const char rendcommon_c_id[] = "$Id$";
#include "or.h"
/** Return 0 if one and two are the same service ids, else -1 or 1 */
int rend_cmp_service_ids(const char *one, const char *two) {
int
rend_cmp_service_ids(const char *one, const char *two)
{
return strcasecmp(one,two);
}
/** Free the storage held by the service descriptor <b>desc</b>.
*/
void rend_service_descriptor_free(rend_service_descriptor_t *desc)
void
rend_service_descriptor_free(rend_service_descriptor_t *desc)
{
int i;
if (desc->pk)

7
src/or/rendservice.c
View File

@ -62,7 +62,9 @@ typedef struct rend_service_t {
static smartlist_t *rend_service_list = NULL;
/** Return the number of rendezvous services we have configured. */
int num_rend_services(void) {
int
num_rend_services(void)
{
if (!rend_service_list)
return 0;
return smartlist_len(rend_service_list);
@ -374,7 +376,8 @@ rend_service_get_by_pk_digest(const char* digest)
* to have good uptime. Else return 0.
*/
static int
rend_service_requires_uptime(rend_service_t *service) {
rend_service_requires_uptime(rend_service_t *service)
{
int i;
rend_service_port_config_t *p;

11
src/or/rephist.c
View File

@ -766,8 +766,15 @@ rep_hist_get_predicted_hidserv(time_t now, int *need_uptime, int *need_capacity)
}
/* not used yet */
void rep_hist_note_used_resolve(time_t now) { }
int rep_hist_get_predicted_resolve(time_t now) { return 0; }
void
rep_hist_note_used_resolve(time_t now)
{
}
int
rep_hist_get_predicted_resolve(time_t now)
{
return 0;
}
/** Free all storage held by the OR/link history caches, by the
* bandwidth history arrays, or by the port history. */