Commit 26e789fb authored by Nick Mathewson's avatar Nick Mathewson 🥄
Browse files

Rename nonconformant identifiers.

Fixes bug 4893.

These changes are pure mechanical, and were generated with this
perl script:

  /usr/bin/perl -w -i.bak -p

  s/crypto_pk_env_t/crypto_pk_t/g;
  s/crypto_dh_env_t/crypto_dh_t/g;
  s/crypto_cipher_env_t/crypto_cipher_t/g;
  s/crypto_digest_env_t/crypto_digest_t/g;

  s/aes_free_cipher/aes_cipher_free/g;
  s/crypto_free_cipher_env/crypto_cipher_free/g;
  s/crypto_free_digest_env/crypto_digest_free/g;
  s/crypto_free_pk_env/crypto_pk_free/g;

  s/_crypto_dh_env_get_dh/_crypto_dh_get_dh/g;
  s/_crypto_new_pk_env_rsa/_crypto_new_pk_from_rsa/g;
  s/_crypto_pk_env_get_evp_pkey/_crypto_pk_get_evp_pkey/g;
  s/_crypto_pk_env_get_rsa/_crypto_pk_get_rsa/g;

  s/crypto_new_cipher_env/crypto_cipher_new/g;
  s/crypto_new_digest_env/crypto_digest_new/g;
  s/crypto_new_digest256_env/crypto_digest256_new/g;
  s/crypto_new_pk_env/crypto_pk_new/g;

  s/crypto_create_crypto_env/crypto_cipher_new/g;

  s/connection_create_listener/connection_listener_new/g;
  s/smartlist_create/smartlist_new/g;
  s/transport_create/transport_new/g;
