Change library to use intrinsic memory allocation functions instead of

OPENSSL_foo wrappers. This changes:
OPENSSL_malloc->malloc
OPENSSL_free->free
OPENSSL_relloc->realloc
OPENSSL_freeFunc->free

5 files changed, 20 insertions, 20 deletions

diff --git a/src/lib/libcrypto/pkcs12/p12_decr.c b/src/lib/libcrypto/pkcs12/p12_decr.c
index 9d3557e8d7..9a73c21866 100644
--- a/src/lib/libcrypto/pkcs12/p12_decr.c
+++ b/src/lib/libcrypto/pkcs12/p12_decr.c
@@ -65,7 +65,7 @@
 
 
 /* Encrypt/Decrypt a buffer based on password and algor, result in a
- * OPENSSL_malloc'ed buffer
+ * malloc'ed buffer
  */
 
 unsigned char * PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass,
@@ -84,14 +84,14 @@ unsigned char * PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass,
                 return NULL;
         }
 
-        if(!(out = OPENSSL_malloc(inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
+        if(!(out = malloc(inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
                 PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_MALLOC_FAILURE);
                 goto err;
         }
 
         if (!EVP_CipherUpdate(&ctx, out, &i, in, inlen))
                 {
-                OPENSSL_free(out);
+                free(out);
                 out = NULL;
                 PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_EVP_LIB);
                 goto err;
@@ -99,7 +99,7 @@ unsigned char * PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass,
 
         outlen = i;
         if(!EVP_CipherFinal_ex(&ctx, out + i, &i)) {
-                OPENSSL_free(out);
+                free(out);
                 out = NULL;
                 PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,PKCS12_R_PKCS12_CIPHERFINAL_ERROR);
                 goto err;
@@ -146,7 +146,7 @@ void * PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it,
         ret = ASN1_item_d2i(NULL, &p, outlen, it);
         if (zbuf) OPENSSL_cleanse(out, outlen);
         if(!ret) PKCS12err(PKCS12_F_PKCS12_ITEM_DECRYPT_D2I,PKCS12_R_DECODE_ERROR);
-        OPENSSL_free(out);
+        free(out);
         return ret;
 }
 
@@ -173,11 +173,11 @@ ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, const ASN1_ITEM *i
         if (!PKCS12_pbe_crypt(algor, pass, passlen, in, inlen, &oct->data,
                                  &oct->length, 1)) {
                 PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,PKCS12_R_ENCRYPT_ERROR);
-                OPENSSL_free(in);
+                free(in);
                 return NULL;
         }
         if (zbuf) OPENSSL_cleanse(in, inlen);
-        OPENSSL_free(in);
+        free(in);
         return oct;
 }
 
diff --git a/src/lib/libcrypto/pkcs12/p12_key.c b/src/lib/libcrypto/pkcs12/p12_key.c
index 61d58502fd..b3672a95e5 100644
--- a/src/lib/libcrypto/pkcs12/p12_key.c
+++ b/src/lib/libcrypto/pkcs12/p12_key.c
@@ -95,7 +95,7 @@ int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt,
             return 0;
         if(unipass) {
                 OPENSSL_cleanse(unipass, uniplen);      /* Clear password from memory */
-                OPENSSL_free(unipass);
+                free(unipass);
         }
         return ret;
 }
@@ -135,14 +135,14 @@ int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
         u = EVP_MD_size (md_type);
         if (u < 0)
             return 0;
-        D = OPENSSL_malloc (v);
-        Ai = OPENSSL_malloc (u);
-        B = OPENSSL_malloc (v + 1);
+        D = malloc (v);
+        Ai = malloc (u);
+        B = malloc (v + 1);
         Slen = v * ((saltlen+v-1)/v);
         if(passlen) Plen = v * ((passlen+v-1)/v);
         else Plen = 0;
         Ilen = Slen + Plen;
-        I = OPENSSL_malloc (Ilen);
+        I = malloc (Ilen);
         Ij = BN_new();
         Bpl1 = BN_new();
         if (!D || !Ai || !B || !I || !Ij || !Bpl1)
@@ -209,10 +209,10 @@ err:
         PKCS12err(PKCS12_F_PKCS12_KEY_GEN_UNI,ERR_R_MALLOC_FAILURE);
 
 end:
-        OPENSSL_free (Ai);
-        OPENSSL_free (B);
-        OPENSSL_free (D);
-        OPENSSL_free (I);
+        free (Ai);
+        free (B);
+        free (D);
+        free (I);
         BN_free (Ij);
         BN_free (Bpl1);
         EVP_MD_CTX_cleanup(&ctx);
diff --git a/src/lib/libcrypto/pkcs12/p12_kiss.c b/src/lib/libcrypto/pkcs12/p12_kiss.c
index 206b1b0b18..bc1fcff45d 100644
--- a/src/lib/libcrypto/pkcs12/p12_kiss.c
+++ b/src/lib/libcrypto/pkcs12/p12_kiss.c
@@ -271,7 +271,7 @@ static int parse_bag(PKCS12_SAFEBAG *bag, const char *pass, int passlen,
                         len = ASN1_STRING_to_UTF8(&data, fname);
                         if(len > 0) {
                                 r = X509_alias_set1(x509, data, len);
-                                OPENSSL_free(data);
+                                free(data);
                                 if (!r)
                                         {
                                         X509_free(x509);
diff --git a/src/lib/libcrypto/pkcs12/p12_mutl.c b/src/lib/libcrypto/pkcs12/p12_mutl.c
index 96de1bd11e..98128e31cb 100644
--- a/src/lib/libcrypto/pkcs12/p12_mutl.c
+++ b/src/lib/libcrypto/pkcs12/p12_mutl.c
@@ -169,7 +169,7 @@ int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, int saltlen,
         }
         if (!saltlen) saltlen = PKCS12_SALT_LEN;
         p12->mac->salt->length = saltlen;
-        if (!(p12->mac->salt->data = OPENSSL_malloc (saltlen))) {
+        if (!(p12->mac->salt->data = malloc (saltlen))) {
                 PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
                 return 0;
         }
diff --git a/src/lib/libcrypto/pkcs12/p12_utl.c b/src/lib/libcrypto/pkcs12/p12_utl.c
index 59c6f453f6..9c58036169 100644
--- a/src/lib/libcrypto/pkcs12/p12_utl.c
+++ b/src/lib/libcrypto/pkcs12/p12_utl.c
@@ -68,7 +68,7 @@ unsigned char *OPENSSL_asc2uni(const char *asc, int asclen, unsigned char **uni,
         unsigned char *unitmp;
         if (asclen == -1) asclen = strlen(asc);
         ulen = asclen*2  + 2;
-        if (!(unitmp = OPENSSL_malloc(ulen))) return NULL;
+        if (!(unitmp = malloc(ulen))) return NULL;
         for (i = 0; i < ulen - 2; i+=2) {
                 unitmp[i] = 0;
                 unitmp[i + 1] = asc[i>>1];
@@ -89,7 +89,7 @@ char *OPENSSL_uni2asc(unsigned char *uni, int unilen)
         /* If no terminating zero allow for one */
         if (!unilen || uni[unilen - 1]) asclen++;
         uni++;
-        if (!(asctmp = OPENSSL_malloc(asclen))) return NULL;
+        if (!(asctmp = malloc(asclen))) return NULL;
         for (i = 0; i < unilen; i+=2) asctmp[i>>1] = uni[i];
         asctmp[asclen - 1] = 0;
         return asctmp;