11 files changed, 68 insertions, 68 deletions

diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c
index 55a5ca1a32..ff0089e82e 100644
--- a/src/lib/libcrypto/bio/b_print.c
+++ b/src/lib/libcrypto/bio/b_print.c
@@ -706,7 +706,7 @@ doapr_outch(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
                         if (*buffer == NULL) {
                                 if (*maxlen == 0)
                                         *maxlen = 1024;
-                                *buffer = OPENSSL_malloc(*maxlen);
+                                *buffer = malloc(*maxlen);
                                 if (*currlen > 0) {
                                         assert(*sbuffer != NULL);
                                         memcpy(*buffer, *sbuffer, *currlen);
@@ -714,7 +714,7 @@ doapr_outch(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
                                 *sbuffer = NULL;
                         } else {
                                 *maxlen += 1024;
-                                *buffer = OPENSSL_realloc(*buffer, *maxlen);
+                                *buffer = realloc(*buffer, *maxlen);
                         }
                 }
                 /* What to do if *buffer is NULL? */
@@ -764,7 +764,7 @@ int BIO_vprintf (BIO *bio, const char *format, va_list args)
             format, args);
         if (dynbuf) {
                 ret = BIO_write(bio, dynbuf, (int)retlen);
-                OPENSSL_free(dynbuf);
+                free(dynbuf);
         } else {
                 ret = BIO_write(bio, hugebuf, (int)retlen);
         }
diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c
index b08226d52b..1ae9d96577 100644
--- a/src/lib/libcrypto/bio/b_sock.c
+++ b/src/lib/libcrypto/bio/b_sock.c
@@ -490,7 +490,7 @@ again:
         ret = 1;
 err:
         if (str != NULL)
-                OPENSSL_free(str);
+                free(str);
         if ((ret == 0) && (s != -1)) {
                 close(s);
                 s = -1;
@@ -591,9 +591,9 @@ BIO_accept(int sock, char **addr)
                 p = *addr;
                 if (p) {
                         *p = '\0';
-                        p = OPENSSL_realloc(p, nl);
+                        p = realloc(p, nl);
                 } else {
-                        p = OPENSSL_malloc(nl);
+                        p = malloc(nl);
                 }
                 if (p == NULL) {
                         BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
@@ -609,7 +609,7 @@ BIO_accept(int sock, char **addr)
         l = ntohl(sa.from.sa_in.sin_addr.s_addr);
         port = ntohs(sa.from.sa_in.sin_port);
         if (*addr == NULL) {
-                if ((p = OPENSSL_malloc(24)) == NULL) {
+                if ((p = malloc(24)) == NULL) {
                         BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
                         goto end;
                 }
diff --git a/src/lib/libcrypto/bio/bf_buff.c b/src/lib/libcrypto/bio/bf_buff.c
index 937a1c58d5..be2ebab148 100644
--- a/src/lib/libcrypto/bio/bf_buff.c
+++ b/src/lib/libcrypto/bio/bf_buff.c
@@ -95,18 +95,18 @@ buffer_new(BIO *bi)
 {
         BIO_F_BUFFER_CTX *ctx;
 
-        ctx = (BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX));
+        ctx = (BIO_F_BUFFER_CTX *)malloc(sizeof(BIO_F_BUFFER_CTX));
         if (ctx == NULL)
                 return (0);
-        ctx->ibuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+        ctx->ibuf = (char *)malloc(DEFAULT_BUFFER_SIZE);
         if (ctx->ibuf == NULL) {
-                OPENSSL_free(ctx);
+                free(ctx);
                 return (0);
         }
-        ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+        ctx->obuf = (char *)malloc(DEFAULT_BUFFER_SIZE);
         if (ctx->obuf == NULL) {
-                OPENSSL_free(ctx->ibuf);
-                OPENSSL_free(ctx);
+                free(ctx->ibuf);
+                free(ctx);
                 return (0);
         }
         ctx->ibuf_size = DEFAULT_BUFFER_SIZE;
@@ -131,10 +131,10 @@ buffer_free(BIO *a)
                 return (0);
         b = (BIO_F_BUFFER_CTX *)a->ptr;
         if (b->ibuf != NULL)
-                OPENSSL_free(b->ibuf);
+                free(b->ibuf);
         if (b->obuf != NULL)
-                OPENSSL_free(b->obuf);
-        OPENSSL_free(a->ptr);
+                free(b->obuf);
+        free(a->ptr);
         a->ptr = NULL;
         a->init = 0;
         a->flags = 0;
@@ -339,11 +339,11 @@ buffer_ctrl(BIO *b, int cmd, long num, void *ptr)
                 break;
         case BIO_C_SET_BUFF_READ_DATA:
                 if (num > ctx->ibuf_size) {
-                        p1 = OPENSSL_malloc((int)num);
+                        p1 = malloc((int)num);
                         if (p1 == NULL)
                                 goto malloc_error;
                         if (ctx->ibuf != NULL)
-                                OPENSSL_free(ctx->ibuf);
+                                free(ctx->ibuf);
                         ctx->ibuf = p1;
                 }
                 ctx->ibuf_off = 0;
@@ -370,27 +370,27 @@ buffer_ctrl(BIO *b, int cmd, long num, void *ptr)
                 p1 = ctx->ibuf;
                 p2 = ctx->obuf;
                 if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) {
-                        p1 = (char *)OPENSSL_malloc((int)num);
+                        p1 = (char *)malloc((int)num);
                         if (p1 == NULL)
                                 goto malloc_error;
                 }
                 if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) {
-                        p2 = (char *)OPENSSL_malloc((int)num);
+                        p2 = (char *)malloc((int)num);
                         if (p2 == NULL) {
                                 if (p1 != ctx->ibuf)
-                                        OPENSSL_free(p1);
+                                        free(p1);
                                 goto malloc_error;
                         }
                 }
                 if (ctx->ibuf != p1) {
-                        OPENSSL_free(ctx->ibuf);
+                        free(ctx->ibuf);
                         ctx->ibuf = p1;
                         ctx->ibuf_off = 0;
                         ctx->ibuf_len = 0;
                         ctx->ibuf_size = ibs;
                 }
                 if (ctx->obuf != p2) {
-                        OPENSSL_free(ctx->obuf);
+                        free(ctx->obuf);
                         ctx->obuf = p2;
                         ctx->obuf_off = 0;
                         ctx->obuf_len = 0;
diff --git a/src/lib/libcrypto/bio/bf_lbuf.c b/src/lib/libcrypto/bio/bf_lbuf.c
index 006ed9d91c..5020795ded 100644
--- a/src/lib/libcrypto/bio/bf_lbuf.c
+++ b/src/lib/libcrypto/bio/bf_lbuf.c
@@ -106,12 +106,12 @@ linebuffer_new(BIO *bi)
 {
         BIO_LINEBUFFER_CTX *ctx;
 
-        ctx = (BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX));
+        ctx = (BIO_LINEBUFFER_CTX *)malloc(sizeof(BIO_LINEBUFFER_CTX));
         if (ctx == NULL)
                 return (0);
-        ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE);
+        ctx->obuf = (char *)malloc(DEFAULT_LINEBUFFER_SIZE);
         if (ctx->obuf == NULL) {
-                OPENSSL_free(ctx);
+                free(ctx);
                 return (0);
         }
         ctx->obuf_size = DEFAULT_LINEBUFFER_SIZE;
@@ -132,8 +132,8 @@ linebuffer_free(BIO *a)
                 return (0);
         b = (BIO_LINEBUFFER_CTX *)a->ptr;
         if (b->obuf != NULL)
-                OPENSSL_free(b->obuf);
-        OPENSSL_free(a->ptr);
+                free(b->obuf);
+        free(a->ptr);
         a->ptr = NULL;
         a->init = 0;
         a->flags = 0;
@@ -299,7 +299,7 @@ linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr)
                 obs = (int)num;
                 p = ctx->obuf;
                 if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) {
-                        p = (char *)OPENSSL_malloc((int)num);
+                        p = (char *)malloc((int)num);
                         if (p == NULL)
                                 goto malloc_error;
                 }
@@ -308,7 +308,7 @@ linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr)
                                 ctx->obuf_len = obs;
                         }
                         memcpy(p, ctx->obuf, ctx->obuf_len);
