[or-cvs] canonicalize "src" and "dest" arg order in crypto.c (and ot...

[arma@seul.org (Roger Dingledine)]

Update of /home/or/cvsroot/src/common
In directory moria.mit.edu:/home2/arma/work/onion/cvs/src/common

Modified Files:
	container.h crypto.c crypto.h util.c util.h 
Log Message:
canonicalize "src" and "dest" arg order in crypto.c (and others)


Index: container.h
===================================================================
RCS file: /home/or/cvsroot/src/common/container.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- container.h	1 Nov 2004 20:41:46 -0000	1.1
+++ container.h	2 Nov 2004 02:28:42 -0000	1.2
@@ -21,7 +21,7 @@
 int smartlist_overlap(const smartlist_t *sl1, const smartlist_t *sl2);
 void smartlist_intersect(smartlist_t *sl1, const smartlist_t *sl2);
 void smartlist_subtract(smartlist_t *sl1, const smartlist_t *sl2);
-void *smartlist_choose(const smartlist_t *sl);
+/* smartlist_choose() is defined in crypto.[ch] */
 void *smartlist_get(const smartlist_t *sl, int idx);
 void *smartlist_set(smartlist_t *sl, int idx, void *val);
 void *smartlist_del(smartlist_t *sl, int idx);

Index: crypto.c
===================================================================
RCS file: /home/or/cvsroot/src/common/crypto.c,v
retrieving revision 1.118
retrieving revision 1.119
diff -u -d -r1.118 -r1.119
--- crypto.c	1 Nov 2004 20:41:46 -0000	1.118
+++ crypto.c	2 Nov 2004 02:28:42 -0000	1.119
@@ -589,7 +589,9 @@
  * write the result to <b>to</b>, and return the number of bytes
  * written.  On failure, return -1.
  */
-int crypto_pk_public_encrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding)
+int
+crypto_pk_public_encrypt(crypto_pk_env_t *env, unsigned char *to,
+                         const unsigned char *from, int fromlen, int padding)
 {
   int r;
   tor_assert(env);
@@ -610,7 +612,10 @@
  * write the result to <b>to</b>, and return the number of bytes
  * written.  On failure, return -1.
  */
-int crypto_pk_private_decrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding, int warnOnFailure)
+int
+crypto_pk_private_decrypt(crypto_pk_env_t *env, unsigned char *to,
+                          const unsigned char *from, int fromlen,
+                          int padding, int warnOnFailure)
 {
   int r;
   tor_assert(env);
@@ -636,7 +641,9 @@
  * signed data to <b>to</b>, and return the number of bytes written.
  * On failure, return -1.
  */
-int crypto_pk_public_checksig(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to)
+int
+crypto_pk_public_checksig(crypto_pk_env_t *env, unsigned char *to,
+                          const unsigned char *from, int fromlen)
 {
   int r;
   tor_assert(env);
@@ -651,35 +658,14 @@
   return r;
 }
 
-/** Sign <b>fromlen</b> bytes of data from <b>from</b> with the private key in
- * <b>env</b>, using PKCS1 padding.  On success, write the signature to
- * <b>to</b>, and return the number of bytes written.  On failure, return
- * -1.
- */
-int crypto_pk_private_sign(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to)
-{
-  int r;
-  tor_assert(env);
-  tor_assert(from);
-  tor_assert(to);
-  if (!env->key->p)
-    /* Not a private key */
-    return -1;
-
-  r = RSA_private_encrypt(fromlen, (unsigned char*)from, to, env->key, RSA_PKCS1_PADDING);
-  if (r<0) {
-    crypto_log_errors(LOG_WARN, "generating RSA signature");
-    return -1;
-  }
-  return r;
-}
-
 /** Check a siglen-byte long signature at <b>sig</b> against
  * <b>datalen</b> bytes of data at <b>data</b>, using the public key
  * in <b>env</b>. Return 0 if <b>sig</b> is a correct signature for
  * SHA1(data).  Else return -1.
  */
-int crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const unsigned char *data, int datalen, const unsigned char *sig, int siglen)
+int
+crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const unsigned char *data,
+                                 int datalen, const unsigned char *sig, int siglen)
 {
   char digest[DIGEST_LEN];
   char buf[PK_BYTES+1];
@@ -689,11 +675,11 @@
   tor_assert(data);
   tor_assert(sig);
 
-  if (crypto_digest(data,datalen,digest)<0) {
+  if (crypto_digest(digest,data,datalen)<0) {
     log_fn(LOG_WARN, "couldn't compute digest");
     return -1;
   }
-  r = crypto_pk_public_checksig(env,sig,siglen,buf);
+  r = crypto_pk_public_checksig(env,buf,sig,siglen);
   if (r != DIGEST_LEN) {
     log_fn(LOG_WARN, "Invalid signature");
     return -1;
@@ -706,17 +692,44 @@
   return 0;
 }
 
+/** Sign <b>fromlen</b> bytes of data from <b>from</b> with the private key in
+ * <b>env</b>, using PKCS1 padding.  On success, write the signature to
+ * <b>to</b>, and return the number of bytes written.  On failure, return
+ * -1.
+ */
+int
+crypto_pk_private_sign(crypto_pk_env_t *env, unsigned char *to,
+                       const unsigned char *from, int fromlen)
+{
+  int r;
+  tor_assert(env);
+  tor_assert(from);
+  tor_assert(to);
+  if (!env->key->p)
+    /* Not a private key */
+    return -1;
+
+  r = RSA_private_encrypt(fromlen, (unsigned char*)from, to, env->key, RSA_PKCS1_PADDING);
+  if (r<0) {
+    crypto_log_errors(LOG_WARN, "generating RSA signature");
+    return -1;
+  }
+  return r;
+}
+
 /** Compute a SHA1 digest of <b>fromlen</b> bytes of data stored at
  * <b>from</b>; sign the data with the private key in <b>env</b>, and
  * store it in <b>to</b>.  Return the number of bytes written on
  * success, and -1 on failure.
  */
-int crypto_pk_private_sign_digest(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to)
+int
+crypto_pk_private_sign_digest(crypto_pk_env_t *env, unsigned char *to,
+                              const unsigned char *from, int fromlen)
 {
   char digest[DIGEST_LEN];
-  if (crypto_digest(from,fromlen,digest)<0)
+  if (crypto_digest(digest,from,fromlen)<0)
     return -1;
-  return crypto_pk_private_sign(env,digest,DIGEST_LEN,to);
+  return crypto_pk_private_sign(env,to,digest,DIGEST_LEN);
 }
 
 
@@ -738,8 +751,9 @@
  *     the source data encrypted in AES-CTR mode with the symmetric key.
  */
 int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
+                                    unsigned char *to,
                                     const unsigned char *from,
-                                    int fromlen, unsigned char *to,
+                                    int fromlen,
                                     int padding, int force)
 {
   int overhead, pkeylen, outlen, r, symlen;
@@ -758,7 +772,7 @@
 
   if (!force && fromlen+overhead <= pkeylen) {
     /* It all fits in a single encrypt. */
-    return crypto_pk_public_encrypt(env,from,fromlen,to,padding);
+    return crypto_pk_public_encrypt(env,to,from,fromlen,padding);
   }
   cipher = crypto_new_cipher_env();
   if (!cipher) return -1;
@@ -780,13 +794,12 @@
   /* Length of symmetrically encrypted data. */
   symlen = fromlen-(pkeylen-overhead-CIPHER_KEY_LEN);
 
-  outlen = crypto_pk_public_encrypt(env,buf,pkeylen-overhead,to,padding);
+  outlen = crypto_pk_public_encrypt(env,to,buf,pkeylen-overhead,padding);
   if (outlen!=pkeylen) {
     goto err;
   }
-  r = crypto_cipher_encrypt(cipher,
-                            from+pkeylen-overhead-CIPHER_KEY_LEN, symlen,
-                            to+outlen);
+  r = crypto_cipher_encrypt(cipher, to+outlen,
+                            from+pkeylen-overhead-CIPHER_KEY_LEN, symlen);
 
   if (r<0) goto err;
   memset(buf, 0, sizeof(buf));
@@ -800,8 +813,9 @@
 
 /** Invert crypto_pk_public_hybrid_encrypt. */
 int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
+                                     unsigned char *to,
                                      const unsigned char *from,
-                                     int fromlen, unsigned char *to,
+                                     int fromlen,
                                      int padding, int warnOnFailure)
 {
   int overhead, pkeylen, outlen, r;
@@ -812,9 +826,9 @@
   pkeylen = crypto_pk_keysize(env);
 
   if (fromlen <= pkeylen) {
-    return crypto_pk_private_decrypt(env,from,fromlen,to,padding,warnOnFailure);
+    return crypto_pk_private_decrypt(env,to,from,fromlen,padding,warnOnFailure);
   }
-  outlen = crypto_pk_private_decrypt(env,from,pkeylen,buf,padding,warnOnFailure);
+  outlen = crypto_pk_private_decrypt(env,buf,from,pkeylen,padding,warnOnFailure);
   if (outlen<0) {
     log_fn(warnOnFailure?LOG_WARN:LOG_INFO, "Error decrypting public-key data");
     return -1;
@@ -829,8 +843,7 @@
   }
   memcpy(to,buf+CIPHER_KEY_LEN,outlen-CIPHER_KEY_LEN);
   outlen -= CIPHER_KEY_LEN;
-  r = crypto_cipher_decrypt(cipher, from+pkeylen, fromlen-pkeylen,
-                            to+outlen);
+  r = crypto_cipher_decrypt(cipher, to+outlen, from+pkeylen, fromlen-pkeylen);
   if (r<0)
     goto err;
   memset(buf,0,sizeof(buf));
@@ -912,7 +925,7 @@
     free(buf);
     return -1;
   }
-  if (crypto_digest(buf, len, digest_out) < 0) {
+  if (crypto_digest(digest_out, buf, len) < 0) {
     free(buf);
     return -1;
   }
@@ -975,7 +988,7 @@
 {
   tor_assert(env);
 
-  return crypto_rand(CIPHER_KEY_LEN, env->key);
+  return crypto_rand(env->key, CIPHER_KEY_LEN);
 }
 
 /** Set the symmetric key for the cipher in <b>env</b> to the first
@@ -1028,7 +1041,9 @@
  * <b>env</b>; on success, store the result to <b>to</b> and return 0.
  * On failure, return -1.
  */
-int crypto_cipher_encrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to)
+int
+crypto_cipher_encrypt(crypto_cipher_env_t *env, unsigned char *to,
+                      const unsigned char *from, unsigned int fromlen)
 {
   tor_assert(env);
   tor_assert(env->cipher);
@@ -1044,7 +1059,9 @@
  * <b>env</b>; on success, store the result to <b>to</b> and return 0.
  * On failure, return -1.
  */
-int crypto_cipher_decrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to)
+int
+crypto_cipher_decrypt(crypto_cipher_env_t *env, unsigned char *to,
+                      const unsigned char *from, unsigned int fromlen)
 {
   tor_assert(env);
   tor_assert(from);
@@ -1079,7 +1096,7 @@
  * <b>m</b>.  Write the DIGEST_LEN byte result into <b>digest</b>.
  * Return 0 on suuccess, -1 on failure.
  */
-int crypto_digest(const unsigned char *m, int len, unsigned char *digest)
+int crypto_digest(unsigned char *digest, const unsigned char *m, int len)
 {
   tor_assert(m);
   tor_assert(digest);
@@ -1300,7 +1317,7 @@
 /** Given a DH key exchange object, and our peer's value of g^y (as a
  * <b>pubkey_len</b>-byte value in <b>pubkey</b>) generate
  * <b>secret_bytes_out</b> bytes of shared key material and write them
- * to <b>secret_out</b>.  Return the number of bytes generated on suuccess,
+ * to <b>secret_out</b>.  Return the number of bytes generated on success,
  * or -1 on failure.
  *
  * (We generate key material by computing
@@ -1332,7 +1349,7 @@
   /* sometimes secret_len might be less than 128, e.g., 127. that's ok. */
   for (i = 0; i < secret_bytes_out; i += DIGEST_LEN) {
     secret_tmp[secret_len] = (unsigned char) i/DIGEST_LEN;
-    if (crypto_digest(secret_tmp, secret_len+1, hash))
+    if (crypto_digest(hash, secret_tmp, secret_len+1))
       goto error;
     memcpy(secret_out+i, hash, MIN(DIGEST_LEN, secret_bytes_out-i));
   }
@@ -1428,7 +1445,7 @@
 /** Write n bytes of strong random data to <b>to</b>. Return 0 on
  * success, -1 on failure.
  */
-int crypto_rand(unsigned int n, unsigned char *to)
+int crypto_rand(unsigned char *to, unsigned int n)
 {
   int r;
   tor_assert(to);
@@ -1441,7 +1458,7 @@
 /** Write n bytes of pseudorandom data to <b>to</b>. Return 0 on
  * success, -1 on failure.
  */
-void crypto_pseudo_rand(unsigned int n, unsigned char *to)
+void crypto_pseudo_rand(unsigned char *to, unsigned int n)
 {
   tor_assert(to);
   if (RAND_pseudo_bytes(to, n) == -1) {
@@ -1465,7 +1482,7 @@
    */
   cutoff = UINT_MAX - (UINT_MAX%max);
   while(1) {
-    crypto_pseudo_rand(sizeof(val), (unsigned char*) &val);
+    crypto_pseudo_rand((unsigned char*) &val, sizeof(val));
     if (val < cutoff)
       return val % max;
   }
@@ -1551,7 +1568,6 @@
   dest[i] = '\0';
 }
 
-
 /*
   Local Variables:
   mode:c

Index: crypto.h
===================================================================
RCS file: /home/or/cvsroot/src/common/crypto.h,v
retrieving revision 1.55
retrieving revision 1.56
diff -u -d -r1.55 -r1.56
--- crypto.h	27 Oct 2004 18:16:37 -0000	1.55
+++ crypto.h	2 Nov 2004 02:28:42 -0000	1.56
@@ -53,38 +53,46 @@
 crypto_pk_env_t *crypto_new_pk_env(void);
 void crypto_free_pk_env(crypto_pk_env_t *env);
 
+/* convenience function: wraps crypto_create_crypto_env, set_key, and init. */
+crypto_cipher_env_t *crypto_create_init_cipher(const char *key, int encrypt_mode);
+
 crypto_cipher_env_t *crypto_new_cipher_env(void);
 void crypto_free_cipher_env(crypto_cipher_env_t *env);
 
 /* public key crypto */
 int crypto_pk_generate_key(crypto_pk_env_t *env);
 
+int crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, const char *keyfile);
 int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest, size_t *len);
 int crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src, size_t len);
 int crypto_pk_write_private_key_to_filename(crypto_pk_env_t *env, const char *fname);
-int crypto_pk_check_key(crypto_pk_env_t *env);
-int crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, const char *keyfile);
 int crypto_pk_DER64_encode_public_key(crypto_pk_env_t *env, char **dest);
 crypto_pk_env_t *crypto_pk_DER64_decode_public_key(const char *in);
 
-
+int crypto_pk_check_key(crypto_pk_env_t *env);
 int crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b);
