diff --git a/dlls/wininet/dialogs.c b/dlls/wininet/dialogs.c index babb449549b..5e226c476fd 100644 --- a/dlls/wininet/dialogs.c +++ b/dlls/wininet/dialogs.c @@ -74,7 +74,7 @@ static BOOL WININET_GetProxyServer( HINTERNET hRequest, LPWSTR szBuf, DWORD sz ) if (NULL == request) return FALSE; - session = request->lpHttpSession; + session = request->session; if (NULL == session) goto done; @@ -111,7 +111,7 @@ static BOOL WININET_GetServer( HINTERNET hRequest, LPWSTR szBuf, DWORD sz ) if (NULL == request) return FALSE; - session = request->lpHttpSession; + session = request->session; if (NULL == session) goto done; @@ -250,7 +250,7 @@ static BOOL WININET_SetAuthorization( HINTERNET hRequest, LPWSTR username, if( !request ) return FALSE; - session = request->lpHttpSession; + session = request->session; if (NULL == session || session->hdr.htype != WH_HHTTPSESSION) { INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE); diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c index b23f1542736..ae45b082aaf 100644 --- a/dlls/wininet/http.c +++ b/dlls/wininet/http.c @@ -237,7 +237,7 @@ static LPHTTPHEADERW HTTP_GetHeader(http_request_t *req, LPCWSTR head) if (HeaderIndex == -1) return NULL; else - return &req->pCustHeaders[HeaderIndex]; + return &req->custHeaders[HeaderIndex]; } #ifdef HAVE_ZLIB @@ -291,16 +291,16 @@ static DWORD set_content_length( http_request_t *request ) WCHAR encoding[20]; DWORD size; - size = sizeof(request->dwContentLength); + size = sizeof(request->contentLength); if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH, - &request->dwContentLength, &size, NULL) != ERROR_SUCCESS) - request->dwContentLength = ~0u; + &request->contentLength, &size, NULL) != ERROR_SUCCESS) + request->contentLength = ~0u; size = sizeof(encoding); if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_TRANSFER_ENCODING, encoding, &size, NULL) == ERROR_SUCCESS && !strcmpiW(encoding, szChunked)) { - request->dwContentLength = ~0u; + request->contentLength = ~0u; request->read_chunked = TRUE; } @@ -310,11 +310,11 @@ static DWORD set_content_length( http_request_t *request ) static const WCHAR gzipW[] = {'g','z','i','p',0}; encoding_idx = HTTP_GetCustomHeaderIndex(request, szContent_Encoding, 0, FALSE); - if(encoding_idx != -1 && !strcmpiW(request->pCustHeaders[encoding_idx].lpszValue, gzipW)) + if(encoding_idx != -1 && !strcmpiW(request->custHeaders[encoding_idx].lpszValue, gzipW)) init_gzip_stream(request); } - return request->dwContentLength; + return request->contentLength; } /*********************************************************************** @@ -388,33 +388,33 @@ static void HTTP_FixURL(http_request_t *request) static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/', 0 }; /* If we don't have a path we set it to root */ - if (NULL == request->lpszPath) - request->lpszPath = heap_strdupW(szSlash); + if (NULL == request->path) + request->path = heap_strdupW(szSlash); else /* remove \r and \n*/ { - int nLen = strlenW(request->lpszPath); - while ((nLen >0 ) && ((request->lpszPath[nLen-1] == '\r')||(request->lpszPath[nLen-1] == '\n'))) + int nLen = strlenW(request->path); + while ((nLen >0 ) && ((request->path[nLen-1] == '\r')||(request->path[nLen-1] == '\n'))) { nLen--; - request->lpszPath[nLen]='\0'; + request->path[nLen]='\0'; } /* Replace '\' with '/' */ while (nLen>0) { nLen--; - if (request->lpszPath[nLen] == '\\') request->lpszPath[nLen]='/'; + if (request->path[nLen] == '\\') request->path[nLen]='/'; } } if(CSTR_EQUAL != CompareStringW( LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, - request->lpszPath, strlenW(request->lpszPath), szHttp, strlenW(szHttp) ) - && request->lpszPath[0] != '/') /* not an absolute path ?? --> fix it !! */ + request->path, strlenW(request->path), szHttp, strlenW(szHttp) ) + && request->path[0] != '/') /* not an absolute path ?? --> fix it !! */ { WCHAR *fixurl = HeapAlloc(GetProcessHeap(), 0, - (strlenW(request->lpszPath) + 2)*sizeof(WCHAR)); + (strlenW(request->path) + 2)*sizeof(WCHAR)); *fixurl = '/'; - strcpyW(fixurl + 1, request->lpszPath); - HeapFree( GetProcessHeap(), 0, request->lpszPath ); - request->lpszPath = fixurl; + strcpyW(fixurl + 1, request->path); + HeapFree( GetProcessHeap(), 0, request->path ); + request->path = fixurl; } } @@ -445,16 +445,16 @@ static LPWSTR HTTP_BuildHeaderRequestString( http_request_t *request, LPCWSTR ve /* Append custom request headers */ for (i = 0; i < request->nCustHeaders; i++) { - if (request->pCustHeaders[i].wFlags & HDR_ISREQUEST) + if (request->custHeaders[i].wFlags & HDR_ISREQUEST) { req[n++] = szCrLf; - req[n++] = request->pCustHeaders[i].lpszField; + req[n++] = request->custHeaders[i].lpszField; req[n++] = szColon; - req[n++] = request->pCustHeaders[i].lpszValue; + req[n++] = request->custHeaders[i].lpszValue; TRACE("Adding custom header %s (%s)\n", - debugstr_w(request->pCustHeaders[i].lpszField), - debugstr_w(request->pCustHeaders[i].lpszValue)); + debugstr_w(request->custHeaders[i].lpszField), + debugstr_w(request->custHeaders[i].lpszValue)); } } @@ -485,7 +485,7 @@ static void HTTP_ProcessCookies( http_request_t *request ) while((HeaderIndex = HTTP_GetCustomHeaderIndex(request, szSet_Cookie, numCookies, FALSE)) != -1) { - setCookieHeader = &request->pCustHeaders[HeaderIndex]; + setCookieHeader = &request->custHeaders[HeaderIndex]; if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES) && setCookieHeader->lpszValue) { @@ -495,9 +495,9 @@ static void HTTP_ProcessCookies( http_request_t *request ) LPHTTPHEADERW Host; Host = HTTP_GetHeader(request, hostW); - len = lstrlenW(Host->lpszValue) + 9 + lstrlenW(request->lpszPath); + len = lstrlenW(Host->lpszValue) + 9 + lstrlenW(request->path); buf_url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); - sprintfW(buf_url, szFmt, Host->lpszValue, request->lpszPath); + sprintfW(buf_url, szFmt, Host->lpszValue, request->path); InternetSetCookieW(buf_url, NULL, setCookieHeader->lpszValue); HeapFree(GetProcessHeap(), 0, buf_url); @@ -939,7 +939,7 @@ static BOOL HTTP_DoAuthorization( http_request_t *request, LPCWSTR pszAuthValue, sec_status = InitializeSecurityContextW(first ? &pAuthInfo->cred : NULL, first ? NULL : &pAuthInfo->ctx, - first ? request->lpHttpSession->serverName : NULL, + first ? request->session->serverName : NULL, context_req, 0, SECURITY_NETWORK_DREP, in.pvBuffer ? &in_desc : NULL, 0, &pAuthInfo->ctx, &out_desc, @@ -1426,10 +1426,10 @@ static WCHAR *HTTP_BuildProxyRequestUrl(http_request_t *req) static const WCHAR slash[] = { '/',0 }; static const WCHAR format[] = { 'h','t','t','p',':','/','/','%','s',':','%','d',0 }; static const WCHAR formatSSL[] = { 'h','t','t','p','s',':','/','/','%','s',':','%','d',0 }; - http_session_t *session = req->lpHttpSession; + http_session_t *session = req->session; size = 16; /* "https://" + sizeof(port#) + ":/\0" */ - size += strlenW( session->hostName ) + strlenW( req->lpszPath ); + size += strlenW( session->hostName ) + strlenW( req->path ); if (!(url = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL; @@ -1437,8 +1437,8 @@ static WCHAR *HTTP_BuildProxyRequestUrl(http_request_t *req) sprintfW( url, formatSSL, session->hostName, session->hostPort ); else sprintfW( url, format, session->hostName, session->hostPort ); - if (req->lpszPath[0] != '/') strcatW( url, slash ); - strcatW( url, req->lpszPath ); + if (req->path[0] != '/') strcatW( url, slash ); + strcatW( url, req->path ); } TRACE("url=%s\n", debugstr_w(url)); return url; @@ -1476,8 +1476,8 @@ static BOOL HTTP_DealWithProxy(appinfo_t *hIC, http_session_t *session, http_req if( UrlComponents.dwHostNameLength == 0 ) return FALSE; - if( !request->lpszPath ) - request->lpszPath = szNul; + if( !request->path ) + request->path = szNul; if(UrlComponents.nPort == INTERNET_INVALID_PORT_NUMBER) UrlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT; @@ -1497,7 +1497,7 @@ static BOOL HTTP_DealWithProxy(appinfo_t *hIC, http_session_t *session, http_req static DWORD HTTP_ResolveName(http_request_t *request) { char szaddr[INET6_ADDRSTRLEN]; - http_session_t *session = request->lpHttpSession; + http_session_t *session = request->session; const void *addr; INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, @@ -1541,7 +1541,7 @@ static BOOL HTTP_GetRequestURL(http_request_t *req, LPWSTR buf) if(!host_header) return FALSE; - sprintfW(buf, formatW, host_header->lpszValue, req->lpszPath); /* FIXME */ + sprintfW(buf, formatW, host_header->lpszValue, req->path); /* FIXME */ return TRUE; } @@ -1567,29 +1567,29 @@ static void HTTPREQ_Destroy(object_header_t *hdr) memset(&ft, 0, sizeof(FILETIME)); if(HTTP_GetRequestURL(request, url)) { - CommitUrlCacheEntryW(url, request->lpszCacheFile, ft, ft, + CommitUrlCacheEntryW(url, request->cacheFile, ft, ft, NORMAL_CACHE_ENTRY, NULL, 0, NULL, 0); } } - HeapFree(GetProcessHeap(), 0, request->lpszCacheFile); + HeapFree(GetProcessHeap(), 0, request->cacheFile); DeleteCriticalSection( &request->read_section ); - WININET_Release(&request->lpHttpSession->hdr); + WININET_Release(&request->session->hdr); - destroy_authinfo(request->pAuthInfo); - destroy_authinfo(request->pProxyAuthInfo); + destroy_authinfo(request->authInfo); + destroy_authinfo(request->proxyAuthInfo); - HeapFree(GetProcessHeap(), 0, request->lpszPath); - HeapFree(GetProcessHeap(), 0, request->lpszVerb); - HeapFree(GetProcessHeap(), 0, request->lpszRawHeaders); - HeapFree(GetProcessHeap(), 0, request->lpszVersion); - HeapFree(GetProcessHeap(), 0, request->lpszStatusText); + HeapFree(GetProcessHeap(), 0, request->path); + HeapFree(GetProcessHeap(), 0, request->verb); + HeapFree(GetProcessHeap(), 0, request->rawHeaders); + HeapFree(GetProcessHeap(), 0, request->version); + HeapFree(GetProcessHeap(), 0, request->statusText); for (i = 0; i < request->nCustHeaders; i++) { - HeapFree(GetProcessHeap(), 0, request->pCustHeaders[i].lpszField); - HeapFree(GetProcessHeap(), 0, request->pCustHeaders[i].lpszValue); + HeapFree(GetProcessHeap(), 0, request->custHeaders[i].lpszField); + HeapFree(GetProcessHeap(), 0, request->custHeaders[i].lpszValue); } #ifdef HAVE_ZLIB @@ -1600,7 +1600,7 @@ static void HTTPREQ_Destroy(object_header_t *hdr) } #endif - HeapFree(GetProcessHeap(), 0, request->pCustHeaders); + HeapFree(GetProcessHeap(), 0, request->custHeaders); } static void HTTPREQ_CloseConnection(object_header_t *hdr) @@ -1653,7 +1653,7 @@ static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffe switch(option) { case INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO: { - http_session_t *session = req->lpHttpSession; + http_session_t *session = req->session; INTERNET_DIAGNOSTIC_SOCKET_INFO *info = buffer; FIXME("INTERNET_DIAGNOSTIC_SOCKET_INFO stub\n"); @@ -1728,7 +1728,7 @@ static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffe strcatW(url, host->lpszValue); if (NULL != (pch = strchrW(url + strlenW(httpW), ':'))) *pch = 0; - strcatW(url, req->lpszPath); + strcatW(url, req->path); TRACE("INTERNET_OPTION_URL: %s\n",debugstr_w(url)); @@ -1790,25 +1790,25 @@ static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffe TRACE("INTERNET_OPTION_DATAFILE_NAME\n"); - if(!req->lpszCacheFile) { + if(!req->cacheFile) { *size = 0; return ERROR_INTERNET_ITEM_NOT_FOUND; } if(unicode) { - req_size = (lstrlenW(req->lpszCacheFile)+1) * sizeof(WCHAR); + req_size = (lstrlenW(req->cacheFile)+1) * sizeof(WCHAR); if(*size < req_size) return ERROR_INSUFFICIENT_BUFFER; *size = req_size; - memcpy(buffer, req->lpszCacheFile, *size); + memcpy(buffer, req->cacheFile, *size); return ERROR_SUCCESS; }else { - req_size = WideCharToMultiByte(CP_ACP, 0, req->lpszCacheFile, -1, NULL, 0, NULL, NULL); + req_size = WideCharToMultiByte(CP_ACP, 0, req->cacheFile, -1, NULL, 0, NULL, NULL); if (req_size > *size) return ERROR_INSUFFICIENT_BUFFER; - *size = WideCharToMultiByte(CP_ACP, 0, req->lpszCacheFile, + *size = WideCharToMultiByte(CP_ACP, 0, req->cacheFile, -1, buffer, *size, NULL, NULL); return ERROR_SUCCESS; } @@ -1881,13 +1881,13 @@ static DWORD HTTPREQ_SetOption(object_header_t *hdr, DWORD option, void *buffer, *(DWORD*)buffer); case INTERNET_OPTION_USERNAME: - HeapFree(GetProcessHeap(), 0, req->lpHttpSession->userName); - if (!(req->lpHttpSession->userName = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY; + HeapFree(GetProcessHeap(), 0, req->session->userName); + if (!(req->session->userName = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY; return ERROR_SUCCESS; case INTERNET_OPTION_PASSWORD: - HeapFree(GetProcessHeap(), 0, req->lpHttpSession->password); - if (!(req->lpHttpSession->password = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY; + HeapFree(GetProcessHeap(), 0, req->session->password); + if (!(req->session->password = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY; return ERROR_SUCCESS; case INTERNET_OPTION_HTTP_DECODING: if(size != sizeof(BOOL)) @@ -1998,13 +1998,13 @@ static DWORD start_next_chunk( http_request_t *req ) { DWORD chunk_size = 0, res; - if (!req->dwContentLength) return ERROR_SUCCESS; - if (req->dwContentLength == req->dwContentRead) + if (!req->contentLength) return ERROR_SUCCESS; + if (req->contentLength == req->contentRead) { /* read terminator for the previous chunk */ if ((res = discard_eol( req )) != ERROR_SUCCESS) return res; - req->dwContentLength = ~0u; - req->dwContentRead = 0; + req->contentLength = ~0u; + req->contentRead = 0; } for (;;) { @@ -2017,8 +2017,8 @@ static DWORD start_next_chunk( http_request_t *req ) else if (ch == ';' || ch == '\r' || ch == '\n') { TRACE( "reading %u byte chunk\n", chunk_size ); - req->dwContentLength = chunk_size; - req->dwContentRead = 0; + req->contentLength = chunk_size; + req->contentRead = 0; return discard_eol( req ); } remove_data( req, 1 ); @@ -2026,7 +2026,7 @@ static DWORD start_next_chunk( http_request_t *req ) if ((res = read_more_data( req, -1 )) != ERROR_SUCCESS) return res; if (!req->read_size) { - req->dwContentLength = req->dwContentRead = 0; + req->contentLength = req->contentRead = 0; return ERROR_SUCCESS; } } @@ -2036,9 +2036,9 @@ static DWORD start_next_chunk( http_request_t *req ) static BOOL end_of_read_data( http_request_t *req ) { if (req->gzip_stream) return req->gzip_stream->end_of_data && !req->gzip_stream->buf_size; - if (req->read_chunked) return (req->dwContentLength == 0); - if (req->dwContentLength == ~0u) return FALSE; - return (req->dwContentLength == req->dwContentRead); + if (req->read_chunked) return (req->contentLength == 0); + if (req->contentLength == ~0u) return FALSE; + return (req->contentLength == req->contentRead); } /* fetch some more data into the read buffer (the read section must be held) */ @@ -2047,16 +2047,16 @@ static DWORD refill_buffer( http_request_t *req ) int len = sizeof(req->read_buf); DWORD res; - if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead)) + if (req->read_chunked && (req->contentLength == ~0u || req->contentLength == req->contentRead)) { if ((res = start_next_chunk( req )) != ERROR_SUCCESS) return res; } - if (req->dwContentLength != ~0u) len = min( len, req->dwContentLength - req->dwContentRead ); + if (req->contentLength != ~0u) len = min( len, req->contentLength - req->contentRead ); if (len <= req->read_size) return ERROR_SUCCESS; if ((res = read_more_data( req, len )) != ERROR_SUCCESS) return res; - if (!req->read_size) req->dwContentLength = req->dwContentRead = 0; + if (!req->read_size) req->contentLength = req->contentRead = 0; return ERROR_SUCCESS; } @@ -2076,10 +2076,10 @@ static DWORD read_gzip_data(http_request_t *req, BYTE *buf, int size, BOOL sync, break; } - if(req->dwContentRead == req->dwContentLength) + if(req->contentRead == req->contentLength) break; - buf_avail = req->dwContentLength == ~0 ? req->read_size : min(req->read_size, req->dwContentLength-req->dwContentRead); + buf_avail = req->contentLength == ~0 ? req->read_size : min(req->read_size, req->contentLength-req->contentRead); zstream->next_in = req->read_buf+req->read_pos; zstream->avail_in = buf_avail; @@ -2087,7 +2087,7 @@ static DWORD read_gzip_data(http_request_t *req, BYTE *buf, int size, BOOL sync, zstream->avail_out = size-read; zres = inflate(zstream, Z_FULL_FLUSH); read = size - zstream->avail_out; - req->dwContentRead += buf_avail-zstream->avail_in; + req->contentRead += buf_avail-zstream->avail_in; remove_data(req, buf_avail-zstream->avail_in); if(zres == Z_STREAM_END) { TRACE("end of data\n"); @@ -2133,9 +2133,9 @@ static DWORD get_avail_data( http_request_t *req ) refill_gzip_buffer(req); return req->gzip_stream->buf_size; } - if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead)) + if (req->read_chunked && (req->contentLength == ~0u || req->contentLength == req->contentRead)) return 0; - return min( req->read_size, req->dwContentLength - req->dwContentRead ); + return min( req->read_size, req->contentLength - req->contentRead ); } static void HTTP_ReceiveRequestData(http_request_t *req, BOOL first_notif) @@ -2168,7 +2168,7 @@ static DWORD HTTPREQ_Read(http_request_t *req, void *buffer, DWORD size, DWORD * EnterCriticalSection( &req->read_section ); - if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead)) + if (req->read_chunked && (req->contentLength == ~0u || req->contentLength == req->contentRead)) { if (start_next_chunk( req ) != ERROR_SUCCESS) goto done; } @@ -2191,7 +2191,7 @@ static DWORD HTTPREQ_Read(http_request_t *req, void *buffer, DWORD size, DWORD * finished_reading = req->gzip_stream->end_of_data && !req->gzip_stream->buf_size; }else { - if (req->dwContentLength != ~0u) size = min( size, req->dwContentLength - req->dwContentRead ); + if (req->contentLength != ~0u) size = min( size, req->contentLength - req->contentRead ); if (req->read_size) { bytes_read = min( req->read_size, size ); @@ -2206,16 +2206,16 @@ static DWORD HTTPREQ_Read(http_request_t *req, void *buffer, DWORD size, DWORD * /* always return success, even if the network layer returns an error */ } - finished_reading = !bytes_read && req->dwContentRead == req->dwContentLength; - req->dwContentRead += bytes_read; + finished_reading = !bytes_read && req->contentRead == req->contentLength; + req->contentRead += bytes_read; } done: *read = bytes_read; - TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, req->dwContentRead, req->dwContentLength ); + TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, req->contentRead, req->contentLength ); LeaveCriticalSection( &req->read_section ); - if(ret == ERROR_SUCCESS && req->lpszCacheFile) { + if(ret == ERROR_SUCCESS && req->cacheFile) { BOOL res; DWORD dwBytesWritten; @@ -2325,8 +2325,8 @@ static DWORD HTTPREQ_ReadFileExA(object_header_t *hdr, INTERNET_BUFFERSA *buffer else break; - if(!req->read_chunked || read==size || req->dwContentLength!=req->dwContentRead - || !req->dwContentLength || (req->gzip_stream && req->gzip_stream->end_of_data)) + if(!req->read_chunked || read==size || req->contentLength!=req->contentRead + || !req->contentLength || (req->gzip_stream && req->gzip_stream->end_of_data)) break; LeaveCriticalSection( &req->read_section ); @@ -2434,8 +2434,8 @@ static DWORD HTTPREQ_ReadFileExW(object_header_t *hdr, INTERNET_BUFFERSW *buffer else break; - if(!req->read_chunked || read==size || req->dwContentLength!=req->dwContentRead - || !req->dwContentLength || (req->gzip_stream && req->gzip_stream->end_of_data)) + if(!req->read_chunked || read==size || req->contentLength!=req->contentRead + || !req->contentLength || (req->gzip_stream && req->gzip_stream->end_of_data)) break; LeaveCriticalSection( &req->read_section ); @@ -2475,7 +2475,7 @@ static DWORD HTTPREQ_WriteFile(object_header_t *hdr, const void *buffer, DWORD s *written = 0; res = NETCON_send(&request->netConnection, buffer, size, 0, (LPINT)written); if (res == ERROR_SUCCESS) - request->dwBytesWritten += *written; + request->bytesWritten += *written; INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REQUEST_SENT, written, sizeof(DWORD)); return res; @@ -2494,7 +2494,7 @@ static DWORD HTTPREQ_QueryDataAvailable(object_header_t *hdr, DWORD *available, TRACE("(%p %p %x %lx)\n", req, available, flags, ctx); - if (req->lpHttpSession->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) + if (req->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) { WORKREQUEST workRequest; @@ -2527,7 +2527,7 @@ done: { DWORD extra; if (NETCON_query_data_available(&req->netConnection, &extra)) - *available = min( *available + extra, req->dwContentLength - req->dwContentRead ); + *available = min( *available + extra, req->contentLength - req->contentRead ); } LeaveCriticalSection( &req->read_section ); @@ -2581,12 +2581,12 @@ static DWORD HTTP_HttpOpenRequestW(http_session_t *session, request->hdr.htype = WH_HHTTPREQ; request->hdr.dwFlags = dwFlags; request->hdr.dwContext = dwContext; - request->dwContentLength = ~0u; + request->contentLength = ~0u; InitializeCriticalSection( &request->read_section ); WININET_AddRef( &session->hdr ); - request->lpHttpSession = session; + request->session = session; list_add_head( &session->hdr.children, &request->hdr.entry ); lpszHostName = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * @@ -2607,18 +2607,18 @@ static DWORD HTTP_HttpOpenRequestW(http_session_t *session, rc = UrlEscapeW(lpszObjectName, NULL, &len, URL_ESCAPE_SPACES_ONLY); if (rc != E_POINTER) len = strlenW(lpszObjectName)+1; - request->lpszPath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); - rc = UrlEscapeW(lpszObjectName, request->lpszPath, &len, + request->path = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); + rc = UrlEscapeW(lpszObjectName, request->path, &len, URL_ESCAPE_SPACES_ONLY); if (rc != S_OK) { ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(lpszObjectName),rc); - strcpyW(request->lpszPath,lpszObjectName); + strcpyW(request->path,lpszObjectName); } }else { static const WCHAR slashW[] = {'/',0}; - request->lpszPath = heap_strdupW(slashW); + request->path = heap_strdupW(slashW); } if (lpszReferrer && *lpszReferrer) @@ -2637,8 +2637,8 @@ static DWORD HTTP_HttpOpenRequestW(http_session_t *session, } } - request->lpszVerb = heap_strdupW(lpszVerb && *lpszVerb ? lpszVerb : szGET); - request->lpszVersion = heap_strdupW(lpszVersion ? lpszVersion : g_szHttp1_1); + request->verb = heap_strdupW(lpszVerb && *lpszVerb ? lpszVerb : szGET); + request->version = heap_strdupW(lpszVersion ? lpszVersion : g_szHttp1_1); if (session->hostPort != INTERNET_INVALID_PORT_NUMBER && session->hostPort != INTERNET_DEFAULT_HTTP_PORT && @@ -2747,12 +2747,12 @@ static void HTTP_DrainContent(http_request_t *req) if (!NETCON_connected(&req->netConnection)) return; - if (req->dwContentLength == -1) + if (req->contentLength == -1) { NETCON_close(&req->netConnection); return; } - if (!strcmpW(req->lpszVerb, szHEAD)) return; + if (!strcmpW(req->verb, szHEAD)) return; do { @@ -2864,9 +2864,9 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, DWORD res = ERROR_INVALID_PARAMETER; if (request_only) - headers = HTTP_BuildHeaderRequestString(request, request->lpszVerb, request->lpszPath, request->lpszVersion); + headers = HTTP_BuildHeaderRequestString(request, request->verb, request->path, request->version); else - headers = request->lpszRawHeaders; + headers = request->rawHeaders; if (headers) len = strlenW(headers) * sizeof(WCHAR); @@ -2896,7 +2896,7 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, } case HTTP_QUERY_RAW_HEADERS: { - LPWSTR * ppszRawHeaderLines = HTTP_Tokenize(request->lpszRawHeaders, szCrLf); + LPWSTR * ppszRawHeaderLines = HTTP_Tokenize(request->rawHeaders, szCrLf); DWORD i, size = 0; LPWSTR pszString = lpBuffer; @@ -2926,9 +2926,9 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, return ERROR_SUCCESS; } case HTTP_QUERY_STATUS_TEXT: - if (request->lpszStatusText) + if (request->statusText) { - DWORD len = strlenW(request->lpszStatusText); + DWORD len = strlenW(request->statusText); if (len + 1 > *lpdwBufferLength/sizeof(WCHAR)) { *lpdwBufferLength = (len + 1) * sizeof(WCHAR); @@ -2936,7 +2936,7 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, } if (lpBuffer) { - memcpy(lpBuffer, request->lpszStatusText, (len + 1) * sizeof(WCHAR)); + memcpy(lpBuffer, request->statusText, (len + 1) * sizeof(WCHAR)); TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len)); } *lpdwBufferLength = len * sizeof(WCHAR); @@ -2944,9 +2944,9 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, } break; case HTTP_QUERY_VERSION: - if (request->lpszVersion) + if (request->version) { - DWORD len = strlenW(request->lpszVersion); + DWORD len = strlenW(request->version); if (len + 1 > *lpdwBufferLength/sizeof(WCHAR)) { *lpdwBufferLength = (len + 1) * sizeof(WCHAR); @@ -2954,7 +2954,7 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, } if (lpBuffer) { - memcpy(lpBuffer, request->lpszVersion, (len + 1) * sizeof(WCHAR)); + memcpy(lpBuffer, request->version, (len + 1) * sizeof(WCHAR)); TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len)); } *lpdwBufferLength = len * sizeof(WCHAR); @@ -2974,7 +2974,7 @@ static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel, } if (index >= 0) - lphttpHdr = &request->pCustHeaders[index]; + lphttpHdr = &request->custHeaders[index]; /* Ensure header satisfies requested attributes */ if (!lphttpHdr || @@ -3256,7 +3256,7 @@ static LPWSTR HTTP_GetRedirectURL(http_request_t *request, LPCWSTR lpszUrl) { static WCHAR szHttp[] = {'h','t','t','p',0}; static WCHAR szHttps[] = {'h','t','t','p','s',0}; - http_session_t *session = request->lpHttpSession; + http_session_t *session = request->session; URL_COMPONENTSW urlComponents; DWORD url_length = 0; LPWSTR orig_url; @@ -3272,7 +3272,7 @@ static LPWSTR HTTP_GetRedirectURL(http_request_t *request, LPCWSTR lpszUrl) urlComponents.dwUserNameLength = 0; urlComponents.lpszPassword = NULL; urlComponents.dwPasswordLength = 0; - urlComponents.lpszUrlPath = request->lpszPath; + urlComponents.lpszUrlPath = request->path; urlComponents.dwUrlPathLength = 0; urlComponents.lpszExtraInfo = NULL; urlComponents.dwExtraInfoLength = 0; @@ -3316,7 +3316,7 @@ static LPWSTR HTTP_GetRedirectURL(http_request_t *request, LPCWSTR lpszUrl) */ static DWORD HTTP_HandleRedirect(http_request_t *request, LPCWSTR lpszUrl) { - http_session_t *session = request->lpHttpSession; + http_session_t *session = request->session; appinfo_t *hIC = session->appInfo; BOOL using_proxy = hIC->proxy && hIC->proxy[0]; WCHAR path[INTERNET_MAX_URL_LENGTH]; @@ -3441,8 +3441,8 @@ static DWORD HTTP_HandleRedirect(http_request_t *request, LPCWSTR lpszUrl) TRACE("Redirect through proxy\n"); } - HeapFree(GetProcessHeap(), 0, request->lpszPath); - request->lpszPath=NULL; + HeapFree(GetProcessHeap(), 0, request->path); + request->path=NULL; if (*path) { DWORD needed = 0; @@ -3451,13 +3451,13 @@ static DWORD HTTP_HandleRedirect(http_request_t *request, LPCWSTR lpszUrl) rc = UrlEscapeW(path, NULL, &needed, URL_ESCAPE_SPACES_ONLY); if (rc != E_POINTER) needed = strlenW(path)+1; - request->lpszPath = HeapAlloc(GetProcessHeap(), 0, needed*sizeof(WCHAR)); - rc = UrlEscapeW(path, request->lpszPath, &needed, + request->path = HeapAlloc(GetProcessHeap(), 0, needed*sizeof(WCHAR)); + rc = UrlEscapeW(path, request->path, &needed, URL_ESCAPE_SPACES_ONLY); if (rc != S_OK) { ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc); - strcpyW(request->lpszPath,path); + strcpyW(request->path,path); } } @@ -3506,7 +3506,7 @@ static DWORD HTTP_SecureProxyConnect(http_request_t *request) DWORD res; static const WCHAR szConnect[] = {'C','O','N','N','E','C','T',0}; static const WCHAR szFormat[] = {'%','s',':','%','d',0}; - http_session_t *session = request->lpHttpSession; + http_session_t *session = request->session; TRACE("\n"); @@ -3544,9 +3544,9 @@ static void HTTP_InsertCookies(http_request_t *request) DWORD nCookieSize, size; LPHTTPHEADERW Host = HTTP_GetHeader(request, hostW); - size = (strlenW(Host->lpszValue) + strlenW(szUrlForm) + strlenW(request->lpszPath)) * sizeof(WCHAR); + size = (strlenW(Host->lpszValue) + strlenW(szUrlForm) + strlenW(request->path)) * sizeof(WCHAR); if (!(lpszUrl = HeapAlloc(GetProcessHeap(), 0, size))) return; - sprintfW( lpszUrl, szUrlForm, Host->lpszValue, request->lpszPath); + sprintfW( lpszUrl, szUrlForm, Host->lpszValue, request->path); if (InternetGetCookieW(lpszUrl, NULL, NULL, &nCookieSize)) { @@ -3598,24 +3598,24 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, assert(request->hdr.htype == WH_HHTTPREQ); /* if the verb is NULL default to GET */ - if (!request->lpszVerb) - request->lpszVerb = heap_strdupW(szGET); + if (!request->verb) + request->verb = heap_strdupW(szGET); - if (dwContentLength || strcmpW(request->lpszVerb, szGET)) + if (dwContentLength || strcmpW(request->verb, szGET)) { sprintfW(contentLengthStr, szContentLength, dwContentLength); HTTP_HttpAddRequestHeadersW(request, contentLengthStr, -1L, HTTP_ADDREQ_FLAG_REPLACE); - request->dwBytesToWrite = dwContentLength; + request->bytesToWrite = dwContentLength; } - if (request->lpHttpSession->appInfo->agent) + if (request->session->appInfo->agent) { WCHAR *agent_header; static const WCHAR user_agent[] = {'U','s','e','r','-','A','g','e','n','t',':',' ','%','s','\r','\n',0}; int len; - len = strlenW(request->lpHttpSession->appInfo->agent) + strlenW(user_agent); + len = strlenW(request->session->appInfo->agent) + strlenW(user_agent); agent_header = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); - sprintfW(agent_header, user_agent, request->lpHttpSession->appInfo->agent); + sprintfW(agent_header, user_agent, request->session->appInfo->agent); HTTP_HttpAddRequestHeadersW(request, agent_header, strlenW(agent_header), HTTP_ADDREQ_FLAG_ADD_IF_NEW); HeapFree(GetProcessHeap(), 0, agent_header); @@ -3625,7 +3625,7 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, static const WCHAR pragma_nocache[] = {'P','r','a','g','m','a',':',' ','n','o','-','c','a','c','h','e','\r','\n',0}; HTTP_HttpAddRequestHeadersW(request, pragma_nocache, strlenW(pragma_nocache), HTTP_ADDREQ_FLAG_ADD_IF_NEW); } - if ((request->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && !strcmpW(request->lpszVerb, szPost)) + if ((request->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && !strcmpW(request->verb, szPost)) { static const WCHAR cache_control[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',':', ' ','n','o','-','c','a','c','h','e','\r','\n',0}; @@ -3643,16 +3643,16 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, /* like native, just in case the caller forgot to call InternetReadFile * for all the data */ HTTP_DrainContent(request); - request->dwContentRead = 0; + request->contentRead = 0; if(redirected) { - request->dwContentLength = ~0u; - request->dwBytesToWrite = 0; + request->contentLength = ~0u; + request->bytesToWrite = 0; } if (TRACE_ON(wininet)) { LPHTTPHEADERW Host = HTTP_GetHeader(request, hostW); - TRACE("Going to url %s %s\n", debugstr_w(Host->lpszValue), debugstr_w(request->lpszPath)); + TRACE("Going to url %s %s\n", debugstr_w(Host->lpszValue), debugstr_w(request->path)); } HTTP_FixURL(request); @@ -3660,8 +3660,8 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, { HTTP_ProcessHeader(request, szConnection, szKeepAlive, HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE); } - HTTP_InsertAuthorization(request, request->pAuthInfo, szAuthorization); - HTTP_InsertAuthorization(request, request->pProxyAuthInfo, szProxy_Authorization); + HTTP_InsertAuthorization(request, request->authInfo, szAuthorization); + HTTP_InsertAuthorization(request, request->proxyAuthInfo, szProxy_Authorization); if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES)) HTTP_InsertCookies(request); @@ -3673,14 +3673,14 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE); } - if (request->lpHttpSession->appInfo->proxy && request->lpHttpSession->appInfo->proxy[0]) + if (request->session->appInfo->proxy && request->session->appInfo->proxy[0]) { WCHAR *url = HTTP_BuildProxyRequestUrl(request); - requestString = HTTP_BuildHeaderRequestString(request, request->lpszVerb, url, request->lpszVersion); + requestString = HTTP_BuildHeaderRequestString(request, request->verb, url, request->version); HeapFree(GetProcessHeap(), 0, url); } else - requestString = HTTP_BuildHeaderRequestString(request, request->lpszVerb, request->lpszPath, request->lpszVersion); + requestString = HTTP_BuildHeaderRequestString(request, request->verb, request->path, request->version); TRACE("Request header -> %s\n", debugstr_w(requestString) ); @@ -3714,7 +3714,7 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, res = NETCON_send(&request->netConnection, ascii_req, len, 0, &cnt); HeapFree( GetProcessHeap(), 0, ascii_req ); - request->dwBytesWritten = dwOptionalLength; + request->bytesWritten = dwOptionalLength; INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REQUEST_SENT, @@ -3762,10 +3762,10 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, dwStatusCode == HTTP_STATUS_REDIRECT_METHOD) && HTTP_HttpQueryInfoW(request,HTTP_QUERY_LOCATION,szNewLocation,&dwBufferSize,NULL) == ERROR_SUCCESS) { - if (strcmpW(request->lpszVerb, szGET) && strcmpW(request->lpszVerb, szHEAD)) + if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD)) { - HeapFree(GetProcessHeap(), 0, request->lpszVerb); - request->lpszVerb = heap_strdupW(szGET); + HeapFree(GetProcessHeap(), 0, request->verb); + request->verb = heap_strdupW(szGET); } HTTP_DrainContent(request); if ((new_url = HTTP_GetRedirectURL( request, szNewLocation ))) @@ -3794,9 +3794,9 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_WWW_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS) { if (HTTP_DoAuthorization(request, szAuthValue, - &request->pAuthInfo, - request->lpHttpSession->userName, - request->lpHttpSession->password, + &request->authInfo, + request->session->userName, + request->session->password, Host->lpszValue)) { HeapFree(GetProcessHeap(), 0, requestString); @@ -3807,8 +3807,8 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, if(!loop_next) { TRACE("Cleaning wrong authorization data\n"); - destroy_authinfo(request->pAuthInfo); - request->pAuthInfo = NULL; + destroy_authinfo(request->authInfo); + request->authInfo = NULL; } } if (dwStatusCode == HTTP_STATUS_PROXY_AUTH_REQ) @@ -3817,9 +3817,9 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_PROXY_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS) { if (HTTP_DoAuthorization(request, szAuthValue, - &request->pProxyAuthInfo, - request->lpHttpSession->appInfo->proxyUsername, - request->lpHttpSession->appInfo->proxyPassword, + &request->proxyAuthInfo, + request->session->appInfo->proxyUsername, + request->session->appInfo->proxyPassword, NULL)) { loop_next = TRUE; @@ -3829,8 +3829,8 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, if(!loop_next) { TRACE("Cleaning wrong proxy authorization data\n"); - destroy_authinfo(request->pProxyAuthInfo); - request->pProxyAuthInfo = NULL; + destroy_authinfo(request->proxyAuthInfo); + request->proxyAuthInfo = NULL; } } } @@ -3851,13 +3851,13 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders, goto lend; } - b = CreateUrlCacheEntryW(url, request->dwContentLength > 0 ? request->dwContentLength : 0, NULL, cacheFileName, 0); + b = CreateUrlCacheEntryW(url, request->contentLength > 0 ? request->contentLength : 0, NULL, cacheFileName, 0); if(b) { - HeapFree(GetProcessHeap(), 0, request->lpszCacheFile); + HeapFree(GetProcessHeap(), 0, request->cacheFile); CloseHandle(request->hCacheFile); - request->lpszCacheFile = heap_strdupW(cacheFileName); - request->hCacheFile = CreateFileW(request->lpszCacheFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, + request->cacheFile = heap_strdupW(cacheFileName); + request->hCacheFile = CreateFileW(request->cacheFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if(request->hCacheFile == INVALID_HANDLE_VALUE) { WARN("Could not create file: %u\n", GetLastError()); @@ -3874,9 +3874,9 @@ lend: /* TODO: send notification for P3P header */ - if (request->lpHttpSession->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) + if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) { - if (res == ERROR_SUCCESS && request->dwBytesWritten == request->dwBytesToWrite) + if (res == ERROR_SUCCESS && request->bytesWritten == request->bytesToWrite) HTTP_ReceiveRequestData(request, TRUE); else { @@ -3945,10 +3945,10 @@ static DWORD HTTP_HttpEndRequestW(http_request_t *request, DWORD dwFlags, DWORD_ dwBufferSize=sizeof(szNewLocation); if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, szNewLocation, &dwBufferSize, NULL) == ERROR_SUCCESS) { - if (strcmpW(request->lpszVerb, szGET) && strcmpW(request->lpszVerb, szHEAD)) + if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD)) { - HeapFree(GetProcessHeap(), 0, request->lpszVerb); - request->lpszVerb = heap_strdupW(szGET); + HeapFree(GetProcessHeap(), 0, request->verb); + request->verb = heap_strdupW(szGET); } HTTP_DrainContent(request); if ((new_url = HTTP_GetRedirectURL( request, szNewLocation ))) @@ -4042,7 +4042,7 @@ BOOL WINAPI HttpEndRequestW(HINTERNET hRequest, } request->hdr.dwFlags |= dwFlags; - if (request->lpHttpSession->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) + if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC) { WORKREQUEST work; struct WORKREQ_HTTPENDREQUESTW *work_endrequest; @@ -4154,7 +4154,7 @@ BOOL WINAPI HttpSendRequestExW(HINTERNET hRequest, goto lend; } - session = request->lpHttpSession; + session = request->session; assert(session->hdr.htype == WH_HHTTPSESSION); hIC = session->appInfo; assert(hIC->hdr.htype == WH_HINIT); @@ -4252,7 +4252,7 @@ BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders, goto lend; } - session = request->lpHttpSession; + session = request->session; if (NULL == session || session->hdr.htype != WH_HHTTPSESSION) { res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE; @@ -4517,7 +4517,7 @@ static DWORD HTTP_OpenConnection(http_request_t *request) goto lend; if ((res = HTTP_ResolveName(request)) != ERROR_SUCCESS) goto lend; - session = request->lpHttpSession; + session = request->session; hIC = session->appInfo; switch (session->socketAddress.ss_family) @@ -4608,11 +4608,11 @@ static void HTTP_clear_response_headers( http_request_t *request ) for( i=0; inCustHeaders; i++) { - if( !request->pCustHeaders[i].lpszField ) + if( !request->custHeaders[i].lpszField ) continue; - if( !request->pCustHeaders[i].lpszValue ) + if( !request->custHeaders[i].lpszValue ) continue; - if ( request->pCustHeaders[i].wFlags & HDR_ISREQUEST ) + if ( request->custHeaders[i].wFlags & HDR_ISREQUEST ) continue; HTTP_DeleteCustomHeader( request, i ); i--; @@ -4690,14 +4690,14 @@ static INT HTTP_GetResponseHeaders(http_request_t *request, BOOL clear) { WARN("No status line at head of response (%s)\n", debugstr_w(buffer)); - HeapFree(GetProcessHeap(), 0, request->lpszVersion); - HeapFree(GetProcessHeap(), 0, request->lpszStatusText); + HeapFree(GetProcessHeap(), 0, request->version); + HeapFree(GetProcessHeap(), 0, request->statusText); - request->lpszVersion = heap_strdupW(g_szHttp1_0); - request->lpszStatusText = heap_strdupW(szOK); + request->version = heap_strdupW(g_szHttp1_0); + request->statusText = heap_strdupW(szOK); - HeapFree(GetProcessHeap(), 0, request->lpszRawHeaders); - request->lpszRawHeaders = heap_strdupW(szDefaultHeader); + HeapFree(GetProcessHeap(), 0, request->rawHeaders); + request->rawHeaders = heap_strdupW(szDefaultHeader); bSuccess = TRUE; goto lend; @@ -4708,11 +4708,11 @@ static INT HTTP_GetResponseHeaders(http_request_t *request, BOOL clear) HTTP_ProcessHeader(request, szStatus, status_code, HTTP_ADDHDR_FLAG_REPLACE); - HeapFree(GetProcessHeap(),0,request->lpszVersion); - HeapFree(GetProcessHeap(),0,request->lpszStatusText); + HeapFree(GetProcessHeap(),0,request->version); + HeapFree(GetProcessHeap(),0,request->statusText); - request->lpszVersion = heap_strdupW(buffer); - request->lpszStatusText = heap_strdupW(status_text); + request->version = heap_strdupW(buffer); + request->statusText = heap_strdupW(status_text); /* Restore the spaces */ *(status_code-1) = ' '; @@ -4787,8 +4787,8 @@ static INT HTTP_GetResponseHeaders(http_request_t *request, BOOL clear) memcpy(&lpszRawHeaders[cchRawHeaders], szCrLf, sizeof(szCrLf)); - HeapFree(GetProcessHeap(), 0, request->lpszRawHeaders); - request->lpszRawHeaders = lpszRawHeaders; + HeapFree(GetProcessHeap(), 0, request->rawHeaders); + request->rawHeaders = lpszRawHeaders; TRACE("raw headers: %s\n", debugstr_w(lpszRawHeaders)); bSuccess = TRUE; @@ -4890,7 +4890,7 @@ static DWORD HTTP_ProcessHeader(http_request_t *request, LPCWSTR field, LPCWSTR { if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW) return ERROR_HTTP_INVALID_HEADER; - lphttpHdr = &request->pCustHeaders[index]; + lphttpHdr = &request->custHeaders[index]; } else if (value) { @@ -5021,13 +5021,13 @@ static INT HTTP_GetCustomHeaderIndex(http_request_t *request, LPCWSTR lpszField, for (index = 0; index < request->nCustHeaders; index++) { - if (strcmpiW(request->pCustHeaders[index].lpszField, lpszField)) + if (strcmpiW(request->custHeaders[index].lpszField, lpszField)) continue; - if (request_only && !(request->pCustHeaders[index].wFlags & HDR_ISREQUEST)) + if (request_only && !(request->custHeaders[index].wFlags & HDR_ISREQUEST)) continue; - if (!request_only && (request->pCustHeaders[index].wFlags & HDR_ISREQUEST)) + if (!request_only && (request->custHeaders[index].wFlags & HDR_ISREQUEST)) continue; if (requested_index == 0) @@ -5057,18 +5057,18 @@ static DWORD HTTP_InsertCustomHeader(http_request_t *request, LPHTTPHEADERW lpHd TRACE("--> %s: %s\n", debugstr_w(lpHdr->lpszField), debugstr_w(lpHdr->lpszValue)); count = request->nCustHeaders + 1; if (count > 1) - lph = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, request->pCustHeaders, sizeof(HTTPHEADERW) * count); + lph = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, request->custHeaders, sizeof(HTTPHEADERW) * count); else lph = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HTTPHEADERW) * count); if (!lph) return ERROR_OUTOFMEMORY; - request->pCustHeaders = lph; - request->pCustHeaders[count-1].lpszField = heap_strdupW(lpHdr->lpszField); - request->pCustHeaders[count-1].lpszValue = heap_strdupW(lpHdr->lpszValue); - request->pCustHeaders[count-1].wFlags = lpHdr->wFlags; - request->pCustHeaders[count-1].wCount= lpHdr->wCount; + request->custHeaders = lph; + request->custHeaders[count-1].lpszField = heap_strdupW(lpHdr->lpszField); + request->custHeaders[count-1].lpszValue = heap_strdupW(lpHdr->lpszValue); + request->custHeaders[count-1].wFlags = lpHdr->wFlags; + request->custHeaders[count-1].wCount= lpHdr->wCount; request->nCustHeaders++; return ERROR_SUCCESS; @@ -5089,12 +5089,12 @@ static BOOL HTTP_DeleteCustomHeader(http_request_t *request, DWORD index) return FALSE; request->nCustHeaders--; - HeapFree(GetProcessHeap(), 0, request->pCustHeaders[index].lpszField); - HeapFree(GetProcessHeap(), 0, request->pCustHeaders[index].lpszValue); + HeapFree(GetProcessHeap(), 0, request->custHeaders[index].lpszField); + HeapFree(GetProcessHeap(), 0, request->custHeaders[index].lpszValue); - memmove( &request->pCustHeaders[index], &request->pCustHeaders[index+1], + memmove( &request->custHeaders[index], &request->custHeaders[index+1], (request->nCustHeaders - index)* sizeof(HTTPHEADERW) ); - memset( &request->pCustHeaders[request->nCustHeaders], 0, sizeof(HTTPHEADERW) ); + memset( &request->custHeaders[request->nCustHeaders], 0, sizeof(HTTPHEADERW) ); return TRUE; } @@ -5109,7 +5109,7 @@ static BOOL HTTP_DeleteCustomHeader(http_request_t *request, DWORD index) static BOOL HTTP_VerifyValidHeader(http_request_t *request, LPCWSTR field) { /* Accept-Encoding is stripped from HTTP/1.0 requests. It is invalid */ - if (!strcmpW(request->lpszVersion, g_szHttp1_0) && !strcmpiW(field, szAccept_Encoding)) + if (!strcmpW(request->version, g_szHttp1_0) && !strcmpiW(field, szAccept_Encoding)) return ERROR_HTTP_INVALID_HEADER; return ERROR_SUCCESS; diff --git a/dlls/wininet/internet.h b/dlls/wininet/internet.h index 46f3dc348dc..1d890455bfc 100644 --- a/dlls/wininet/internet.h +++ b/dlls/wininet/internet.h @@ -263,25 +263,25 @@ typedef struct gzip_stream_t gzip_stream_t; typedef struct { object_header_t hdr; - http_session_t *lpHttpSession; - LPWSTR lpszPath; - LPWSTR lpszVerb; - LPWSTR lpszRawHeaders; + http_session_t *session; + LPWSTR path; + LPWSTR verb; + LPWSTR rawHeaders; WININET_NETCONNECTION netConnection; - LPWSTR lpszVersion; - LPWSTR lpszStatusText; - DWORD dwBytesToWrite; - DWORD dwBytesWritten; - HTTPHEADERW *pCustHeaders; + LPWSTR version; + LPWSTR statusText; + DWORD bytesToWrite; + DWORD bytesWritten; + HTTPHEADERW *custHeaders; DWORD nCustHeaders; HANDLE hCacheFile; - LPWSTR lpszCacheFile; - struct HttpAuthInfo *pAuthInfo; - struct HttpAuthInfo *pProxyAuthInfo; + LPWSTR cacheFile; + struct HttpAuthInfo *authInfo; + struct HttpAuthInfo *proxyAuthInfo; CRITICAL_SECTION read_section; /* section to protect the following fields */ - DWORD dwContentLength; /* total number of bytes to be read */ - DWORD dwContentRead; /* bytes of the content read so far */ + DWORD contentLength; /* total number of bytes to be read */ + DWORD contentRead; /* bytes of the content read so far */ BOOL read_chunked; /* are we reading in chunked mode? */ DWORD read_pos; /* current read position in read_buf */ DWORD read_size; /* valid data size in read_buf */