parent d1b40cf2
o Code simplifications and refactorings:
- Rename a handful of old identifiers, mostly related to crypto
structures and crypto functions. By convention, our "create an
object" functions are called "type_new()", our "free an object"
functions are called "type_free()", and our types indicate that
they are types only with a final "_t". But a handful of older
types and functions broke these rules, with function names like
"type_create" or "subsystem_op_type", or with type names like
type_env_t.
......@@ -1125,7 +1125,7 @@ get_interface_addresses_raw(int severity)
return NULL;
}
result = smartlist_create();
result = smartlist_new();
for (i = ifa; i; i = i->ifa_next) {
tor_addr_t tmp;
if (!i->ifa_addr)
......@@ -1184,7 +1184,7 @@ get_interface_addresses_raw(int severity)
goto done;
}
result = smartlist_create();
result = smartlist_new();
for (address = addresses; address; address = address->Next) {
IP_ADAPTER_UNICAST_ADDRESS *a;
for (a = address->FirstUnicastAddress; a; a = a->Next) {
......@@ -1224,7 +1224,7 @@ get_interface_addresses_raw(int severity)
goto done;
}
close(fd);
result = smartlist_create();
result = smartlist_new();
if (ifc.ifc_len < sz)
sz = ifc.ifc_len;
n = sz / sizeof(struct ifreq);
......
......@@ -264,7 +264,7 @@ aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits)
/** Release storage held by <b>cipher</b>
*/
void
aes_free_cipher(aes_cnt_cipher_t *cipher)
aes_cipher_free(aes_cnt_cipher_t *cipher)
{
if (!cipher)
return;
......
......@@ -17,7 +17,7 @@ struct aes_cnt_cipher;
typedef struct aes_cnt_cipher aes_cnt_cipher_t;
aes_cnt_cipher_t* aes_new_cipher(void);
void aes_free_cipher(aes_cnt_cipher_t *cipher);
void aes_cipher_free(aes_cnt_cipher_t *cipher);
void aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits);
void aes_crypt(aes_cnt_cipher_t *cipher, const char *input, size_t len,
char *output);
......
......@@ -1352,7 +1352,7 @@ log_credential_status(void)
} else {
int i, retval = 0;
char *s = NULL;
smartlist_t *elts = smartlist_create();
smartlist_t *elts = smartlist_new();
for (i = 0; i<ngids; i++) {
smartlist_add_asprintf(elts, "%u", (unsigned)sup_gids[i]);
......@@ -2587,7 +2587,7 @@ tor_cond_new(void)
{
tor_cond_t *cond = tor_malloc_zero(sizeof(tor_cond_t));
InitializeCriticalSection(&cond->mutex);
cond->events = smartlist_create();
cond->events = smartlist_new();
return cond;
}
void
......
......@@ -29,7 +29,7 @@
/** Allocate and return an empty smartlist.
*/
smartlist_t *
smartlist_create(void)
smartlist_new(void)
{
smartlist_t *sl = tor_malloc(sizeof(smartlist_t));
sl->num_used = 0;
......
......@@ -26,7 +26,7 @@ typedef struct smartlist_t {
/** @} */
} smartlist_t;
smartlist_t *smartlist_create(void);
smartlist_t *smartlist_new(void);
void smartlist_free(smartlist_t *sl);
void smartlist_clear(smartlist_t *sl);
void smartlist_add(smartlist_t *sl, void *element);
......
......@@ -109,14 +109,14 @@ static int _n_openssl_mutexes = 0;
#endif
/** A public key, or a public/private key-pair. */
struct crypto_pk_env_t
struct crypto_pk_t
{
int refs; /**< reference count, so we don't have to copy keys */
RSA *key; /**< The key itself */
};
/** Key and stream information for a stream cipher. */
struct crypto_cipher_env_t
struct crypto_cipher_t
{
char key[CIPHER_KEY_LEN]; /**< The raw key. */
aes_cnt_cipher_t *cipher; /**< The key in format usable for counter-mode AES
......@@ -125,7 +125,7 @@ struct crypto_cipher_env_t
/** A structure to hold the first half (x, g^x) of a Diffie-Hellman handshake
* while we're waiting for the second.*/
struct crypto_dh_env_t {
struct crypto_dh_t {
DH *dh; /**< The openssl DH object */
};
......@@ -295,30 +295,30 @@ crypto_thread_cleanup(void)
ERR_remove_state(0);
}
/** used by tortls.c: wrap an RSA* in a crypto_pk_env_t. */
crypto_pk_env_t *
_crypto_new_pk_env_rsa(RSA *rsa)
/** used by tortls.c: wrap an RSA* in a crypto_pk_t. */
crypto_pk_t *
_crypto_new_pk_from_rsa(RSA *rsa)
{
crypto_pk_env_t *env;
crypto_pk_t *env;
tor_assert(rsa);
env = tor_malloc(sizeof(crypto_pk_env_t));
env = tor_malloc(sizeof(crypto_pk_t));
env->refs = 1;
env->key = rsa;
return env;
}
/** Helper, used by tor-checkkey.c and tor-gencert.c. Return the RSA from a
* crypto_pk_env_t. */
* crypto_pk_t. */
RSA *
_crypto_pk_env_get_rsa(crypto_pk_env_t *env)
_crypto_pk_get_rsa(crypto_pk_t *env)
{
return env->key;
}
/** used by tortls.c: get an equivalent EVP_PKEY* for a crypto_pk_env_t. Iff
/** used by tortls.c: get an equivalent EVP_PKEY* for a crypto_pk_t. Iff
* private is set, include the private-key portion of the key. */
EVP_PKEY *
_crypto_pk_env_get_evp_pkey(crypto_pk_env_t *env, int private)
_crypto_pk_get_evp_pkey(crypto_pk_t *env, int private)
{
RSA *key = NULL;
EVP_PKEY *pkey = NULL;
......@@ -343,10 +343,10 @@ _crypto_pk_env_get_evp_pkey(crypto_pk_env_t *env, int private)
return NULL;
}
/** Used by tortls.c: Get the DH* from a crypto_dh_env_t.
/** Used by tortls.c: Get the DH* from a crypto_dh_t.
*/
DH *
_crypto_dh_env_get_dh(crypto_dh_env_t *dh)
_crypto_dh_get_dh(crypto_dh_t *dh)
{
return dh->dh;
}
......@@ -354,21 +354,21 @@ _crypto_dh_env_get_dh(crypto_dh_env_t *dh)
/** Allocate and return storage for a public key. The key itself will not yet
* be set.
*/
crypto_pk_env_t *
crypto_new_pk_env(void)
crypto_pk_t *
crypto_pk_new(void)
{
RSA *rsa;
rsa = RSA_new();
tor_assert(rsa);
return _crypto_new_pk_env_rsa(rsa);
return _crypto_new_pk_from_rsa(rsa);
}
/** 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)
crypto_pk_free(crypto_pk_t *env)
{
if (!env)
return;
......@@ -387,13 +387,13 @@ crypto_free_pk_env(crypto_pk_env_t *env)
* (1=encrypt, 0=decrypt). Return the crypto object on success; NULL
* on failure.
*/
crypto_cipher_env_t *
crypto_cipher_t *
crypto_create_init_cipher(const char *key, int encrypt_mode)
{
int r;
crypto_cipher_env_t *crypto = NULL;
crypto_cipher_t *crypto = NULL;
if (! (crypto = crypto_new_cipher_env())) {
if (! (crypto = crypto_cipher_new())) {
log_warn(LD_CRYPTO, "Unable to allocate crypto object");
return NULL;
}
......@@ -411,18 +411,18 @@ crypto_create_init_cipher(const char *key, int encrypt_mode)
error:
if (crypto)
crypto_free_cipher_env(crypto);
crypto_cipher_free(crypto);
return NULL;
}
/** Allocate and return a new symmetric cipher.
*/
crypto_cipher_env_t *
crypto_new_cipher_env(void)
crypto_cipher_t *
crypto_cipher_new(void)
{
crypto_cipher_env_t *env;
crypto_cipher_t *env;
env = tor_malloc_zero(sizeof(crypto_cipher_env_t));
env = tor_malloc_zero(sizeof(crypto_cipher_t));
env->cipher = aes_new_cipher();
return env;
}
......@@ -430,14 +430,14 @@ crypto_new_cipher_env(void)
/** Free a symmetric cipher.
*/
void
crypto_free_cipher_env(crypto_cipher_env_t *env)
crypto_cipher_free(crypto_cipher_t *env)
{
if (!env)
return;
tor_assert(env->cipher);
aes_free_cipher(env->cipher);
memset(env, 0, sizeof(crypto_cipher_env_t));
aes_cipher_free(env->cipher);
memset(env, 0, sizeof(crypto_cipher_t));
tor_free(env);
}
......@@ -447,7 +447,7 @@ crypto_free_cipher_env(crypto_cipher_env_t *env)
* Return 0 on success, -1 on failure.
*/
int
crypto_pk_generate_key_with_bits(crypto_pk_env_t *env, int bits)
crypto_pk_generate_key_with_bits(crypto_pk_t *env, int bits)
{
tor_assert(env);
......@@ -494,7 +494,7 @@ crypto_pk_generate_key_with_bits(crypto_pk_env_t *env, int bits)
*/
/* Used here, and used for testing. */
int
crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
crypto_pk_read_private_key_from_string(crypto_pk_t *env,
const char *s, ssize_t len)
{
BIO *b;
......@@ -526,7 +526,7 @@ crypto_pk_read_private_key_from_string(crypto_pk_env_t *env,
* <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,
crypto_pk_read_private_key_from_filename(crypto_pk_t *env,
const char *keyfile)
{
char *contents;
......@@ -555,7 +555,7 @@ crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env,
/** Helper function to implement crypto_pk_write_*_key_to_string. */
static int
crypto_pk_write_key_to_string_impl(crypto_pk_env_t *env, char **dest,
crypto_pk_write_key_to_string_impl(crypto_pk_t *env, char **dest,
size_t *len, int is_public)
{
BUF_MEM *buf;
......@@ -603,7 +603,7 @@ crypto_pk_write_key_to_string_impl(crypto_pk_env_t *env, char **dest,
* failure, return -1.
*/
int
crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest,
crypto_pk_write_public_key_to_string(crypto_pk_t *env, char **dest,
size_t *len)
{
return crypto_pk_write_key_to_string_impl(env, dest, len, 1);
......@@ -615,7 +615,7 @@ crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, char **dest,
* failure, return -1.
*/
int
crypto_pk_write_private_key_to_string(crypto_pk_env_t *env, char **dest,
crypto_pk_write_private_key_to_string(crypto_pk_t *env, char **dest,
size_t *len)
{
return crypto_pk_write_key_to_string_impl(env, dest, len, 0);
......@@ -626,7 +626,7 @@ crypto_pk_write_private_key_to_string(crypto_pk_env_t *env, char **dest,
* failure.
*/
int
crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src,
crypto_pk_read_public_key_from_string(crypto_pk_t *env, const char *src,
size_t len)
{
BIO *b;
......@@ -657,7 +657,7 @@ crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, const char *src,
* PEM-encoded. Return 0 on success, -1 on failure.
*/
int
crypto_pk_write_private_key_to_filename(crypto_pk_env_t *env,
crypto_pk_write_private_key_to_filename(crypto_pk_t *env,
const char *fname)
{
BIO *bio;
......@@ -691,7 +691,7 @@ crypto_pk_write_private_key_to_filename(crypto_pk_env_t *env,
/** Return true iff <b>env</b> has a valid key.
*/
int
crypto_pk_check_key(crypto_pk_env_t *env)
crypto_pk_check_key(crypto_pk_t *env)
{
int r;
tor_assert(env);
......@@ -705,7 +705,7 @@ crypto_pk_check_key(crypto_pk_env_t *env)
/** Return true iff <b>key</b> contains the private-key portion of the RSA
* key. */
int
crypto_pk_key_is_private(const crypto_pk_env_t *key)
crypto_pk_key_is_private(const crypto_pk_t *key)
{
tor_assert(key);
return PRIVATE_KEY_OK(key);
......@@ -715,7 +715,7 @@ crypto_pk_key_is_private(const crypto_pk_env_t *key)
* equals 65537.
*/
int
crypto_pk_public_exponent_ok(crypto_pk_env_t *env)
crypto_pk_public_exponent_ok(crypto_pk_t *env)
{
tor_assert(env);
tor_assert(env->key);
......@@ -727,7 +727,7 @@ crypto_pk_public_exponent_ok(crypto_pk_env_t *env)
* if a==b, and 1 if a\>b.
*/
int
crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b)
crypto_pk_cmp_keys(crypto_pk_t *a, crypto_pk_t *b)
{
int result;
......@@ -747,7 +747,7 @@ 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)
crypto_pk_keysize(crypto_pk_t *env)
{
tor_assert(env);
tor_assert(env->key);
......@@ -757,7 +757,7 @@ crypto_pk_keysize(crypto_pk_env_t *env)
/** Return the size of the public key modulus of <b>env</b>, in bits. */
int
crypto_pk_num_bits(crypto_pk_env_t *env)
crypto_pk_num_bits(crypto_pk_t *env)
{
tor_assert(env);
tor_assert(env->key);
......@@ -768,8 +768,8 @@ crypto_pk_num_bits(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_t *
crypto_pk_dup_key(crypto_pk_t *env)
{
tor_assert(env);
tor_assert(env->key);
......@@ -779,8 +779,8 @@ crypto_pk_dup_key(crypto_pk_env_t *env)
}
/** Make a real honest-to-goodness copy of <b>env</b>, and return it. */
crypto_pk_env_t *
crypto_pk_copy_full(crypto_pk_env_t *env)
crypto_pk_t *
crypto_pk_copy_full(crypto_pk_t *env)
{
RSA *new_key;
int privatekey = 0;
......@@ -803,7 +803,7 @@ crypto_pk_copy_full(crypto_pk_env_t *env)
return NULL;
}
return _crypto_new_pk_env_rsa(new_key);
return _crypto_new_pk_from_rsa(new_key);
}
/** Encrypt <b>fromlen</b> bytes from <b>from</b> with the public key
......@@ -815,7 +815,7 @@ crypto_pk_copy_full(crypto_pk_env_t *env)
* at least the length of the modulus of <b>env</b>.
*/
int
crypto_pk_public_encrypt(crypto_pk_env_t *env, char *to, size_t tolen,
crypto_pk_public_encrypt(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen, int padding)
{
int r;
......@@ -844,7 +844,7 @@ crypto_pk_public_encrypt(crypto_pk_env_t *env, char *to, size_t tolen,
* at least the length of the modulus of <b>env</b>.
*/
int
crypto_pk_private_decrypt(crypto_pk_env_t *env, char *to,
crypto_pk_private_decrypt(crypto_pk_t *env, char *to,
size_t tolen,
const char *from, size_t fromlen,
int padding, int warnOnFailure)
......@@ -881,7 +881,7 @@ crypto_pk_private_decrypt(crypto_pk_env_t *env, char *to,
* at least the length of the modulus of <b>env</b>.
*/
int
crypto_pk_public_checksig(crypto_pk_env_t *env, char *to,
crypto_pk_public_checksig(crypto_pk_t *env, char *to,
size_t tolen,
const char *from, size_t fromlen)
{
......@@ -908,7 +908,7 @@ crypto_pk_public_checksig(crypto_pk_env_t *env, char *to,
* SHA1(data). Else return -1.
*/
int
crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const char *data,
crypto_pk_public_checksig_digest(crypto_pk_t *env, const char *data,
size_t datalen, const char *sig, size_t siglen)
{
char digest[DIGEST_LEN];
......@@ -953,7 +953,7 @@ crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const char *data,
* at least the length of the modulus of <b>env</b>.
*/
int
crypto_pk_private_sign(crypto_pk_env_t *env, char *to, size_t tolen,
crypto_pk_private_sign(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen)
{
int r;
......@@ -985,7 +985,7 @@ crypto_pk_private_sign(crypto_pk_env_t *env, char *to, size_t tolen,
* at least the length of the modulus of <b>env</b>.
*/
int
crypto_pk_private_sign_digest(crypto_pk_env_t *env, char *to, size_t tolen,
crypto_pk_private_sign_digest(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen)
{
int r;
......@@ -1015,7 +1015,7 @@ crypto_pk_private_sign_digest(crypto_pk_env_t *env, char *to, size_t tolen,
* the source data encrypted in AES-CTR mode with the symmetric key.
*/
int
crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
crypto_pk_public_hybrid_encrypt(crypto_pk_t *env,
char *to, size_t tolen,
const char *from,
size_t fromlen,
......@@ -1023,7 +1023,7 @@ crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
{
int overhead, outlen, r;
size_t pkeylen, symlen;
crypto_cipher_env_t *cipher = NULL;
crypto_cipher_t *cipher = NULL;
char *buf = NULL;
tor_assert(env);
......@@ -1046,7 +1046,7 @@ crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
tor_assert(tolen >= fromlen + overhead + CIPHER_KEY_LEN);
tor_assert(tolen >= pkeylen);
cipher = crypto_new_cipher_env();
cipher = crypto_cipher_new();
if (!cipher) return -1;
if (crypto_cipher_generate_key(cipher)<0)
goto err;
......@@ -1077,7 +1077,7 @@ crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
if (r<0) goto err;
memset(buf, 0, pkeylen);
tor_free(buf);
crypto_free_cipher_env(cipher);
crypto_cipher_free(cipher);
tor_assert(outlen+symlen < INT_MAX);
return (int)(outlen + symlen);
err:
......@@ -1085,13 +1085,13 @@ crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env,
memset(buf, 0, pkeylen);
tor_free(buf);
}
if (cipher) crypto_free_cipher_env(cipher);
if (cipher) crypto_cipher_free(cipher);
return -1;
}
/** Invert crypto_pk_public_hybrid_encrypt. */
int
crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
crypto_pk_private_hybrid_decrypt(crypto_pk_t *env,
char *to,
size_t tolen,
const char *from,
......@@ -1100,7 +1100,7 @@ crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
{
int outlen, r;
size_t pkeylen;
crypto_cipher_env_t *cipher = NULL;
crypto_cipher_t *cipher = NULL;
char *buf = NULL;
tor_assert(fromlen < SIZE_T_CEILING);
......@@ -1136,13 +1136,13 @@ crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
goto err;
memset(buf,0,pkeylen);
tor_free(buf);
crypto_free_cipher_env(cipher);
crypto_cipher_free(cipher);
tor_assert(outlen + fromlen < INT_MAX);
return (int)(outlen + (fromlen-pkeylen));
err:
memset(buf,0,pkeylen);
tor_free(buf);
if (cipher) crypto_free_cipher_env(cipher);
if (cipher) crypto_cipher_free(cipher);
return -1;
}
......@@ -1150,7 +1150,7 @@ crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env,
* Return -1 on error, or the number of characters used on success.
*/
int
crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, size_t dest_len)
crypto_pk_asn1_encode(crypto_pk_t *pk, char *dest, size_t dest_len)
{
int len;
unsigned char *buf, *cp;
......@@ -1175,7 +1175,7 @@ crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, size_t 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_t *
crypto_pk_asn1_decode(const char *str, size_t len)
{
RSA *rsa;
......@@ -1189,7 +1189,7 @@ crypto_pk_asn1_decode(const char *str, size_t len)
crypto_log_errors(LOG_WARN,"decoding public key");
return NULL;
}
return _crypto_new_pk_env_rsa(rsa);
return _crypto_new_pk_from_rsa(rsa);
}
/** Given a private or public key <b>pk</b>, put a SHA1 hash of the
......@@ -1197,7 +1197,7 @@ crypto_pk_asn1_decode(const char *str, size_t len)
* Return 0 on success, -1 on failure.
*/
int
crypto_pk_get_digest(crypto_pk_env_t *pk, char *digest_out)
crypto_pk_get_digest(crypto_pk_t *pk, char *digest_out)
{
unsigned char *buf, *bufp;
int len;
......@@ -1223,7 +1223,7 @@ crypto_pk_get_digest(crypto_pk_env_t *pk, char *digest_out)
/** Compute all digests of the DER encoding of <b>pk</b>, and store them
* in <b>digests_out</b>. Return 0 on success, -1 on failure. */
int
crypto_pk_get_all_digests(crypto_pk_env_t *pk, digests_t *digests_out)
crypto_pk_get_all_digests(crypto_pk_t *pk, digests_t *digests_out)
{
unsigned char *buf, *bufp;
int len;
......@@ -1277,7 +1277,7 @@ add_spaces_to_fp(char *out, size_t outlen, const char *in)
* If <b>add_space</b> is false, omit the spaces.
*/
int
crypto_pk_get_fingerprint(crypto_pk_env_t *pk, char *fp_out, int add_space)
crypto_pk_get_fingerprint(crypto_pk_t *pk, char *fp_out, int add_space)
{
char digest[DIGEST_LEN];
char hexdigest[HEX_DIGEST_LEN+1];
......@@ -1316,7 +1316,7 @@ crypto_pk_check_fingerprint_syntax(const char *s)
* Return 0 on success, -1 on failure. Does not initialize the cipher.
*/
int
crypto_cipher_generate_key(crypto_cipher_env_t *env)
crypto_cipher_generate_key(crypto_cipher_t *env)
{
tor_assert(env);
......@@ -1327,7 +1327,7 @@ crypto_cipher_generate_key(crypto_cipher_env_t *env)
* CIPHER_KEY_LEN bytes of <b>key</b>. Does not initialize the cipher.
*/
void
crypto_cipher_set_key(crypto_cipher_env_t *env, const char *key)
crypto_cipher_set_key(crypto_cipher_t *env, const char *key)
{
tor_assert(env);
tor_assert(key);
......@@ -1347,7 +1347,7 @@ crypto_cipher_generate_iv(char *iv_out)
* corresponding to the encryption of the CIPHER_IV_LEN bytes at
* <b>iv</b>. */
int
crypto_cipher_set_iv(crypto_cipher_env_t *env, const char *iv)
crypto_cipher_set_iv(crypto_cipher_t *env, const char *iv)
{
tor_assert(env);
tor_assert(iv);
......@@ -1358,7 +1358,7 @@ crypto_cipher_set_iv(crypto_cipher_env_t *env, const char *iv)
/** 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)
crypto_cipher_get_key(crypto_cipher_t *env)
{
return env->key;
}
......@@ -1367,7 +1367,7 @@ crypto_cipher_get_key(crypto_cipher_env_t *env)
* success, -1 on failure.
*/
int
crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env)
crypto_cipher_encrypt_init_cipher(crypto_cipher_t *env)
{
tor_assert(env);
......@@ -1379,7 +1379,7 @@ crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env)
* success, -1 on failure.
*/
int
crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env)
crypto_cipher_decrypt_init_cipher(crypto_cipher_t *env)
{
tor_assert(env);
......@@ -1392,7 +1392,7 @@ crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env)
* On failure, return -1.
*/
int
crypto_cipher_encrypt(crypto_cipher_env_t *env, char *to,
crypto_cipher_encrypt(crypto_cipher_t *env, char *to,
const char *from, size_t fromlen)
{
tor_assert(env);
......@@ -1411,7 +1411,7 @@ crypto_cipher_encrypt(crypto_cipher_env_t *env, char *to,
* On failure, return -1.
*/