-crypto_pk_env_t *crypto_pk_dup_key(crypto_pk_env_t *orig);
 int crypto_pk_keysize(crypto_pk_env_t *env);
+crypto_pk_env_t *crypto_pk_dup_key(crypto_pk_env_t *orig);
 
-int crypto_pk_public_encrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding);
-int crypto_pk_private_decrypt(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to, int padding, int warnOnFailure);
-int crypto_pk_private_sign(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to);
-int crypto_pk_private_sign_digest(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to);
-int crypto_pk_public_checksig(crypto_pk_env_t *env, const unsigned char *from, int fromlen, unsigned char *to);
-int crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const unsigned char *data, int datalen, const unsigned char *sig, int siglen);
-int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
+int crypto_pk_public_encrypt(crypto_pk_env_t *env, unsigned char *to,
+                             const unsigned char *from, int fromlen, int padding);
+int crypto_pk_private_decrypt(crypto_pk_env_t *env, unsigned char *to,
+                              const unsigned char *from, int fromlen,
+                              int padding, int warnOnFailure);
+int crypto_pk_public_checksig(crypto_pk_env_t *env, unsigned char *to,
+                              const unsigned char *from, int fromlen);
+int crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const unsigned char *data,
+                                     int datalen, const unsigned char *sig, int siglen);
+int crypto_pk_private_sign(crypto_pk_env_t *env, unsigned char *to,
+                           const unsigned char *from, int fromlen);
+int crypto_pk_private_sign_digest(crypto_pk_env_t *env, unsigned char *to,
+                                  const unsigned char *from, int fromlen);
+int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env, unsigned char *to,
                                     const unsigned char *from, int fromlen,