-                        OPENSSL_free(ctx->obuf);
+                        free(ctx->obuf);
                         ctx->obuf = p;
                         ctx->obuf_size = obs;
                 }
diff --git a/src/lib/libcrypto/bio/bf_nbio.c b/src/lib/libcrypto/bio/bf_nbio.c
index d181f518ec..200ca706ff 100644
--- a/src/lib/libcrypto/bio/bf_nbio.c
+++ b/src/lib/libcrypto/bio/bf_nbio.c
@@ -104,7 +104,7 @@ nbiof_new(BIO *bi)
 {
         NBIO_TEST *nt;
 
-        if (!(nt = (NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST))))
+        if (!(nt = (NBIO_TEST *)malloc(sizeof(NBIO_TEST))))
                 return (0);
         nt->lrn = -1;
         nt->lwn = -1;
@@ -120,7 +120,7 @@ nbiof_free(BIO *a)
         if (a == NULL)
                 return (0);
         if (a->ptr != NULL)
-                OPENSSL_free(a->ptr);
+                free(a->ptr);
         a->ptr = NULL;
         a->init = 0;
         a->flags = 0;
diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c
index 90f1b1c1ef..c226d943af 100644
--- a/src/lib/libcrypto/bio/bio_lib.c
+++ b/src/lib/libcrypto/bio/bio_lib.c
@@ -68,13 +68,13 @@ BIO
 {
         BIO *ret = NULL;
 
-        ret = (BIO *)OPENSSL_malloc(sizeof(BIO));
+        ret = (BIO *)malloc(sizeof(BIO));
         if (ret == NULL) {
                 BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE);
                 return (NULL);
         }
         if (!BIO_set(ret, method)) {
-                OPENSSL_free(ret);
+                free(ret);
                 ret = NULL;
         }
         return (ret);
