*argv=NULL;
len=(unsigned int)stbuf.st_size;
- if (buf != NULL) Free(buf);
- buf=(char *)Malloc(len+1);
+ if (buf != NULL) OPENSSL_free(buf);
+ buf=(char *)OPENSSL_malloc(len+1);
if (buf == NULL) return(0);
len=fread(buf,1,len,fp);
i=0;
for (p=buf; *p; p++)
if (*p == '\n') i++;
- if (arg != NULL) Free(arg);
- arg=(char **)Malloc(sizeof(char *)*(i*2));
+ if (arg != NULL) OPENSSL_free(arg);
+ arg=(char **)OPENSSL_malloc(sizeof(char *)*(i*2));
*argv=arg;
num=0;
if (arg->count == 0)
{
arg->count=20;
- arg->data=(char **)Malloc(sizeof(char *)*arg->count);
+ arg->data=(char **)OPENSSL_malloc(sizeof(char *)*arg->count);
}
for (i=0; i<arg->count; i++)
arg->data[i]=NULL;
if (num >= arg->count)
{
arg->count+=20;
- arg->data=(char **)Realloc(arg->data,
+ arg->data=(char **)OPENSSL_realloc(arg->data,
sizeof(char *)*arg->count);
if (argc == 0) return(0);
}
argv++;
if ((osk=sk_new_null()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto end;
}
while (argc >= 1)
{
if ((f=BN_bn2hex(serial)) == NULL) goto err;
BIO_printf(bio_err,"next serial number is %s\n",f);
- Free(f);
+ OPENSSL_free(f);
}
if ((attribs=CONF_get_section(conf,policy)) == NULL)
if ((cert_sk=sk_X509_new_null()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
if (spkac_file != NULL)
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
if (outfile)
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
if (!BN_add_word(serial,1)) goto err;
if (!sk_X509_push(cert_sk,x))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
/* Ok, now we check the 'policy' stuff. */
if ((subject=X509_NAME_new()) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
{
if (push != NULL)
X509_NAME_ENTRY_free(push);
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
}
row[DB_serial]=BN_bn2hex(serial);
if ((row[DB_name] == NULL) || (row[DB_serial] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
goto err;
/* We now just add it to the database */
- row[DB_type]=(char *)Malloc(2);
+ row[DB_type]=(char *)OPENSSL_malloc(2);
tm=X509_get_notAfter(ret);
- row[DB_exp_date]=(char *)Malloc(tm->length+1);
+ row[DB_exp_date]=(char *)OPENSSL_malloc(tm->length+1);
memcpy(row[DB_exp_date],tm->data,tm->length);
row[DB_exp_date][tm->length]='\0';
row[DB_rev_date]=NULL;
/* row[DB_serial] done already */
- row[DB_file]=(char *)Malloc(8);
+ row[DB_file]=(char *)OPENSSL_malloc(8);
/* row[DB_name] done already */
if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
(row[DB_file] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
strcpy(row[DB_file],"unknown");
row[DB_type][0]='V';
row[DB_type][1]='\0';
- if ((irow=(char **)Malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
+ if ((irow=(char **)OPENSSL_malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
ok=1;
err:
for (i=0; i<DB_NUMBER; i++)
- if (row[i] != NULL) Free(row[i]);
+ if (row[i] != NULL) OPENSSL_free(row[i]);
if (CAname != NULL)
X509_NAME_free(CAname);
BN_free(bn);
if ((row[DB_name] == NULL) || (row[DB_serial] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
/* We have to lookup by serial number because name lookup
BIO_printf(bio_err,"Adding Entry to DB for %s\n", row[DB_name]);
/* We now just add it to the database */
- row[DB_type]=(char *)Malloc(2);
+ row[DB_type]=(char *)OPENSSL_malloc(2);
tm=X509_get_notAfter(x509);
- row[DB_exp_date]=(char *)Malloc(tm->length+1);
+ row[DB_exp_date]=(char *)OPENSSL_malloc(tm->length+1);
memcpy(row[DB_exp_date],tm->data,tm->length);
row[DB_exp_date][tm->length]='\0';
row[DB_rev_date]=NULL;
/* row[DB_serial] done already */
- row[DB_file]=(char *)Malloc(8);
+ row[DB_file]=(char *)OPENSSL_malloc(8);
/* row[DB_name] done already */
if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
(row[DB_file] == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
strcpy(row[DB_file],"unknown");
row[DB_type][0]='V';
row[DB_type][1]='\0';
- if ((irow=(char **)Malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
+ if ((irow=(char **)OPENSSL_malloc(sizeof(char *)*(DB_NUMBER+1))) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto err;
}
revtm=X509_gmtime_adj(revtm,0);
rrow[DB_type][0]='R';
rrow[DB_type][1]='\0';
- rrow[DB_rev_date]=(char *)Malloc(revtm->length+1);
+ rrow[DB_rev_date]=(char *)OPENSSL_malloc(revtm->length+1);
memcpy(rrow[DB_rev_date],revtm->data,revtm->length);
rrow[DB_rev_date][revtm->length]='\0';
ASN1_UTCTIME_free(revtm);
for (i=0; i<DB_NUMBER; i++)
{
if (row[i] != NULL)
- Free(row[i]);
+ OPENSSL_free(row[i]);
}
return(ok);
}
if (crl != NULL)
{
sk_X509_CRL_push(crl_stack,crl);
- crl=NULL; /* now part of p7 for Freeing */
+ crl=NULL; /* now part of p7 for OPENSSL_freeing */
}
if ((cert_stack=sk_X509_new(NULL)) == NULL) goto end;
ret=count;
end:
- /* never need to Free x */
+ /* never need to OPENSSL_free x */
if (in != NULL) BIO_free(in);
if (sk != NULL) sk_X509_INFO_free(sk);
return(ret);
apps_startup();
- if ((buf=(unsigned char *)Malloc(BUFSIZE)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
if (buf != NULL)
{
memset(buf,0,BUFSIZE);
- Free(buf);
+ OPENSSL_free(buf);
}
if (in != NULL) BIO_free(in);
if (bmd != NULL) BIO_free(bmd);
len=BN_num_bytes(dh->p);
bits=BN_num_bits(dh->p);
- data=(unsigned char *)Malloc(len);
+ data=(unsigned char *)OPENSSL_malloc(len);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
l=BN_bn2bin(dh->p,data);
printf("\tif ((dh->p == NULL) || (dh->g == NULL))\n");
printf("\t\treturn(NULL);\n");
printf("\treturn(dh);\n\t}\n");
- Free(data);
+ OPENSSL_free(data);
}
len=BN_num_bytes(dh->p);
bits=BN_num_bits(dh->p);
- data=(unsigned char *)Malloc(len);
+ data=(unsigned char *)OPENSSL_malloc(len);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
printf("#ifndef HEADER_DH_H\n"
if (dh->length)
printf("\tdh->length = %d;\n", dh->length);
printf("\treturn(dh);\n\t}\n");
- Free(data);
+ OPENSSL_free(data);
}
if(in != NULL) BIO_free(in);
if(out != NULL) BIO_free(out);
if(dsa != NULL) DSA_free(dsa);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#endif
bits_p=BN_num_bits(dsa->p);
bits_q=BN_num_bits(dsa->q);
bits_g=BN_num_bits(dsa->g);
- data=(unsigned char *)Malloc(len+20);
+ data=(unsigned char *)OPENSSL_malloc(len+20);
if (data == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
goto end;
}
l=BN_bn2bin(dsa->p,data);
if (verbose) BIO_printf(bio_err,"bufsize=%d\n",bsize);
}
- strbuf=Malloc(SIZE);
- buff=(unsigned char *)Malloc(EVP_ENCODE_LENGTH(bsize));
+ strbuf=OPENSSL_malloc(SIZE);
+ buff=(unsigned char *)OPENSSL_malloc(EVP_ENCODE_LENGTH(bsize));
if ((buff == NULL) || (strbuf == NULL))
{
- BIO_printf(bio_err,"Malloc failure %ld\n",(long)EVP_ENCODE_LENGTH(bsize));
+ BIO_printf(bio_err,"OPENSSL_malloc failure %ld\n",(long)EVP_ENCODE_LENGTH(bsize));
goto end;
}
}
end:
ERR_print_errors(bio_err);
- if (strbuf != NULL) Free(strbuf);
- if (buff != NULL) Free(buff);
+ if (strbuf != NULL) OPENSSL_free(strbuf);
+ if (buff != NULL) OPENSSL_free(buff);
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (benc != NULL) BIO_free(benc);
if (b64 != NULL) BIO_free(b64);
- if(pass) Free(pass);
+ if(pass) OPENSSL_free(pass);
EXIT(ret);
}
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (dsa != NULL) DSA_free(dsa);
- if(passout) Free(passout);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#endif
err:
if (rsa != NULL) RSA_free(rsa);
if (out != NULL) BIO_free(out);
- if(passout) Free(passout);
+ if(passout) OPENSSL_free(passout);
if (ret != 0)
ERR_print_errors(bio_err);
EXIT(ret);
config=NULL;
}
if (prog != NULL) lh_free(prog);
- if (arg.data != NULL) Free(arg.data);
+ if (arg.data != NULL) OPENSSL_free(arg.data);
ERR_remove_state(0);
EVP_cleanup();
passwd_malloc_size = pw_maxlen + 2;
/* longer than necessary so that we can warn about truncation */
- passwd = passwd_malloc = Malloc(passwd_malloc_size);
+ passwd = passwd_malloc = OPENSSL_malloc(passwd_malloc_size);
if (passwd_malloc == NULL)
goto err;
}
err:
ERR_print_errors(bio_err);
if (salt_malloc)
- Free(salt_malloc);
+ OPENSSL_free(salt_malloc);
if (passwd_malloc)
- Free(passwd_malloc);
+ OPENSSL_free(passwd_malloc);
if (in)
BIO_free(in);
if (out)
{
if (*salt_malloc_p == NULL)
{
- *salt_p = *salt_malloc_p = Malloc(3);
+ *salt_p = *salt_malloc_p = OPENSSL_malloc(3);
if (*salt_malloc_p == NULL)
goto err;
}
if (*salt_malloc_p == NULL)
{
- *salt_p = *salt_malloc_p = Malloc(9);
+ *salt_p = *salt_malloc_p = OPENSSL_malloc(9);
if (*salt_malloc_p == NULL)
goto err;
}
#endif
BIO_free(in);
BIO_free(out);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
value = uni2asc(av->value.bmpstring->data,
av->value.bmpstring->length);
BIO_printf(out, "%s\n", value);
- Free(value);
+ OPENSSL_free(value);
break;
case V_ASN1_OCTET_STRING:
PKCS8_PRIV_KEY_INFO_free (p8inf);
EVP_PKEY_free(pkey);
BIO_free(out);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
return (0);
}
EVP_PKEY_free(pkey);
BIO_free(out);
BIO_free(in);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
return (0);
}
EVP_PKEY_free(pkey);
X509_REQ_free(req);
X509_free(x509ss);
- if(passargin && passin) Free(passin);
- if(passargout && passout) Free(passout);
+ if(passargin && passin) OPENSSL_free(passin);
+ if(passargout && passout) OPENSSL_free(passout);
OBJ_cleanup();
#ifndef NO_DSA
if (dsa_params != NULL) DSA_free(dsa_params);
i=1;
size=i2d_Netscape_RSA(rsa,NULL,NULL);
- if ((p=(unsigned char *)Malloc(size)) == NULL)
+ if ((p=(unsigned char *)OPENSSL_malloc(size)) == NULL)
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"Memory allocation failure\n");
goto end;
}
pp=p;
i2d_Netscape_RSA(rsa,&p,NULL);
BIO_write(out,(char *)pp,size);
- Free(pp);
+ OPENSSL_free(pp);
}
#endif
else if (outformat == FORMAT_PEM) {
if(in != NULL) BIO_free(in);
if(out != NULL) BIO_free(out);
if(rsa != NULL) RSA_free(rsa);
- if(passin) Free(passin);
- if(passout) Free(passout);
+ if(passin) OPENSSL_free(passin);
+ if(passout) OPENSSL_free(passout);
EXIT(ret);
}
#else /* !NO_RSA */
if (bio_err == NULL)
bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
- if ( ((cbuf=Malloc(BUFSIZZ)) == NULL) ||
- ((sbuf=Malloc(BUFSIZZ)) == NULL))
+ if ( ((cbuf=OPENSSL_malloc(BUFSIZZ)) == NULL) ||
+ ((sbuf=OPENSSL_malloc(BUFSIZZ)) == NULL))
{
BIO_printf(bio_err,"out of memory\n");
goto end;
if (con != NULL) SSL_free(con);
if (con2 != NULL) SSL_free(con2);
if (ctx != NULL) SSL_CTX_free(ctx);
- if (cbuf != NULL) { memset(cbuf,0,BUFSIZZ); Free(cbuf); }
- if (sbuf != NULL) { memset(sbuf,0,BUFSIZZ); Free(sbuf); }
+ if (cbuf != NULL) { memset(cbuf,0,BUFSIZZ); OPENSSL_free(cbuf); }
+ if (sbuf != NULL) { memset(sbuf,0,BUFSIZZ); OPENSSL_free(sbuf); }
if (bio_c_out != NULL)
{
BIO_free(bio_c_out);
{
EBCDIC_OUTBUFF *wbuf;
- wbuf = (EBCDIC_OUTBUFF *)Malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
+ wbuf = (EBCDIC_OUTBUFF *)OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + 1024);
wbuf->alloced = 1024;
wbuf->buff[0] = '\0';
{
if (a == NULL) return(0);
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
num = num + num; /* double the size */
if (num < inl)
num = inl;
- Free(wbuf);
- wbuf=(EBCDIC_OUTBUFF *)Malloc(sizeof(EBCDIC_OUTBUFF) + num);
+ OPENSSL_free(wbuf);
+ wbuf=(EBCDIC_OUTBUFF *)OPENSSL_malloc(sizeof(EBCDIC_OUTBUFF) + num);
wbuf->alloced = num;
wbuf->buff[0] = '\0';
struct timeval tv;
#endif
- if ((buf=Malloc(bufsize)) == NULL)
+ if ((buf=OPENSSL_malloc(bufsize)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto err;
if (buf != NULL)
{
memset(buf,0,bufsize);
- Free(buf);
+ OPENSSL_free(buf);
}
if (ret >= 0)
BIO_printf(bio_s_out,"ACCEPT\n");
BIO *io,*ssl_bio,*sbio;
long total_bytes;
- buf=Malloc(bufsize);
+ buf=OPENSSL_malloc(bufsize);
if (buf == NULL) return(0);
io=BIO_new(BIO_f_buffer());
ssl_bio=BIO_new(BIO_f_ssl());
if (ret >= 0)
BIO_printf(bio_s_out,"ACCEPT\n");
- if (buf != NULL) Free(buf);
+ if (buf != NULL) OPENSSL_free(buf);
if (io != NULL) BIO_free_all(io);
/* if (ssl_bio != NULL) BIO_free(ssl_bio);*/
return(ret);
return(0);
}
i=(*cb)(name,sock, context);
- if (name != NULL) Free(name);
+ if (name != NULL) OPENSSL_free(name);
SHUTDOWN2(sock);
if (i < 0)
{
}
else
{
- if ((*host=(char *)Malloc(strlen(h1->h_name)+1)) == NULL)
+ if ((*host=(char *)OPENSSL_malloc(strlen(h1->h_name)+1)) == NULL)
{
- perror("Malloc");
+ perror("OPENSSL_malloc");
return(0);
}
strcpy(*host,h1->h_name);
BIO_free(in);
BIO_free(indata);
BIO_free(out);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
return (ret);
}
rsa_key[i]=NULL;
#endif
- if ((buf=(unsigned char *)Malloc((int)BUFSIZE)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
#ifndef NO_DES
buf_as_des_cblock = (des_cblock *)buf;
#endif
- if ((buf2=(unsigned char *)Malloc((int)BUFSIZE)) == NULL)
+ if ((buf2=(unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL)
{
BIO_printf(bio_err,"out of memory\n");
goto end;
#endif
mret=0;
end:
- if (buf != NULL) Free(buf);
- if (buf2 != NULL) Free(buf2);
+ if (buf != NULL) OPENSSL_free(buf);
+ if (buf2 != NULL) OPENSSL_free(buf2);
#ifndef NO_RSA
for (i=0; i<RSA_NUM; i++)
if (rsa_key[i] != NULL)
goto end;
}
BIO_printf(out, "SPKAC=%s\n", spkstr);
- Free(spkstr);
+ OPENSSL_free(spkstr);
ret = 0;
goto end;
}
BIO_free(out);
BIO_free(key);
EVP_PKEY_free(pkey);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
EXIT(ret);
}
BIO_printf(STDout,"/* issuer :%s */\n",buf);
z=i2d_X509(x,NULL);
- m=Malloc(z);
+ m=OPENSSL_malloc(z);
d=(unsigned char *)m;
z=i2d_X509_NAME(X509_get_subject_name(x),&d);
if (y%16 != 0) BIO_printf(STDout,"\n");
BIO_printf(STDout,"};\n");
- Free(m);
+ OPENSSL_free(m);
}
else if (text == i)
{
X509_REQ_free(rq);
sk_ASN1_OBJECT_pop_free(trust, ASN1_OBJECT_free);
sk_ASN1_OBJECT_pop_free(reject, ASN1_OBJECT_free);
- if(passin) Free(passin);
+ if(passin) OPENSSL_free(passin);
EXIT(ret);
}
EVP_PKEY_free(upkey);
X509_STORE_CTX_init(&xsc,ctx,x,NULL);
- buf=Malloc(EVP_PKEY_size(pkey)*2+
+ buf=OPENSSL_malloc(EVP_PKEY_size(pkey)*2+
((serialfile == NULL)
?(strlen(CAfile)+strlen(POSTFIX)+1)
:(strlen(serialfile)))+1);
X509_STORE_CTX_cleanup(&xsc);
if (!ret)
ERR_print_errors(bio_err);
- if (buf != NULL) Free(buf);
+ if (buf != NULL) OPENSSL_free(buf);
if (bs != NULL) ASN1_INTEGER_free(bs);
if (io != NULL) BIO_free(io);
if (serial != NULL) BN_free(serial);
if (len-- > 1) /* using one because of the bits left byte */
{
- s=(unsigned char *)Malloc((int)len);
+ s=(unsigned char *)OPENSSL_malloc((int)len);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
s=NULL;
ret->length=(int)len;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->type=V_ASN1_BIT_STRING;
if (a != NULL) (*a)=ret;
{
if (!value) return(1); /* Don't need to set */
if (a->data == NULL)
- c=(unsigned char *)Malloc(w+1);
+ c=(unsigned char *)OPENSSL_malloc(w+1);
else
- c=(unsigned char *)Realloc(a->data,w+1);
+ c=(unsigned char *)OPENSSL_realloc(a->data,w+1);
if (c == NULL) return(0);
a->data=c;
a->length=w+1;
if (len != 0)
{
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
else
s=NULL;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->length=(int)len;
ret->data=s;
ret->type=tag;
{
if ((ret->length < len) || (ret->data == NULL))
{
- if (ret->data != NULL) Free(ret->data);
- s=(unsigned char *)Malloc((int)len + 1);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
+ s=(unsigned char *)OPENSSL_malloc((int)len + 1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
else
{
s=NULL;
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
}
ret->length=(int)len;
if (!asn1_Finish(c)) goto err;
a->length=num;
- if (a->data != NULL) Free(a->data);
+ if (a->data != NULL) OPENSSL_free(a->data);
a->data=(unsigned char *)b.data;
if (os != NULL) ASN1_STRING_free(os);
return(1);
err:
ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE,c->error);
if (os != NULL) ASN1_STRING_free(os);
- if (b.data != NULL) Free(b.data);
+ if (b.data != NULL) OPENSSL_free(b.data);
return(0);
}
unsigned char *str,*p;
i=i2d(data,NULL);
- if ((str=(unsigned char *)Malloc(i)) == NULL) return(0);
+ if ((str=(unsigned char *)OPENSSL_malloc(i)) == NULL) return(0);
p=str;
i2d(data,&p);
EVP_DigestInit(&ctx,type);
EVP_DigestUpdate(&ctx,str,i);
EVP_DigestFinal(&ctx,md,len);
- Free(str);
+ OPENSSL_free(str);
return(1);
}
if (x == NULL) return(NULL);
i=(long)i2d(x,NULL);
- b=(unsigned char *)Malloc((unsigned int)i+10);
+ b=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (b == NULL)
{ ASN1err(ASN1_F_ASN1_DUP,ERR_R_MALLOC_FAILURE); return(NULL); }
p= b;
i=i2d(x,&p);
p= b;
ret=d2i(NULL,&p,i);
- Free(b);
+ OPENSSL_free(b);
return(ret);
}
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
p+=len;
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
if (a->length < (sizeof(long)+1))
{
if (a->data != NULL)
- Free(a->data);
- if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)
+ OPENSSL_free(a->data);
+ if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
memset((char *)a->data,0,sizeof(long)+1);
}
if (a->data == NULL)
else ret->type=V_ASN1_ENUMERATED;
j=BN_num_bits(bn);
len=((j == 0)?0:((j/8)+1));
- ret->data=(unsigned char *)Malloc(len+4);
+ ret->data=(unsigned char *)OPENSSL_malloc(len+4);
ret->length=BN_bn2bin(bn,ret->data);
return(ret);
err:
p=(char *)s->data;
if ((p == NULL) || (s->length < 16))
{
- p=Malloc(20);
+ p=OPENSSL_malloc(20);
if (p == NULL) return(NULL);
if (s->data != NULL)
- Free(s->data);
+ OPENSSL_free(s->data);
s->data=(unsigned char *)p;
}
M_ASN1_OCTET_STRING_free(a->header);
if (a->meth != NULL)
a->meth->destroy(a->data);
- Free(a);
+ OPENSSL_free(a);
}
int i,j=0,n,ret=1;
n=i2d(x,NULL);
- b=(char *)Malloc(n);
+ b=(char *)OPENSSL_malloc(n);
if (b == NULL)
{
ASN1err(ASN1_F_ASN1_I2D_BIO,ERR_R_MALLOC_FAILURE);
j+=i;
n-=i;
}
- Free(b);
+ OPENSSL_free(b);
return(ret);
}
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
memcpy(s,p,(int)len);
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
goto err;
}
- /* We must Malloc stuff, even for 0 bytes otherwise it
+ /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
* signifies a missing NULL parameter. */
- s=(unsigned char *)Malloc((int)len+1);
+ s=(unsigned char *)OPENSSL_malloc((int)len+1);
if (s == NULL)
{
i=ERR_R_MALLOC_FAILURE;
p+=len;
}
- if (ret->data != NULL) Free(ret->data);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
ret->data=s;
ret->length=(int)len;
if (a != NULL) (*a)=ret;
if (a->length < (sizeof(long)+1))
{
if (a->data != NULL)
- Free(a->data);
- if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)
+ OPENSSL_free(a->data);
+ if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
memset((char *)a->data,0,sizeof(long)+1);
}
if (a->data == NULL)
else ret->type=V_ASN1_INTEGER;
j=BN_num_bits(bn);
len=((j == 0)?0:((j/8)+1));
- ret->data=(unsigned char *)Malloc(len+4);
+ ret->data=(unsigned char *)OPENSSL_malloc(len+4);
ret->length=BN_bn2bin(bn,ret->data);
return(ret);
err:
dest = *out;
if(dest->data) {
dest->length = 0;
- Free(dest->data);
+ OPENSSL_free(dest->data);
dest->data = NULL;
}
dest->type = str_type;
cpyfunc = cpy_utf8;
break;
}
- if(!(p = Malloc(outlen + 1))) {
+ if(!(p = OPENSSL_malloc(outlen + 1))) {
ASN1_STRING_free(dest);
ASN1err(ASN1_F_ASN1_MBSTRING_COPY,ERR_R_MALLOC_FAILURE);
return -1;
}
if ((ret->data == NULL) || (ret->length < len))
{
- if (ret->data != NULL) Free(ret->data);
- ret->data=(unsigned char *)Malloc(len ? (int)len : 1);
+ if (ret->data != NULL) OPENSSL_free(ret->data);
+ ret->data=(unsigned char *)OPENSSL_malloc(len ? (int)len : 1);
ret->flags|=ASN1_OBJECT_FLAG_DYNAMIC_DATA;
if (ret->data == NULL)
{ i=ERR_R_MALLOC_FAILURE; goto err; }
{
ASN1_OBJECT *ret;
- ret=(ASN1_OBJECT *)Malloc(sizeof(ASN1_OBJECT));
+ ret=(ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
if (ret == NULL)
{
ASN1err(ASN1_F_ASN1_OBJECT_NEW,ERR_R_MALLOC_FAILURE);
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS)
{
#ifndef CONST_STRICT /* disable purely for compile-time strict const checking. Doing this on a "real" compile will cause memory leaks */
- if (a->sn != NULL) Free((void *)a->sn);
- if (a->ln != NULL) Free((void *)a->ln);
+ if (a->sn != NULL) OPENSSL_free((void *)a->sn);
+ if (a->ln != NULL) OPENSSL_free((void *)a->ln);
#endif
a->sn=a->ln=NULL;
}
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA)
{
- if (a->data != NULL) Free(a->data);
+ if (a->data != NULL) OPENSSL_free(a->data);
a->data=NULL;
a->length=0;
}
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
- Free(a);
+ OPENSSL_free(a);
}
ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
}
pStart = p; /* Catch the beg of Setblobs*/
- rgSetBlob = (MYBLOB *)Malloc( sk_num(a) * sizeof(MYBLOB)); /* In this array
+ rgSetBlob = (MYBLOB *)OPENSSL_malloc( sk_num(a) * sizeof(MYBLOB)); /* In this array
we will store the SET blobs */
for (i=0; i<sk_num(a); i++)
/* Now we have to sort the blobs. I am using a simple algo.
*Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/
qsort( rgSetBlob, sk_num(a), sizeof(MYBLOB), SetBlobCmp);
- pTempMem = Malloc(totSize);
+ pTempMem = OPENSSL_malloc(totSize);
/* Copy to temp mem */
p = pTempMem;
/* Copy back to user mem*/
memcpy(pStart, pTempMem, totSize);
- Free(pTempMem);
- Free(rgSetBlob);
+ OPENSSL_free(pTempMem);
+ OPENSSL_free(rgSetBlob);
return(r);
}
}
}
inl=i2d(data,NULL);
- buf_in=(unsigned char *)Malloc((unsigned int)inl);
+ buf_in=(unsigned char *)OPENSSL_malloc((unsigned int)inl);
outll=outl=EVP_PKEY_size(pkey);
- buf_out=(unsigned char *)Malloc((unsigned int)outl);
+ buf_out=(unsigned char *)OPENSSL_malloc((unsigned int)outl);
if ((buf_in == NULL) || (buf_out == NULL))
{
outl=0;
ASN1err(ASN1_F_ASN1_SIGN,ERR_R_EVP_LIB);
goto err;
}
- if (signature->data != NULL) Free(signature->data);
+ if (signature->data != NULL) OPENSSL_free(signature->data);
signature->data=buf_out;
buf_out=NULL;
signature->length=outl;
err:
memset(&ctx,0,sizeof(ctx));
if (buf_in != NULL)
- { memset((char *)buf_in,0,(unsigned int)inl); Free(buf_in); }
+ { memset((char *)buf_in,0,(unsigned int)inl); OPENSSL_free(buf_in); }
if (buf_out != NULL)
- { memset((char *)buf_out,0,outll); Free(buf_out); }
+ { memset((char *)buf_out,0,outll); OPENSSL_free(buf_out); }
return(outl);
}
return 0;
}
if(!(tmp = ASN1_STRING_TABLE_get(nid))) {
- tmp = Malloc(sizeof(ASN1_STRING_TABLE));
+ tmp = OPENSSL_malloc(sizeof(ASN1_STRING_TABLE));
if(!tmp) {
ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD,
ERR_R_MALLOC_FAILURE);
static void st_free(ASN1_STRING_TABLE *tbl)
{
- if(tbl->flags & STABLE_FLAGS_MALLOC) Free(tbl);
+ if(tbl->flags & STABLE_FLAGS_MALLOC) OPENSSL_free(tbl);
}
IMPLEMENT_STACK_OF(ASN1_STRING_TABLE)
{
if (a == NULL) return;
ASN1_TYPE_component_free(a);
- Free(a);
+ OPENSSL_free(a);
}
int ASN1_TYPE_get(ASN1_TYPE *a)
p=(char *)s->data;
if ((p == NULL) || (s->length < 14))
{
- p=Malloc(20);
+ p=OPENSSL_malloc(20);
if (p == NULL) return(NULL);
if (s->data != NULL)
- Free(s->data);
+ OPENSSL_free(s->data);
s->data=(unsigned char *)p;
}
}
inl=i2d(data,NULL);
- buf_in=Malloc((unsigned int)inl);
+ buf_in=OPENSSL_malloc((unsigned int)inl);
if (buf_in == NULL)
{
ASN1err(ASN1_F_ASN1_VERIFY,ERR_R_MALLOC_FAILURE);
EVP_VerifyUpdate(&ctx,(unsigned char *)buf_in,inl);
memset(buf_in,0,(unsigned int)inl);
- Free(buf_in);
+ OPENSSL_free(buf_in);
if (EVP_VerifyFinal(&ctx,(unsigned char *)signature->data,
(unsigned int)signature->length,pkey) <= 0)
{
c=str->data;
if (c == NULL)
- str->data=Malloc(len+1);
+ str->data=OPENSSL_malloc(len+1);
else
- str->data=Realloc(c,len+1);
+ str->data=OPENSSL_realloc(c,len+1);
if (str->data == NULL)
{
{
ASN1_STRING *ret;
- ret=(ASN1_STRING *)Malloc(sizeof(ASN1_STRING));
+ ret=(ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
if (ret == NULL)
{
ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW,ERR_R_MALLOC_FAILURE);
void ASN1_STRING_free(ASN1_STRING *a)
{
if (a == NULL) return;
- if (a->data != NULL) Free(a->data);
- Free(a);
+ if (a->data != NULL) OPENSSL_free(a->data);
+ OPENSSL_free(a);
}
int ASN1_STRING_cmp(ASN1_STRING *a, ASN1_STRING *b)
/* New macros */
#define M_ASN1_New_Malloc(ret,type) \
- if ((ret=(type *)Malloc(sizeof(type))) == NULL) \
+ if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \
{ c.line=__LINE__; goto err2; }
#define M_ASN1_New(arg,func) \
}
/* Turn a STACK structures into an ASN1 encoded SEQUENCE OF structure in a
- * Malloc'ed buffer
+ * OPENSSL_malloc'ed buffer
*/
unsigned char *ASN1_seq_pack(STACK *safes, int (*i2d)(), unsigned char **buf,
ASN1err(ASN1_F_ASN1_SEQ_PACK,ASN1_R_ENCODE_ERROR);
return NULL;
}
- if (!(safe = Malloc (safelen))) {
+ if (!(safe = OPENSSL_malloc (safelen))) {
ASN1err(ASN1_F_ASN1_SEQ_PACK,ERR_R_MALLOC_FAILURE);
return NULL;
}
ASN1err(ASN1_F_ASN1_PACK_STRING,ASN1_R_ENCODE_ERROR);
return NULL;
}
- if (!(p = Malloc (octmp->length))) {
+ if (!(p = OPENSSL_malloc (octmp->length))) {
ASN1err(ASN1_F_ASN1_PACK_STRING,ERR_R_MALLOC_FAILURE);
return NULL;
}
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_ENUMERATED,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_INTEGER,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
if (num+i > slen)
{
if (s == NULL)
- sp=(unsigned char *)Malloc(
+ sp=(unsigned char *)OPENSSL_malloc(
(unsigned int)num+i*2);
else
- sp=(unsigned char *)Realloc(s,
+ sp=(unsigned char *)OPENSSL_realloc(s,
(unsigned int)num+i*2);
if (sp == NULL)
{
ASN1err(ASN1_F_A2I_ASN1_STRING,ERR_R_MALLOC_FAILURE);
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
goto err;
}
s=sp;
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DHPARAMS,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
ret=t;
err:
if (num[2] != NULL) BN_free(num[2]);
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPARAMS,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
ret=t;
err:
*pp=p;
i2d_ASN1_INTEGER(&bs,&p);
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_RSAPUBLICKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
i2d_ASN1_INTEGER(&bs,&p);
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
return(t);
}
ASN1_put_object(&p,1,tot,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
bs.type=V_ASN1_INTEGER;
- bs.data=(unsigned char *)Malloc(max+4);
+ bs.data=(unsigned char *)OPENSSL_malloc(max+4);
if (bs.data == NULL)
{
ASN1err(ASN1_F_I2D_DSAPUBLICKEY,ERR_R_MALLOC_FAILURE);
bs.length=BN_bn2bin(num[i],bs.data);
i2d_ASN1_INTEGER(&bs,&p);
}
- Free(bs.data);
+ OPENSSL_free(bs.data);
*pp=p;
if(all) return(t);
else return(tot);
}
if (pkey->private_key->data != NULL)
- Free(pkey->private_key->data);
- if ((pkey->private_key->data=(unsigned char *)Malloc(l[0])) == NULL)
+ OPENSSL_free(pkey->private_key->data);
+ if ((pkey->private_key->data=(unsigned char *)OPENSSL_malloc(l[0])) == NULL)
{
ASN1err(ASN1_F_I2D_NETSCAPE_RSA,ERR_R_MALLOC_FAILURE);
goto err;
zz=pkey->private_key->data;
i2d_RSAPrivateKey(a,&zz);
- if ((os2.data=(unsigned char *)Malloc(os2.length)) == NULL)
+ if ((os2.data=(unsigned char *)OPENSSL_malloc(os2.length)) == NULL)
{
ASN1err(ASN1_F_I2D_NETSCAPE_RSA,ERR_R_MALLOC_FAILURE);
goto err;
i2d_ASN1_OCTET_STRING(&os2,&p);
ret=l[5];
err:
- if (os2.data != NULL) Free(os2.data);
+ if (os2.data != NULL) OPENSSL_free(os2.data);
if (alg != NULL) X509_ALGOR_free(alg);
if (pkey != NULL) NETSCAPE_PKEY_free(pkey);
r=r;
M_ASN1_INTEGER_free(a->version);
X509_ALGOR_free(a->algor);
M_ASN1_OCTET_STRING_free(a->private_key);
- Free(a);
+ OPENSSL_free(a);
}
#endif /* NO_RC4 */
ASN1_OBJECT_free(a->type);
if(a->certs)
sk_X509_pop_free(a->certs, X509_free);
- Free (a);
+ OPENSSL_free (a);
}
if(a==NULL) return;
M_ASN1_OCTET_STRING_free(a->salt);
M_ASN1_INTEGER_free (a->iter);
- Free (a);
+ OPENSSL_free (a);
}
/* Return an algorithm identifier for a PKCS#5 PBE algorithm */
if(iter <= 0) iter = PKCS5_DEFAULT_ITER;
ASN1_INTEGER_set (pbe->iter, iter);
if (!saltlen) saltlen = PKCS5_SALT_LEN;
- if (!(pbe->salt->data = Malloc (saltlen))) {
+ if (!(pbe->salt->data = OPENSSL_malloc (saltlen))) {
ASN1err(ASN1_F_ASN1_PBE_SET,ERR_R_MALLOC_FAILURE);
return NULL;
}
if(a==NULL) return;
X509_ALGOR_free(a->keyfunc);
X509_ALGOR_free(a->encryption);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **pp)
M_ASN1_INTEGER_free(a->iter);
M_ASN1_INTEGER_free(a->keylength);
X509_ALGOR_free(a->prf);
- Free (a);
+ OPENSSL_free (a);
}
/* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm:
if(!(osalt = M_ASN1_OCTET_STRING_new())) goto merr;
if (!saltlen) saltlen = PKCS5_SALT_LEN;
- if (!(osalt->data = Malloc (saltlen))) goto merr;
+ if (!(osalt->data = OPENSSL_malloc (saltlen))) goto merr;
osalt->length = saltlen;
if (salt) memcpy (osalt->data, salt, saltlen);
else if (RAND_pseudo_bytes (osalt->data, saltlen) < 0) goto merr;
X509_ALGOR_free(a->md);
PKCS7_free(a->contents);
M_ASN1_OCTET_STRING_free(a->digest);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
M_ASN1_INTEGER_free(a->version);
PKCS7_ENC_CONTENT_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
ASN1_OBJECT_free(a->content_type);
X509_ALGOR_free(a->algorithm);
M_ASN1_OCTET_STRING_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_INTEGER_free(a->version);
sk_PKCS7_RECIP_INFO_pop_free(a->recipientinfo,PKCS7_RECIP_INFO_free);
PKCS7_ENC_CONTENT_free(a->enc_data);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_NAME_free(a->issuer);
M_ASN1_INTEGER_free(a->serial);
- Free(a);
+ OPENSSL_free(a);
}
{
if ((*a)->asn1 != NULL)
{
- Free((*a)->asn1);
+ OPENSSL_free((*a)->asn1);
(*a)->asn1=NULL;
}
(*a)->length=0;
{
ASN1_OBJECT_free(a->type);
}
- Free(a);
+ OPENSSL_free(a);
}
void PKCS7_content_free(PKCS7 *a)
if(a == NULL)
return;
- if (a->asn1 != NULL) Free(a->asn1);
+ if (a->asn1 != NULL) OPENSSL_free(a->asn1);
if (a->d.ptr != NULL)
{
X509_ALGOR_free(a->key_enc_algor);
M_ASN1_OCTET_STRING_free(a->enc_key);
if (a->cert != NULL) X509_free(a->cert);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(PKCS7_RECIP_INFO)
sk_X509_pop_free(a->cert,X509_free);
sk_X509_CRL_pop_free(a->crl,X509_CRL_free);
sk_PKCS7_SIGNER_INFO_pop_free(a->signer_info,PKCS7_SIGNER_INFO_free);
- Free(a);
+ OPENSSL_free(a);
}
sk_X509_pop_free(a->cert,X509_free);
sk_X509_CRL_pop_free(a->crl,X509_CRL_free);
sk_PKCS7_SIGNER_INFO_pop_free(a->signer_info,PKCS7_SIGNER_INFO_free);
- Free(a);
+ OPENSSL_free(a);
}
sk_X509_ATTRIBUTE_pop_free(a->unauth_attr,X509_ATTRIBUTE_free);
if (a->pkey != NULL)
EVP_PKEY_free(a->pkey);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(PKCS7_SIGNER_INFO)
{
X509_KEY *ret=NULL;
- M_ASN1_New_Malloc(ret,X509_KEY);
+ M_ASN1_New_OPENSSL_malloc(ret,X509_KEY);
ret->references=1;
ret->type=NID
M_ASN1_New(ret->cert_info,X509_CINF_new);
X509_CINF_free(a->cert_info);
X509_ALGOR_free(a->sig_alg);
ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
0, a->pkey->value.octet_string->length);
ASN1_TYPE_free (a->pkey);
sk_X509_ATTRIBUTE_pop_free (a->attributes, X509_ATTRIBUTE_free);
- Free (a);
+ OPENSSL_free (a);
}
int i,ret=0;
i=RSA_size(x);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
RSAerr(RSA_F_RSA_PRINT,ERR_R_MALLOC_FAILURE);
if (!print(bp,"coefficient:",x->iqmp,m,off)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif /* NO_RSA */
i=BN_num_bytes(bn)*2;
else
i=256;
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
DSAerr(DSA_F_DSA_PRINT,ERR_R_MALLOC_FAILURE);
if ((x->g != NULL) && !print(bp,"G: ",x->g,m,off)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif /* !NO_DSA */
int reason=ERR_R_BUF_LIB,i,ret=0;
i=BN_num_bytes(x->p);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
err:
DHerr(DH_F_DHPARAMS_PRINT,reason);
}
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
#endif
int reason=ERR_R_BUF_LIB,i,ret=0;
i=BN_num_bytes(x->p);
- m=(unsigned char *)Malloc((unsigned int)i+10);
+ m=(unsigned char *)OPENSSL_malloc((unsigned int)i+10);
if (m == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
if (!print(bp,"g:",x->g,m,4)) goto err;
ret=1;
err:
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
DSAerr(DSA_F_DSAPARAMS_PRINT,reason);
return(ret);
}
ret=1;
err:
if (str != NULL) ASN1_STRING_free(str);
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
if (a == NULL) return;
ASN1_OBJECT_free(a->algorithm);
ASN1_TYPE_free(a->parameter);
- Free(a);
+ OPENSSL_free(a);
}
IMPLEMENT_STACK_OF(X509_ALGOR)
sk_ASN1_TYPE_pop_free(a->value.set,ASN1_TYPE_free);
else
ASN1_TYPE_free(a->value.single);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_BIT_STRING_free(a->issuerUID);
M_ASN1_BIT_STRING_free(a->subjectUID);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_INTEGER_free(a->serialNumber);
M_ASN1_UTCTIME_free(a->revocationDate);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_CRL_INFO_free(X509_CRL_INFO *a)
M_ASN1_UTCTIME_free(a->nextUpdate);
sk_X509_REVOKED_pop_free(a->revoked,X509_REVOKED_free);
sk_X509_EXTENSION_pop_free(a->extensions,X509_EXTENSION_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_CRL_free(X509_CRL *a)
X509_CRL_INFO_free(a->crl);
X509_ALGOR_free(a->sig_alg);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
if (a == NULL) return;
ASN1_OBJECT_free(a->object);
M_ASN1_OCTET_STRING_free(a->value);
- Free(a);
+ OPENSSL_free(a);
}
{
X509_INFO *ret=NULL;
- ret=(X509_INFO *)Malloc(sizeof(X509_INFO));
+ ret=(X509_INFO *)OPENSSL_malloc(sizeof(X509_INFO));
if (ret == NULL)
{
ASN1err(ASN1_F_X509_INFO_NEW,ERR_R_MALLOC_FAILURE);
if (x->x509 != NULL) X509_free(x->x509);
if (x->crl != NULL) X509_CRL_free(x->crl);
if (x->x_pkey != NULL) X509_PKEY_free(x->x_pkey);
- if (x->enc_data != NULL) Free(x->enc_data);
- Free(x);
+ if (x->enc_data != NULL) OPENSSL_free(x->enc_data);
+ OPENSSL_free(x);
}
IMPLEMENT_STACK_OF(X509_INFO)
BUF_MEM_free(a->bytes);
sk_X509_NAME_ENTRY_pop_free(a->entries,X509_NAME_ENTRY_free);
- Free(a);
+ OPENSSL_free(a);
}
void X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
if (a == NULL) return;
ASN1_OBJECT_free(a->object);
M_ASN1_BIT_STRING_free(a->value);
- Free(a);
+ OPENSSL_free(a);
}
int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
if (x->enc_algor != NULL) X509_ALGOR_free(x->enc_algor);
if (x->enc_pkey != NULL) M_ASN1_OCTET_STRING_free(x->enc_pkey);
if (x->dec_pkey != NULL)EVP_PKEY_free(x->dec_pkey);
- if ((x->key_data != NULL) && (x->key_free)) Free(x->key_data);
- Free(x);
+ if ((x->key_data != NULL) && (x->key_free)) OPENSSL_free(x->key_data);
+ OPENSSL_free(x);
}
X509_ALGOR_free(a->algor);
M_ASN1_BIT_STRING_free(a->public_key);
if (a->pkey != NULL) EVP_PKEY_free(a->pkey);
- Free(a);
+ OPENSSL_free(a);
}
int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
dsa->write_params=0;
ASN1_TYPE_free(a->parameter);
i=i2d_DSAparams(dsa,NULL);
- p=(unsigned char *)Malloc(i);
+ p=(unsigned char *)OPENSSL_malloc(i);
pp=p;
i2d_DSAparams(dsa,&pp);
a->parameter=ASN1_TYPE_new();
a->parameter->type=V_ASN1_SEQUENCE;
a->parameter->value.sequence=ASN1_STRING_new();
ASN1_STRING_set(a->parameter->value.sequence,p,i);
- Free(p);
+ OPENSSL_free(p);
}
else
#endif
}
if ((i=i2d_PublicKey(pkey,NULL)) <= 0) goto err;
- if ((s=(unsigned char *)Malloc(i+1)) == NULL) goto err;
+ if ((s=(unsigned char *)OPENSSL_malloc(i+1)) == NULL) goto err;
p=s;
i2d_PublicKey(pkey,&p);
if (!M_ASN1_BIT_STRING_set(pk->public_key,s,i)) goto err;
pk->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
pk->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
- Free(s);
+ OPENSSL_free(s);
#if 0
CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
X509_NAME_free(a->subject);
X509_PUBKEY_free(a->pubkey);
sk_X509_ATTRIBUTE_pop_free(a->attributes,X509_ATTRIBUTE_free);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_X509_REQ(X509_REQ *a, unsigned char **pp)
X509_REQ_INFO_free(a->req_info);
X509_ALGOR_free(a->sig_alg);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_ALGOR_free(a->algor);
M_ASN1_OCTET_STRING_free(a->digest);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
X509_PUBKEY_free(a->pubkey);
M_ASN1_IA5STRING_free(a->challenge);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **pp)
NETSCAPE_SPKAC_free(a->spkac);
X509_ALGOR_free(a->sig_algor);
M_ASN1_BIT_STRING_free(a->signature);
- Free(a);
+ OPENSSL_free(a);
}
if (a == NULL) return;
M_ASN1_TIME_free(a->notBefore);
M_ASN1_TIME_free(a->notAfter);
- Free(a);
+ OPENSSL_free(a);
}
M_ASN1_D2I_get(ret->cert_info,d2i_X509_CINF);
M_ASN1_D2I_get(ret->sig_alg,d2i_X509_ALGOR);
M_ASN1_D2I_get(ret->signature,d2i_ASN1_BIT_STRING);
- if (ret->name != NULL) Free(ret->name);
+ if (ret->name != NULL) OPENSSL_free(ret->name);
ret->name=X509_NAME_oneline(ret->cert_info->subject,NULL,0);
M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
M_ASN1_BIT_STRING_free(a->signature);
X509_CERT_AUX_free(a->aux);
- if (a->name != NULL) Free(a->name);
- Free(a);
+ if (a->name != NULL) OPENSSL_free(a->name);
+ OPENSSL_free(a);
}
int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
ASN1_UTF8STRING_free(a->alias);
ASN1_OCTET_STRING_free(a->keyid);
sk_X509_ALGOR_pop_free(a->other, X509_ALGOR_free);
- Free(a);
+ OPENSSL_free(a);
}
int i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **pp)
if (*buffer == NULL) {
if (*maxlen == 0)
*maxlen = 1024;
- *buffer = Malloc(*maxlen);
+ *buffer = OPENSSL_malloc(*maxlen);
}
while (*currlen >= *maxlen) {
*maxlen += 1024;
- *buffer = Realloc(*buffer, *maxlen);
+ *buffer = OPENSSL_realloc(*buffer, *maxlen);
}
/* What to do if *buffer is NULL? */
assert(*buffer != NULL);
ret=BIO_write(bio, hugebuf, (int)retlen);
#ifdef USE_ALLOCATING_PRINT
- Free(hugebuf);
+ OPENSSL_free(hugebuf);
}
CRYPTO_pop_info();
#endif
int i,j;
MemCheck_off();
- ret=(struct hostent *)Malloc(sizeof(struct hostent));
+ ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
if (ret == NULL) return(NULL);
memset(ret,0,sizeof(struct hostent));
for (i=0; a->h_aliases[i] != NULL; i++)
;
i++;
- ret->h_aliases = (char **)Malloc(i*sizeof(char *));
+ ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
if (ret->h_aliases == NULL)
goto err;
memset(ret->h_aliases, 0, i*sizeof(char *));
for (i=0; a->h_addr_list[i] != NULL; i++)
;
i++;
- ret->h_addr_list=(char **)Malloc(i*sizeof(char *));
+ ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));
if (ret->h_addr_list == NULL)
goto err;
memset(ret->h_addr_list, 0, i*sizeof(char *));
j=strlen(a->h_name)+1;
- if ((ret->h_name=Malloc(j)) == NULL) goto err;
+ if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;
memcpy((char *)ret->h_name,a->h_name,j);
for (i=0; a->h_aliases[i] != NULL; i++)
{
j=strlen(a->h_aliases[i])+1;
- if ((ret->h_aliases[i]=Malloc(j)) == NULL) goto err;
+ if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;
memcpy(ret->h_aliases[i],a->h_aliases[i],j);
}
ret->h_length=a->h_length;
ret->h_addrtype=a->h_addrtype;
for (i=0; a->h_addr_list[i] != NULL; i++)
{
- if ((ret->h_addr_list[i]=Malloc(a->h_length)) == NULL)
+ if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
goto err;
memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
}
if (a->h_aliases != NULL)
{
for (i=0; a->h_aliases[i] != NULL; i++)
- Free(a->h_aliases[i]);
- Free(a->h_aliases);
+ OPENSSL_free(a->h_aliases[i]);
+ OPENSSL_free(a->h_aliases);
}
if (a->h_addr_list != NULL)
{
for (i=0; a->h_addr_list[i] != NULL; i++)
- Free(a->h_addr_list[i]);
- Free(a->h_addr_list);
+ OPENSSL_free(a->h_addr_list[i]);
+ OPENSSL_free(a->h_addr_list);
}
- if (a->h_name != NULL) Free(a->h_name);
- Free(a);
+ if (a->h_name != NULL) OPENSSL_free(a->h_name);
+ OPENSSL_free(a);
}
struct hostent *BIO_gethostbyname(const char *name)
}
ret=1;
err:
- if (str != NULL) Free(str);
+ if (str != NULL) OPENSSL_free(str);
if ((ret == 0) && (s != INVALID_SOCKET))
{
closesocket(s);
port=ntohs(from.sin_port);
if (*addr == NULL)
{
- if ((p=Malloc(24)) == NULL)
+ if ((p=OPENSSL_malloc(24)) == NULL)
{
BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
goto end;
{
BIO_F_BUFFER_CTX *ctx;
- ctx=(BIO_F_BUFFER_CTX *)Malloc(sizeof(BIO_F_BUFFER_CTX));
+ ctx=(BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX));
if (ctx == NULL) return(0);
- ctx->ibuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
- if (ctx->ibuf == NULL) { Free(ctx); return(0); }
- ctx->obuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
- if (ctx->obuf == NULL) { Free(ctx->ibuf); Free(ctx); return(0); }
+ ctx->ibuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->ibuf == NULL) { OPENSSL_free(ctx); return(0); }
+ ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->obuf == NULL) { OPENSSL_free(ctx->ibuf); OPENSSL_free(ctx); return(0); }
ctx->ibuf_size=DEFAULT_BUFFER_SIZE;
ctx->obuf_size=DEFAULT_BUFFER_SIZE;
ctx->ibuf_len=0;
if (a == NULL) return(0);
b=(BIO_F_BUFFER_CTX *)a->ptr;
- if (b->ibuf != NULL) Free(b->ibuf);
- if (b->obuf != NULL) Free(b->obuf);
- Free(a->ptr);
+ if (b->ibuf != NULL) OPENSSL_free(b->ibuf);
+ if (b->obuf != NULL) OPENSSL_free(b->obuf);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
case BIO_C_SET_BUFF_READ_DATA:
if (num > ctx->ibuf_size)
{
- p1=Malloc((int)num);
+ p1=OPENSSL_malloc((int)num);
if (p1 == NULL) goto malloc_error;
- if (ctx->ibuf != NULL) Free(ctx->ibuf);
+ if (ctx->ibuf != NULL) OPENSSL_free(ctx->ibuf);
ctx->ibuf=p1;
}
ctx->ibuf_off=0;
p2=ctx->obuf;
if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size))
{
- p1=(char *)Malloc((int)num);
+ p1=(char *)OPENSSL_malloc((int)num);
if (p1 == NULL) goto malloc_error;
}
if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size))
{
- p2=(char *)Malloc((int)num);
+ p2=(char *)OPENSSL_malloc((int)num);
if (p2 == NULL)
{
- if (p1 != ctx->ibuf) Free(p1);
+ if (p1 != ctx->ibuf) OPENSSL_free(p1);
goto malloc_error;
}
}
if (ctx->ibuf != p1)
{
- Free(ctx->ibuf);
+ OPENSSL_free(ctx->ibuf);
ctx->ibuf=p1;
ctx->ibuf_off=0;
ctx->ibuf_len=0;
}
if (ctx->obuf != p2)
{
- Free(ctx->obuf);
+ OPENSSL_free(ctx->obuf);
ctx->obuf=p2;
ctx->obuf_off=0;
ctx->obuf_len=0;
{
NBIO_TEST *nt;
- nt=(NBIO_TEST *)Malloc(sizeof(NBIO_TEST));
+ nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST));
nt->lrn= -1;
nt->lwn= -1;
bi->ptr=(char *)nt;
{
if (a == NULL) return(0);
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
BIO *ret=NULL;
- ret=(BIO *)Malloc(sizeof(BIO));
+ ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
if (ret == NULL)
{
BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
}
if (!BIO_set(ret,method))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
return(ret);
if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
ret=a->method->destroy(a);
- Free(a);
+ OPENSSL_free(a);
return(1);
}
{
BIO_ACCEPT *ret;
- if ((ret=(BIO_ACCEPT *)Malloc(sizeof(BIO_ACCEPT))) == NULL)
+ if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL)
return(NULL);
memset(ret,0,sizeof(BIO_ACCEPT));
if(a == NULL)
return;
- if (a->param_addr != NULL) Free(a->param_addr);
- if (a->addr != NULL) Free(a->addr);
+ if (a->param_addr != NULL) OPENSSL_free(a->param_addr);
+ if (a->addr != NULL) OPENSSL_free(a->addr);
if (a->bio_chain != NULL) BIO_free(a->bio_chain);
- Free(a);
+ OPENSSL_free(a);
}
static void acpt_close_socket(BIO *bio)
{
b->init=1;
if (data->param_addr != NULL)
- Free(data->param_addr);
+ OPENSSL_free(data->param_addr);
data->param_addr=BUF_strdup(ptr);
}
else if (num == 1)
{
struct bio_bio_st *b;
- b = Malloc(sizeof *b);
+ b = OPENSSL_malloc(sizeof *b);
if (b == NULL)
return 0;
if (b->buf != NULL)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
}
- Free(b);
+ OPENSSL_free(b);
return 1;
}
{
if (b->buf)
{
- Free(b->buf);
+ OPENSSL_free(b->buf);
b->buf = NULL;
}
b->size = new_size;
if (b1->buf == NULL)
{
- b1->buf = Malloc(b1->size);
+ b1->buf = OPENSSL_malloc(b1->size);
if (b1->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
if (b2->buf == NULL)
{
- b2->buf = Malloc(b2->size);
+ b2->buf = OPENSSL_malloc(b2->size);
if (b2->buf == NULL)
{
BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
break;
}
if (c->param_port != NULL)
- Free(c->param_port);
+ OPENSSL_free(c->param_port);
c->param_port=BUF_strdup(p);
}
}
{
BIO_CONNECT *ret;
- if ((ret=(BIO_CONNECT *)Malloc(sizeof(BIO_CONNECT))) == NULL)
+ if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL)
return(NULL);
ret->state=BIO_CONN_S_BEFORE;
ret->param_hostname=NULL;
return;
if (a->param_hostname != NULL)
- Free(a->param_hostname);
+ OPENSSL_free(a->param_hostname);
if (a->param_port != NULL)
- Free(a->param_port);
- Free(a);
+ OPENSSL_free(a->param_port);
+ OPENSSL_free(a);
}
BIO_METHOD *BIO_s_connect(void)
if (num == 0)
{
if (data->param_hostname != NULL)
- Free(data->param_hostname);
+ OPENSSL_free(data->param_hostname);
data->param_hostname=BUF_strdup(ptr);
}
else if (num == 1)
{
if (data->param_port != NULL)
- Free(data->param_port);
+ OPENSSL_free(data->param_port);
data->param_port=BUF_strdup(ptr);
}
else if (num == 2)
sprintf(buf,"%d.%d.%d.%d",
p[0],p[1],p[2],p[3]);
if (data->param_hostname != NULL)
- Free(data->param_hostname);
+ OPENSSL_free(data->param_hostname);
data->param_hostname=BUF_strdup(buf);
memcpy(&(data->ip[0]),ptr,4);
}
sprintf(buf,"%d",*(int *)ptr);
if (data->param_port != NULL)
- Free(data->param_port);
+ OPENSSL_free(data->param_port);
data->param_port=BUF_strdup(buf);
data->port= *(int *)ptr;
}
char* pp;
int priority;
- if((buf= (char *)Malloc(inl+ 1)) == NULL){
+ if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
return(0);
}
strncpy(buf, in, inl);
xsyslog(b, priority, pp);
- Free(buf);
+ OPENSSL_free(buf);
return(ret);
}
lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
/* we know there's an 8 byte header. That's documented */
- opcdef_p = (struct opcdef *) Malloc(8 + len);
+ opcdef_p = (struct opcdef *) OPENSSL_malloc(8 + len);
opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
opcdef_p->opc$l_ms_rqstid = 0;
sys$sndopr(opc_dsc, 0);
- Free(opcdef_p);
+ OPENSSL_free(opcdef_p);
}
static void xcloselog(BIO* bp)
bi->init=1;
bi->num=0;
bi->flags = 0;
- bi->ptr=Malloc(sizeof(struct rpc_ctx));
+ bi->ptr=OPENSSL_malloc(sizeof(struct rpc_ctx));
ctx = (struct rpc_ctx *) bi->ptr;
ctx->filled = 0;
ctx->pos = 0;
static int rtcp_free(BIO *a)
{
if (a == NULL) return(0);
- if ( a->ptr ) Free ( a->ptr );
+ if ( a->ptr ) OPENSSL_free ( a->ptr );
a->ptr = NULL;
return(1);
}
bn_check_top(Ai);
bn_check_top(mod);
- if ((ret=(BN_BLINDING *)Malloc(sizeof(BN_BLINDING))) == NULL)
+ if ((ret=(BN_BLINDING *)OPENSSL_malloc(sizeof(BN_BLINDING))) == NULL)
{
BNerr(BN_F_BN_BLINDING_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
if (r->A != NULL) BN_free(r->A );
if (r->Ai != NULL) BN_free(r->Ai);
- Free(r);
+ OPENSSL_free(r);
}
int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
{
BN_CTX *ret;
- ret=(BN_CTX *)Malloc(sizeof(BN_CTX));
+ ret=(BN_CTX *)OPENSSL_malloc(sizeof(BN_CTX));
if (ret == NULL)
{
BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
for (i=0; i < BN_CTX_NUM; i++)
BN_clear_free(&(ctx->bn[i]));
if (ctx->flags & BN_FLG_MALLOCED)
- Free(ctx);
+ OPENSSL_free(ctx);
}
void BN_CTX_start(BN_CTX *ctx)
{
memset(a->d,0,a->max*sizeof(a->d[0]));
if (!(BN_get_flags(a,BN_FLG_STATIC_DATA)))
- Free(a->d);
+ OPENSSL_free(a->d);
}
i=BN_get_flags(a,BN_FLG_MALLOCED);
memset(a,0,sizeof(BIGNUM));
if (i)
- Free(a);
+ OPENSSL_free(a);
}
void BN_free(BIGNUM *a)
{
if (a == NULL) return;
if ((a->d != NULL) && !(BN_get_flags(a,BN_FLG_STATIC_DATA)))
- Free(a->d);
+ OPENSSL_free(a->d);
a->flags|=BN_FLG_FREE; /* REMOVE? */
if (a->flags & BN_FLG_MALLOCED)
- Free(a);
+ OPENSSL_free(a);
}
void BN_init(BIGNUM *a)
{
BIGNUM *ret;
- if ((ret=(BIGNUM *)Malloc(sizeof(BIGNUM))) == NULL)
+ if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
{
BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
BNerr(BN_F_BN_EXPAND2,BN_R_EXPAND_ON_STATIC_BIGNUM_DATA);
return(NULL);
}
- a=A=(BN_ULONG *)Malloc(sizeof(BN_ULONG)*(words+1));
+ a=A=(BN_ULONG *)OPENSSL_malloc(sizeof(BN_ULONG)*(words+1));
if (A == NULL)
{
BNerr(BN_F_BN_EXPAND2,ERR_R_MALLOC_FAILURE);
case 0: ; /* ultrix cc workaround, see above */
}
#endif
- Free(b->d);
+ OPENSSL_free(b->d);
}
b->d=a;
{
BN_MONT_CTX *ret;
- if ((ret=(BN_MONT_CTX *)Malloc(sizeof(BN_MONT_CTX))) == NULL)
+ if ((ret=(BN_MONT_CTX *)OPENSSL_malloc(sizeof(BN_MONT_CTX))) == NULL)
return(NULL);
BN_MONT_CTX_init(ret);
BN_free(&(mont->N));
BN_free(&(mont->Ni));
if (mont->flags & BN_FLG_MALLOCED)
- Free(mont);
+ OPENSSL_free(mont);
}
int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
static const char *Hex="0123456789ABCDEF";
-/* Must 'Free' the returned data */
+/* Must 'OPENSSL_free' the returned data */
char *BN_bn2hex(const BIGNUM *a)
{
int i,j,v,z=0;
char *buf;
char *p;
- buf=(char *)Malloc(a->top*BN_BYTES*2+2);
+ buf=(char *)OPENSSL_malloc(a->top*BN_BYTES*2+2);
if (buf == NULL)
{
BNerr(BN_F_BN_BN2HEX,ERR_R_MALLOC_FAILURE);
return(buf);
}
-/* Must 'Free' the returned data */
+/* Must 'OPENSSL_free' the returned data */
char *BN_bn2dec(const BIGNUM *a)
{
int i=0,num;
i=BN_num_bits(a)*3;
num=(i/10+i/1000+3)+1;
- bn_data=(BN_ULONG *)Malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
- buf=(char *)Malloc(num+3);
+ bn_data=(BN_ULONG *)OPENSSL_malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
+ buf=(char *)OPENSSL_malloc(num+3);
if ((buf == NULL) || (bn_data == NULL))
{
BNerr(BN_F_BN_BN2DEC,ERR_R_MALLOC_FAILURE);
}
}
err:
- if (bn_data != NULL) Free(bn_data);
+ if (bn_data != NULL) OPENSSL_free(bn_data);
if (t != NULL) BN_free(t);
return(buf);
}
bit=(bits-1)%8;
mask=0xff<<bit;
- buf=(unsigned char *)Malloc(bytes);
+ buf=(unsigned char *)OPENSSL_malloc(bytes);
if (buf == NULL)
{
BNerr(BN_F_BN_RAND,ERR_R_MALLOC_FAILURE);
if (buf != NULL)
{
memset(buf,0,bytes);
- Free(buf);
+ OPENSSL_free(buf);
}
return(ret);
}
{
BN_RECP_CTX *ret;
- if ((ret=(BN_RECP_CTX *)Malloc(sizeof(BN_RECP_CTX))) == NULL)
+ if ((ret=(BN_RECP_CTX *)OPENSSL_malloc(sizeof(BN_RECP_CTX))) == NULL)
return(NULL);
BN_RECP_CTX_init(ret);
BN_free(&(recp->N));
BN_free(&(recp->Nr));
if (recp->flags & BN_FLG_MALLOCED)
- Free(recp);
+ OPENSSL_free(recp);
}
int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *d, BN_CTX *ctx)
{
BUF_MEM *ret;
- ret=Malloc(sizeof(BUF_MEM));
+ ret=OPENSSL_malloc(sizeof(BUF_MEM));
if (ret == NULL)
{
BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
if (a->data != NULL)
{
memset(a->data,0,(unsigned int)a->max);
- Free(a->data);
+ OPENSSL_free(a->data);
}
- Free(a);
+ OPENSSL_free(a);
}
int BUF_MEM_grow(BUF_MEM *str, int len)
}
n=(len+3)/3*4;
if (str->data == NULL)
- ret=Malloc(n);
+ ret=OPENSSL_malloc(n);
else
- ret=Realloc(str->data,n);
+ ret=OPENSSL_realloc(str->data,n);
if (ret == NULL)
{
BUFerr(BUF_F_BUF_MEM_GROW,ERR_R_MALLOC_FAILURE);
if (str == NULL) return(NULL);
n=strlen(str);
- ret=Malloc(n+1);
+ ret=OPENSSL_malloc(n+1);
if (ret == NULL)
{
BUFerr(BUF_F_BUF_STRDUP,ERR_R_MALLOC_FAILURE);
{
COMP_CTX *ret;
- if ((ret=(COMP_CTX *)Malloc(sizeof(COMP_CTX))) == NULL)
+ if ((ret=(COMP_CTX *)OPENSSL_malloc(sizeof(COMP_CTX))) == NULL)
{
/* ZZZZZZZZZZZZZZZZ */
return(NULL);
ret->meth=meth;
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
#if 0
if (ctx->meth->finish != NULL)
ctx->meth->finish(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
if (v != NULL)
{
sk_CONF_VALUE_delete_ptr(ts,v);
- Free(v->name);
- Free(v->value);
- Free(v);
+ OPENSSL_free(v->name);
+ OPENSSL_free(v->value);
+ OPENSSL_free(v);
}
return 1;
}
{
if (conf == NULL || conf->data == NULL) return;
- conf->data->down_load=0; /* evil thing to make sure the 'Free()'
+ conf->data->down_load=0; /* evil thing to make sure the 'OPENSSL_free()'
* works as expected */
lh_doall_arg(conf->data,(void (*)())value_free_hash,conf->data);
for (i=sk_num(sk)-1; i>=0; i--)
{
vv=(CONF_VALUE *)sk_value(sk,i);
- Free(vv->value);
- Free(vv->name);
- Free(vv);
+ OPENSSL_free(vv->value);
+ OPENSSL_free(vv->name);
+ OPENSSL_free(vv);
}
if (sk != NULL) sk_free(sk);
- Free(a->section);
- Free(a);
+ OPENSSL_free(a->section);
+ OPENSSL_free(a);
}
static unsigned long hash(CONF_VALUE *v)
if ((sk=sk_new_null()) == NULL)
goto err;
- if ((v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))) == NULL)
+ if ((v=(CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))) == NULL)
goto err;
i=strlen(section)+1;
- if ((v->section=(char *)Malloc(i)) == NULL)
+ if ((v->section=(char *)OPENSSL_malloc(i)) == NULL)
goto err;
memcpy(v->section,section,i);
if (!ok)
{
if (sk != NULL) sk_free(sk);
- if (v != NULL) Free(v);
+ if (v != NULL) OPENSSL_free(v);
v=NULL;
}
return(v);
{
CONF *ret;
- ret = (CONF *)Malloc(sizeof(CONF) + sizeof(unsigned short *));
+ ret = (CONF *)OPENSSL_malloc(sizeof(CONF) + sizeof(unsigned short *));
if (ret)
if (meth->init(ret) == 0)
{
- Free(ret);
+ OPENSSL_free(ret);
ret = NULL;
}
return ret;
{
if (def_destroy_data(conf))
{
- Free(conf);
+ OPENSSL_free(conf);
return 1;
}
return 0;
goto err;
}
- section=(char *)Malloc(10);
+ section=(char *)OPENSSL_malloc(10);
if (section == NULL)
{
CONFerr(CONF_F_CONF_LOAD_BIO,ERR_R_MALLOC_FAILURE);
p++;
*p='\0';
- if (!(v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))))
+ if (!(v=(CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))))
{
CONFerr(CONF_F_CONF_LOAD_BIO,
ERR_R_MALLOC_FAILURE);
goto err;
}
if (psection == NULL) psection=section;
- v->name=(char *)Malloc(strlen(pname)+1);
+ v->name=(char *)OPENSSL_malloc(strlen(pname)+1);
v->value=NULL;
if (v->name == NULL)
{
if (vv != NULL)
{
sk_CONF_VALUE_delete_ptr(ts,vv);
- Free(vv->name);
- Free(vv->value);
- Free(vv);
+ OPENSSL_free(vv->name);
+ OPENSSL_free(vv->value);
+ OPENSSL_free(vv);
}
#endif
v=NULL;
}
}
if (buff != NULL) BUF_MEM_free(buff);
- if (section != NULL) Free(section);
+ if (section != NULL) OPENSSL_free(section);
return(1);
err:
if (buff != NULL) BUF_MEM_free(buff);
- if (section != NULL) Free(section);
+ if (section != NULL) OPENSSL_free(section);
if (line != NULL) *line=eline;
sprintf(btmp,"%ld",eline);
ERR_add_error_data(2,"line ",btmp);
if ((h != conf->data) && (conf->data != NULL)) CONF_free(conf->data);
if (v != NULL)
{
- if (v->name != NULL) Free(v->name);
- if (v->value != NULL) Free(v->value);
- if (v != NULL) Free(v);
+ if (v->name != NULL) OPENSSL_free(v->name);
+ if (v->value != NULL) OPENSSL_free(v->value);
+ if (v != NULL) OPENSSL_free(v);
}
return(0);
}
buf->data[to++]= *(from++);
}
buf->data[to]='\0';
- if (*pto != NULL) Free(*pto);
+ if (*pto != NULL) OPENSSL_free(*pto);
*pto=buf->data;
- Free(buf);
+ OPENSSL_free(buf);
return(1);
err:
if (buf != NULL) BUF_MEM_free(buf);
return(0);
i=sk_push(app_locks,str);
if (!i)
- Free(str);
+ OPENSSL_free(str);
else
i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
return(i);
#define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
#define is_MemCheck_on() CRYPTO_is_mem_check_on()
-#define Malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
-#define Realloc(addr,num) \
+#define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
+#define OPENSSL_realloc(addr,num) \
CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
-#define Remalloc(addr,num) \
+#define OPENSSL_remalloc(addr,num) \
CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
-#define FreeFunc CRYPTO_free
-#define Free(addr) CRYPTO_free(addr)
+#define OPENSSL_freeFunc CRYPTO_free
+#define OPENSSL_free(addr) CRYPTO_free(addr)
-#define Malloc_locked(num) CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
-#define Free_locked(addr) CRYPTO_free_locked(addr)
+#define OPENSSL_malloc_locked(num) \
+ CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
+#define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
/* Case insensiteve linking causes problems.... */
if (buf == NULL)
{
- if ( (( buf=Malloc(BUFSIZE+8)) == NULL) ||
- ((obuf=Malloc(BUFSIZE+8)) == NULL))
+ if ( (( buf=OPENSSL_malloc(BUFSIZE+8)) == NULL) ||
+ ((obuf=OPENSSL_malloc(BUFSIZE+8)) == NULL))
{
fputs("Not enough memory\n",stderr);
Exit=10;
if (tmpbuf == NULL)
{
- tmpbuf=Malloc(BSIZE);
+ tmpbuf=OPENSSL_malloc(BSIZE);
if (tmpbuf == NULL) return(-1);
}
if (net == NULL)
{
- net=Malloc(BSIZE);
+ net=OPENSSL_malloc(BSIZE);
if (net == NULL) return(-1);
}
if (unnet == NULL)
{
- unnet=Malloc(BSIZE);
+ unnet=OPENSSL_malloc(BSIZE);
if (unnet == NULL) return(-1);
}
/* left over data from last decrypt */
if (outbuf == NULL)
{
- outbuf=Malloc(BSIZE+HDRSIZE);
+ outbuf=OPENSSL_malloc(BSIZE+HDRSIZE);
if (outbuf == NULL) return(-1);
}
/* If we are sending less than 8 bytes, the same char will look
DH *DH_new_method(DH_METHOD *meth)
{
DH *ret;
- ret=(DH *)Malloc(sizeof(DH));
+ ret=(DH *)OPENSSL_malloc(sizeof(DH));
if (ret == NULL)
{
ret->flags=ret->meth->flags;
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->g != NULL) BN_clear_free(r->g);
if (r->q != NULL) BN_clear_free(r->q);
if (r->j != NULL) BN_clear_free(r->j);
- if (r->seed) Free(r->seed);
+ if (r->seed) OPENSSL_free(r->seed);
if (r->counter != NULL) BN_clear_free(r->counter);
if (r->pub_key != NULL) BN_clear_free(r->pub_key);
if (r->priv_key != NULL) BN_clear_free(r->priv_key);
- Free(r);
+ OPENSSL_free(r);
}
int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
BIO_puts(out,"\n");
alen=DH_size(a);
- abuf=(unsigned char *)Malloc(alen);
+ abuf=(unsigned char *)OPENSSL_malloc(alen);
aout=DH_compute_key(abuf,b->pub_key,a);
BIO_puts(out,"key1 =");
BIO_puts(out,"\n");
blen=DH_size(b);
- bbuf=(unsigned char *)Malloc(blen);
+ bbuf=(unsigned char *)OPENSSL_malloc(blen);
bout=DH_compute_key(bbuf,a->pub_key,b);
BIO_puts(out,"key2 =");
else
ret=0;
err:
- if (abuf != NULL) Free(abuf);
- if (bbuf != NULL) Free(bbuf);
+ if (abuf != NULL) OPENSSL_free(abuf);
+ if (bbuf != NULL) OPENSSL_free(bbuf);
if(b != NULL) DH_free(b);
if(a != NULL) DH_free(a);
BIO_free(out);
{
DSA_SIG *ret;
- ret = Malloc(sizeof(DSA_SIG));
+ ret = OPENSSL_malloc(sizeof(DSA_SIG));
if (ret == NULL)
{
DSAerr(DSA_F_DSA_SIG_NEW,ERR_R_MALLOC_FAILURE);
if (r == NULL) return;
if (r->r) BN_clear_free(r->r);
if (r->s) BN_clear_free(r->s);
- Free(r);
+ OPENSSL_free(r);
}
int i2d_DSA_SIG(DSA_SIG *v, unsigned char **pp)
ASN1_INTEGER rbs,sbs;
unsigned char *p;
- rbs.data=Malloc(BN_num_bits(v->r)/8+1);
+ rbs.data=OPENSSL_malloc(BN_num_bits(v->r)/8+1);
if (rbs.data == NULL)
{
DSAerr(DSA_F_I2D_DSA_SIG, ERR_R_MALLOC_FAILURE);
}
rbs.type=V_ASN1_INTEGER;
rbs.length=BN_bn2bin(v->r,rbs.data);
- sbs.data=Malloc(BN_num_bits(v->s)/8+1);
+ sbs.data=OPENSSL_malloc(BN_num_bits(v->s)/8+1);
if (sbs.data == NULL)
{
- Free(rbs.data);
+ OPENSSL_free(rbs.data);
DSAerr(DSA_F_I2D_DSA_SIG, ERR_R_MALLOC_FAILURE);
return(0);
}
i2d_ASN1_INTEGER(&sbs,&p);
}
t=ASN1_object_size(1,len,V_ASN1_SEQUENCE);
- Free(rbs.data);
- Free(sbs.data);
+ OPENSSL_free(rbs.data);
+ OPENSSL_free(sbs.data);
return(t);
}
{
DSA *ret;
- ret=(DSA *)Malloc(sizeof(DSA));
+ ret=(DSA *)OPENSSL_malloc(sizeof(DSA));
if (ret == NULL)
{
DSAerr(DSA_F_DSA_NEW,ERR_R_MALLOC_FAILURE);
ret->flags=ret->meth->flags;
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->priv_key != NULL) BN_clear_free(r->priv_key);
if (r->kinv != NULL) BN_clear_free(r->kinv);
if (r->r != NULL) BN_clear_free(r->r);
- Free(r);
+ OPENSSL_free(r);
}
int DSA_size(DSA *r)
* to stealing the "best available" method. Will fallback
* to DSO_METH_null() in the worst case. */
default_DSO_meth = DSO_METHOD_openssl();
- ret = (DSO *)Malloc(sizeof(DSO));
+ ret = (DSO *)OPENSSL_malloc(sizeof(DSO));
if(ret == NULL)
{
DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
{
/* sk_new doesn't generate any errors so we do */
DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);
- Free(ret);
+ OPENSSL_free(ret);
return(NULL);
}
if(meth == NULL)
ret->references = 1;
if((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
return(ret);
sk_free(dso->meth_data);
- Free(dso);
+ OPENSSL_free(dso);
return(1);
}
DSOerr(DSO_F_WIN32_LOAD,DSO_R_LOAD_FAILED);
return(0);
}
- p = (HINSTANCE *)Malloc(sizeof(HINSTANCE));
+ p = (HINSTANCE *)OPENSSL_malloc(sizeof(HINSTANCE));
if(p == NULL)
{
DSOerr(DSO_F_WIN32_LOAD,ERR_R_MALLOC_FAILURE);
- FreeLibrary(h);
+ OPENSSL_freeLibrary(h);
return(0);
}
*p = h;
if(!sk_push(dso->meth_data, (char *)p))
{
DSOerr(DSO_F_WIN32_LOAD,DSO_R_STACK_ERROR);
- FreeLibrary(h);
- Free(p);
+ OPENSSL_freeLibrary(h);
+ OPENSSL_free(p);
return(0);
}
return(1);
DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_NULL_HANDLE);
return(0);
}
- if(!FreeLibrary(p))
+ if(!OPENSSL_freeLibrary(p))
{
DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_UNLOAD_FAILED);
/* We should push the value back onto the stack in
return(0);
}
/* Cleanup */
- Free(p);
+ OPENSSL_free(p);
return(1);
}
static void build_SYS_str_reasons()
{
- /* Malloc cannot be used here, use static storage instead */
+ /* OPENSSL_malloc cannot be used here, use static storage instead */
static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON];
int i;
if (((p)->err_data[i] != NULL) && \
(p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
{ \
- Free((p)->err_data[i]); \
+ OPENSSL_free((p)->err_data[i]); \
(p)->err_data[i]=NULL; \
} \
(p)->err_data_flags[i]=0;
{
err_clear_data(s,i);
}
- Free(s);
+ OPENSSL_free(s);
}
void ERR_load_ERR_strings(void)
/* ret == the error state, if NULL, make a new one */
if (ret == NULL)
{
- ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
+ ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
if (ret == NULL) return(&fallback);
ret->pid=pid;
ret->top=0;
char *str,*p,*a;
s=64;
- str=Malloc(s+1);
+ str=OPENSSL_malloc(s+1);
if (str == NULL) return;
str[0]='\0';
if (n > s)
{
s=n+20;
- p=Realloc(str,s+1);
+ p=OPENSSL_realloc(str,s+1);
if (p == NULL)
{
- Free(str);
+ OPENSSL_free(str);
return;
}
else
{
BIO_B64_CTX *ctx;
- ctx=(BIO_B64_CTX *)Malloc(sizeof(BIO_B64_CTX));
+ ctx=(BIO_B64_CTX *)OPENSSL_malloc(sizeof(BIO_B64_CTX));
if (ctx == NULL) return(0);
ctx->buf_len=0;
static int b64_free(BIO *a)
{
if (a == NULL) return(0);
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
BIO_ENC_CTX *ctx;
- ctx=(BIO_ENC_CTX *)Malloc(sizeof(BIO_ENC_CTX));
+ ctx=(BIO_ENC_CTX *)OPENSSL_malloc(sizeof(BIO_ENC_CTX));
EVP_CIPHER_CTX_init(&ctx->cipher);
if (ctx == NULL) return(0);
b=(BIO_ENC_CTX *)a->ptr;
EVP_CIPHER_CTX_cleanup(&(b->cipher));
memset(a->ptr,0,sizeof(BIO_ENC_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
EVP_MD_CTX *ctx;
- ctx=(EVP_MD_CTX *)Malloc(sizeof(EVP_MD_CTX));
+ ctx=(EVP_MD_CTX *)OPENSSL_malloc(sizeof(EVP_MD_CTX));
if (ctx == NULL) return(0);
bi->init=0;
static int md_free(BIO *a)
{
if (a == NULL) return(0);
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
BIO_OK_CTX *ctx;
- ctx=(BIO_OK_CTX *)Malloc(sizeof(BIO_OK_CTX));
+ ctx=(BIO_OK_CTX *)OPENSSL_malloc(sizeof(BIO_OK_CTX));
if (ctx == NULL) return(0);
ctx->buf_len=0;
{
if (a == NULL) return(0);
memset(a->ptr,0,sizeof(BIO_OK_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
{
EVP_PBE_CTL *pbe_tmp;
if (!pbe_algs) pbe_algs = sk_new ((int (*)())pbe_cmp);
- if (!(pbe_tmp = (EVP_PBE_CTL*) Malloc (sizeof(EVP_PBE_CTL)))) {
+ if (!(pbe_tmp = (EVP_PBE_CTL*) OPENSSL_malloc (sizeof(EVP_PBE_CTL)))) {
EVPerr(EVP_F_EVP_PBE_ALG_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
void EVP_PBE_cleanup(void)
{
- sk_pop_free(pbe_algs, FreeFunc);
+ sk_pop_free(pbe_algs, OPENSSL_freeFunc);
pbe_algs = NULL;
}
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_dsa);
len = i2d_DSAparams (pkey->pkey.dsa, NULL);
- if (!(p = Malloc(len))) {
+ if (!(p = OPENSSL_malloc(len))) {
EVPerr(EVP_F_EVP_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
PKCS8_PRIV_KEY_INFO_free (p8);
return 0;
i2d_DSAparams (pkey->pkey.dsa, &q);
params = ASN1_STRING_new();
ASN1_STRING_set(params, p, len);
- Free(p);
+ OPENSSL_free(p);
/* Get private key into integer */
if (!(prkey = BN_to_ASN1_INTEGER (pkey->pkey.dsa->priv_key, NULL))) {
EVPerr(EVP_F_EVP_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
{
EVP_PKEY *ret;
- ret=(EVP_PKEY *)Malloc(sizeof(EVP_PKEY));
+ ret=(EVP_PKEY *)OPENSSL_malloc(sizeof(EVP_PKEY));
if (ret == NULL)
{
EVPerr(EVP_F_EVP_PKEY_NEW,ERR_R_MALLOC_FAILURE);
}
#endif
EVP_PKEY_free_it(x);
- Free(x);
+ OPENSSL_free(x);
}
static void EVP_PKEY_free_it(EVP_PKEY *x)
}
size=RSA_size(priv->pkey.rsa);
- key=(unsigned char *)Malloc(size+2);
+ key=(unsigned char *)OPENSSL_malloc(size+2);
if (key == NULL)
{
/* ERROR */
ret=1;
err:
if (key != NULL) memset(key,0,size);
- Free(key);
+ OPENSSL_free(key);
return(ret);
}
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
goto err;
}
- a=(CRYPTO_EX_DATA_FUNCS *)Malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
+ a=(CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
if (a == NULL)
{
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
if (!sk_CRYPTO_EX_DATA_FUNCS_push(*skp,NULL))
{
CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
- Free(a);
+ OPENSSL_free(a);
goto err;
}
}
if (buf[0] == '\0') break;
buf[256]='\0';
i=strlen(buf);
- p=Malloc(i+1);
+ p=OPENSSL_malloc(i+1);
memcpy(p,buf,i+1);
lh_insert(conf,p);
}
LHASH *ret;
int i;
- if ((ret=(LHASH *)Malloc(sizeof(LHASH))) == NULL)
+ if ((ret=(LHASH *)OPENSSL_malloc(sizeof(LHASH))) == NULL)
goto err0;
- if ((ret->b=(LHASH_NODE **)Malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
+ if ((ret->b=(LHASH_NODE **)OPENSSL_malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
goto err1;
for (i=0; i<MIN_NODES; i++)
ret->b[i]=NULL;
ret->error=0;
return(ret);
err1:
- Free(ret);
+ OPENSSL_free(ret);
err0:
return(NULL);
}
while (n != NULL)
{
nn=n->next;
- Free(n);
+ OPENSSL_free(n);
n=nn;
}
}
- Free(lh->b);
- Free(lh);
+ OPENSSL_free(lh->b);
+ OPENSSL_free(lh);
}
void *lh_insert(LHASH *lh, void *data)
if (*rn == NULL)
{
- if ((nn=(LHASH_NODE *)Malloc(sizeof(LHASH_NODE))) == NULL)
+ if ((nn=(LHASH_NODE *)OPENSSL_malloc(sizeof(LHASH_NODE))) == NULL)
{
lh->error++;
return(NULL);
nn= *rn;
*rn=nn->next;
ret=nn->data;
- Free(nn);
+ OPENSSL_free(nn);
lh->num_delete++;
}
if ((lh->p) >= lh->pmax)
{
j=(int)lh->num_alloc_nodes*2;
- n=(LHASH_NODE **)Realloc(lh->b,
+ n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
(unsigned int)sizeof(LHASH_NODE *)*j);
if (n == NULL)
{
lh->b[lh->p+lh->pmax-1]=NULL; /* 24/07-92 - eay - weird but :-( */
if (lh->p == 0)
{
- n=(LHASH_NODE **)Realloc(lh->b,
+ n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
(unsigned int)(sizeof(LHASH_NODE *)*lh->pmax));
if (n == NULL)
{
void *CRYPTO_remalloc(void *a, int num, const char *file, int line)
{
- if (a != NULL) Free(a);
- a=(char *)Malloc(num);
+ if (a != NULL) OPENSSL_free(a);
+ a=(char *)OPENSSL_malloc(num);
return(a);
}
ret->next = NULL;
if (next != NULL)
next->references--;
- Free(ret);
+ OPENSSL_free(ret);
}
}
}
{
MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
- if ((ami = (APP_INFO *)Malloc(sizeof(APP_INFO))) == NULL)
+ if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
{
ret=0;
goto err;
{
if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
{
- Free(ami);
+ OPENSSL_free(ami);
ret=0;
goto err;
}
if (is_MemCheck_on())
{
MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
- if ((m=(MEM *)Malloc(sizeof(MEM))) == NULL)
+ if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
{
- Free(addr);
+ OPENSSL_free(addr);
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
return;
}
{
if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
{
- Free(addr);
- Free(m);
+ OPENSSL_free(addr);
+ OPENSSL_free(m);
addr=NULL;
goto err;
}
{
mm->app_info->references--;
}
- Free(mm);
+ OPENSSL_free(mm);
}
err:
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
{
mp->app_info->references--;
}
- Free(mp);
+ OPENSSL_free(mp);
}
MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
for (i=sk_NAME_FUNCS_num(name_funcs_stack); i<names_type_num; i++)
{
MemCheck_off();
- name_funcs = Malloc(sizeof(NAME_FUNCS));
+ name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));
name_funcs->hash_func = lh_strhash;
name_funcs->cmp_func = (int (*)())strcmp;
name_funcs->free_func = 0; /* NULL is often declared to
alias=type&OBJ_NAME_ALIAS;
type&= ~OBJ_NAME_ALIAS;
- onp=(OBJ_NAME *)Malloc(sizeof(OBJ_NAME));
+ onp=(OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME));
if (onp == NULL)
{
/* ERROR */
sk_NAME_FUNCS_value(name_funcs_stack,ret->type)
->free_func(ret->name,ret->type,ret->data);
}
- Free(ret);
+ OPENSSL_free(ret);
}
else
{
sk_NAME_FUNCS_value(name_funcs_stack,ret->type)
->free_func(ret->name,ret->type,ret->data);
}
- Free(ret);
+ OPENSSL_free(ret);
return(1);
}
else
static void name_funcs_free(NAME_FUNCS *ptr)
{
- Free(ptr);
+ OPENSSL_free(ptr);
}
void OBJ_NAME_cleanup(int type)
{
if (--a->obj->nid == 0)
ASN1_OBJECT_free(a->obj);
- Free(a);
+ OPENSSL_free(a);
}
void OBJ_cleanup(void)
if (added == NULL)
if (!init_added()) return(0);
if ((o=OBJ_dup(obj)) == NULL) goto err;
- ao[ADDED_NID]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if ((o->length != 0) && (obj->data != NULL))
- ao[ADDED_DATA]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if (o->sn != NULL)
- ao[ADDED_SNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
if (o->ln != NULL)
- ao[ADDED_LNAME]=(ADDED_OBJ *)Malloc(sizeof(ADDED_OBJ));
+ ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ));
for (i=ADDED_DATA; i<=ADDED_NID; i++)
{
aop=(ADDED_OBJ *)lh_insert(added,ao[i]);
/* memory leak, buit should not normally matter */
if (aop != NULL)
- Free(aop);
+ OPENSSL_free(aop);
}
}
o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
return(o->nid);
err:
for (i=ADDED_DATA; i<=ADDED_NID; i++)
- if (ao[i] != NULL) Free(ao[i]);
- if (o != NULL) Free(o);
+ if (ao[i] != NULL) OPENSSL_free(ao[i]);
+ if (o != NULL) OPENSSL_free(o);
return(NID_undef);
}
/* Work out total size */
j = ASN1_object_size(0,i,V_ASN1_OBJECT);
- if((buf=(unsigned char *)Malloc(j)) == NULL) return NULL;
+ if((buf=(unsigned char *)OPENSSL_malloc(j)) == NULL) return NULL;
p = buf;
/* Write out tag+length */
p=buf;
op=d2i_ASN1_OBJECT(NULL,&p,i);
- Free(buf);
+ OPENSSL_free(buf);
return op;
}
i=a2d_ASN1_OBJECT(NULL,0,oid,-1);
if (i <= 0) return(0);
- if ((buf=(unsigned char *)Malloc(i)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(i)) == NULL)
{
OBJerr(OBJ_F_OBJ_CREATE,OBJ_R_MALLOC_FAILURE);
return(0);
ok=OBJ_add_object(op);
err:
ASN1_OBJECT_free(op);
- Free(buf);
+ OPENSSL_free(buf);
return(ok);
}
OBJerr(OBJ_F_OBJ_DUP,ERR_R_ASN1_LIB);
return(NULL);
}
- r->data=Malloc(o->length);
+ r->data=OPENSSL_malloc(o->length);
if (r->data == NULL)
goto err;
memcpy(r->data,o->data,o->length);
if (o->ln != NULL)
{
i=strlen(o->ln)+1;
- r->ln=ln=Malloc(i);
+ r->ln=ln=OPENSSL_malloc(i);
if (r->ln == NULL) goto err;
memcpy(ln,o->ln,i);
}
char *s;
i=strlen(o->sn)+1;
- r->sn=s=Malloc(i);
+ r->sn=s=OPENSSL_malloc(i);
if (r->sn == NULL) goto err;
memcpy(s,o->sn,i);
}
OBJerr(OBJ_F_OBJ_DUP,ERR_R_MALLOC_FAILURE);
if (r != NULL)
{
- if (ln != NULL) Free(ln);
- if (r->data != NULL) Free(r->data);
- Free(r);
+ if (ln != NULL) OPENSSL_free(ln);
+ if (r->data != NULL) OPENSSL_free(r->data);
+ OPENSSL_free(r);
}
return(NULL);
}
else {
/* unknown */
}
- if (name != NULL) Free(name);
- if (header != NULL) Free(header);
- if (data != NULL) Free(data);
+ if (name != NULL) OPENSSL_free(name);
+ if (header != NULL) OPENSSL_free(header);
+ if (data != NULL) OPENSSL_free(data);
name=NULL;
header=NULL;
data=NULL;
ret=NULL;
}
- if (name != NULL) Free(name);
- if (header != NULL) Free(header);
- if (data != NULL) Free(data);
+ if (name != NULL) OPENSSL_free(name);
+ if (header != NULL) OPENSSL_free(header);
+ if (data != NULL) OPENSSL_free(data);
return(ret);
}
return(NULL);
}
if(check_pem(nm, name)) break;
- Free(nm);
- Free(header);
- Free(data);
+ OPENSSL_free(nm);
+ OPENSSL_free(header);
+ OPENSSL_free(data);
}
if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;
if (ret == NULL)
PEMerr(PEM_F_PEM_ASN1_READ_BIO,ERR_R_ASN1_LIB);
err:
- Free(nm);
- Free(header);
- Free(data);
+ OPENSSL_free(nm);
+ OPENSSL_free(header);
+ OPENSSL_free(data);
return(ret);
}
goto err;
}
/* dzise + 8 bytes are needed */
- data=(unsigned char *)Malloc((unsigned int)dsize+20);
+ data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);
if (data == NULL)
{
PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
memset((char *)&ctx,0,sizeof(ctx));
memset(buf,0,PEM_BUFSIZE);
memset(data,0,(unsigned int)dsize);
- Free(data);
+ OPENSSL_free(data);
return(ret);
}
goto err;
}
- buf=(unsigned char *)Malloc(PEM_BUFSIZE*8);
+ buf=(unsigned char *)OPENSSL_malloc(PEM_BUFSIZE*8);
if (buf == NULL)
{
reason=ERR_R_MALLOC_FAILURE;
}
EVP_EncodeFinal(&ctx,buf,&outl);
if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
- Free(buf);
+ OPENSSL_free(buf);
if ( (BIO_write(bp,"-----END ",9) != 9) ||
(BIO_write(bp,name,nlen) != nlen) ||
(BIO_write(bp,"-----\n",6) != 6))
*header=headerB->data;
*data=(unsigned char *)dataB->data;
*len=bl;
- Free(nameB);
- Free(headerB);
- Free(dataB);
+ OPENSSL_free(nameB);
+ OPENSSL_free(headerB);
+ OPENSSL_free(dataB);
return(1);
err:
BUF_MEM_free(nameB);
j=RSA_size(pubk[i]->pkey.rsa);
if (j > max) max=j;
}
- s=(char *)Malloc(max*2);
+ s=(char *)OPENSSL_malloc(max*2);
if (s == NULL)
{
PEMerr(PEM_F_PEM_SEALINIT,ERR_R_MALLOC_FAILURE);
ret=npubk;
err:
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
memset(key,0,EVP_MAX_KEY_LENGTH);
return(ret);
}
}
i=RSA_size(priv->pkey.rsa);
if (i < 100) i=100;
- s=(unsigned char *)Malloc(i*2);
+ s=(unsigned char *)OPENSSL_malloc(i*2);
if (s == NULL)
{
PEMerr(PEM_F_PEM_SEALFINAL,ERR_R_MALLOC_FAILURE);
err:
memset((char *)&(ctx->md),0,sizeof(ctx->md));
memset((char *)&(ctx->cipher),0,sizeof(ctx->cipher));
- if (s != NULL) Free(s);
+ if (s != NULL) OPENSSL_free(s);
return(ret);
}
#else /* !NO_RSA */
int i,ret=0;
unsigned int m_len;
- m=(unsigned char *)Malloc(EVP_PKEY_size(pkey)+2);
+ m=(unsigned char *)OPENSSL_malloc(EVP_PKEY_size(pkey)+2);
if (m == NULL)
{
PEMerr(PEM_F_PEM_SIGNFINAL,ERR_R_MALLOC_FAILURE);
ret=1;
err:
/* ctx has been zeroed by EVP_SignFinal() */
- if (m != NULL) Free(m);
+ if (m != NULL) OPENSSL_free(m);
return(ret);
}
return 0;
}
ret = PKCS12_add_friendlyname_uni (bag, uniname, unilen);
- Free(uniname);
+ OPENSSL_free(uniname);
return ret;
}
ERR_R_MALLOC_FAILURE);
return 0;
}
- if (!(bmp->data = Malloc (namelen))) {
+ if (!(bmp->data = OPENSSL_malloc (namelen))) {
PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free (a->type);
- Free (a);
+ OPENSSL_free (a);
}
/* Encrypt/Decrypt a buffer based on password and algor, result in a
- * Malloc'ed buffer
+ * OPENSSL_malloc'ed buffer
*/
unsigned char * PKCS12_pbe_crypt (X509_ALGOR *algor, const char *pass,
return NULL;
}
- if(!(out = Malloc (inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
+ if(!(out = OPENSSL_malloc (inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_MALLOC_FAILURE);
return NULL;
}
EVP_CipherUpdate (&ctx, out, &i, in, inlen);
outlen = i;
if(!EVP_CipherFinal (&ctx, out + i, &i)) {
- Free (out);
+ OPENSSL_free (out);
PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,PKCS12_R_PKCS12_CIPHERFINAL_ERROR);
return NULL;
}
else ret = d2i(NULL, &p, outlen);
if (seq & 2) memset(out, 0, outlen);
if(!ret) PKCS12err(PKCS12_F_PKCS12_DECRYPT_D2I,PKCS12_R_DECODE_ERROR);
- Free (out);
+ OPENSSL_free (out);
return ret;
}
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,PKCS12_R_ENCODE_ERROR);
return NULL;
}
- if (!(in = Malloc (inlen))) {
+ if (!(in = OPENSSL_malloc (inlen))) {
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!PKCS12_pbe_crypt (algor, pass, passlen, in, inlen, &oct->data,
&oct->length, 1)) {
PKCS12err(PKCS12_F_PKCS12_I2D_ENCRYPT,PKCS12_R_ENCRYPT_ERROR);
- Free(in);
+ OPENSSL_free(in);
return NULL;
}
- Free (in);
+ OPENSSL_free (in);
return oct;
}
id, iter, n, out, md_type);
if(unipass) {
memset(unipass, 0, uniplen); /* Clear password from memory */
- Free(unipass);
+ OPENSSL_free(unipass);
}
return ret;
}
#endif
v = EVP_MD_block_size (md_type);
u = EVP_MD_size (md_type);
- D = Malloc (v);
- Ai = Malloc (u);
- B = Malloc (v + 1);
+ D = OPENSSL_malloc (v);
+ Ai = OPENSSL_malloc (u);
+ B = OPENSSL_malloc (v + 1);
Slen = v * ((saltlen+v-1)/v);
if(passlen) Plen = v * ((passlen+v-1)/v);
else Plen = 0;
Ilen = Slen + Plen;
- I = Malloc (Ilen);
+ I = OPENSSL_malloc (Ilen);
Ij = BN_new();
Bpl1 = BN_new();
if (!D || !Ai || !B || !I || !Ij || !Bpl1) {
}
memcpy (out, Ai, min (n, u));
if (u >= n) {
- Free (Ai);
- Free (B);
- Free (D);
- Free (I);
+ OPENSSL_free (Ai);
+ OPENSSL_free (B);
+ OPENSSL_free (D);
+ OPENSSL_free (I);
BN_free (Ij);
BN_free (Bpl1);
#ifdef DEBUG_KEYGEN
M_ASN1_INTEGER_free(a->version);
PKCS12_MAC_DATA_free (a->mac);
PKCS7_free (a->authsafes);
- Free (a);
+ OPENSSL_free (a);
}
X509_SIG_free (a->dinfo);
M_ASN1_OCTET_STRING_free(a->salt);
M_ASN1_INTEGER_free(a->iter);
- Free (a);
+ OPENSSL_free (a);
}
}
if (!saltlen) saltlen = PKCS12_SALT_LEN;
p12->mac->salt->length = saltlen;
- if (!(p12->mac->salt->data = Malloc (saltlen))) {
+ if (!(p12->mac->salt->data = OPENSSL_malloc (saltlen))) {
PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free (a->type);
sk_X509_ATTRIBUTE_pop_free (a->attrib, X509_ATTRIBUTE_free);
- Free (a);
+ OPENSSL_free (a);
}
IMPLEMENT_STACK_OF(PKCS12_SAFEBAG)
int ulen, i;
unsigned char *unitmp;
ulen = strlen(asc)*2 + 2;
- if (!(unitmp = Malloc (ulen))) return NULL;
+ if (!(unitmp = OPENSSL_malloc (ulen))) return NULL;
for (i = 0; i < ulen; i+=2) {
unitmp[i] = 0;
unitmp[i + 1] = asc[i>>1];
/* If no terminating zero allow for one */
if (uni[unilen - 1]) asclen++;
uni++;
- if (!(asctmp = Malloc (asclen))) return NULL;
+ if (!(asctmp = OPENSSL_malloc (asclen))) return NULL;
for (i = 0; i < unilen; i+=2) asctmp[i>>1] = uni[i];
asctmp[asclen - 1] = 0;
return asctmp;
{
BIO_BER_CTX *ctx;
- ctx=(BIO_BER_CTX *)Malloc(sizeof(BIO_BER_CTX));
+ ctx=(BIO_BER_CTX *)OPENSSL_malloc(sizeof(BIO_BER_CTX));
if (ctx == NULL) return(0);
memset((char *)ctx,0,sizeof(BIO_BER_CTX));
if (a == NULL) return(0);
b=(BIO_BER_CTX *)a->ptr;
memset(a->ptr,0,sizeof(BIO_BER_CTX));
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
a->ptr=NULL;
a->init=0;
a->flags=0;
len=i2d_ASN1_SET_OF_X509_ALGOR(cap,NULL,i2d_X509_ALGOR,
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL,
IS_SEQUENCE);
- if(!(pp=(unsigned char *)Malloc(len))) {
+ if(!(pp=(unsigned char *)OPENSSL_malloc(len))) {
PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
return 0;
}
PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
return 0;
}
- Free (pp);
+ OPENSSL_free (pp);
return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities,
V_ASN1_SEQUENCE, seq);
}
EVP_PKEY_free(pkey);
if (max < jj) max=jj;
}
- if ((tmp=(unsigned char *)Malloc(max)) == NULL)
+ if ((tmp=(unsigned char *)OPENSSL_malloc(max)) == NULL)
{
PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_MALLOC_FAILURE);
goto err;
if (jj <= 0)
{
PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_EVP_LIB);
- Free(tmp);
+ OPENSSL_free(tmp);
goto err;
}
M_ASN1_OCTET_STRING_set(ri->enc_key,tmp,jj);
}
- Free(tmp);
+ OPENSSL_free(tmp);
memset(key, 0, keylen);
if (out == NULL)
}
jj=EVP_PKEY_size(pkey);
- tmp=(unsigned char *)Malloc(jj+10);
+ tmp=(unsigned char *)OPENSSL_malloc(jj+10);
if (tmp == NULL)
{
PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_MALLOC_FAILURE);
out=NULL;
}
if (tmp != NULL)
- Free(tmp);
+ OPENSSL_free(tmp);
return(out);
}
x=i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,NULL,
i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
- pp=(unsigned char *)Malloc(x);
+ pp=(unsigned char *)OPENSSL_malloc(x);
p=pp;
i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,&p,
i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
EVP_SignUpdate(&ctx_tmp,pp,x);
- Free(pp);
+ OPENSSL_free(pp);
pp=NULL;
}
(unsigned char *)buf_mem->data,buf_mem->length);
#endif
}
- if (pp != NULL) Free(pp);
+ if (pp != NULL) OPENSSL_free(pp);
pp=NULL;
ret=1;
*/
i=i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,NULL,i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL, IS_SEQUENCE);
- pp=Malloc(i);
+ pp=OPENSSL_malloc(i);
p=pp;
i2d_ASN1_SET_OF_X509_ATTRIBUTE(sk,&p,i2d_X509_ATTRIBUTE,
V_ASN1_SET,V_ASN1_UNIVERSAL, IS_SEQUENCE);
EVP_VerifyUpdate(&mdc_tmp,pp,i);
- Free(pp);
+ OPENSSL_free(pp);
}
os=si->enc_digest;
}
}
} else tmpval = NULL;
- mhdr = (MIME_HEADER *) Malloc(sizeof(MIME_HEADER));
+ mhdr = (MIME_HEADER *) OPENSSL_malloc(sizeof(MIME_HEADER));
if(!mhdr) return NULL;
mhdr->name = tmpname;
mhdr->value = tmpval;
if(!tmpval) return 0;
} else tmpval = NULL;
/* Parameter values are case sensitive so leave as is */
- mparam = (MIME_PARAM *) Malloc(sizeof(MIME_PARAM));
+ mparam = (MIME_PARAM *) OPENSSL_malloc(sizeof(MIME_PARAM));
if(!mparam) return 0;
mparam->param_name = tmpname;
mparam->param_value = tmpval;
static void mime_hdr_free(MIME_HEADER *hdr)
{
- if(hdr->name) Free(hdr->name);
- if(hdr->value) Free(hdr->value);
+ if(hdr->name) OPENSSL_free(hdr->name);
+ if(hdr->value) OPENSSL_free(hdr->value);
if(hdr->params) sk_MIME_PARAM_pop_free(hdr->params, mime_param_free);
- Free(hdr);
+ OPENSSL_free(hdr);
}
static void mime_param_free(MIME_PARAM *param)
{
- if(param->param_name) Free(param->param_name);
- if(param->param_value) Free(param->param_value);
- Free(param);
+ if(param->param_name) OPENSSL_free(param->param_name);
+ if(param->param_value) OPENSSL_free(param->param_value);
+ OPENSSL_free(param);
}
/* Check for a multipart boundary. Returns:
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
size = (unsigned int)bm.bmWidthBytes * bm.bmHeight * bm.bmPlanes;
- bmbits = Malloc(size);
+ bmbits = OPENSSL_malloc(size);
if (bmbits) {
/* Now go through the whole screen, repeatedly grabbing n lines */
for (y = 0; y < h-n; y += n)
RAND_seed(md, MD_DIGEST_LENGTH);
}
- Free(bmbits);
+ OPENSSL_free(bmbits);
}
/* Select old bitmap back into memory DC */
{
char *tmpf;
- tmpf = Malloc(strlen(file) + 4); /* to add ";-1" and a nul */
+ tmpf = OPENSSL_malloc(strlen(file) + 4); /* to add ";-1" and a nul */
if (tmpf)
{
strcpy(tmpf, file);
BN_init(&ret);
if ((ctx=BN_CTX_new()) == NULL) goto err;
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
if ((ctx=BN_CTX_new()) == NULL) goto err;
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
num=BN_num_bytes(rsa->n);
- if ((buf=(unsigned char *)Malloc(num)) == NULL)
+ if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
{
RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
goto err;
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
if (ctx == NULL) goto err;
num=BN_num_bytes(rsa->n);
- buf=(unsigned char *)Malloc(num);
+ buf=(unsigned char *)OPENSSL_malloc(num);
if (buf == NULL)
{
RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
if (buf != NULL)
{
memset(buf,0,num);
- Free(buf);
+ OPENSSL_free(buf);
}
return(r);
}
{
RSA *ret;
- ret=(RSA *)Malloc(sizeof(RSA));
+ ret=(RSA *)OPENSSL_malloc(sizeof(RSA));
if (ret == NULL)
{
RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
ret->flags=ret->meth->flags;
if ((ret->meth->init != NULL) && !ret->meth->init(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
ret=NULL;
}
else
if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
if (r->iqmp != NULL) BN_clear_free(r->iqmp);
if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
- if (r->bignum_data != NULL) Free_locked(r->bignum_data);
- Free(r);
+ if (r->bignum_data != NULL) OPENSSL_free_locked(r->bignum_data);
+ OPENSSL_free(r);
}
int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
j=1;
for (i=0; i<6; i++)
j+= (*t[i])->top;
- if ((p=Malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
+ if ((p=OPENSSL_malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
{
RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
return(0);
return (0);
}
- dbmask = Malloc(emlen - SHA_DIGEST_LENGTH);
+ dbmask = OPENSSL_malloc(emlen - SHA_DIGEST_LENGTH);
if (dbmask == NULL)
{
RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
seed[i] ^= seedmask[i];
- Free(dbmask);
+ OPENSSL_free(dbmask);
return (1);
}
}
dblen = num - SHA_DIGEST_LENGTH;
- db = Malloc(dblen);
+ db = OPENSSL_malloc(dblen);
if (db == NULL)
{
RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
memcpy(to, db + i, mlen);
}
}
- Free(db);
+ OPENSSL_free(db);
return (mlen);
}
RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY);
return(0);
}
- s=(unsigned char *)Malloc((unsigned int)j+1);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)j+1);
if (s == NULL)
{
RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE);
*siglen=i;
memset(s,0,(unsigned int)j+1);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
return(0);
}
- s=(unsigned char *)Malloc((unsigned int)siglen);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)siglen);
if (s == NULL)
{
RSAerr(RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE);
err:
if (sig != NULL) M_ASN1_OCTET_STRING_free(sig);
memset(s,0,(unsigned int)siglen);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
return(0);
}
if(type != NID_md5_sha1) {
- s=(unsigned char *)Malloc((unsigned int)j+1);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)j+1);
if (s == NULL)
{
RSAerr(RSA_F_RSA_SIGN,ERR_R_MALLOC_FAILURE);
if(type != NID_md5_sha1) {
memset(s,0,(unsigned int)j+1);
- Free(s);
+ OPENSSL_free(s);
}
return(ret);
}
if(rsa->flags & RSA_FLAG_SIGN_VER)
return rsa->meth->rsa_verify(dtype, m, m_len, sigbuf, siglen, rsa);
- s=(unsigned char *)Malloc((unsigned int)siglen);
+ s=(unsigned char *)OPENSSL_malloc((unsigned int)siglen);
if (s == NULL)
{
RSAerr(RSA_F_RSA_VERIFY,ERR_R_MALLOC_FAILURE);
err:
if (sig != NULL) X509_SIG_free(sig);
memset(s,0,(unsigned int)siglen);
- Free(s);
+ OPENSSL_free(s);
return(ret);
}
char **s;
if ((ret=sk_new(sk->comp)) == NULL) goto err;
- s=(char **)Realloc((char *)ret->data,
+ s=(char **)OPENSSL_realloc((char *)ret->data,
(unsigned int)sizeof(char *)*sk->num_alloc);
if (s == NULL) goto err;
ret->data=s;
STACK *ret;
int i;
- if ((ret=(STACK *)Malloc(sizeof(STACK))) == NULL)
+ if ((ret=(STACK *)OPENSSL_malloc(sizeof(STACK))) == NULL)
goto err0;
- if ((ret->data=(char **)Malloc(sizeof(char *)*MIN_NODES)) == NULL)
+ if ((ret->data=(char **)OPENSSL_malloc(sizeof(char *)*MIN_NODES)) == NULL)
goto err1;
for (i=0; i<MIN_NODES; i++)
ret->data[i]=NULL;
ret->sorted=0;
return(ret);
err1:
- Free(ret);
+ OPENSSL_free(ret);
err0:
return(NULL);
}
if(st == NULL) return 0;
if (st->num_alloc <= st->num+1)
{
- s=(char **)Realloc((char *)st->data,
+ s=(char **)OPENSSL_realloc((char *)st->data,
(unsigned int)sizeof(char *)*st->num_alloc*2);
if (s == NULL)
return(0);
void sk_free(STACK *st)
{
if (st == NULL) return;
- if (st->data != NULL) Free(st->data);
- Free(st);
+ if (st->data != NULL) OPENSSL_free(st->data);
+ OPENSSL_free(st);
}
int sk_num(const STACK *st)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
CRYPTO_set_locking_callback(NULL);
for (i=0; i<CRYPTO_num_locks(); i++)
CloseHandle(lock_cs[i]);
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void win32_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
mutex_destroy(&(lock_cs[i]));
fprintf(stderr,"%8ld:%s\n",lock_count[i],CRYPTO_get_lock_name(i));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
fprintf(stderr,"done cleanup\n");
arena=usinit(filename);
unlink(filename);
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(usema_t *));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=usnewsema(arena,1);
usdumpsema(lock_cs[i],stdout,buf);
usfreesema(lock_cs[i],arena);
}
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void irix_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
fprintf(stderr,"%8ld:%s\n",lock_count[i],
CRYPTO_get_lock_name(i));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
fprintf(stderr,"done cleanup\n");
}
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(HANDLE));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(HANDLE));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
CRYPTO_set_locking_callback(NULL);
for (i=0; i<CRYPTO_num_locks(); i++)
CloseHandle(lock_cs[i]);
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void win32_locking_callback(int mode, int type, char *file, int line)
int i;
#ifdef USE_MUTEX
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
#else
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(rwlock_t));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(rwlock_t));
#endif
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
rwlock_destroy(&(lock_cs[i]));
#endif
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
}
void solaris_locking_callback(int mode, int type, char *file, int line)
arena=usinit(filename);
unlink(filename);
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(usema_t *));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_cs[i]=usnewsema(arena,1);
usdumpsema(lock_cs[i],stdout,buf);
usfreesema(lock_cs[i],arena);
}
- Free(lock_cs);
+ OPENSSL_free(lock_cs);
}
void irix_locking_callback(int mode, int type, char *file, int line)
{
int i;
- lock_cs=Malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
- lock_count=Malloc(CRYPTO_num_locks() * sizeof(long));
+ lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+ lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
for (i=0; i<CRYPTO_num_locks(); i++)
{
lock_count[i]=0;
{
pthread_mutex_destroy(&(lock_cs[i]));
}
- Free(lock_cs);
- Free(lock_count);
+ OPENSSL_free(lock_cs);
+ OPENSSL_free(lock_count);
}
void pthreads_locking_callback(int mode, int type, char *file,
{
MS_TM *ret;
- ret=(MS_TM *)Malloc(sizeof(MS_TM));
+ ret=(MS_TM *)OPENSSL_malloc(sizeof(MS_TM));
if (ret == NULL)
return(NULL);
memset(ret,0,sizeof(MS_TM));
void ms_time_free(char *a)
{
if (a != NULL)
- Free(a);
+ OPENSSL_free(a);
}
void ms_time_get(char *a)
if ((buf=BUF_MEM_new()) == NULL) goto err;
if (!BUF_MEM_grow(buf,size)) goto err;
- if ((ret=(TXT_DB *)Malloc(sizeof(TXT_DB))) == NULL)
+ if ((ret=(TXT_DB *)OPENSSL_malloc(sizeof(TXT_DB))) == NULL)
goto err;
ret->num_fields=num;
ret->index=NULL;
ret->qual=NULL;
if ((ret->data=sk_new_null()) == NULL)
goto err;
- if ((ret->index=(LHASH **)Malloc(sizeof(LHASH *)*num)) == NULL)
+ if ((ret->index=(LHASH **)OPENSSL_malloc(sizeof(LHASH *)*num)) == NULL)
goto err;
- if ((ret->qual=(int (**)())Malloc(sizeof(int (**)())*num)) == NULL)
+ if ((ret->qual=(int (**)())OPENSSL_malloc(sizeof(int (**)())*num)) == NULL)
goto err;
for (i=0; i<num; i++)
{
else
{
buf->data[offset-1]='\0'; /* blat the '\n' */
- p=(char *)Malloc(add+offset);
+ p=(char *)OPENSSL_malloc(add+offset);
offset=0;
}
pp=(char **)p;
if (er)
{
#if !defined(NO_STDIO) && !defined(WIN16)
- if (er == 1) fprintf(stderr,"Malloc failure\n");
+ if (er == 1) fprintf(stderr,"OPENSSL_malloc failure\n");
#endif
if (ret->data != NULL) sk_free(ret->data);
- if (ret->index != NULL) Free(ret->index);
- if (ret->qual != NULL) Free(ret->qual);
- if (ret != NULL) Free(ret);
+ if (ret->index != NULL) OPENSSL_free(ret->index);
+ if (ret->qual != NULL) OPENSSL_free(ret->qual);
+ if (ret != NULL) OPENSSL_free(ret);
return(NULL);
}
else
{
for (i=db->num_fields-1; i>=0; i--)
if (db->index[i] != NULL) lh_free(db->index[i]);
- Free(db->index);
+ OPENSSL_free(db->index);
}
if (db->qual != NULL)
- Free(db->qual);
+ OPENSSL_free(db->qual);
if (db->data != NULL)
{
for (i=sk_num(db->data)-1; i>=0; i--)
if (max == NULL) /* new row */
{
for (n=0; n<db->num_fields; n++)
- if (p[n] != NULL) Free(p[n]);
+ if (p[n] != NULL) OPENSSL_free(p[n]);
}
else
{
{
if (((p[n] < (char *)p) || (p[n] > max))
&& (p[n] != NULL))
- Free(p[n]);
+ OPENSSL_free(p[n]);
}
}
- Free(sk_value(db->data,i));
+ OPENSSL_free(sk_value(db->data,i));
}
sk_free(db->data);
}
- Free(db);
+ OPENSSL_free(db);
}
{
BY_DIR *a;
- if ((a=(BY_DIR *)Malloc(sizeof(BY_DIR))) == NULL)
+ if ((a=(BY_DIR *)OPENSSL_malloc(sizeof(BY_DIR))) == NULL)
return(0);
if ((a->buffer=BUF_MEM_new()) == NULL)
{
- Free(a);
+ OPENSSL_free(a);
return(0);
}
a->num_dirs=0;
a=(BY_DIR *)lu->method_data;
for (i=0; i<a->num_dirs; i++)
- if (a->dirs[i] != NULL) Free(a->dirs[i]);
- if (a->dirs != NULL) Free(a->dirs);
- if (a->dirs_type != NULL) Free(a->dirs_type);
+ if (a->dirs[i] != NULL) OPENSSL_free(a->dirs[i]);
+ if (a->dirs != NULL) OPENSSL_free(a->dirs);
+ if (a->dirs_type != NULL) OPENSSL_free(a->dirs_type);
if (a->buffer != NULL) BUF_MEM_free(a->buffer);
- Free(a);
+ OPENSSL_free(a);
}
static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
if (ctx->num_dirs_alloced < (ctx->num_dirs+1))
{
ctx->num_dirs_alloced+=10;
- pp=(char **)Malloc(ctx->num_dirs_alloced*
+ pp=(char **)OPENSSL_malloc(ctx->num_dirs_alloced*
sizeof(char *));
- ip=(int *)Malloc(ctx->num_dirs_alloced*
+ ip=(int *)OPENSSL_malloc(ctx->num_dirs_alloced*
sizeof(int));
if ((pp == NULL) || (ip == NULL))
{
memcpy(ip,ctx->dirs_type,(ctx->num_dirs_alloced-10)*
sizeof(int));
if (ctx->dirs != NULL)
- Free(ctx->dirs);
+ OPENSSL_free(ctx->dirs);
if (ctx->dirs_type != NULL)
- Free(ctx->dirs_type);
+ OPENSSL_free(ctx->dirs_type);
ctx->dirs=pp;
ctx->dirs_type=ip;
}
ctx->dirs_type[ctx->num_dirs]=type;
- ctx->dirs[ctx->num_dirs]=(char *)Malloc((unsigned int)len+1);
+ ctx->dirs[ctx->num_dirs]=(char *)OPENSSL_malloc((unsigned int)len+1);
if (ctx->dirs[ctx->num_dirs] == NULL) return(0);
strncpy(ctx->dirs[ctx->num_dirs],ss,(unsigned int)len);
ctx->dirs[ctx->num_dirs][len]='\0';
i=i2d_X509_NAME(x,NULL);
if (i > sizeof(str))
- p=Malloc(i);
+ p=OPENSSL_malloc(i);
else
p=str;
pp=p;
i2d_X509_NAME(x,&pp);
MD5((unsigned char *)p,i,&(md[0]));
- if (p != str) Free(p);
+ if (p != str) OPENSSL_free(p);
ret=( ((unsigned long)md[0] )|((unsigned long)md[1]<<8L)|
((unsigned long)md[2]<<16L)|((unsigned long)md[3]<<24L)
{
X509_LOOKUP *ret;
- ret=(X509_LOOKUP *)Malloc(sizeof(X509_LOOKUP));
+ ret=(X509_LOOKUP *)OPENSSL_malloc(sizeof(X509_LOOKUP));
if (ret == NULL) return(NULL);
ret->init=0;
ret->store_ctx=NULL;
if ((method->new_item != NULL) && !method->new_item(ret))
{
- Free(ret);
+ OPENSSL_free(ret);
return(NULL);
}
return(ret);
if ( (ctx->method != NULL) &&
(ctx->method->free != NULL))
ctx->method->free(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
int X509_LOOKUP_init(X509_LOOKUP *ctx)
{
X509_STORE *ret;
- if ((ret=(X509_STORE *)Malloc(sizeof(X509_STORE))) == NULL)
+ if ((ret=(X509_STORE *)OPENSSL_malloc(sizeof(X509_STORE))) == NULL)
return(NULL);
ret->certs=lh_new(x509_object_hash,x509_object_cmp);
ret->cache=1;
else
abort();
- Free(a);
+ OPENSSL_free(a);
}
void X509_STORE_free(X509_STORE *vfy)
CRYPTO_free_ex_data(x509_store_meth,vfy,&vfy->ex_data);
lh_doall(vfy->certs,cleanup);
lh_free(vfy->certs);
- Free(vfy);
+ OPENSSL_free(vfy);
}
X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
X509_STORE_CTX *X509_STORE_CTX_new(void)
{
X509_STORE_CTX *ctx;
- ctx = (X509_STORE_CTX *)Malloc(sizeof(X509_STORE_CTX));
+ ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX));
if(ctx) memset(ctx, 0, sizeof(X509_STORE_CTX));
return ctx;
}
void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
{
X509_STORE_CTX_cleanup(ctx);
- Free(ctx);
+ OPENSSL_free(ctx);
}
void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
if(b)
{
buf=b->data;
- Free(b);
+ OPENSSL_free(b);
}
strncpy(buf,"NO X509_NAME",len);
return buf;
if (b != NULL)
{
p=b->data;
- Free(b);
+ OPENSSL_free(b);
}
else
p=buf;
ri=ret->req_info;
ri->version->length=1;
- ri->version->data=(unsigned char *)Malloc(1);
+ ri->version->data=(unsigned char *)OPENSSL_malloc(1);
if (ri->version->data == NULL) goto err;
ri->version->data[0]=0; /* version == 0 */
/* Generate encoding of extensions */
len = i2d_ASN1_SET_OF_X509_EXTENSION(exts, NULL, i2d_X509_EXTENSION,
V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
- if(!(p = Malloc(len))) goto err;
+ if(!(p = OPENSSL_malloc(len))) goto err;
q = p;
i2d_ASN1_SET_OF_X509_EXTENSION(exts, &q, i2d_X509_EXTENSION,
V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, IS_SEQUENCE);
if(!sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr)) goto err;
return 1;
err:
- if(p) Free(p);
+ if(p) OPENSSL_free(p);
X509_ATTRIBUTE_free(attr);
ASN1_TYPE_free(at);
return 0;
idx = X509_TRUST_get_by_id(id);
/* Need a new entry */
if(idx == -1) {
- if(!(trtmp = Malloc(sizeof(X509_TRUST)))) {
+ if(!(trtmp = OPENSSL_malloc(sizeof(X509_TRUST)))) {
X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
trtmp->flags = X509_TRUST_DYNAMIC;
} else trtmp = X509_TRUST_get0(idx);
- /* Free existing name if dynamic */
- if(trtmp->flags & X509_TRUST_DYNAMIC_NAME) Free(trtmp->name);
+ /* OPENSSL_free existing name if dynamic */
+ if(trtmp->flags & X509_TRUST_DYNAMIC_NAME) OPENSSL_free(trtmp->name);
/* dup supplied name */
if(!(trtmp->name = BUF_strdup(name))) {
X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
if (p->flags & X509_TRUST_DYNAMIC)
{
if (p->flags & X509_TRUST_DYNAMIC_NAME)
- Free(p->name);
- Free(p);
+ OPENSSL_free(p->name);
+ OPENSSL_free(p);
}
}
int ret=1;
if (x == NULL) return(0);
- obj=(X509_OBJECT *)Malloc(sizeof(X509_OBJECT));
+ obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
if (obj == NULL)
{
X509err(X509_F_X509_STORE_ADD_CERT,ERR_R_MALLOC_FAILURE);
{ /* oops, put it back */
lh_delete(ctx->certs,obj);
X509_OBJECT_free_contents(obj);
- Free(obj);
+ OPENSSL_free(obj);
lh_insert(ctx->certs,r);
X509err(X509_F_X509_STORE_ADD_CERT,X509_R_CERT_ALREADY_IN_HASH_TABLE);
ret=0;
int ret=1;
if (x == NULL) return(0);
- obj=(X509_OBJECT *)Malloc(sizeof(X509_OBJECT));
+ obj=(X509_OBJECT *)OPENSSL_malloc(sizeof(X509_OBJECT));
if (obj == NULL)
{
X509err(X509_F_X509_STORE_ADD_CRL,ERR_R_MALLOC_FAILURE);
{ /* oops, put it back */
lh_delete(ctx->certs,obj);
X509_OBJECT_free_contents(obj);
- Free(obj);
+ OPENSSL_free(obj);
lh_insert(ctx->certs,r);
X509err(X509_F_X509_STORE_ADD_CRL,X509_R_CERT_ALREADY_IN_HASH_TABLE);
ret=0;
int spki_len;
NETSCAPE_SPKI *spki;
if(len <= 0) len = strlen(str);
- if (!(spki_der = Malloc(len + 1))) {
+ if (!(spki_der = OPENSSL_malloc(len + 1))) {
X509err(X509_F_NETSCAPE_SPKI_B64_DECODE, ERR_R_MALLOC_FAILURE);
return NULL;
}
if(spki_len < 0) {
X509err(X509_F_NETSCAPE_SPKI_B64_DECODE,
X509_R_BASE64_DECODE_ERROR);
- Free(spki_der);
+ OPENSSL_free(spki_der);
return NULL;
}
p = spki_der;
spki = d2i_NETSCAPE_SPKI(NULL, &p, spki_len);
- Free(spki_der);
+ OPENSSL_free(spki_der);
return spki;
}
char *b64_str;
int der_len;
der_len = i2d_NETSCAPE_SPKI(spki, NULL);
- der_spki = Malloc(der_len);
- b64_str = Malloc(der_len * 2);
+ der_spki = OPENSSL_malloc(der_len);
+ b64_str = OPENSSL_malloc(der_len * 2);
if(!der_spki || !b64_str) {
X509err(X509_F_NETSCAPE_SPKI_B64_ENCODE, ERR_R_MALLOC_FAILURE);
return NULL;
p = der_spki;
i2d_NETSCAPE_SPKI(spki, &p);
EVP_EncodeBlock((unsigned char *)b64_str, der_spki, der_len);
- Free(der_spki);
+ OPENSSL_free(der_spki);
return b64_str;
}
M_ASN1_OCTET_STRING_free(a->keyid);
sk_GENERAL_NAME_pop_free(a->issuer, GENERAL_NAME_free);
M_ASN1_INTEGER_free (a->serial);
- Free (a);
+ OPENSSL_free (a);
}
static STACK_OF(CONF_VALUE) *i2v_AUTHORITY_KEYID(X509V3_EXT_METHOD *method,
if(akeyid->keyid) {
tmp = hex_to_string(akeyid->keyid->data, akeyid->keyid->length);
X509V3_add_value("keyid", tmp, &extlist);
- Free(tmp);
+ OPENSSL_free(tmp);
}
if(akeyid->issuer)
extlist = i2v_GENERAL_NAMES(NULL, akeyid->issuer, extlist);
tmp = hex_to_string(akeyid->serial->data,
akeyid->serial->length);
X509V3_add_value("serial", tmp, &extlist);
- Free(tmp);
+ OPENSSL_free(tmp);
}
return extlist;
}
{
if (a == NULL) return;
M_ASN1_INTEGER_free (a->pathlen);
- Free (a);
+ OPENSSL_free (a);
}
static STACK_OF(CONF_VALUE) *i2v_BASIC_CONSTRAINTS(X509V3_EXT_METHOD *method,
X509_EXTENSION *ext;
/* Convert internal representation to DER */
ext_len = method->i2d(ext_struc, NULL);
- if(!(ext_der = Malloc(ext_len))) goto merr;
+ if(!(ext_der = OPENSSL_malloc(ext_len))) goto merr;
p = ext_der;
method->i2d(ext_struc, &p);
if(!(ext_oct = M_ASN1_OCTET_STRING_new())) goto merr;
err:
ASN1_OBJECT_free(obj);
M_ASN1_OCTET_STRING_free(oct);
-if(ext_der) Free(ext_der);
+if(ext_der) OPENSSL_free(ext_der);
return extension;
}
if (a == NULL) return;
ASN1_OBJECT_free(a->policyid);
sk_POLICYQUALINFO_pop_free(a->qualifiers, POLICYQUALINFO_free);
- Free (a);
+ OPENSSL_free (a);
}
static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals,
if(i) BIO_puts(out, ", ");
tmp = i2s_ASN1_INTEGER(NULL, num);
BIO_puts(out, tmp);
- Free(tmp);
+ OPENSSL_free(tmp);
}
BIO_puts(out, "\n");
}
}
ASN1_OBJECT_free(a->pqualid);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_USERNOTICE(USERNOTICE *a, unsigned char **pp)
if (a == NULL) return;
NOTICEREF_free(a->noticeref);
M_DISPLAYTEXT_free(a->exptext);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_NOTICEREF(NOTICEREF *a, unsigned char **pp)
if (a == NULL) return;
M_DISPLAYTEXT_free(a->organization);
sk_ASN1_INTEGER_pop_free(a->noticenos, ASN1_STRING_free);
- Free (a);
+ OPENSSL_free (a);
}
IMPLEMENT_STACK_OF(POLICYQUALINFO)
DIST_POINT_NAME_free(a->distpoint);
M_ASN1_BIT_STRING_free(a->reasons);
sk_GENERAL_NAME_pop_free(a->CRLissuer, GENERAL_NAME_free);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **pp)
if (a == NULL) return;
sk_X509_NAME_ENTRY_pop_free(a->relativename, X509_NAME_ENTRY_free);
sk_GENERAL_NAME_pop_free(a->fullname, GENERAL_NAME_free);
- Free (a);
+ OPENSSL_free (a);
}
DIST_POINT_NAME *d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, unsigned char **pp,
break;
}
- Free (a);
+ OPENSSL_free (a);
}
/* Now the GeneralNames versions: a SEQUENCE OF GeneralName. These are needed as
if (a == NULL) return;
ASN1_OBJECT_free(a->type_id);
ASN1_TYPE_free(a->value);
- Free (a);
+ OPENSSL_free (a);
}
{
char *tmp;
if(!ia5 || !ia5->length) return NULL;
- tmp = Malloc(ia5->length + 1);
+ tmp = OPENSSL_malloc(ia5->length + 1);
memcpy(tmp, ia5->data, ia5->length);
tmp[ia5->length] = 0;
return tmp;
if(!ret) break;
vtmp = sk_CONF_VALUE_value(ret, i);
i2t_ASN1_OBJECT(objtmp, 80, desc->method);
- ntmp = Malloc(strlen(objtmp) + strlen(vtmp->name) + 5);
+ ntmp = OPENSSL_malloc(strlen(objtmp) + strlen(vtmp->name) + 5);
if(!ntmp) {
X509V3err(X509V3_F_I2V_AUTHORITY_INFO_ACCESS,
ERR_R_MALLOC_FAILURE);
strcpy(ntmp, objtmp);
strcat(ntmp, " - ");
strcat(ntmp, vtmp->name);
- Free(vtmp->name);
+ OPENSSL_free(vtmp->name);
vtmp->name = ntmp;
}
ctmp.value = cnf->value;
if(!(acc->location = v2i_GENERAL_NAME(method, ctx, &ctmp)))
goto err;
- if(!(objtmp = Malloc(objlen + 1))) {
+ if(!(objtmp = OPENSSL_malloc(objlen + 1))) {
X509V3err(X509V3_F_V2I_ACCESS_DESCRIPTION,ERR_R_MALLOC_FAILURE);
goto err;
}
if(!acc->method) {
X509V3err(X509V3_F_V2I_ACCESS_DESCRIPTION,X509V3_R_BAD_OBJECT);
ERR_add_error_data(2, "value=", objtmp);
- Free(objtmp);
+ OPENSSL_free(objtmp);
goto err;
}
- Free(objtmp);
+ OPENSSL_free(objtmp);
}
return ainfo;
if (a == NULL) return;
ASN1_OBJECT_free(a->method);
GENERAL_NAME_free(a->location);
- Free (a);
+ OPENSSL_free (a);
}
STACK_OF(ACCESS_DESCRIPTION) *AUTHORITY_INFO_ACCESS_new(void)
X509V3err(X509V3_F_X509V3_EXT_ADD_ALIAS,X509V3_R_EXTENSION_NOT_FOUND);
return 0;
}
- if(!(tmpext = (X509V3_EXT_METHOD *)Malloc(sizeof(X509V3_EXT_METHOD)))) {
+ if(!(tmpext = (X509V3_EXT_METHOD *)OPENSSL_malloc(sizeof(X509V3_EXT_METHOD)))) {
X509V3err(X509V3_F_X509V3_EXT_ADD_ALIAS,ERR_R_MALLOC_FAILURE);
return 0;
}
static void ext_list_free(X509V3_EXT_METHOD *ext)
{
- if(ext->ext_flags & X509V3_EXT_DYNAMIC) Free(ext);
+ if(ext->ext_flags & X509V3_EXT_DYNAMIC) OPENSSL_free(ext);
}
/* Legacy function: we don't need to add standard extensions
if (a == NULL) return;
M_ASN1_GENERALIZEDTIME_free(a->notBefore);
M_ASN1_GENERALIZEDTIME_free(a->notAfter);
- Free (a);
+ OPENSSL_free (a);
}
static int i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method,
err:
sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
- if(value) Free(value);
+ if(value) OPENSSL_free(value);
method->ext_free(ext_str);
return ok;
}
idx = X509_PURPOSE_get_by_id(id);
/* Need a new entry */
if(idx == -1) {
- if(!(ptmp = Malloc(sizeof(X509_PURPOSE)))) {
+ if(!(ptmp = OPENSSL_malloc(sizeof(X509_PURPOSE)))) {
X509V3err(X509V3_F_X509_PURPOSE_ADD,ERR_R_MALLOC_FAILURE);
return 0;
}
ptmp->flags = X509_PURPOSE_DYNAMIC;
} else ptmp = X509_PURPOSE_get0(idx);
- /* Free existing name if dynamic */
+ /* OPENSSL_free existing name if dynamic */
if(ptmp->flags & X509_PURPOSE_DYNAMIC_NAME) {
- Free(ptmp->name);
- Free(ptmp->sname);
+ OPENSSL_free(ptmp->name);
+ OPENSSL_free(ptmp->sname);
}
/* dup supplied name */
ptmp->name = BUF_strdup(name);
if (p->flags & X509_PURPOSE_DYNAMIC)
{
if (p->flags & X509_PURPOSE_DYNAMIC_NAME) {
- Free(p->name);
- Free(p->sname);
+ OPENSSL_free(p->name);
+ OPENSSL_free(p->sname);
}
- Free(p);
+ OPENSSL_free(p);
}
}
if (a == NULL) return;
M_ASN1_INTEGER_free(a->version);
sk_SXNETID_pop_free(a->ids, SXNETID_free);
- Free (a);
+ OPENSSL_free (a);
}
int i2d_SXNETID(SXNETID *a, unsigned char **pp)
if (a == NULL) return;
M_ASN1_INTEGER_free(a->zone);
M_ASN1_OCTET_STRING_free(a->user);
- Free (a);
+ OPENSSL_free (a);
}
static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out,
id = sk_SXNETID_value(sx->ids, i);
tmp = i2s_ASN1_INTEGER(NULL, id->zone);
BIO_printf(out, "\n%*sZone: %s, User: ", indent, "", tmp);
- Free(tmp);
+ OPENSSL_free(tmp);
M_ASN1_OCTET_STRING_print(out, id->user);
}
return 1;
char *tname = NULL, *tvalue = NULL;
if(name && !(tname = BUF_strdup(name))) goto err;
if(value && !(tvalue = BUF_strdup(value))) goto err;;
- if(!(vtmp = (CONF_VALUE *)Malloc(sizeof(CONF_VALUE)))) goto err;
+ if(!(vtmp = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE)))) goto err;
if(!*extlist && !(*extlist = sk_CONF_VALUE_new(NULL))) goto err;
vtmp->section = NULL;
vtmp->name = tname;
return 1;
err:
X509V3err(X509V3_F_X509V3_ADD_VALUE,ERR_R_MALLOC_FAILURE);
- if(vtmp) Free(vtmp);
- if(tname) Free(tname);
- if(tvalue) Free(tvalue);
+ if(vtmp) OPENSSL_free(vtmp);
+ if(tname) OPENSSL_free(tname);
+ if(tvalue) OPENSSL_free(tvalue);
return 0;
}
void X509V3_conf_free(CONF_VALUE *conf)
{
if(!conf) return;
- if(conf->name) Free(conf->name);
- if(conf->value) Free(conf->value);
- if(conf->section) Free(conf->section);
- Free(conf);
+ if(conf->name) OPENSSL_free(conf->name);
+ if(conf->value) OPENSSL_free(conf->value);
+ if(conf->section) OPENSSL_free(conf->section);
+ OPENSSL_free(conf);
}
int X509V3_add_value_bool(const char *name, int asn1_bool,
if(!aint) return 1;
if(!(strtmp = i2s_ASN1_INTEGER(NULL, aint))) return 0;
ret = X509V3_add_value(name, strtmp, extlist);
- Free(strtmp);
+ OPENSSL_free(strtmp);
return ret;
}
}
X509V3_add_value(ntmp, NULL, &values);
}
-Free(linebuf);
+OPENSSL_free(linebuf);
return values;
err:
-Free(linebuf);
+OPENSSL_free(linebuf);
sk_CONF_VALUE_pop_free(values, X509V3_conf_free);
return NULL;
/* hex string utilities */
-/* Given a buffer of length 'len' return a Malloc'ed string with its
+/* Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
* hex representation
*/
int i;
static char hexdig[] = "0123456789ABCDEF";
if(!buffer || !len) return NULL;
- if(!(tmp = Malloc(len * 3 + 1))) {
+ if(!(tmp = OPENSSL_malloc(len * 3 + 1))) {
X509V3err(X509V3_F_HEX_TO_STRING,ERR_R_MALLOC_FAILURE);
return NULL;
}
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_INVALID_NULL_ARGUMENT);
return NULL;
}
- if(!(hexbuf = Malloc(strlen(str) >> 1))) goto err;
+ if(!(hexbuf = OPENSSL_malloc(strlen(str) >> 1))) goto err;
for(p = (unsigned char *)str, q = hexbuf; *p;) {
ch = *p++;
if(ch == ':') continue;
cl = *p++;
if(!cl) {
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ODD_NUMBER_OF_DIGITS);
- Free(hexbuf);
+ OPENSSL_free(hexbuf);
return NULL;
}
if(isupper(ch)) ch = tolower(ch);
return hexbuf;
err:
- if(hexbuf) Free(hexbuf);
+ if(hexbuf) OPENSSL_free(hexbuf);
X509V3err(X509V3_F_STRING_TO_HEX,ERR_R_MALLOC_FAILURE);
return NULL;
badhex:
- Free(hexbuf);
+ OPENSSL_free(hexbuf);
X509V3err(X509V3_F_STRING_TO_HEX,X509V3_R_ILLEGAL_HEX_DIGIT);
return NULL;
if (verbose) BIO_printf(bio_err,"bufsize=%d\n",bsize);
}
- strbuf=Malloc(SIZE);
- buff=(unsigned char *)Malloc(EVP_ENCODE_LENGTH(bsize));
+ strbuf=OPENSSL_malloc(SIZE);
+ buff=(unsigned char *)OPENSSL_malloc(EVP_ENCODE_LENGTH(bsize));
if ((buff == NULL) || (strbuf == NULL))
{
- BIO_printf(bio_err,"Malloc failure\n");
+ BIO_printf(bio_err,"OPENSSL_malloc failure\n");
goto end;
}
BIO_printf(bio_err,"bytes written:%8ld\n",BIO_number_written(out));
}
end:
- if (strbuf != NULL) Free(strbuf);
- if (buff != NULL) Free(buff);
+ if (strbuf != NULL) OPENSSL_free(strbuf);
+ if (buff != NULL) OPENSSL_free(buff);
if (in != NULL) BIO_free(in);
if (out != NULL) BIO_free(out);
if (benc != NULL) BIO_free(benc);
{
BIO_SSL *bs;
- bs=(BIO_SSL *)Malloc(sizeof(BIO_SSL));
+ bs=(BIO_SSL *)OPENSSL_malloc(sizeof(BIO_SSL));
if (bs == NULL)
{
BIOerr(BIO_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
a->flags=0;
}
if (a->ptr != NULL)
- Free(a->ptr);
+ OPENSSL_free(a->ptr);
return(1);
}
if (n <= 0) return(n);
p=s->packet;
- if ((buf=Malloc(n)) == NULL)
+ if ((buf=OPENSSL_malloc(n)) == NULL)
{
SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
goto err;
}
s->init_num=0;
- if (buf != buf_space) Free(buf);
+ if (buf != buf_space) OPENSSL_free(buf);
s->first_packet=1;
return(SSL_accept(s));
err:
- if (buf != buf_space) Free(buf);
+ if (buf != buf_space) OPENSSL_free(buf);
return(-1);
}
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
rs= s->enc_read_ctx;
{
SSL2_STATE *s2;
- if ((s2=Malloc(sizeof *s2)) == NULL) goto err;
+ if ((s2=OPENSSL_malloc(sizeof *s2)) == NULL) goto err;
memset(s2,0,sizeof *s2);
- if ((s2->rbuf=Malloc(
+ if ((s2->rbuf=OPENSSL_malloc(
SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
- if ((s2->wbuf=Malloc(
+ if ((s2->wbuf=OPENSSL_malloc(
SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
s->s2=s2;
err:
if (s2 != NULL)
{
- if (s2->wbuf != NULL) Free(s2->wbuf);
- if (s2->rbuf != NULL) Free(s2->rbuf);
- Free(s2);
+ if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
+ if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
+ OPENSSL_free(s2);
}
return(0);
}
return;
s2=s->s2;
- if (s2->rbuf != NULL) Free(s2->rbuf);
- if (s2->wbuf != NULL) Free(s2->wbuf);
+ if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
+ if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
memset(s2,0,sizeof *s2);
- Free(s2);
+ OPENSSL_free(s2);
s->s2=NULL;
}
EVP_VerifyUpdate(&ctx,ccd,SSL2_MIN_CERT_CHALLENGE_LENGTH);
i=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,NULL);
- buf2=Malloc((unsigned int)i);
+ buf2=OPENSSL_malloc((unsigned int)i);
if (buf2 == NULL)
{
SSLerr(SSL_F_REQUEST_CERTIFICATE,ERR_R_MALLOC_FAILURE);
p2=buf2;
i=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,&p2);
EVP_VerifyUpdate(&ctx,buf2,(unsigned int)i);
- Free(buf2);
+ OPENSSL_free(buf2);
pkey=X509_get_pubkey(x509);
if (pkey == NULL) goto end;
extra=SSL3_RT_MAX_EXTRA;
else
extra=0;
- if ((p=Malloc(SSL3_RT_MAX_PACKET_SIZE+extra))
+ if ((p=OPENSSL_malloc(SSL3_RT_MAX_PACKET_SIZE+extra))
== NULL)
goto err;
s->s3->rbuf.buf=p;
if (s->s3->wbuf.buf == NULL)
{
- if ((p=Malloc(SSL3_RT_MAX_PACKET_SIZE))
+ if ((p=OPENSSL_malloc(SSL3_RT_MAX_PACKET_SIZE))
== NULL)
goto err;
s->s3->wbuf.buf=p;
{
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_read_ctx;
s->read_hash=m;
}
if (s->s3->rrec.comp == NULL)
s->s3->rrec.comp=(unsigned char *)
- Malloc(SSL3_RT_MAX_PLAIN_LENGTH);
+ OPENSSL_malloc(SSL3_RT_MAX_PLAIN_LENGTH);
if (s->s3->rrec.comp == NULL)
goto err;
}
{
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_write_ctx;
s->write_hash=m;
ssl3_cleanup_key_block(s);
- if ((p=Malloc(num)) == NULL)
+ if ((p=OPENSSL_malloc(num)) == NULL)
goto err;
s->s3->tmp.key_block_length=num;
{
memset(s->s3->tmp.key_block,0,
s->s3->tmp.key_block_length);
- Free(s->s3->tmp.key_block);
+ OPENSSL_free(s->s3->tmp.key_block);
s->s3->tmp.key_block=NULL;
}
s->s3->tmp.key_block_length=0;
{
SSL3_STATE *s3;
- if ((s3=Malloc(sizeof *s3)) == NULL) goto err;
+ if ((s3=OPENSSL_malloc(sizeof *s3)) == NULL) goto err;
memset(s3,0,sizeof *s3);
s->s3=s3;
ssl3_cleanup_key_block(s);
if (s->s3->rbuf.buf != NULL)
- Free(s->s3->rbuf.buf);
+ OPENSSL_free(s->s3->rbuf.buf);
if (s->s3->wbuf.buf != NULL)
- Free(s->s3->wbuf.buf);
+ OPENSSL_free(s->s3->wbuf.buf);
if (s->s3->rrec.comp != NULL)
- Free(s->s3->rrec.comp);
+ OPENSSL_free(s->s3->rrec.comp);
#ifndef NO_DH
if (s->s3->tmp.dh != NULL)
DH_free(s->s3->tmp.dh);
if (s->s3->tmp.ca_names != NULL)
sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
memset(s->s3,0,sizeof *s->s3);
- Free(s->s3);
+ OPENSSL_free(s->s3);
s->s3=NULL;
}
if (s->s3->rrec.comp != NULL)
{
- Free(s->s3->rrec.comp);
+ OPENSSL_free(s->s3->rrec.comp);
s->s3->rrec.comp=NULL;
}
#ifndef NO_DH
/* Note that I cheat in the following 2 assignments. I know
* that if the ASN1_INTEGER passed to ASN1_INTEGER_set
- * is > sizeof(long)+1, the buffer will not be re-Malloc()ed.
+ * is > sizeof(long)+1, the buffer will not be re-OPENSSL_malloc()ed.
* This is a bit evil but makes things simple, no dynamic allocation
* to clean up :-) */
a.version.length=LSIZE2;
ai.data=NULL; ai.length=0;
M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
version=(int)ASN1_INTEGER_get(aip);
- if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+ if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
/* we don't care about the version right now :-) */
M_ASN1_D2I_get(aip,d2i_ASN1_INTEGER);
ssl_version=(int)ASN1_INTEGER_get(aip);
ret->ssl_version=ssl_version;
- if (ai.data != NULL) { Free(ai.data); ai.data=NULL; ai.length=0; }
+ if (ai.data != NULL) { OPENSSL_free(ai.data); ai.data=NULL; ai.length=0; }
os.data=NULL; os.length=0;
M_ASN1_D2I_get(osp,d2i_ASN1_OCTET_STRING);
else
ret->key_arg_length=os.length;
memcpy(ret->key_arg,os.data,ret->key_arg_length);
- if (os.data != NULL) Free(os.data);
+ if (os.data != NULL) OPENSSL_free(os.data);
ai.length=0;
M_ASN1_D2I_get_EXP_opt(aip,d2i_ASN1_INTEGER,1);
if (ai.data != NULL)
{
ret->time=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->time=time(NULL);
if (ai.data != NULL)
{
ret->timeout=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->timeout=3;
SSLerr(SSL_F_D2I_SSL_SESSION,SSL_R_BAD_LENGTH);
ret->sid_ctx_length=os.length;
memcpy(ret->sid_ctx,os.data,os.length);
- Free(os.data); os.data=NULL; os.length=0;
+ OPENSSL_free(os.data); os.data=NULL; os.length=0;
}
else
ret->sid_ctx_length=0;
if (ai.data != NULL)
{
ret->verify_result=ASN1_INTEGER_get(aip);
- Free(ai.data); ai.data=NULL; ai.length=0;
+ OPENSSL_free(ai.data); ai.data=NULL; ai.length=0;
}
else
ret->verify_result=X509_V_OK;
{
CERT *ret;
- ret=(CERT *)Malloc(sizeof(CERT));
+ ret=(CERT *)OPENSSL_malloc(sizeof(CERT));
if (ret == NULL)
{
SSLerr(SSL_F_SSL_CERT_NEW,ERR_R_MALLOC_FAILURE);
CERT *ret;
int i;
- ret = (CERT *)Malloc(sizeof(CERT));
+ ret = (CERT *)OPENSSL_malloc(sizeof(CERT));
if (ret == NULL)
{
SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
EVP_PKEY_free(c->pkeys[i].publickey);
#endif
}
- Free(c);
+ OPENSSL_free(c);
}
int ssl_cert_inst(CERT **o)
{
SESS_CERT *ret;
- ret = Malloc(sizeof *ret);
+ ret = OPENSSL_malloc(sizeof *ret);
if (ret == NULL)
{
SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE);
DH_free(sc->peer_dh_tmp);
#endif
- Free(sc);
+ OPENSSL_free(sc);
}
int ssl_set_peer_cert_type(SESS_CERT *sc,int type)
curr = curr->next;
}
- number_uses = Malloc((max_strength_bits + 1) * sizeof(int));
+ number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));
if (!number_uses)
{
SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT,ERR_R_MALLOC_FAILURE);
ssl_cipher_apply_rule(0, 0, 0, 0, CIPHER_ORD, i,
list, head_p, tail_p);
- Free(number_uses);
+ OPENSSL_free(number_uses);
return(1);
}
* it is used for allocation.
*/
num_of_ciphers = ssl_method->num_ciphers();
- list = (CIPHER_ORDER *)Malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
+ list = (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
if (list == NULL)
{
SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
ca_list =
- (SSL_CIPHER **)Malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);
+ (SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);
if (ca_list == NULL)
{
- Free(list);
+ OPENSSL_free(list);
SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
return(NULL); /* Failure */
}
ok = ssl_cipher_process_rulestr(rule_p, list, &head, &tail,
ca_list);
- Free(ca_list); /* Not needed anymore */
+ OPENSSL_free(ca_list); /* Not needed anymore */
if (!ok)
{ /* Rule processing failure */
- Free(list);
+ OPENSSL_free(list);
return(NULL);
}
/*
*/
if ((cipherstack = sk_SSL_CIPHER_new(NULL)) == NULL)
{
- Free(list);
+ OPENSSL_free(list);
return(NULL);
}
#endif
}
}
- Free(list); /* Not needed any longer */
+ OPENSSL_free(list); /* Not needed any longer */
/*
* The following passage is a little bit odd. If pointer variables
if (buf == NULL)
{
len=128;
- buf=Malloc(len);
- if (buf == NULL) return("Malloc Error");
+ buf=OPENSSL_malloc(len);
+ if (buf == NULL) return("OPENSSL_malloc Error");
}
else if (len < 128)
return("Buffer too small");
SSL_COMP *comp;
STACK_OF(SSL_COMP) *sk;
- comp=(SSL_COMP *)Malloc(sizeof(SSL_COMP));
+ comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
comp->id=id;
comp->method=cm;
if (ssl_comp_methods == NULL)
return(NULL);
}
- s=(SSL *)Malloc(sizeof(SSL));
+ s=(SSL *)OPENSSL_malloc(sizeof(SSL));
if (s == NULL) goto err;
memset(s,0,sizeof(SSL));
ssl_cert_free(s->cert);
if (s->ctx != NULL)
SSL_CTX_free(s->ctx); /* decrement reference count */
- Free(s);
+ OPENSSL_free(s);
}
SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
if (s->method != NULL) s->method->ssl_free(s);
- Free(s);
+ OPENSSL_free(s);
}
void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
goto err;
}
- ret=(SSL_CTX *)Malloc(sizeof(SSL_CTX));
+ ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
if (ret == NULL)
goto err;
}
static void SSL_COMP_free(SSL_COMP *comp)
- { Free(comp); }
+ { OPENSSL_free(comp); }
void SSL_CTX_free(SSL_CTX *a)
{
sk_X509_pop_free(a->extra_certs,X509_free);
if (a->comp_methods != NULL)
sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
- Free(a);
+ OPENSSL_free(a);
}
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
if (s->enc_read_ctx != NULL)
{
EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
- Free(s->enc_read_ctx);
+ OPENSSL_free(s->enc_read_ctx);
s->enc_read_ctx=NULL;
}
if (s->enc_write_ctx != NULL)
{
EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
- Free(s->enc_write_ctx);
+ OPENSSL_free(s->enc_write_ctx);
s->enc_write_ctx=NULL;
}
if (s->expand != NULL)
{
SSL_SESSION *ss;
- ss=(SSL_SESSION *)Malloc(sizeof(SSL_SESSION));
+ ss=(SSL_SESSION *)OPENSSL_malloc(sizeof(SSL_SESSION));
if (ss == NULL)
{
SSLerr(SSL_F_SSL_SESSION_NEW,ERR_R_MALLOC_FAILURE);
#if 0 /* This is way too late. */
/* If a thread got the session, then 'swaped', and another got
- * it and then due to a time-out decided to 'Free' it we could
+ * it and then due to a time-out decided to 'OPENSSL_free' it we could
* be in trouble. So I'll increment it now, then double decrement
* later - am I speaking rubbish?. */
CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
if (ss->peer != NULL) X509_free(ss->peer);
if (ss->ciphers != NULL) sk_SSL_CIPHER_free(ss->ciphers);
memset(ss,0,sizeof(*ss));
- Free(ss);
+ OPENSSL_free(ss);
}
int SSL_set_session(SSL *s, SSL_SESSION *session)
ret=0;
err:
/* We have to set the BIO's to NULL otherwise they will be
- * Free()ed twice. Once when th s_ssl is SSL_free()ed and
+ * OPENSSL_free()ed twice. Once when th s_ssl is SSL_free()ed and
* again when c_ssl is SSL_free()ed.
* This is a hack required because s_ssl and c_ssl are sharing the same
* BIO structure and SSL_set_bio() and SSL_free() automatically
{
if ((s->enc_read_ctx == NULL) &&
((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_read_ctx;
s->read_hash=m;
}
if (s->s3->rrec.comp == NULL)
s->s3->rrec.comp=(unsigned char *)
- Malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
+ OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
if (s->s3->rrec.comp == NULL)
goto err;
}
{
if ((s->enc_write_ctx == NULL) &&
((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
+ OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
goto err;
dd= s->enc_write_ctx;
s->write_hash=m;
ssl3_cleanup_key_block(s);
- if ((p1=(unsigned char *)Malloc(num)) == NULL)
+ if ((p1=(unsigned char *)OPENSSL_malloc(num)) == NULL)
goto err;
- if ((p2=(unsigned char *)Malloc(num)) == NULL)
+ if ((p2=(unsigned char *)OPENSSL_malloc(num)) == NULL)
goto err;
s->s3->tmp.key_block_length=num;
#endif
tls1_generate_key_block(s,p1,p2,num);
memset(p2,0,num);
- Free(p2);
+ OPENSSL_free(p2);
#ifdef TLS_DEBUG
printf("\nkey block\n");
{ int z; for (z=0; z<num; z++) printf("%02X%c",p1[z],((z+1)%16)?' ':'\n'); }
projects / oweals / openssl.git / commitdiff