[PATCH 3/3] winhttp: Use CRT memory allocators.
Hans Leidekker
hans at codeweavers.com
Tue Jun 8 09:27:44 CDT 2021
Signed-off-by: Hans Leidekker <hans at codeweavers.com>
---
dlls/winhttp/cookie.c | 50 +++---
dlls/winhttp/handle.c | 7 +-
dlls/winhttp/net.c | 34 ++--
dlls/winhttp/request.c | 316 +++++++++++++++++----------------
dlls/winhttp/session.c | 144 ++++++++-------
dlls/winhttp/url.c | 8 +-
dlls/winhttp/winhttp_private.h | 18 +-
7 files changed, 286 insertions(+), 291 deletions(-)
diff --git a/dlls/winhttp/cookie.c b/dlls/winhttp/cookie.c
index 6247e379ec7..ebcd1b4d17e 100644
--- a/dlls/winhttp/cookie.c
+++ b/dlls/winhttp/cookie.c
@@ -49,7 +49,7 @@ static struct domain *add_domain( struct session *session, WCHAR *name )
{
struct domain *domain;
- if (!(domain = heap_alloc_zero( sizeof(struct domain) ))) return NULL;
+ if (!(domain = calloc( 1, sizeof(*domain) ))) return NULL;
list_init( &domain->entry );
list_init( &domain->cookies );
@@ -89,10 +89,10 @@ static BOOL domain_match( const WCHAR *name, struct domain *domain, BOOL partial
static void free_cookie( struct cookie *cookie )
{
- heap_free( cookie->name );
- heap_free( cookie->value );
- heap_free( cookie->path );
- heap_free( cookie );
+ free( cookie->name );
+ free( cookie->value );
+ free( cookie->path );
+ free( cookie );
}
static void delete_cookie( struct cookie *cookie )
@@ -113,8 +113,8 @@ static void delete_domain( struct domain *domain )
}
list_remove( &domain->entry );
- heap_free( domain->name );
- heap_free( domain );
+ free( domain->name );
+ free( domain );
}
void destroy_cookies( struct session *session )
@@ -170,12 +170,12 @@ static struct cookie *parse_cookie( const WCHAR *string )
while (len && string[len - 1] == ' ') len--;
if (!len) return NULL;
- if (!(cookie = heap_alloc_zero( sizeof(struct cookie) ))) return NULL;
+ if (!(cookie = calloc( 1, sizeof(*cookie) ))) return NULL;
list_init( &cookie->entry );
- if (!(cookie->name = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(cookie->name = malloc( (len + 1) * sizeof(WCHAR) )))
{
- heap_free( cookie );
+ free( cookie );
return NULL;
}
memcpy( cookie->name, string, len * sizeof(WCHAR) );
@@ -187,7 +187,7 @@ static struct cookie *parse_cookie( const WCHAR *string )
len = lstrlenW( p );
while (len && p[len - 1] == ' ') len--;
- if (!(cookie->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(cookie->value = malloc( (len + 1) * sizeof(WCHAR) )))
{
free_cookie( cookie );
return NULL;
@@ -207,9 +207,9 @@ struct attr
static void free_attr( struct attr *attr )
{
if (!attr) return;
- heap_free( attr->name );
- heap_free( attr->value );
- heap_free( attr );
+ free( attr->name );
+ free( attr->value );
+ free( attr );
}
static struct attr *parse_attr( const WCHAR *str, int *used )
@@ -224,10 +224,10 @@ static struct attr *parse_attr( const WCHAR *str, int *used )
len = q - p;
if (!len) return NULL;
- if (!(attr = heap_alloc( sizeof(struct attr) ))) return NULL;
- if (!(attr->name = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(attr = malloc( sizeof(*attr) ))) return NULL;
+ if (!(attr->name = malloc( (len + 1) * sizeof(WCHAR) )))
{
- heap_free( attr );
+ free( attr );
return NULL;
}
memcpy( attr->name, p, len * sizeof(WCHAR) );
@@ -244,7 +244,7 @@ static struct attr *parse_attr( const WCHAR *str, int *used )
len = q - p;
while (len && p[len - 1] == ' ') len--;
- if (!(attr->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(attr->value = malloc( (len + 1) * sizeof(WCHAR) )))
{
free_attr( attr );
return NULL;
@@ -271,7 +271,7 @@ BOOL set_cookies( struct request *request, const WCHAR *cookies )
int len, used;
len = lstrlenW( cookies );
- if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
+ if (!(buffer = malloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
lstrcpyW( buffer, cookies );
p = buffer;
@@ -279,7 +279,7 @@ BOOL set_cookies( struct request *request, const WCHAR *cookies )
if (*p == ';') *p++ = 0;
if (!(cookie = parse_cookie( buffer )))
{
- heap_free( buffer );
+ free( buffer );
return FALSE;
}
len = lstrlenW( p );
@@ -312,10 +312,10 @@ BOOL set_cookies( struct request *request, const WCHAR *cookies )
end:
if (!ret) free_cookie( cookie );
if (domain) free_attr( domain );
- else heap_free( cookie_domain );
+ else free( cookie_domain );
if (path) free_attr( path );
- else heap_free( cookie_path );
- heap_free( buffer );
+ else free( cookie_path );
+ free( buffer );
return ret;
}
@@ -349,7 +349,7 @@ DWORD add_cookie_headers( struct request *request )
len = len_cookie + len_name;
if (cookie->value) len += lstrlenW( cookie->value ) + 1;
- if (!(header = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(header = malloc( (len + 1) * sizeof(WCHAR) )))
{
LeaveCriticalSection( &session->cs );
return ERROR_OUTOFMEMORY;
@@ -366,7 +366,7 @@ DWORD add_cookie_headers( struct request *request )
TRACE("%s\n", debugstr_w(header));
ret = add_request_headers( request, header, len,
WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
- heap_free( header );
+ free( header );
}
}
}
diff --git a/dlls/winhttp/handle.c b/dlls/winhttp/handle.c
index 08052b91ee3..4fc94f10d01 100644
--- a/dlls/winhttp/handle.c
+++ b/dlls/winhttp/handle.c
@@ -94,14 +94,17 @@ HINTERNET alloc_handle( struct object_header *hdr )
if (!max_handles)
{
num = HANDLE_CHUNK_SIZE;
- if (!(p = heap_alloc_zero( sizeof(ULONG_PTR) * num ))) goto end;
+ if (!(p = calloc( 1, sizeof(ULONG_PTR) * num ))) goto end;
handles = p;
max_handles = num;
}
if (max_handles == next_handle)
{
+ size_t new_size, old_size = max_handles * sizeof(ULONG_PTR);
num = max_handles * 2;
- if (!(p = heap_realloc_zero( handles, sizeof(ULONG_PTR) * num ))) goto end;
+ new_size = num * sizeof(ULONG_PTR);
+ if (!(p = realloc( handles, new_size ))) goto end;
+ memset( (char *)p + old_size, 0, new_size - old_size );
handles = p;
max_handles = num;
}
diff --git a/dlls/winhttp/net.c b/dlls/winhttp/net.c
index 0cc2bb2bef7..8597179dc3e 100644
--- a/dlls/winhttp/net.c
+++ b/dlls/winhttp/net.c
@@ -187,14 +187,14 @@ DWORD netconn_create( struct hostdata *host, const struct sockaddr_storage *sock
winsock_init();
- if (!(conn = heap_alloc_zero( sizeof(*conn) ))) return ERROR_OUTOFMEMORY;
+ if (!(conn = calloc( 1, sizeof(*conn) ))) return ERROR_OUTOFMEMORY;
conn->host = host;
conn->sockaddr = *sockaddr;
if ((conn->socket = socket( sockaddr->ss_family, SOCK_STREAM, 0 )) == -1)
{
ret = WSAGetLastError();
WARN("unable to create socket (%u)\n", ret);
- heap_free( conn );
+ free( conn );
return ret;
}
@@ -208,7 +208,7 @@ DWORD netconn_create( struct hostdata *host, const struct sockaddr_storage *sock
break;
default:
ERR( "unhandled family %u\n", conn->sockaddr.ss_family );
- heap_free( conn );
+ free( conn );
return ERROR_INVALID_PARAMETER;
}
@@ -237,7 +237,7 @@ DWORD netconn_create( struct hostdata *host, const struct sockaddr_storage *sock
{
WARN("unable to connect to host (%u)\n", ret);
closesocket( conn->socket );
- heap_free( conn );
+ free( conn );
return ret;
}
@@ -249,14 +249,14 @@ void netconn_close( struct netconn *conn )
{
if (conn->secure)
{
- heap_free( conn->peek_msg_mem );
- heap_free(conn->ssl_buf);
- heap_free(conn->extra_buf);
+ free( conn->peek_msg_mem );
+ free(conn->ssl_buf);
+ free(conn->extra_buf);
DeleteSecurityContext(&conn->ssl_ctx);
}
closesocket( conn->socket );
release_host( conn->host );
- heap_free(conn);
+ free(conn);
}
DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD security_flags, CredHandle *cred_handle,
@@ -276,7 +276,7 @@ DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD secur
const DWORD isc_req_flags = ISC_REQ_ALLOCATE_MEMORY|ISC_REQ_USE_SESSION_KEY|ISC_REQ_CONFIDENTIALITY
|ISC_REQ_SEQUENCE_DETECT|ISC_REQ_REPLAY_DETECT|ISC_REQ_MANUAL_CRED_VALIDATION;
- if (!(read_buf = heap_alloc( read_buf_size ))) return ERROR_OUTOFMEMORY;
+ if (!(read_buf = malloc( read_buf_size ))) return ERROR_OUTOFMEMORY;
status = InitializeSecurityContextW(cred_handle, NULL, hostname, isc_req_flags, 0, 0, NULL, 0,
&ctx, &out_desc, &attrs, NULL);
@@ -318,7 +318,7 @@ DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD secur
if(in_bufs[0].cbBuffer + 1024 > read_buf_size) {
BYTE *new_read_buf;
- new_read_buf = heap_realloc(read_buf, read_buf_size + 1024);
+ new_read_buf = realloc(read_buf, read_buf_size + 1024);
if(!new_read_buf) {
status = E_OUTOFMEMORY;
break;
@@ -365,7 +365,7 @@ DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD secur
break;
}
- conn->ssl_buf = heap_alloc(conn->ssl_sizes.cbHeader + conn->ssl_sizes.cbMaximumMessage + conn->ssl_sizes.cbTrailer);
+ conn->ssl_buf = malloc(conn->ssl_sizes.cbHeader + conn->ssl_sizes.cbMaximumMessage + conn->ssl_sizes.cbTrailer);
if(!conn->ssl_buf) {
res = ERROR_OUTOFMEMORY;
break;
@@ -373,11 +373,11 @@ DWORD netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD secur
}
}
- heap_free(read_buf);
+ free(read_buf);
if(status != SEC_E_OK || res != ERROR_SUCCESS) {
WARN("Failed to initialize security context: %08x\n", status);
- heap_free(conn->ssl_buf);
+ free(conn->ssl_buf);
conn->ssl_buf = NULL;
DeleteSecurityContext(&ctx);
return ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
@@ -459,7 +459,7 @@ static DWORD read_ssl_chunk( struct netconn *conn, void *buf, SIZE_T buf_size, S
memcpy(conn->ssl_buf, conn->extra_buf, conn->extra_len);
buf_len = conn->extra_len;
conn->extra_len = 0;
- heap_free(conn->extra_buf);
+ free(conn->extra_buf);
conn->extra_buf = NULL;
}else {
if ((buf_len = sock_recv( conn->socket, conn->ssl_buf + conn->extra_len, ssl_buf_size - conn->extra_len, 0)) < 0)
@@ -516,7 +516,7 @@ static DWORD read_ssl_chunk( struct netconn *conn, void *buf, SIZE_T buf_size, S
memcpy(buf, bufs[i].pvBuffer, size);
if(size < bufs[i].cbBuffer) {
assert(!conn->peek_len);
- conn->peek_msg_mem = conn->peek_msg = heap_alloc(bufs[i].cbBuffer - size);
+ conn->peek_msg_mem = conn->peek_msg = malloc(bufs[i].cbBuffer - size);
if(!conn->peek_msg)
return ERROR_OUTOFMEMORY;
conn->peek_len = bufs[i].cbBuffer-size;
@@ -529,7 +529,7 @@ static DWORD read_ssl_chunk( struct netconn *conn, void *buf, SIZE_T buf_size, S
for(i = 0; i < ARRAY_SIZE(bufs); i++) {
if(bufs[i].BufferType == SECBUFFER_EXTRA) {
- conn->extra_buf = heap_alloc(bufs[i].cbBuffer);
+ conn->extra_buf = malloc(bufs[i].cbBuffer);
if(!conn->extra_buf)
return ERROR_OUTOFMEMORY;
@@ -561,7 +561,7 @@ DWORD netconn_recv( struct netconn *conn, void *buf, size_t len, int flags, int
if (conn->peek_len == 0)
{
- heap_free( conn->peek_msg_mem );
+ free( conn->peek_msg_mem );
conn->peek_msg_mem = NULL;
conn->peek_msg = NULL;
}
diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c
index 2ff211255ee..946168786ae 100644
--- a/dlls/winhttp/request.c
+++ b/dlls/winhttp/request.c
@@ -163,9 +163,9 @@ static DWORD queue_task( struct queue *queue, PTP_WORK_CALLBACK task, void *ctx
static void free_header( struct header *header )
{
- heap_free( header->field );
- heap_free( header->value );
- heap_free( header );
+ free( header->field );
+ free( header->value );
+ free( header );
}
static BOOL valid_token_char( WCHAR c )
@@ -216,10 +216,10 @@ static struct header *parse_header( const WCHAR *string )
p++;
}
len = q - string;
- if (!(header = heap_alloc_zero( sizeof(struct header) ))) return NULL;
- if (!(header->field = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(header = calloc( 1, sizeof(*header) ))) return NULL;
+ if (!(header->field = malloc( (len + 1) * sizeof(WCHAR) )))
{
- heap_free( header );
+ free( header );
return NULL;
}
memcpy( header->field, string, len * sizeof(WCHAR) );
@@ -229,7 +229,7 @@ static struct header *parse_header( const WCHAR *string )
while (*q == ' ') q++;
len = lstrlenW( q );
- if (!(header->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(header->value = malloc( (len + 1) * sizeof(WCHAR) )))
{
free_header( header );
return NULL;
@@ -266,9 +266,11 @@ static DWORD insert_header( struct request *request, struct header *header )
struct header *hdrs;
if (request->headers)
- hdrs = heap_realloc_zero( request->headers, sizeof(struct header) * count );
- else
- hdrs = heap_alloc_zero( sizeof(struct header) );
+ {
+ if ((hdrs = realloc( request->headers, sizeof(*header) * count )))
+ memset( &hdrs[count - 1], 0, sizeof(*header) );
+ }
+ else hdrs = calloc( 1, sizeof(*header) );
if (!hdrs) return ERROR_OUTOFMEMORY;
request->headers = hdrs;
@@ -284,8 +286,8 @@ static void delete_header( struct request *request, DWORD index )
if (!request->num_headers || index >= request->num_headers) return;
request->num_headers--;
- heap_free( request->headers[index].field );
- heap_free( request->headers[index].value );
+ free( request->headers[index].field );
+ free( request->headers[index].value );
memmove( &request->headers[index], &request->headers[index + 1],
(request->num_headers - index) * sizeof(struct header) );
@@ -332,7 +334,7 @@ DWORD process_header( struct request *request, const WCHAR *field, const WCHAR *
len_value = lstrlenW( value );
len = len_orig + len_value + 2;
- if (!(tmp = heap_realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(tmp = realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
header->value = tmp;
header->value[len_orig++] = (flags & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) ? ',' : ';';
header->value[len_orig++] = ' ';
@@ -361,7 +363,7 @@ DWORD add_request_headers( struct request *request, const WCHAR *headers, DWORD
if (len == ~0u) len = lstrlenW( headers );
if (!len) return ERROR_SUCCESS;
- if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(buffer = malloc( (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
memcpy( buffer, headers, len * sizeof(WCHAR) );
buffer[len] = 0;
@@ -393,7 +395,7 @@ DWORD add_request_headers( struct request *request, const WCHAR *headers, DWORD
p = q;
} while (!ret);
- heap_free( buffer );
+ free( buffer );
return ret;
}
@@ -443,7 +445,7 @@ static WCHAR *build_absolute_request_path( struct request *request, const WCHAR
if (request->connect->hostport) len += 6; /* ':' between host and port, up to 5 for port */
len += lstrlenW( request->path );
- if ((ret = heap_alloc( len * sizeof(WCHAR) )))
+ if ((ret = malloc( len * sizeof(WCHAR) )))
{
offset = swprintf( ret, len, L"%s://%s", scheme, request->connect->hostname );
if (request->connect->hostport)
@@ -476,7 +478,7 @@ static WCHAR *build_request_string( struct request *request )
}
len += 4; /* '\r\n\r\n' */
- if ((ret = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
{
lstrcpyW( ret, request->verb );
lstrcatW( ret, L" " );
@@ -497,7 +499,7 @@ static WCHAR *build_request_string( struct request *request )
lstrcatW( ret, L"\r\n\r\n" );
}
- if (path != request->path) heap_free( path );
+ if (path != request->path) free( path );
return ret;
}
@@ -551,7 +553,7 @@ static DWORD query_headers( struct request *request, DWORD level, const WCHAR *n
ret = ERROR_SUCCESS;
}
*buflen = len * sizeof(WCHAR);
- if (request_only) heap_free( headers );
+ if (request_only) free( headers );
return ret;
}
case WINHTTP_QUERY_RAW_HEADERS_CRLF:
@@ -577,7 +579,7 @@ static DWORD query_headers( struct request *request, DWORD level, const WCHAR *n
ret = ERROR_SUCCESS;
}
*buflen = len;
- if (request_only) heap_free( headers );
+ if (request_only) free( headers );
return ret;
}
case WINHTTP_QUERY_VERSION:
@@ -771,14 +773,14 @@ static DWORD query_auth_schemes( struct request *request, DWORD level, DWORD *su
break;
}
- if (!(buffer = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
+ if (!(buffer = malloc( size ))) return ERROR_OUTOFMEMORY;
if ((ret = query_headers( request, level, NULL, buffer, &size, &index )))
{
- heap_free( buffer );
+ free( buffer );
return ret;
}
scheme = auth_scheme_from_header( buffer );
- heap_free( buffer );
+ free( buffer );
if (!scheme) continue;
if (!first_scheme) first_scheme = scheme;
@@ -954,7 +956,7 @@ static struct authinfo *alloc_authinfo(void)
{
struct authinfo *ret;
- if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
+ if (!(ret = malloc( sizeof(*ret) ))) return NULL;
SecInvalidateHandle( &ret->cred );
SecInvalidateHandle( &ret->ctx );
@@ -977,8 +979,8 @@ void destroy_authinfo( struct authinfo *authinfo )
if (SecIsValidHandle( &authinfo->cred ))
FreeCredentialsHandle( &authinfo->cred );
- heap_free( authinfo->data );
- heap_free( authinfo );
+ free( authinfo->data );
+ free( authinfo );
}
static BOOL get_authvalue( struct request *request, DWORD level, DWORD scheme, WCHAR *buffer, DWORD len )
@@ -1060,7 +1062,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
passlen = WideCharToMultiByte( CP_UTF8, 0, password, lstrlenW( password ), NULL, 0, NULL, NULL );
authinfo->data_len = userlen + 1 + passlen;
- if (!(authinfo->data = heap_alloc( authinfo->data_len ))) return FALSE;
+ if (!(authinfo->data = malloc( authinfo->data_len ))) return FALSE;
WideCharToMultiByte( CP_UTF8, 0, username, -1, authinfo->data, userlen, NULL, NULL );
authinfo->data[userlen] = ':';
@@ -1123,7 +1125,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
{
WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
debugstr_w(auth_schemes[scheme].str), status);
- heap_free( authinfo );
+ free( authinfo );
return FALSE;
}
authinfo->scheme = scheme;
@@ -1152,7 +1154,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
{
int len = lstrlenW( ++p );
in.cbBuffer = decode_base64( p, len, NULL );
- if (!(in.pvBuffer = heap_alloc( in.cbBuffer ))) {
+ if (!(in.pvBuffer = malloc( in.cbBuffer ))) {
destroy_authinfo( authinfo );
*auth_ptr = NULL;
return FALSE;
@@ -1161,9 +1163,9 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
}
out.BufferType = SECBUFFER_TOKEN;
out.cbBuffer = authinfo->max_token;
- if (!(out.pvBuffer = heap_alloc( authinfo->max_token )))
+ if (!(out.pvBuffer = malloc( authinfo->max_token )))
{
- heap_free( in.pvBuffer );
+ free( in.pvBuffer );
destroy_authinfo( authinfo );
*auth_ptr = NULL;
return FALSE;
@@ -1176,10 +1178,10 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
first ? request->connect->servername : NULL, flags, 0,
SECURITY_NETWORK_DREP, in.pvBuffer ? &in_desc : NULL, 0,
&authinfo->ctx, &out_desc, &authinfo->attr, &authinfo->exp );
- heap_free( in.pvBuffer );
+ free( in.pvBuffer );
if (status == SEC_E_OK)
{
- heap_free( authinfo->data );
+ free( authinfo->data );
authinfo->data = out.pvBuffer;
authinfo->data_len = out.cbBuffer;
authinfo->finished = TRUE;
@@ -1187,7 +1189,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
}
else if (status == SEC_I_CONTINUE_NEEDED)
{
- heap_free( authinfo->data );
+ free( authinfo->data );
authinfo->data = out.pvBuffer;
authinfo->data_len = out.cbBuffer;
TRACE("sending next auth packet\n");
@@ -1195,7 +1197,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
else
{
ERR("InitializeSecurityContextW failed with error 0x%08x\n", status);
- heap_free( out.pvBuffer );
+ free( out.pvBuffer );
destroy_authinfo( authinfo );
*auth_ptr = NULL;
return FALSE;
@@ -1210,7 +1212,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
len_scheme = auth_schemes[authinfo->scheme].len;
len = len_scheme + 1 + ((authinfo->data_len + 2) * 4) / 3;
- if (!(auth_reply = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
+ if (!(auth_reply = malloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
memcpy( auth_reply, auth_schemes[authinfo->scheme].str, len_scheme * sizeof(WCHAR) );
auth_reply[len_scheme] = ' ';
@@ -1218,7 +1220,7 @@ static BOOL do_authorization( struct request *request, DWORD target, DWORD schem
flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
ret = !process_header( request, auth_target, auth_reply, flags, TRUE );
- heap_free( auth_reply );
+ free( auth_reply );
return ret;
}
@@ -1228,7 +1230,7 @@ static WCHAR *build_proxy_connect_string( struct request *request )
unsigned int i;
int len = lstrlenW( request->connect->hostname ) + 7;
- if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
+ if (!(host = malloc( len * sizeof(WCHAR) ))) return NULL;
len = swprintf( host, len, L"%s:%u", request->connect->hostname, request->connect->hostport );
len += ARRAY_SIZE(L"CONNECT");
@@ -1241,7 +1243,7 @@ static WCHAR *build_proxy_connect_string( struct request *request )
}
len += 4; /* '\r\n\r\n' */
- if ((ret = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
{
lstrcpyW( ret, L"CONNECT" );
lstrcatW( ret, L" " );
@@ -1262,7 +1264,7 @@ static WCHAR *build_proxy_connect_string( struct request *request )
lstrcatW( ret, L"\r\n\r\n" );
}
- heap_free( host );
+ free( host );
return ret;
}
@@ -1277,12 +1279,12 @@ static DWORD secure_proxy_connect( struct request *request )
if (!(str = build_proxy_connect_string( request ))) return ERROR_OUTOFMEMORY;
strA = strdupWA( str );
- heap_free( str );
+ free( str );
if (!strA) return ERROR_OUTOFMEMORY;
len = strlen( strA );
ret = netconn_send( request->netconn, strA, len, &bytes_sent );
- heap_free( strA );
+ free( strA );
if (!ret) ret = read_reply( request );
return ret;
@@ -1330,8 +1332,8 @@ void release_host( struct hostdata *host )
if (ref) return;
assert( list_empty( &host->connections ) );
- heap_free( host->hostname );
- heap_free( host );
+ free( host->hostname );
+ free( host );
}
static BOOL connection_collector_running;
@@ -1467,7 +1469,7 @@ static DWORD open_connection( struct request *request )
if (!host)
{
- if ((host = heap_alloc( sizeof(*host) )))
+ if ((host = malloc( sizeof(*host) )))
{
host->ref = 1;
host->secure = is_secure;
@@ -1479,7 +1481,7 @@ static DWORD open_connection( struct request *request )
}
else
{
- heap_free( host );
+ free( host );
host = NULL;
}
}
@@ -1548,7 +1550,7 @@ static DWORD open_connection( struct request *request )
if ((ret = netconn_create( host, &connect->sockaddr, request->connect_timeout, &netconn )))
{
- heap_free( addressW );
+ free( addressW );
release_host( host );
return ret;
}
@@ -1564,7 +1566,7 @@ static DWORD open_connection( struct request *request )
if ((ret = secure_proxy_connect( request )))
{
request->netconn = NULL;
- heap_free( addressW );
+ free( addressW );
netconn_close( netconn );
return ret;
}
@@ -1578,7 +1580,7 @@ static DWORD open_connection( struct request *request )
&request->cred_handle, request->check_revocation )))
{
request->netconn = NULL;
- heap_free( addressW );
+ free( addressW );
netconn_close( netconn );
return ret;
}
@@ -1597,7 +1599,7 @@ static DWORD open_connection( struct request *request )
if (netconn->secure && !(request->server_cert = netconn_get_certificate( netconn )))
{
- heap_free( addressW );
+ free( addressW );
netconn_close( netconn );
return ERROR_WINHTTP_SECURE_FAILURE;
}
@@ -1607,7 +1609,7 @@ done:
request->read_chunked = FALSE;
request->read_chunked_size = ~0u;
request->read_chunked_eof = FALSE;
- heap_free( addressW );
+ free( addressW );
return ERROR_SUCCESS;
}
@@ -1635,10 +1637,10 @@ static DWORD add_host_header( struct request *request, DWORD modifier )
return process_header( request, L"Host", connect->hostname, modifier, TRUE );
}
len = lstrlenW( connect->hostname ) + 7; /* sizeof(":65335") */
- if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(host = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
swprintf( host, len, L"%s:%u", connect->hostname, port );
ret = process_header( request, L"Host", host, modifier, TRUE );
- heap_free( host );
+ free( host );
return ret;
}
@@ -1950,11 +1952,11 @@ static DWORD str_to_wire( const WCHAR *src, int src_len, char *dst, enum escape_
if (src_len < 0) src_len = lstrlenW( src );
len = WideCharToMultiByte( CP_UTF8, 0, src, src_len, NULL, 0, NULL, NULL );
- if (!(utf8 = heap_alloc( len ))) return 0;
+ if (!(utf8 = malloc( len ))) return 0;
WideCharToMultiByte( CP_UTF8, 0, src, -1, utf8, len, NULL, NULL );
len = escape_string( utf8, len, dst, flags );
- heap_free( utf8 );
+ free( utf8 );
return len;
}
@@ -1992,14 +1994,14 @@ static char *build_wire_path( struct request *request, DWORD *ret_len )
if (path) *ret_len += str_to_wire( path, len_path, NULL, path_flags );
if (query) *ret_len += str_to_wire( query, len_query, NULL, query_flags );
- if ((ret = heap_alloc( *ret_len + 1 )))
+ if ((ret = malloc( *ret_len + 1 )))
{
len = str_to_wire( full_path, len - len_path - len_query, ret, 0 );
if (path) len += str_to_wire( path, len_path, ret + len, path_flags );
if (query) str_to_wire( query, len_query, ret + len, query_flags );
}
- if (full_path != request->path) heap_free( full_path );
+ if (full_path != request->path) free( full_path );
return ret;
}
@@ -2024,7 +2026,7 @@ static char *build_wire_request( struct request *request, DWORD *len )
}
*len += 4; /* '\r\n\r\n' */
- if ((ret = ptr = heap_alloc( *len + 1 )))
+ if ((ret = ptr = malloc( *len + 1 )))
{
ptr += str_to_wire( request->verb, -1, ptr, 0 );
*ptr++ = ' ';
@@ -2048,7 +2050,7 @@ static char *build_wire_request( struct request *request, DWORD *len )
memcpy( ptr, "\r\n\r\n", sizeof("\r\n\r\n") );
}
- heap_free( path );
+ free( path );
return ret;
}
@@ -2058,7 +2060,7 @@ static WCHAR *create_websocket_key(void)
char buf[16];
DWORD base64_len = ((sizeof(buf) + 2) * 4) / 3;
if (!RtlGenRandom( buf, sizeof(buf) )) return NULL;
- if ((ret = heap_alloc( (base64_len + 1) * sizeof(WCHAR) ))) encode_base64( buf, sizeof(buf), ret );
+ if ((ret = malloc( (base64_len + 1) * sizeof(WCHAR) ))) encode_base64( buf, sizeof(buf), ret );
return ret;
}
@@ -2067,7 +2069,7 @@ static DWORD add_websocket_key_header( struct request *request )
WCHAR *key = create_websocket_key();
if (!key) return ERROR_OUTOFMEMORY;
process_header( request, L"Sec-WebSocket-Key", key, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE );
- heap_free( key );
+ free( key );
return ERROR_SUCCESS;
}
@@ -2139,7 +2141,7 @@ static DWORD send_request( struct request *request, const WCHAR *headers, DWORD
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
ret = netconn_send( request->netconn, wire_req, len, &bytes_sent );
- heap_free( wire_req );
+ free( wire_req );
if (ret) goto end;
if (optional_len)
@@ -2174,8 +2176,8 @@ static void CALLBACK task_send_request( TP_CALLBACK_INSTANCE *instance, void *ct
send_request( s->request, s->headers, s->headers_len, s->optional, s->optional_len, s->total_len, s->context, TRUE );
release_object( &s->request->hdr );
- heap_free( s->headers );
- heap_free( s );
+ free( s->headers );
+ free( s );
}
/***********************************************************************
@@ -2208,7 +2210,7 @@ BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD heade
{
struct send_request *s;
- if (!(s = heap_alloc( sizeof(*s) ))) return FALSE;
+ if (!(s = malloc( sizeof(*s) ))) return FALSE;
s->request = request;
s->headers = strdupW( headers );
s->headers_len = headers_len;
@@ -2221,8 +2223,8 @@ BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD heade
if ((ret = queue_task( &request->queue, task_send_request, s )))
{
release_object( &request->hdr );
- heap_free( s->headers );
- heap_free( s );
+ free( s->headers );
+ free( s );
}
}
else ret = send_request( request, headers, headers_len, optional, optional_len, total_len, context, FALSE );
@@ -2245,22 +2247,22 @@ static DWORD set_credentials( struct request *request, DWORD target, DWORD schem
{
case WINHTTP_AUTH_TARGET_SERVER:
{
- heap_free( request->creds[TARGET_SERVER][scheme].username );
+ free( request->creds[TARGET_SERVER][scheme].username );
if (!username) request->creds[TARGET_SERVER][scheme].username = NULL;
else if (!(request->creds[TARGET_SERVER][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
- heap_free( request->creds[TARGET_SERVER][scheme].password );
+ free( request->creds[TARGET_SERVER][scheme].password );
if (!password) request->creds[TARGET_SERVER][scheme].password = NULL;
else if (!(request->creds[TARGET_SERVER][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
break;
}
case WINHTTP_AUTH_TARGET_PROXY:
{
- heap_free( request->creds[TARGET_PROXY][scheme].username );
+ free( request->creds[TARGET_PROXY][scheme].username );
if (!username) request->creds[TARGET_PROXY][scheme].username = NULL;
else if (!(request->creds[TARGET_PROXY][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
- heap_free( request->creds[TARGET_PROXY][scheme].password );
+ free( request->creds[TARGET_PROXY][scheme].password );
if (!password) request->creds[TARGET_PROXY][scheme].password = NULL;
else if (!(request->creds[TARGET_PROXY][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
break;
@@ -2443,26 +2445,26 @@ static DWORD read_reply( struct request *request )
WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, FALSE ))) return ret;
len = status_code - buffer;
- if (!(versionW = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(versionW = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, buffer, len - 1, versionW, len -1 );
versionW[len - 1] = 0;
- heap_free( request->version );
+ free( request->version );
request->version = versionW;
len = buflen - (status_text - buffer);
- if (!(status_textW = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(status_textW = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, status_text, len, status_textW, len );
- heap_free( request->status_text );
+ free( request->status_text );
request->status_text = status_textW;
len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_LEN );
- if (!(raw_headers = heap_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(raw_headers = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers, buflen );
memcpy( raw_headers + buflen - 1, L"\r\n", sizeof(L"\r\n") );
- heap_free( request->raw_headers );
+ free( request->raw_headers );
request->raw_headers = raw_headers;
offset = buflen + crlf_len - 1;
@@ -2478,7 +2480,7 @@ static DWORD read_reply( struct request *request )
{
WCHAR *tmp;
len *= 2;
- if (!(tmp = heap_realloc( raw_headers, len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(tmp = realloc( raw_headers, len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
request->raw_headers = raw_headers = tmp;
}
if (!*buffer)
@@ -2524,10 +2526,10 @@ static DWORD get_redirect_url( struct request *request, WCHAR **ret_url, DWORD *
ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
if (ret != ERROR_INSUFFICIENT_BUFFER) return ret;
- if (!(url = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
+ if (!(url = malloc( size ))) return ERROR_OUTOFMEMORY;
if ((ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, url, &size, NULL )))
{
- heap_free( url );
+ free( url );
return ret;
}
*ret_url = url;
@@ -2557,7 +2559,7 @@ static DWORD handle_redirect( struct request *request, DWORD status )
ret = ERROR_OUTOFMEMORY;
if (location[0] == '/')
{
- if (!(path = heap_alloc( (len_loc + 1) * sizeof(WCHAR) ))) goto end;
+ if (!(path = malloc( (len_loc + 1) * sizeof(WCHAR) ))) goto end;
memcpy( path, location, len_loc * sizeof(WCHAR) );
path[len_loc] = 0;
}
@@ -2565,13 +2567,13 @@ static DWORD handle_redirect( struct request *request, DWORD status )
{
if ((p = wcsrchr( request->path, '/' ))) *p = 0;
len = lstrlenW( request->path ) + 1 + len_loc;
- if (!(path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+ if (!(path = malloc( (len + 1) * sizeof(WCHAR) ))) goto end;
lstrcpyW( path, request->path );
lstrcatW( path, L"/" );
memcpy( path + lstrlenW(path), location, len_loc * sizeof(WCHAR) );
path[len_loc] = 0;
}
- heap_free( request->path );
+ free( request->path );
request->path = path;
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_loc + 1 );
@@ -2597,7 +2599,7 @@ static DWORD handle_redirect( struct request *request, DWORD status )
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_loc + 1 );
len = uc.dwHostNameLength;
- if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(hostname = malloc( (len + 1) * sizeof(WCHAR) )))
{
ret = ERROR_OUTOFMEMORY;
goto end;
@@ -2608,7 +2610,7 @@ static DWORD handle_redirect( struct request *request, DWORD status )
port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80);
if (wcsicmp( connect->hostname, hostname ) || connect->serverport != port)
{
- heap_free( connect->hostname );
+ free( connect->hostname );
connect->hostname = hostname;
connect->hostport = port;
if (!set_server_for_hostname( connect, hostname, port ))
@@ -2623,17 +2625,17 @@ static DWORD handle_redirect( struct request *request, DWORD status )
request->read_pos = request->read_size = 0;
request->read_chunked = request->read_chunked_eof = FALSE;
}
- else heap_free( hostname );
+ else free( hostname );
if ((ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
if ((ret = open_connection( request ))) goto end;
- heap_free( request->path );
+ free( request->path );
request->path = NULL;
if (uc.dwUrlPathLength)
{
len = uc.dwUrlPathLength + uc.dwExtraInfoLength;
- if (!(request->path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+ if (!(request->path = malloc( (len + 1) * sizeof(WCHAR) ))) goto end;
memcpy( request->path, uc.lpszUrlPath, (len + 1) * sizeof(WCHAR) );
request->path[len] = 0;
}
@@ -2646,14 +2648,14 @@ static DWORD handle_redirect( struct request *request, DWORD status )
if (status != HTTP_STATUS_REDIRECT_KEEP_VERB && !wcscmp( request->verb, L"POST" ))
{
- heap_free( request->verb );
+ free( request->verb );
request->verb = strdupW( L"GET" );
request->optional = NULL;
request->optional_len = 0;
}
end:
- heap_free( location );
+ free( location );
return ret;
}
@@ -2764,7 +2766,7 @@ static void CALLBACK task_receive_response( TP_CALLBACK_INSTANCE *instance, void
receive_response( r->request, TRUE );
release_object( &r->request->hdr );
- heap_free( r );
+ free( r );
}
/***********************************************************************
@@ -2793,14 +2795,14 @@ BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
{
struct receive_response *r;
- if (!(r = heap_alloc( sizeof(*r) ))) return FALSE;
+ if (!(r = malloc( sizeof(*r) ))) return FALSE;
r->request = request;
addref_object( &request->hdr );
if ((ret = queue_task( &request->queue, task_receive_response, r )))
{
release_object( &request->hdr );
- heap_free( r );
+ free( r );
}
}
else ret = receive_response( request, FALSE );
@@ -2851,7 +2853,7 @@ static void CALLBACK task_query_data_available( TP_CALLBACK_INSTANCE *instance,
query_data_available( q->request, q->available, TRUE );
release_object( &q->request->hdr );
- heap_free( q );
+ free( q );
}
/***********************************************************************
@@ -2880,7 +2882,7 @@ BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
{
struct query_data *q;
- if (!(q = heap_alloc( sizeof(*q) ))) return FALSE;
+ if (!(q = malloc( sizeof(*q) ))) return FALSE;
q->request = request;
q->available = available;
@@ -2888,7 +2890,7 @@ BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
if ((ret = queue_task( &request->queue, task_query_data_available, q )))
{
release_object( &request->hdr );
- heap_free( q );
+ free( q );
}
}
else ret = query_data_available( request, available, FALSE );
@@ -2906,7 +2908,7 @@ static void CALLBACK task_read_data( TP_CALLBACK_INSTANCE *instance, void *ctx,
read_data( r->request, r->buffer, r->to_read, r->read, TRUE );
release_object( &r->request->hdr );
- heap_free( r );
+ free( r );
}
/***********************************************************************
@@ -2935,7 +2937,7 @@ BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, L
{
struct read_data *r;
- if (!(r = heap_alloc( sizeof(*r) ))) return FALSE;
+ if (!(r = malloc( sizeof(*r) ))) return FALSE;
r->request = request;
r->buffer = buffer;
r->to_read = to_read;
@@ -2945,7 +2947,7 @@ BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, L
if ((ret = queue_task( &request->queue, task_read_data, r )))
{
release_object( &request->hdr );
- heap_free( r );
+ free( r );
}
}
else ret = read_data( request, buffer, to_read, read, FALSE );
@@ -2985,7 +2987,7 @@ static void CALLBACK task_write_data( TP_CALLBACK_INSTANCE *instance, void *ctx,
write_data( w->request, w->buffer, w->to_write, w->written, TRUE );
release_object( &w->request->hdr );
- heap_free( w );
+ free( w );
}
/***********************************************************************
@@ -3014,7 +3016,7 @@ BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write
{
struct write_data *w;
- if (!(w = heap_alloc( sizeof(*w) ))) return FALSE;
+ if (!(w = malloc( sizeof(*w) ))) return FALSE;
w->request = request;
w->buffer = buffer;
w->to_write = to_write;
@@ -3024,7 +3026,7 @@ BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write
if ((ret = queue_task( &request->queue, task_write_data, w )))
{
release_object( &request->hdr );
- heap_free( w );
+ free( w );
}
}
else ret = write_data( request, buffer, to_write, written, FALSE );
@@ -3051,7 +3053,7 @@ static void socket_destroy( struct object_header *hdr )
stop_queue( &socket->recv_q );
release_object( &socket->request->hdr );
- heap_free( socket );
+ free( socket );
}
static BOOL socket_set_option( struct object_header *hdr, DWORD option, void *buffer, DWORD buflen )
@@ -3087,7 +3089,7 @@ HINTERNET WINAPI WinHttpWebSocketCompleteUpgrade( HINTERNET hrequest, DWORD_PTR
SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return NULL;
}
- if (!(socket = heap_alloc_zero( sizeof(struct socket) )))
+ if (!(socket = calloc( 1, sizeof(*socket) )))
{
release_object( &request->hdr );
return NULL;
@@ -3234,7 +3236,7 @@ static void CALLBACK task_socket_send( TP_CALLBACK_INSTANCE *instance, void *ctx
socket_send( s->socket, s->type, s->buf, s->len, TRUE );
release_object( &s->socket->hdr );
- heap_free( s );
+ free( s );
}
DWORD WINAPI WinHttpWebSocketSend( HINTERNET hsocket, WINHTTP_WEB_SOCKET_BUFFER_TYPE type, void *buf, DWORD len )
@@ -3267,7 +3269,7 @@ DWORD WINAPI WinHttpWebSocketSend( HINTERNET hsocket, WINHTTP_WEB_SOCKET_BUFFER_
{
struct socket_send *s;
- if (!(s = heap_alloc( sizeof(*s) ))) return FALSE;
+ if (!(s = malloc( sizeof(*s) ))) return FALSE;
s->socket = socket;
s->type = type;
s->buf = buf;
@@ -3277,7 +3279,7 @@ DWORD WINAPI WinHttpWebSocketSend( HINTERNET hsocket, WINHTTP_WEB_SOCKET_BUFFER_
if ((ret = queue_task( &socket->send_q, task_socket_send, s )))
{
release_object( &socket->hdr );
- heap_free( s );
+ free( s );
}
}
else ret = socket_send( socket, type, buf, len, FALSE );
@@ -3350,7 +3352,7 @@ static void CALLBACK task_socket_send_pong( TP_CALLBACK_INSTANCE *instance, void
send_frame( s->socket->request->netconn, SOCKET_OPCODE_PONG, 0, NULL, 0, TRUE );
release_object( &s->socket->hdr );
- heap_free( s );
+ free( s );
}
static DWORD socket_send_pong( struct socket *socket )
@@ -3360,14 +3362,14 @@ static DWORD socket_send_pong( struct socket *socket )
struct socket_send *s;
DWORD ret;
- if (!(s = heap_alloc( sizeof(*s) ))) return ERROR_OUTOFMEMORY;
+ if (!(s = malloc( sizeof(*s) ))) return ERROR_OUTOFMEMORY;
s->socket = socket;
addref_object( &socket->hdr );
if ((ret = queue_task( &socket->send_q, task_socket_send_pong, s )))
{
release_object( &socket->hdr );
- heap_free( s );
+ free( s );
}
return ret;
}
@@ -3484,7 +3486,7 @@ static void CALLBACK task_socket_receive( TP_CALLBACK_INSTANCE *instance, void *
socket_receive( r->socket, r->buf, r->len, NULL, NULL, TRUE );
release_object( &r->socket->hdr );
- heap_free( r );
+ free( r );
}
DWORD WINAPI WinHttpWebSocketReceive( HINTERNET hsocket, void *buf, DWORD len, DWORD *ret_len,
@@ -3513,7 +3515,7 @@ DWORD WINAPI WinHttpWebSocketReceive( HINTERNET hsocket, void *buf, DWORD len, D
{
struct socket_receive *r;
- if (!(r = heap_alloc( sizeof(*r) ))) return FALSE;
+ if (!(r = malloc( sizeof(*r) ))) return FALSE;
r->socket = socket;
r->buf = buf;
r->len = len;
@@ -3522,7 +3524,7 @@ DWORD WINAPI WinHttpWebSocketReceive( HINTERNET hsocket, void *buf, DWORD len, D
if ((ret = queue_task( &socket->recv_q, task_socket_receive, r )))
{
release_object( &socket->hdr );
- heap_free( r );
+ free( r );
}
}
else ret = socket_receive( socket, buf, len, ret_len, ret_type, FALSE );
@@ -3564,7 +3566,7 @@ static void CALLBACK task_socket_shutdown( TP_CALLBACK_INSTANCE *instance, void
TRACE("running %p\n", work);
release_object( &s->socket->hdr );
- heap_free( s );
+ free( s );
}
DWORD WINAPI WinHttpWebSocketShutdown( HINTERNET hsocket, USHORT status, void *reason, DWORD len )
@@ -3592,7 +3594,7 @@ DWORD WINAPI WinHttpWebSocketShutdown( HINTERNET hsocket, USHORT status, void *r
{
struct socket_shutdown *s;
- if (!(s = heap_alloc( sizeof(*s) ))) return FALSE;
+ if (!(s = malloc( sizeof(*s) ))) return FALSE;
s->socket = socket;
s->status = status;
memcpy( s->reason, reason, len );
@@ -3602,7 +3604,7 @@ DWORD WINAPI WinHttpWebSocketShutdown( HINTERNET hsocket, USHORT status, void *r
if ((ret = queue_task( &socket->send_q, task_socket_shutdown, s )))
{
release_object( &socket->hdr );
- heap_free( s );
+ free( s );
}
}
else ret = socket_shutdown( socket, status, reason, len, FALSE );
@@ -3666,7 +3668,7 @@ static void CALLBACK task_socket_close( TP_CALLBACK_INSTANCE *instance, void *ct
TRACE("running %p\n", work);
release_object( &s->socket->hdr );
- heap_free( s );
+ free( s );
}
DWORD WINAPI WinHttpWebSocketClose( HINTERNET hsocket, USHORT status, void *reason, DWORD len )
@@ -3694,7 +3696,7 @@ DWORD WINAPI WinHttpWebSocketClose( HINTERNET hsocket, USHORT status, void *reas
{
struct socket_shutdown *s;
- if (!(s = heap_alloc( sizeof(*s) ))) return FALSE;
+ if (!(s = malloc( sizeof(*s) ))) return FALSE;
s->socket = socket;
s->status = status;
memcpy( s->reason, reason, len );
@@ -3704,7 +3706,7 @@ DWORD WINAPI WinHttpWebSocketClose( HINTERNET hsocket, USHORT status, void *reas
if ((ret = queue_task( &socket->recv_q, task_socket_close, s )))
{
release_object( &socket->hdr );
- heap_free( s );
+ free( s );
}
}
else ret = socket_close( socket, status, reason, len, FALSE );
@@ -3827,10 +3829,10 @@ static void free_request( struct winhttp_request *request )
CloseHandle( request->done );
CloseHandle( request->wait );
CloseHandle( request->cancel );
- heap_free( request->proxy.lpszProxy );
- heap_free( request->proxy.lpszProxyBypass );
- heap_free( request->buffer );
- heap_free( request->verb );
+ free( request->proxy.lpszProxy );
+ free( request->proxy.lpszProxyBypass );
+ free( request->buffer );
+ free( request->verb );
VariantClear( &request->data );
}
@@ -3849,7 +3851,7 @@ static ULONG WINAPI winhttp_request_Release(
LeaveCriticalSection( &request->cs );
request->cs.DebugInfo->Spare[0] = 0;
DeleteCriticalSection( &request->cs );
- heap_free( request );
+ free( request );
}
return refs;
}
@@ -4074,16 +4076,16 @@ static HRESULT WINAPI winhttp_request_SetProxy(
{
case HTTPREQUEST_PROXYSETTING_DEFAULT:
request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
- heap_free( request->proxy.lpszProxy );
- heap_free( request->proxy.lpszProxyBypass );
+ free( request->proxy.lpszProxy );
+ free( request->proxy.lpszProxyBypass );
request->proxy.lpszProxy = NULL;
request->proxy.lpszProxyBypass = NULL;
break;
case HTTPREQUEST_PROXYSETTING_DIRECT:
request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
- heap_free( request->proxy.lpszProxy );
- heap_free( request->proxy.lpszProxyBypass );
+ free( request->proxy.lpszProxy );
+ free( request->proxy.lpszProxyBypass );
request->proxy.lpszProxy = NULL;
request->proxy.lpszProxyBypass = NULL;
break;
@@ -4092,12 +4094,12 @@ static HRESULT WINAPI winhttp_request_SetProxy(
request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
if (V_VT( &proxy_server ) == VT_BSTR)
{
- heap_free( request->proxy.lpszProxy );
+ free( request->proxy.lpszProxy );
request->proxy.lpszProxy = strdupW( V_BSTR( &proxy_server ) );
}
if (V_VT( &bypass_list ) == VT_BSTR)
{
- heap_free( request->proxy.lpszProxyBypass );
+ free( request->proxy.lpszProxyBypass );
request->proxy.lpszProxyBypass = strdupW( V_BSTR( &bypass_list ) );
}
break;
@@ -4169,9 +4171,9 @@ static void reset_request( struct winhttp_request *request )
request->hrequest = NULL;
WinHttpCloseHandle( request->hconnect );
request->hconnect = NULL;
- heap_free( request->buffer );
+ free( request->buffer );
request->buffer = NULL;
- heap_free( request->verb );
+ free( request->verb );
request->verb = NULL;
request->offset = 0;
request->bytes_available = 0;
@@ -4184,9 +4186,9 @@ static void reset_request( struct winhttp_request *request )
request->send_timeout = 30000;
request->receive_timeout = 30000;
request->url_codepage = CP_UTF8;
- heap_free( request->proxy.lpszProxy );
+ free( request->proxy.lpszProxy );
request->proxy.lpszProxy = NULL;
- heap_free( request->proxy.lpszProxyBypass );
+ free( request->proxy.lpszProxyBypass );
request->proxy.lpszProxyBypass = NULL;
VariantClear( &request->data );
request->state = REQUEST_STATE_INITIALIZED;
@@ -4222,11 +4224,11 @@ static HRESULT WINAPI winhttp_request_Open(
EnterCriticalSection( &request->cs );
reset_request( request );
- if (!(hostname = heap_alloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) goto error;
+ if (!(hostname = malloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) goto error;
memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
hostname[uc.dwHostNameLength] = 0;
- if (!(path = heap_alloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) ))) goto error;
+ if (!(path = malloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) ))) goto error;
memcpy( path, uc.lpszUrlPath, (uc.dwUrlPathLength + uc.dwExtraInfoLength) * sizeof(WCHAR) );
path[uc.dwUrlPathLength + uc.dwExtraInfoLength] = 0;
@@ -4270,17 +4272,17 @@ static HRESULT WINAPI winhttp_request_Open(
request->state = REQUEST_STATE_OPEN;
request->verb = verb;
- heap_free( hostname );
- heap_free( path );
+ free( hostname );
+ free( path );
LeaveCriticalSection( &request->cs );
return S_OK;
error:
WinHttpCloseHandle( request->hconnect );
request->hconnect = NULL;
- heap_free( hostname );
- heap_free( path );
- heap_free( verb );
+ free( hostname );
+ free( path );
+ free( verb );
LeaveCriticalSection( &request->cs );
return HRESULT_FROM_WIN32( err );
}
@@ -4311,7 +4313,7 @@ static HRESULT WINAPI winhttp_request_SetRequestHeader(
}
len = lstrlenW( header ) + 4;
if (value) len += lstrlenW( value );
- if (!(str = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if (!(str = malloc( (len + 1) * sizeof(WCHAR) )))
{
err = ERROR_OUTOFMEMORY;
goto done;
@@ -4322,7 +4324,7 @@ static HRESULT WINAPI winhttp_request_SetRequestHeader(
{
err = GetLastError();
}
- heap_free( str );
+ free( str );
done:
LeaveCriticalSection( &request->cs );
@@ -4480,7 +4482,7 @@ static HRESULT request_receive( struct winhttp_request *request )
request->state = REQUEST_STATE_RESPONSE_RECEIVED;
return S_OK;
}
- if (!(request->buffer = heap_alloc( buflen ))) return E_OUTOFMEMORY;
+ if (!(request->buffer = malloc( buflen ))) return E_OUTOFMEMORY;
request->buffer[0] = 0;
size = 0;
do
@@ -4498,7 +4500,7 @@ static HRESULT request_receive( struct winhttp_request *request )
{
char *tmp;
while (buflen < size) buflen *= 2;
- if (!(tmp = heap_realloc( request->buffer, buflen )))
+ if (!(tmp = realloc( request->buffer, buflen )))
{
err = ERROR_OUTOFMEMORY;
goto error;
@@ -4520,7 +4522,7 @@ static HRESULT request_receive( struct winhttp_request *request )
return S_OK;
error:
- heap_free( request->buffer );
+ free( request->buffer );
request->buffer = NULL;
return HRESULT_FROM_WIN32( err );
}
@@ -4584,7 +4586,7 @@ static HRESULT request_send( struct winhttp_request *request )
}
}
size = WideCharToMultiByte( cp, 0, str, len, NULL, 0, NULL, NULL );
- if (!(ptr = heap_alloc( size ))) return E_OUTOFMEMORY;
+ if (!(ptr = malloc( size ))) return E_OUTOFMEMORY;
WideCharToMultiByte( cp, 0, str, len, ptr, size, NULL, NULL );
if (cp == CP_UTF8) request_set_utf8_content_type( request );
}
@@ -4608,13 +4610,13 @@ static HRESULT request_send( struct winhttp_request *request )
}
if ((err = wait_for_completion( request ))) goto error;
if (sa) SafeArrayUnaccessData( sa );
- else heap_free( ptr );
+ else free( ptr );
request->state = REQUEST_STATE_SENT;
return S_OK;
error:
if (sa) SafeArrayUnaccessData( sa );
- else heap_free( ptr );
+ else free( ptr );
return HRESULT_FROM_WIN32( err );
}
@@ -4776,7 +4778,7 @@ static DWORD request_get_codepage( struct winhttp_request *request, UINT *codepa
if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, NULL, &size, NULL ) &&
GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
- if (!(buffer = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
+ if (!(buffer = malloc( size ))) return ERROR_OUTOFMEMORY;
if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, buffer, &size, NULL ))
{
return GetLastError();
@@ -4791,7 +4793,7 @@ static DWORD request_get_codepage( struct winhttp_request *request, UINT *codepa
if (!wcsicmp( p, L"utf-8" )) *codepage = CP_UTF8;
}
}
- heap_free( buffer );
+ free( buffer );
}
return ERROR_SUCCESS;
}
@@ -4920,8 +4922,8 @@ static ULONG WINAPI stream_Release( IStream *iface )
LONG refs = InterlockedDecrement( &stream->refs );
if (!refs)
{
- heap_free( stream->data );
- heap_free( stream );
+ free( stream->data );
+ free( stream );
}
return refs;
}
@@ -5051,16 +5053,16 @@ static HRESULT WINAPI winhttp_request_get_ResponseStream(
err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
goto done;
}
- if (!(stream = heap_alloc( sizeof(*stream) )))
+ if (!(stream = malloc( sizeof(*stream) )))
{
err = ERROR_OUTOFMEMORY;
goto done;
}
stream->IStream_iface.lpVtbl = &stream_vtbl;
stream->refs = 1;
- if (!(stream->data = heap_alloc( request->offset )))
+ if (!(stream->data = malloc( request->offset )))
{
- heap_free( stream );
+ free( stream );
err = ERROR_OUTOFMEMORY;
goto done;
}
@@ -5287,7 +5289,7 @@ HRESULT WinHttpRequest_create( void **obj )
TRACE("%p\n", obj);
- if (!(request = heap_alloc_zero( sizeof(*request) ))) return E_OUTOFMEMORY;
+ if (!(request = calloc( 1, sizeof(*request) ))) return E_OUTOFMEMORY;
request->IWinHttpRequest_iface.lpVtbl = &winhttp_request_vtbl;
request->refs = 1;
InitializeCriticalSection( &request->cs );
diff --git a/dlls/winhttp/session.c b/dlls/winhttp/session.c
index 005c35dea4c..dcea874306a 100644
--- a/dlls/winhttp/session.c
+++ b/dlls/winhttp/session.c
@@ -74,12 +74,12 @@ static void session_destroy( struct object_header *hdr )
session->cs.DebugInfo->Spare[0] = 0;
DeleteCriticalSection( &session->cs );
- heap_free( session->agent );
- heap_free( session->proxy_server );
- heap_free( session->proxy_bypass );
- heap_free( session->proxy_username );
- heap_free( session->proxy_password );
- heap_free( session );
+ free( session->agent );
+ free( session->proxy_server );
+ free( session->proxy_bypass );
+ free( session->proxy_username );
+ free( session->proxy_password );
+ free( session );
}
static BOOL session_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
@@ -239,7 +239,7 @@ HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWST
TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
- if (!(session = heap_alloc_zero( sizeof(struct session) ))) return NULL;
+ if (!(session = calloc( 1, sizeof(*session) ))) return NULL;
session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
session->hdr.vtbl = &session_vtbl;
@@ -299,11 +299,11 @@ static void connect_destroy( struct object_header *hdr )
release_object( &connect->session->hdr );
- heap_free( connect->hostname );
- heap_free( connect->servername );
- heap_free( connect->username );
- heap_free( connect->password );
- heap_free( connect );
+ free( connect->hostname );
+ free( connect->servername );
+ free( connect->username );
+ free( connect->password );
+ free( connect );
}
static BOOL connect_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
@@ -462,16 +462,14 @@ BOOL set_server_for_hostname( struct connect *connect, const WCHAR *server, INTE
if (!connect->servername || wcsnicmp( connect->servername,
session->proxy_server, colon - session->proxy_server - 1 ))
{
- heap_free( connect->servername );
+ free( connect->servername );
connect->resolved = FALSE;
- if (!(connect->servername = heap_alloc(
- (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
+ if (!(connect->servername = malloc( (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
{
ret = FALSE;
goto end;
}
- memcpy( connect->servername, session->proxy_server,
- (colon - session->proxy_server) * sizeof(WCHAR) );
+ memcpy( connect->servername, session->proxy_server, (colon - session->proxy_server) * sizeof(WCHAR) );
connect->servername[colon - session->proxy_server] = 0;
if (*(colon + 1))
connect->serverport = wcstol( colon + 1, NULL, 10 );
@@ -481,10 +479,9 @@ BOOL set_server_for_hostname( struct connect *connect, const WCHAR *server, INTE
}
else
{
- if (!connect->servername || wcsicmp( connect->servername,
- session->proxy_server ))
+ if (!connect->servername || wcsicmp( connect->servername, session->proxy_server ))
{
- heap_free( connect->servername );
+ free( connect->servername );
connect->resolved = FALSE;
if (!(connect->servername = strdupW( session->proxy_server )))
{
@@ -497,7 +494,7 @@ BOOL set_server_for_hostname( struct connect *connect, const WCHAR *server, INTE
}
else if (server)
{
- heap_free( connect->servername );
+ free( connect->servername );
connect->resolved = FALSE;
if (!(connect->servername = strdupW( server )))
{
@@ -537,7 +534,7 @@ HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PO
SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return NULL;
}
- if (!(connect = heap_alloc_zero( sizeof(struct connect) )))
+ if (!(connect = calloc( 1, sizeof(*connect) )))
{
release_object( &session->hdr );
return NULL;
@@ -588,27 +585,27 @@ static void request_destroy( struct object_header *hdr )
destroy_authinfo( request->authinfo );
destroy_authinfo( request->proxy_authinfo );
- heap_free( request->verb );
- heap_free( request->path );
- heap_free( request->version );
- heap_free( request->raw_headers );
- heap_free( request->status_text );
+ free( request->verb );
+ free( request->path );
+ free( request->version );
+ free( request->raw_headers );
+ free( request->status_text );
for (i = 0; i < request->num_headers; i++)
{
- heap_free( request->headers[i].field );
- heap_free( request->headers[i].value );
+ free( request->headers[i].field );
+ free( request->headers[i].value );
}
- heap_free( request->headers );
+ free( request->headers );
for (i = 0; i < TARGET_MAX; i++)
{
for (j = 0; j < SCHEME_MAX; j++)
{
- heap_free( request->creds[i][j].username );
- heap_free( request->creds[i][j].password );
+ free( request->creds[i][j].username );
+ free( request->creds[i][j].password );
}
}
- heap_free( request );
+ free( request );
}
static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen )
@@ -835,7 +832,7 @@ static BOOL request_query_option( struct object_header *hdr, DWORD option, void
static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen )
{
WCHAR *ret;
- if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR))))
+ if ((ret = malloc( (buflen + 1) * sizeof(WCHAR))))
{
memcpy( ret, buffer, buflen * sizeof(WCHAR) );
ret[buflen] = 0;
@@ -950,7 +947,7 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
{
struct connect *connect = request->connect;
- heap_free( connect->username );
+ free( connect->username );
if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
return TRUE;
}
@@ -958,7 +955,7 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
{
struct connect *connect = request->connect;
- heap_free( connect->password );
+ free( connect->password );
if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
return TRUE;
}
@@ -966,7 +963,7 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
{
struct session *session = request->connect->session;
- heap_free( session->proxy_username );
+ free( session->proxy_username );
if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE;
return TRUE;
}
@@ -974,7 +971,7 @@ static BOOL request_set_option( struct object_header *hdr, DWORD option, void *b
{
struct session *session = request->connect->session;
- heap_free( session->proxy_password );
+ free( session->proxy_password );
if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
return TRUE;
}
@@ -1077,7 +1074,7 @@ static WCHAR *get_request_path( const WCHAR *object )
WCHAR *p, *ret;
if (!object || object[0] != '/') len++;
- if (!(p = ret = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
+ if (!(p = ret = malloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
if (!object || object[0] != '/') *p++ = '/';
if (object) lstrcpyW( p, object );
ret[len] = 0;
@@ -1115,7 +1112,7 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR o
SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return NULL;
}
- if (!(request = heap_alloc_zero( sizeof(struct request) )))
+ if (!(request = calloc( 1, sizeof(*request) )))
{
release_object( &connect->hdr );
return NULL;
@@ -1306,16 +1303,16 @@ static IP_ADAPTER_ADDRESSES *get_adapters(void)
GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
IP_ADAPTER_ADDRESSES *tmp, *ret;
- if (!(ret = heap_alloc( size ))) return NULL;
+ if (!(ret = malloc( size ))) return NULL;
err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
while (err == ERROR_BUFFER_OVERFLOW)
{
- if (!(tmp = heap_realloc( ret, size ))) break;
+ if (!(tmp = realloc( ret, size ))) break;
ret = tmp;
err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
}
if (err == ERROR_SUCCESS) return ret;
- heap_free( ret );
+ free( ret );
return NULL;
}
@@ -1345,12 +1342,12 @@ static WCHAR *detect_autoproxyconfig_url_dhcp(void)
/* FIXME: also skip adapters where DHCP is disabled */
size = 256;
- if (!(buf = heap_alloc( size ))) goto done;
+ if (!(buf = malloc( size ))) goto done;
err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
buf, &size, NULL );
while (err == ERROR_MORE_DATA)
{
- if (!(tmp = heap_realloc( buf, size ))) goto done;
+ if (!(tmp = realloc( buf, size ))) goto done;
buf = tmp;
err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
buf, &size, NULL );
@@ -1358,7 +1355,7 @@ static WCHAR *detect_autoproxyconfig_url_dhcp(void)
if (err == ERROR_SUCCESS && param.nBytesData)
{
int len = MultiByteToWideChar( CP_ACP, 0, (const char *)param.Data, param.nBytesData, NULL, 0 );
- if ((ret = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+ if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
{
MultiByteToWideChar( CP_ACP, 0, (const char *)param.Data, param.nBytesData, ret, len );
ret[len] = 0;
@@ -1369,8 +1366,8 @@ static WCHAR *detect_autoproxyconfig_url_dhcp(void)
}
done:
- heap_free( buf );
- heap_free( adapters );
+ free( buf );
+ free( adapters );
return ret;
}
@@ -1381,10 +1378,10 @@ static char *get_computer_name( COMPUTER_NAME_FORMAT format )
GetComputerNameExA( format, NULL, &size );
if (GetLastError() != ERROR_MORE_DATA) return NULL;
- if (!(ret = heap_alloc( size ))) return NULL;
+ if (!(ret = malloc( size ))) return NULL;
if (!GetComputerNameExA( format, ret, &size ))
{
- heap_free( ret );
+ free( ret );
return NULL;
}
return ret;
@@ -1432,7 +1429,7 @@ static WCHAR *detect_autoproxyconfig_url_dns(void)
if (!(fqdn = get_computer_name( ComputerNamePhysicalDnsFullyQualified ))) return NULL;
if (!(domain = get_computer_name( ComputerNamePhysicalDnsDomain )))
{
- heap_free( fqdn );
+ free( fqdn );
return NULL;
}
p = fqdn;
@@ -1442,10 +1439,10 @@ static WCHAR *detect_autoproxyconfig_url_dns(void)
struct addrinfo *ai;
int res;
- if (!(name = heap_alloc( sizeof("wpad") + strlen(p) )))
+ if (!(name = malloc( sizeof("wpad") + strlen(p) )))
{
- heap_free( fqdn );
- heap_free( domain );
+ free( fqdn );
+ free( domain );
return NULL;
}
strcpy( name, "wpad" );
@@ -1458,15 +1455,15 @@ static WCHAR *detect_autoproxyconfig_url_dns(void)
if (ret)
{
TRACE("returning %s\n", debugstr_w(ret));
- heap_free( name );
+ free( name );
break;
}
}
- heap_free( name );
+ free( name );
p++;
}
- heap_free( domain );
- heap_free( fqdn );
+ free( domain );
+ free( fqdn );
return ret;
}
@@ -1547,7 +1544,7 @@ BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
if (!l && type == REG_BINARY &&
size >= sizeof(struct connection_settings_header) + 2 * sizeof(DWORD))
{
- BYTE *buf = heap_alloc( size );
+ BYTE *buf = malloc( size );
if (buf)
{
@@ -1605,7 +1602,7 @@ BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
}
}
}
- heap_free( buf );
+ free( buf );
}
}
RegCloseKey( key );
@@ -1673,7 +1670,7 @@ BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY
ret = TRUE;
goto done;
}
- if (!(hdr = heap_alloc( size ))) goto done;
+ if (!(hdr = malloc( size ))) goto done;
if (RegQueryValueExW( hkey, L"DefaultConnectionSettings", NULL, &type, (BYTE *)hdr, &size ) ||
hdr->magic != WININET_SETTINGS_MAGIC)
{
@@ -1713,7 +1710,7 @@ BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY
done:
RegCloseKey( hkey );
- heap_free( hdr );
+ free( hdr );
if (!ret)
{
GlobalFree( config->lpszAutoConfigUrl );
@@ -1777,7 +1774,7 @@ static char *download_script( const WCHAR *url, DWORD *out_size )
uc.dwHostNameLength = -1;
uc.dwUrlPathLength = -1;
if (!WinHttpCrackUrl( url, 0, 0, &uc )) return NULL;
- if (!(hostname = heap_alloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) return NULL;
+ if (!(hostname = malloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) return NULL;
memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
hostname[uc.dwHostNameLength] = 0;
@@ -1792,7 +1789,7 @@ static char *download_script( const WCHAR *url, DWORD *out_size )
&size, NULL ) || status != HTTP_STATUS_OK) goto done;
size = 4096;
- if (!(buffer = heap_alloc( size ))) goto done;
+ if (!(buffer = malloc( size ))) goto done;
to_read = size;
offset = 0;
for (;;)
@@ -1806,7 +1803,7 @@ static char *download_script( const WCHAR *url, DWORD *out_size )
{
to_read = size;
size *= 2;
- if (!(tmp = heap_realloc( buffer, size ))) goto done;
+ if (!(tmp = realloc( buffer, size ))) goto done;
buffer = tmp;
}
}
@@ -1815,7 +1812,7 @@ done:
WinHttpCloseHandle( req );
WinHttpCloseHandle( con );
WinHttpCloseHandle( ses );
- heap_free( hostname );
+ free( hostname );
if (!buffer) SetLastError( ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT );
return buffer;
}
@@ -1846,7 +1843,7 @@ static BOOL run_script( char *script, DWORD size, const WCHAR *url, WINHTTP_PROX
if (!(urlA = strdupWA( url ))) return FALSE;
if (!(ret = InternetInitializeAutoProxyDll( 0, NULL, NULL, NULL, &buffer )))
{
- heap_free( urlA );
+ free( urlA );
return FALSE;
}
@@ -1862,12 +1859,12 @@ static BOOL run_script( char *script, DWORD size, const WCHAR *url, WINHTTP_PROX
hostnameA, strlen(hostnameA), &result, &len_result )))
{
ret = parse_script_result( result, info );
- heap_free( result );
+ free( result );
}
- heap_free( hostnameA );
+ free( hostnameA );
}
- heap_free( urlA );
+ free( urlA );
InternetDeInitializeAutoProxyDll( NULL, 0 );
return ret;
}
@@ -1918,7 +1915,7 @@ BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTO
if ((script = download_script( pac_url, &size )))
{
ret = run_script( script, size, url, info );
- heap_free( script );
+ free( script );
}
done:
@@ -1990,8 +1987,7 @@ BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
if (info->lpszProxyBypass)
size += lstrlenW( info->lpszProxyBypass );
}
- buf = heap_alloc( size );
- if (buf)
+ if ((buf = malloc( size )))
{
struct connection_settings_header *hdr =
(struct connection_settings_header *)buf;
@@ -2028,7 +2024,7 @@ BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
l = RegSetValueExW( key, L"WinHttpSettings", 0, REG_BINARY, buf, size );
if (!l)
ret = TRUE;
- heap_free( buf );
+ free( buf );
}
RegCloseKey( key );
}
diff --git a/dlls/winhttp/url.c b/dlls/winhttp/url.c
index 3e248bca9f7..0d9dfb76de6 100644
--- a/dlls/winhttp/url.c
+++ b/dlls/winhttp/url.c
@@ -65,7 +65,7 @@ static WCHAR *decode_url( LPCWSTR url, DWORD *len )
const WCHAR *p = url;
WCHAR hex[3], *q, *ret;
- if (!(ret = heap_alloc( *len * sizeof(WCHAR) ))) return NULL;
+ if (!(ret = malloc( *len * sizeof(WCHAR) ))) return NULL;
q = ret;
while (*len > 0)
{
@@ -144,7 +144,7 @@ static DWORD escape_url( const WCHAR *url, DWORD *len, WCHAR **ret )
len_path = 0;
}
- if (!(*ret = heap_alloc( (len_base + len_path + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
+ if (!(*ret = malloc( (len_base + len_path + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
memcpy( *ret, url, len_base * sizeof(WCHAR) );
if (p) escape_string( p, *len - (p - url), *ret + len_base, &len_path );
@@ -331,8 +331,8 @@ exit:
if (overflow) err = ERROR_INSUFFICIENT_BUFFER;
uc->nScheme = scheme_number;
}
- heap_free( url_decoded );
- heap_free( url_escaped );
+ free( url_decoded );
+ free( url_escaped );
SetLastError( err );
return !err;
}
diff --git a/dlls/winhttp/winhttp_private.h b/dlls/winhttp/winhttp_private.h
index e279e58a5fe..069951d4811 100644
--- a/dlls/winhttp/winhttp_private.h
+++ b/dlls/winhttp/winhttp_private.h
@@ -19,13 +19,12 @@
#ifndef _WINE_WINHTTP_PRIVATE_H_
#define _WINE_WINHTTP_PRIVATE_H_
-#include "wine/heap.h"
-#include "wine/list.h"
-
#include "ole2.h"
#include "sspi.h"
#include "wincrypt.h"
+#include "wine/list.h"
+
#define WINHTTP_HANDLE_TYPE_SOCKET 4
struct object_header;
@@ -347,17 +346,12 @@ DWORD process_header( struct request *, const WCHAR *, const WCHAR *, DWORD, BOO
extern HRESULT WinHttpRequest_create( void ** ) DECLSPEC_HIDDEN;
void release_typelib( void ) DECLSPEC_HIDDEN;
-static inline void* __WINE_ALLOC_SIZE(2) heap_realloc_zero( LPVOID mem, SIZE_T size )
-{
- return HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, mem, size );
-}
-
static inline WCHAR *strdupW( const WCHAR *src )
{
WCHAR *dst;
if (!src) return NULL;
- dst = heap_alloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) );
+ dst = malloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) );
if (dst) lstrcpyW( dst, src );
return dst;
}
@@ -368,7 +362,7 @@ static inline WCHAR *strdupAW( const char *src )
if (src)
{
int len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
- if ((dst = heap_alloc( len * sizeof(WCHAR) )))
+ if ((dst = malloc( len * sizeof(WCHAR) )))
MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
}
return dst;
@@ -380,7 +374,7 @@ static inline char *strdupWA( const WCHAR *src )
if (src)
{
int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
- if ((dst = heap_alloc( len )))
+ if ((dst = malloc( len )))
WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
}
return dst;
@@ -392,7 +386,7 @@ static inline char *strdupWA_sized( const WCHAR *src, DWORD size )
if (src)
{
int len = WideCharToMultiByte( CP_ACP, 0, src, size, NULL, 0, NULL, NULL ) + 1;
- if ((dst = heap_alloc( len )))
+ if ((dst = malloc( len )))
{
WideCharToMultiByte( CP_ACP, 0, src, size, dst, len, NULL, NULL );
dst[len - 1] = 0;
--
2.30.2
More information about the wine-devel
mailing list