@@ -136,7 +136,7 @@ BIO_free(BIO *a)
         if ((a->method == NULL) || (a->method->destroy == NULL))
                 return (1);
         a->method->destroy(a);
-        OPENSSL_free(a);
+        free(a);
         return (1);
 }
 
diff --git a/src/lib/libcrypto/bio/bss_acpt.c b/src/lib/libcrypto/bio/bss_acpt.c
index d7c151eaaa..161b5d01f8 100644
--- a/src/lib/libcrypto/bio/bss_acpt.c
+++ b/src/lib/libcrypto/bio/bss_acpt.c
@@ -137,7 +137,7 @@ static BIO_ACCEPT
 {
         BIO_ACCEPT *ret;
 
-        if ((ret = (BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL)
+        if ((ret = (BIO_ACCEPT *)malloc(sizeof(BIO_ACCEPT))) == NULL)
                 return (NULL);
 
         memset(ret, 0, sizeof(BIO_ACCEPT));
@@ -153,12 +153,12 @@ BIO_ACCEPT_free(BIO_ACCEPT *a)
                 return;
 
         if (a->param_addr != NULL)
-                OPENSSL_free(a->param_addr);
+                free(a->param_addr);
         if (a->addr != NULL)
-                OPENSSL_free(a->addr);
+                free(a->addr);
         if (a->bio_chain != NULL)
                 BIO_free(a->bio_chain);
-        OPENSSL_free(a);
+        free(a);
 }
 
 static void
@@ -357,7 +357,7 @@ acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
                         if (num == 0) {
                                 b->init = 1;
                                 if (data->param_addr != NULL)
-                                        OPENSSL_free(data->param_addr);
+                                        free(data->param_addr);
                                 data->param_addr = BUF_strdup(ptr);
                         } else if (num == 1) {
                                 data->accept_nbio = (ptr != NULL);
diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c
index a74fcfdabc..4d93aba0a4 100644
--- a/src/lib/libcrypto/bio/bss_bio.c
+++ b/src/lib/libcrypto/bio/bss_bio.c
@@ -146,7 +146,7 @@ bio_new(BIO *bio)
 {
         struct bio_bio_st *b;
 
-        b = OPENSSL_malloc(sizeof *b);
+        b = malloc(sizeof *b);
         if (b == NULL)
                 return 0;
 
@@ -173,10 +173,10 @@ bio_free(BIO *bio)
                 bio_destroy_pair(bio);
 
         if (b->buf != NULL) {
-                OPENSSL_free(b->buf);
+                free(b->buf);
         }
 
-        OPENSSL_free(b);
+        free(b);
 
         return 1;
 }
@@ -516,7 +516,7 @@ bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
 
                         if (b->size != new_size) {
                                 if (b->buf) {
-                                        OPENSSL_free(b->buf);
+                                        free(b->buf);
                                         b->buf = NULL;
                                 }
                                 b->size = new_size;
@@ -701,7 +701,7 @@ bio_make_pair(BIO *bio1, BIO *bio2)
         }
 
         if (b1->buf == NULL) {
-                b1->buf = OPENSSL_malloc(b1->size);
+                b1->buf = malloc(b1->size);
                 if (b1->buf == NULL) {
                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
                         return 0;
@@ -711,7 +711,7 @@ bio_make_pair(BIO *bio1, BIO *bio2)
         }
 
         if (b2->buf == NULL) {
-                b2->buf = OPENSSL_malloc(b2->size);
+                b2->buf = malloc(b2->size);
                 if (b2->buf == NULL) {
                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
                         return 0;
diff --git a/src/lib/libcrypto/bio/bss_conn.c b/src/lib/libcrypto/bio/bss_conn.c
index db877b140b..78ce240648 100644
--- a/src/lib/libcrypto/bio/bss_conn.c
+++ b/src/lib/libcrypto/bio/bss_conn.c
@@ -147,7 +147,7 @@ conn_state(BIO *b, BIO_CONNECT *c)
                                                         break;
                                                 }
                                         if (c->param_port != NULL)
-                                                OPENSSL_free(c->param_port);
+                                                free(c->param_port);
                                         c->param_port = BUF_strdup(p);
                                 }
                         }
@@ -293,7 +293,7 @@ BIO_CONNECT
 {
         BIO_CONNECT *ret;
 
-        if ((ret = (BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL)
+        if ((ret = (BIO_CONNECT *)malloc(sizeof(BIO_CONNECT))) == NULL)
                 return (NULL);
         ret->state = BIO_CONN_S_BEFORE;
         ret->param_hostname = NULL;
@@ -316,10 +316,10 @@ BIO_CONNECT_free(BIO_CONNECT *a)
                 return;
 
         if (a->param_hostname != NULL)
-                OPENSSL_free(a->param_hostname);
+                free(a->param_hostname);
         if (a->param_port != NULL)
-                OPENSSL_free(a->param_port);
-        OPENSSL_free(a);
+                free(a->param_port);
+        free(a);
 }
 
 BIO_METHOD
@@ -470,11 +470,11 @@ conn_ctrl(BIO *b, int cmd, long num, void *ptr)
                         b->init = 1;
                         if (num == 0) {
                                 if (data->param_hostname != NULL)
-                                        OPENSSL_free(data->param_hostname);
+                                        free(data->param_hostname);
                                 data->param_hostname = BUF_strdup(ptr);
                         } else if (num == 1) {
                                 if (data->param_port != NULL)
-                                        OPENSSL_free(data->param_port);
+                                        free(data->param_port);
                                 data->param_port = BUF_strdup(ptr);
                         } else if (num == 2) {
                                 char buf[16];
@@ -483,7 +483,7 @@ conn_ctrl(BIO *b, int cmd, long num, void *ptr)
                                 (void) snprintf(buf, sizeof buf, "%d.%d.%d.%d",
                                     p[0], p[1], p[2], p[3]);
                                 if (data->param_hostname != NULL)
-                                        OPENSSL_free(data->param_hostname);
+                                        free(data->param_hostname);
                                 data->param_hostname = BUF_strdup(buf);
                                 memcpy(&(data->ip[0]), ptr, 4);
                         } else if (num == 3) {
@@ -492,7 +492,7 @@ conn_ctrl(BIO *b, int cmd, long num, void *ptr)
                                 (void) snprintf(buf, sizeof buf, "%d",
                                     *(int *)ptr);
                                 if (data->param_port != NULL)
-                                        OPENSSL_free(data->param_port);
+                                        free(data->param_port);
                                 data->param_port = BUF_strdup(buf);
                                 data->port= *(int *)ptr;
                         }
diff --git a/src/lib/libcrypto/bio/bss_dgram.c b/src/lib/libcrypto/bio/bss_dgram.c
index 478c765399..e0445fc97e 100644
--- a/src/lib/libcrypto/bio/bss_dgram.c
+++ b/src/lib/libcrypto/bio/bss_dgram.c
@@ -212,7 +212,7 @@ dgram_new(BIO *bi)
 
         bi->init = 0;
         bi->num = 0;
-        data = OPENSSL_malloc(sizeof(bio_dgram_data));
+        data = malloc(sizeof(bio_dgram_data));
         if (data == NULL)
                 return 0;
         memset(data, 0x00, sizeof(bio_dgram_data));
@@ -234,7 +234,7 @@ dgram_free(BIO *a)
 
         data = (bio_dgram_data *)a->ptr;
         if (data != NULL)
-                OPENSSL_free(data);
+                free(data);
 
         return (1);
 }
@@ -805,7 +805,7 @@ BIO
          * SCTP-AUTH has to be activated for the listening socket
          * already, otherwise the connected socket won't use it. */
         sockopt_len = (socklen_t)(sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
-        authchunks = OPENSSL_malloc(sockopt_len);
+        authchunks = malloc(sockopt_len);
         memset(authchunks, 0, sizeof(sockopt_len));
         ret = getsockopt(fd, IPPROTO_SCTP, SCTP_LOCAL_AUTH_CHUNKS, authchunks, &sockopt_len);
         OPENSSL_assert(ret >= 0);
@@ -819,7 +819,7 @@ BIO
                         auth_forward = 1;
         }
 
-        OPENSSL_free(authchunks);
+        free(authchunks);
 
         OPENSSL_assert(auth_data);
         OPENSSL_assert(auth_forward);
@@ -866,7 +866,7 @@ dgram_sctp_new(BIO *bi)
 
         bi->init = 0;
         bi->num = 0;
-        data = OPENSSL_malloc(sizeof(bio_dgram_sctp_data));
+        data = malloc(sizeof(bio_dgram_sctp_data));
         if (data == NULL)
                 return 0;
         memset(data, 0x00, sizeof(bio_dgram_sctp_data));
@@ -891,7 +891,7 @@ dgram_sctp_free(BIO *a)
 
         data = (bio_dgram_sctp_data *)a->ptr;
         if (data != NULL)
-                OPENSSL_free(data);
+                free(data);
 
         return (1);
 }
@@ -998,7 +998,7 @@ dgram_sctp_read(BIO *b, char *out, int outl)
                                         if (data->saved_message.length > 0) {
                                                 dgram_sctp_write(data->saved_message.bio, data->saved_message.data,
                                                 data->saved_message.length);
-                                                OPENSSL_free(data->saved_message.data);
+                                                free(data->saved_message.data);
                                                 data->saved_message.length = 0;
                                         }
 
@@ -1087,7 +1087,7 @@ dgram_sctp_read(BIO *b, char *out, int outl)
                         struct sctp_authchunks *authchunks;
 
                         optlen = (socklen_t)(sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
-                        authchunks = OPENSSL_malloc(optlen);
+                        authchunks = malloc(optlen);
                         memset(authchunks, 0, sizeof(optlen));
                         ii = getsockopt(b->num, IPPROTO_SCTP, SCTP_PEER_AUTH_CHUNKS, authchunks, &optlen);
                         OPENSSL_assert(ii >= 0);
@@ -1101,7 +1101,7 @@ dgram_sctp_read(BIO *b, char *out, int outl)
                                         auth_forward = 1;
                         }
 
-                        OPENSSL_free(authchunks);
+                        free(authchunks);
 
                         if (!auth_data || !auth_forward) {
                                 BIOerr(BIO_F_DGRAM_SCTP_READ, BIO_R_CONNECT_ERROR);
@@ -1154,7 +1154,7 @@ dgram_sctp_write(BIO *b, const char *in, int inl)
         if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b)) {
                 data->saved_message.bio = b;
                 data->saved_message.length = inl;
-                data->saved_message.data = OPENSSL_malloc(inl);
+                data->saved_message.data = malloc(inl);
                 memcpy(data->saved_message.data, in, inl);
                 return inl;
         }
@@ -1282,7 +1282,7 @@ dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr)
 
                 /* Add new key */
                 sockopt_len = sizeof(struct sctp_authkey) + 64 * sizeof(uint8_t);
-                authkey = OPENSSL_malloc(sockopt_len);
+                authkey = malloc(sockopt_len);
                 memset(authkey, 0x00, sockopt_len);
                 authkey->sca_keynumber = authkeyid.scact_keynumber + 1;
 #ifndef __FreeBSD__
diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c
index 2d38837f9e..cde3c858f1 100644
--- a/src/lib/libcrypto/bio/bss_log.c
+++ b/src/lib/libcrypto/bio/bss_log.c
@@ -157,7 +157,7 @@ slg_write(BIO *b, const char *in, int inl)
                 { 0, "", LOG_ERR } /* The default */
         };
 
-        if ((buf = (char *)OPENSSL_malloc(inl + 1)) == NULL) {
+        if ((buf = (char *)malloc(inl + 1)) == NULL) {
                 return (0);
         }
         strlcpy(buf, in, inl + 1);
@@ -169,7 +169,7 @@ slg_write(BIO *b, const char *in, int inl)
 
         xsyslog(b, priority, pp);
 
-        OPENSSL_free(buf);
+        free(buf);
         return (ret);
 }