-                                    unsigned char *to, int padding, int force);
-int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
+                                    int padding, int force);
+int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env, unsigned char *to,
                                      const unsigned char *from, int fromlen,
-                                     unsigned char *to,int padding,
-                                     int warnOnFailure);
+                                     int padding, int warnOnFailure);
 
 int crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, int dest_len);
 crypto_pk_env_t *crypto_pk_asn1_decode(const char *str, int len);
@@ -92,43 +100,24 @@
 int crypto_pk_get_fingerprint(crypto_pk_env_t *pk, char *fp_out,int add_space);
 int crypto_pk_check_fingerprint_syntax(const char *s);
 
-int base64_encode(char *dest, size_t destlen, const char *src, size_t srclen);
-int base64_decode(char *dest, size_t destlen, const char *src, size_t srclen);
-#define BASE32_CHARS "abcdefghijklmnopqrstuvwxyz234567"
-void base32_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);
-int base16_decode(char *dest, size_t destlen, const char *src, size_t srclen);
-
-/* Key negotiation */
-crypto_dh_env_t *crypto_dh_new(void);
-int crypto_dh_get_bytes(crypto_dh_env_t *dh);
-int crypto_dh_generate_public(crypto_dh_env_t *dh);
-int crypto_dh_get_public(crypto_dh_env_t *dh, char *pubkey_out,
-                         size_t pubkey_out_len);
-int crypto_dh_compute_secret(crypto_dh_env_t *dh,
-                             const char *pubkey, size_t pubkey_len,
-                             char *secret_out, size_t secret_out_len);
-void crypto_dh_free(crypto_dh_env_t *dh);
-
 /* symmetric crypto */
 int crypto_cipher_generate_key(crypto_cipher_env_t *env);
 int crypto_cipher_set_key(crypto_cipher_env_t *env, const unsigned char *key);
