[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[or-cvs] Reformat inconsistent function declarations.



Update of /home/or/cvsroot/tor/src/common
In directory moria:/tmp/cvs-serv11873/src/common

Modified Files:
	aes.c compat.c container.c crypto.c log.c torgzip.c tortls.c 
	util.c 
Log Message:
Reformat inconsistent function declarations.

Index: aes.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/aes.c,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -d -r1.26 -r1.27
--- aes.c	29 Sep 2005 22:59:17 -0000	1.26
+++ aes.c	30 Sep 2005 01:09:52 -0000	1.27
@@ -608,7 +608,9 @@
  *
  * @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 @@
         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;

Index: compat.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/compat.c,v
retrieving revision 1.69
retrieving revision 1.70
diff -u -d -r1.69 -r1.70
--- compat.c	29 Sep 2005 22:59:17 -0000	1.69
+++ compat.c	30 Sep 2005 01:09:52 -0000	1.70
@@ -440,7 +440,8 @@
  * 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 @@
  * 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 @@
  * 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();

Index: container.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/container.c,v
retrieving revision 1.40
retrieving revision 1.41
diff -u -d -r1.40 -r1.41
--- container.c	29 Sep 2005 22:59:17 -0000	1.40
+++ container.c	30 Sep 2005 01:09:52 -0000	1.41
@@ -43,7 +43,8 @@
 /** 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 @@
  * list's elements.
  */
 void
-smartlist_free(smartlist_t *sl) {
+smartlist_free(smartlist_t *sl)
+{
   free(sl->list);
   free(sl);
 }
@@ -66,7 +68,9 @@
  * 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 @@
 /** 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 @@
 
 /** 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 */

Index: crypto.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/crypto.c,v
retrieving revision 1.157
retrieving revision 1.158
diff -u -d -r1.157 -r1.158
--- crypto.c	29 Sep 2005 22:59:17 -0000	1.157
+++ crypto.c	30 Sep 2005 01:09:52 -0000	1.158
@@ -119,7 +119,8 @@
 /** 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 @@
 /** 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 @@
 
 /** 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 @@
 /** 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 @@
 
 /** 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 @@
 /** 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 @@
 /** 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 @@
 /** 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 @@
  * 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 @@
  * <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 @@
  * 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 @@
  * 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 @@
 
 /** 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 @@
 /** 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 @@
 }
 
 /** 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 @@
 
 /** 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 @@
  *     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 @@
 }
 
 /** 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 @@
 /** 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 @@
 /** 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 @@
  * 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 @@
 /** 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 @@
  * 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 @@
 
 /** 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 @@
 /** 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 @@
 /** 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 @@
  * <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 @@
 /** 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 @@
  * 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 @@
 
 /** 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 @@
 
 /** 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 @@
 
 /** 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 @@
 /** 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 @@
  * 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 @@
  *         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 @@
 
 /** 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 @@
 /** 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 @@
 /** 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 @@
 /** 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 @@
 
 /** 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 @@
 
 /** 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 @@
   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 @@
   return 0;
 }
 #else
-static int setup_openssl_threading(void) { return 0; }
+static int
+setup_openssl_threading(void)
+{
+  return 0;
+}
 #endif
 

Index: log.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/log.c,v
retrieving revision 1.99
retrieving revision 1.100
diff -u -d -r1.99 -r1.100
--- log.c	29 Sep 2005 22:59:17 -0000	1.99
+++ log.c	30 Sep 2005 01:09:52 -0000	1.100
@@ -46,7 +46,9 @@
 } 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 @@
  *
  * 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 @@
  * 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 @@
 }
 
 /** 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 @@
 
 /** 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 @@
 }
 #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 @@
 #endif
 
 /** Close all open log files. */
-void close_logs(void)
+void
+close_logs(void)
 {
   logfile_t *victim;
   while (logfiles) {
@@ -271,7 +279,8 @@
 }
 
 /** 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 @@
  * 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 @@
 
 /** 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 @@
 /** 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 @@
 
 /** 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 @@
 /** 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 @@
  * <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 @@
   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 @@
 }
 
 /** 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 @@
 }
 
 /** 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 @@
  * 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 @@
 /**
  * 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 @@
 
 /** 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 @@
 }
 
 /** 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 @@
 }
 
 /** 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 @@
       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
 

Index: torgzip.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/torgzip.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- torgzip.c	29 Aug 2005 18:01:38 -0000	1.21
+++ torgzip.c	30 Sep 2005 01:09:52 -0000	1.22
@@ -253,7 +253,8 @@
  * 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;

Index: tortls.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/tortls.c,v
retrieving revision 1.102
retrieving revision 1.103
diff -u -d -r1.102 -r1.103
--- tortls.c	29 Sep 2005 22:59:17 -0000	1.102
+++ tortls.c	30 Sep 2005 01:09:52 -0000	1.103
@@ -174,8 +174,9 @@
  * 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 @@
   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 @@
 }
 
 /** 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 @@
 
 /** 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;

Index: util.c
===================================================================
RCS file: /home/or/cvsroot/tor/src/common/util.c,v
retrieving revision 1.224
retrieving revision 1.225
diff -u -d -r1.224 -r1.225
--- util.c	29 Sep 2005 22:59:17 -0000	1.224
+++ util.c	30 Sep 2005 01:09:52 -0000	1.225
@@ -139,7 +139,9 @@
  * 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 @@
  * 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 @@
  * 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 @@
  * 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 @@
 
 /** 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 @@
  * 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 @@
  * 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 @@
 
 /** 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 @@
 
 /** 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 @@
 /* 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 @@
 /* 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 @@
 /* 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 @@
 /* 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 @@
 /** 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 @@
 
 /** 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 @@
 /** 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 @@
   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 @@
 
 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 @@
     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 @@
 
 /** 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 @@
 
 /** 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 @@
 
 /** 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 @@
  * 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 @@
   { "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 @@
   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 @@
   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 @@
  * 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 @@
  * 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 @@
 /** 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 @@
  * 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 @@
  * 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 @@
 
 /** 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 @@
 /** 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 @@
  *
  * 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 @@
  * 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 @@
  * 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 @@
 }
 #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;