+const unsigned char *crypto_cipher_get_key(crypto_cipher_env_t *env);
 int crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env);
 int crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env);
-const unsigned char *crypto_cipher_get_key(crypto_cipher_env_t *env);
 
-int crypto_cipher_encrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to);
-int crypto_cipher_decrypt(crypto_cipher_env_t *env, const unsigned char *from, unsigned int fromlen, unsigned char *to);
+int crypto_cipher_encrypt(crypto_cipher_env_t *env, unsigned char *to,
+                          const unsigned char *from, unsigned int fromlen);
+int crypto_cipher_decrypt(crypto_cipher_env_t *env, unsigned char *to,
+                          const unsigned char *from, unsigned int fromlen);
 
 /* only implemented for CRYPTO_CIPHER_AES_CTR */
 int crypto_cipher_rewind(crypto_cipher_env_t *env, long delta);
 int crypto_cipher_advance(crypto_cipher_env_t *env, long delta);
 
-/* convenience function: wraps crypto_create_crypto_env, set_key, and init. */
-crypto_cipher_env_t *crypto_create_init_cipher(const char *key, int encrypt_mode);
-
 /* SHA-1 */
-int crypto_digest(const unsigned char *m, int len, unsigned char *digest);
+int crypto_digest(unsigned char *digest, const unsigned char *m, int len);
 crypto_digest_env_t *crypto_new_digest_env(void);
 void crypto_free_digest_env(crypto_digest_env_t *digest);
 void crypto_digest_add_bytes(crypto_digest_env_t *digest, const char *data,
@@ -139,12 +128,31 @@
 void crypto_digest_assign(crypto_digest_env_t *into,
                           const crypto_digest_env_t *from);
 
+/* Key negotiation */
+crypto_dh_env_t *crypto_dh_new(void);
+int crypto_dh_get_bytes(crypto_dh_env_t *dh);
+int crypto_dh_generate_public(crypto_dh_env_t *dh);
+int crypto_dh_get_public(crypto_dh_env_t *dh, char *pubkey_out,
+                         size_t pubkey_out_len);
+int crypto_dh_compute_secret(crypto_dh_env_t *dh,
+                             const char *pubkey, size_t pubkey_len,
+                             char *secret_out, size_t secret_out_len);
+void crypto_dh_free(crypto_dh_env_t *dh);
+
 /* random numbers */
 int crypto_seed_rng(void);
-int crypto_rand(unsigned int n, unsigned char *to);
-void crypto_pseudo_rand(unsigned int n, unsigned char *to);
+int crypto_rand(unsigned char *to, unsigned int n);
+void crypto_pseudo_rand(unsigned char *to, unsigned int n);
 int crypto_pseudo_rand_int(unsigned int max);
 
+struct smartlist_t;
+void *smartlist_choose(const struct smartlist_t *sl);
+
+int base64_encode(char *dest, size_t destlen, const char *src, size_t srclen);
+int base64_decode(char *dest, size_t destlen, const char *src, size_t srclen);
+#define BASE32_CHARS "abcdefghijklmnopqrstuvwxyz234567"
+void base32_encode(char *dest, size_t destlen, const char *src, size_t srclen);
+
 #endif
 
 /*

Index: util.c
===================================================================
RCS file: /home/or/cvsroot/src/common/util.c,v
retrieving revision 1.162
retrieving revision 1.163
diff -u -d -r1.162 -r1.163
--- util.c	1 Nov 2004 21:54:12 -0000	1.162
+++ util.c	2 Nov 2004 02:28:42 -0000	1.163
@@ -367,6 +367,7 @@
   return 0;
 }
 
+#if 0
 unsigned long
 tor_parse_ulong(const char *s, int base, unsigned long min,
                 unsigned long max, int *ok, char **next)
@@ -393,6 +394,7 @@
   if (next) *next = endptr;
   return 0;
 }
+#endif
 
 void base16_encode(char *dest, size_t destlen, const char *src, size_t srclen)
 {
@@ -873,7 +875,9 @@
  * that is whitespace or comment.
  * Return 1 if success, 0 if no more lines, -1 if error.
  */
-int parse_line_from_file(char *line, size_t maxlen, FILE *f, char **key_out, char **value_out) {
+int
+parse_line_from_file(char *line, size_t maxlen, FILE *f,
+                     char **key_out, char **value_out) {
   char *s, *key, *end, *value;
 
 try_next_line:

Index: util.h
===================================================================
RCS file: /home/or/cvsroot/src/common/util.h,v
retrieving revision 1.109
retrieving revision 1.110
diff -u -d -r1.109 -r1.110
--- util.h	1 Nov 2004 20:41:47 -0000	1.109
+++ util.h	2 Nov 2004 02:28:42 -0000	1.110
@@ -67,6 +67,8 @@
 const char *eat_whitespace_no_nl(const char *s);
 const char *find_whitespace(const char *s);
 
+void base16_encode(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);
 
 /* Time helpers */
 long tv_udiff(struct timeval *start, struct timeval *end);