mirror of
https://git.suyu.dev/suyu/breakpad.git
synced 2026-03-12 08:06:27 +00:00
4febb34583
sed -i '' -E -e 's/Copyright (\(c\) )?([0-9-]+),? (Google|The Chromium Authors).*(\r)?$/Copyright \2 Google LLC\4/' -e '/^((\/\/|#| \*) )?All rights reserved\.?\r?$/d' -e 's/name of Google Inc\. nor the/name of Google LLC nor the/' -e 's/POSSIBILITY OF SUCH DAMAGE$/POSSIBILITY OF SUCH DAMAGE./' $(git grep -El 'Copyright (\(c\) )?([0-9-]+),? (Google|The Chromium Authors).*$')
Plus manual fixes for src/processor/disassembler_x86.{cc,h}.
Plus some conversions from CRLF to LF line endings in .cc and .h files.
Bug: chromium:1098010
Change-Id: I8030e804eecd9f5a1ec9d66ae166efd8418c2a67
Reviewed-on: https://chromium-review.googlesource.com/c/breakpad/breakpad/+/3878302
Reviewed-by: Mike Frysinger <vapier@chromium.org>
308 lines
11 KiB
C++
308 lines
11 KiB
C++
// Copyright 2019 Google LLC
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google LLC nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include "tools/windows/converter_exe/winhttp_client.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <windows.h>
|
|
#include <winhttp.h>
|
|
#include <vector>
|
|
|
|
namespace crash {
|
|
|
|
namespace internal {
|
|
|
|
// This class implements HttpClient based on WinInet APIs.
|
|
class WinHttpClient : public HttpClient {
|
|
public:
|
|
virtual ~WinHttpClient() {}
|
|
virtual bool CrackUrl(const TCHAR* url,
|
|
DWORD flags,
|
|
TCHAR* scheme,
|
|
size_t scheme_buffer_length,
|
|
TCHAR* host,
|
|
size_t host_buffer_length,
|
|
TCHAR* uri,
|
|
size_t uri_buffer_length,
|
|
int* port) const;
|
|
virtual bool Open(const TCHAR* user_agent,
|
|
DWORD access_type,
|
|
const TCHAR* proxy_name,
|
|
const TCHAR* proxy_bypass,
|
|
HttpHandle* session_handle) const;
|
|
virtual bool Connect(HttpHandle session_handle,
|
|
const TCHAR* server,
|
|
int port,
|
|
HttpHandle* connection_handle) const;
|
|
virtual bool OpenRequest(HttpHandle connection_handle,
|
|
const TCHAR* verb,
|
|
const TCHAR* uri,
|
|
const TCHAR* version,
|
|
const TCHAR* referrer,
|
|
bool is_secure,
|
|
HttpHandle* request_handle) const;
|
|
virtual bool SendRequest(HttpHandle request_handle,
|
|
const TCHAR* headers,
|
|
DWORD headers_length) const;
|
|
virtual bool ReceiveResponse(HttpHandle request_handle) const;
|
|
virtual bool GetHttpStatusCode(HttpHandle request_handle,
|
|
int* status_code) const;
|
|
virtual bool GetContentLength(HttpHandle request_handle,
|
|
DWORD* content_length) const;
|
|
virtual bool ReadData(HttpHandle request_handle,
|
|
void* buffer,
|
|
DWORD buffer_length,
|
|
DWORD* bytes_read) const;
|
|
virtual bool Close(HttpHandle handle) const;
|
|
|
|
private:
|
|
static DWORD MapAccessType(DWORD access_type);
|
|
static HINTERNET ToHINTERNET(HttpHandle handle);
|
|
static HttpHandle FromHINTERNET(HINTERNET handle);
|
|
};
|
|
|
|
bool WinHttpClient::CrackUrl(const TCHAR* url,
|
|
DWORD flags,
|
|
TCHAR* scheme,
|
|
size_t scheme_buffer_length,
|
|
TCHAR* host,
|
|
size_t host_buffer_length,
|
|
TCHAR* uri,
|
|
size_t uri_buffer_length,
|
|
int* port) const {
|
|
assert(url);
|
|
assert(scheme);
|
|
assert(host);
|
|
assert(uri);
|
|
assert(port);
|
|
|
|
URL_COMPONENTS url_comp = {0};
|
|
url_comp.dwStructSize = sizeof(url_comp);
|
|
url_comp.lpszScheme = scheme;
|
|
url_comp.dwSchemeLength = static_cast<DWORD>(scheme_buffer_length);
|
|
url_comp.lpszHostName = host;
|
|
url_comp.dwHostNameLength = static_cast<DWORD>(host_buffer_length);
|
|
url_comp.lpszUrlPath = uri;
|
|
url_comp.dwUrlPathLength = static_cast<DWORD>(uri_buffer_length);
|
|
|
|
bool result = !!::WinHttpCrackUrl(url, 0, flags, &url_comp);
|
|
if (result) {
|
|
*port = static_cast<int>(url_comp.nPort);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool WinHttpClient::Open(const TCHAR* user_agent,
|
|
DWORD access_type,
|
|
const TCHAR* proxy_name,
|
|
const TCHAR* proxy_bypass,
|
|
HttpHandle* session_handle) const {
|
|
*session_handle = FromHINTERNET(::WinHttpOpen(user_agent,
|
|
MapAccessType(access_type),
|
|
proxy_name,
|
|
proxy_bypass,
|
|
0));
|
|
|
|
return !!(*session_handle);
|
|
}
|
|
|
|
bool WinHttpClient::Connect(HttpHandle session_handle,
|
|
const TCHAR* server,
|
|
int port,
|
|
HttpHandle* connection_handle) const {
|
|
assert(server);
|
|
|
|
// Uses NULL user name and password to connect.
|
|
*connection_handle = FromHINTERNET(::WinHttpConnect(
|
|
ToHINTERNET(session_handle),
|
|
server,
|
|
static_cast<INTERNET_PORT>(port),
|
|
NULL));
|
|
return !!(*connection_handle);
|
|
}
|
|
|
|
bool WinHttpClient::OpenRequest(HttpHandle connection_handle,
|
|
const TCHAR* verb,
|
|
const TCHAR* uri,
|
|
const TCHAR* version,
|
|
const TCHAR* referrer,
|
|
bool is_secure,
|
|
HttpHandle* request_handle) const {
|
|
assert(connection_handle);
|
|
assert(verb);
|
|
assert(uri);
|
|
assert(request_handle);
|
|
|
|
*request_handle = FromHINTERNET(::WinHttpOpenRequest(
|
|
ToHINTERNET(connection_handle),
|
|
verb,
|
|
uri,
|
|
version,
|
|
referrer,
|
|
WINHTTP_DEFAULT_ACCEPT_TYPES,
|
|
is_secure ? WINHTTP_FLAG_SECURE : 0));
|
|
return !!(*request_handle);
|
|
}
|
|
|
|
bool WinHttpClient::SendRequest(HttpHandle request_handle,
|
|
const TCHAR* headers,
|
|
DWORD headers_length) const {
|
|
assert(request_handle);
|
|
|
|
return !!::WinHttpSendRequest(ToHINTERNET(request_handle),
|
|
headers,
|
|
headers_length,
|
|
NULL,
|
|
0,
|
|
WINHTTP_IGNORE_REQUEST_TOTAL_LENGTH,
|
|
NULL);
|
|
}
|
|
|
|
bool WinHttpClient::ReceiveResponse(HttpHandle request_handle) const {
|
|
assert(request_handle);
|
|
|
|
return !!::WinHttpReceiveResponse(ToHINTERNET(request_handle), NULL);
|
|
}
|
|
|
|
bool WinHttpClient::GetHttpStatusCode(HttpHandle request_handle,
|
|
int* status_code) const {
|
|
TCHAR http_status_string[4] = {0};
|
|
DWORD http_status_string_size = sizeof(http_status_string);
|
|
if (!::WinHttpQueryHeaders(ToHINTERNET(request_handle),
|
|
WINHTTP_QUERY_STATUS_CODE,
|
|
WINHTTP_HEADER_NAME_BY_INDEX,
|
|
static_cast<void*>(&http_status_string),
|
|
&http_status_string_size, 0)) {
|
|
return false;
|
|
}
|
|
|
|
*status_code = static_cast<DWORD>(_tcstol(http_status_string, NULL, 10));
|
|
return true;
|
|
}
|
|
|
|
bool WinHttpClient::GetContentLength(HttpHandle request_handle,
|
|
DWORD* content_length) const {
|
|
assert(request_handle);
|
|
assert(content_length);
|
|
|
|
TCHAR content_length_string[11] = {0};
|
|
DWORD content_length_string_size = sizeof(content_length_string);
|
|
if (!::WinHttpQueryHeaders(ToHINTERNET(request_handle),
|
|
WINHTTP_QUERY_CONTENT_LENGTH,
|
|
WINHTTP_HEADER_NAME_BY_INDEX,
|
|
static_cast<void*>(&content_length_string),
|
|
&content_length_string_size, 0)) {
|
|
*content_length = kUnknownContentLength;
|
|
} else {
|
|
*content_length =
|
|
static_cast<DWORD>(wcstol(content_length_string, NULL, 10));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool WinHttpClient::ReadData(HttpHandle request_handle,
|
|
void* buffer,
|
|
DWORD buffer_length,
|
|
DWORD* bytes_read) const {
|
|
assert(request_handle);
|
|
assert(buffer);
|
|
assert(bytes_read);
|
|
|
|
DWORD bytes_read_local = 0;
|
|
if (!::WinHttpReadData(ToHINTERNET(request_handle),
|
|
buffer,
|
|
buffer_length,
|
|
&bytes_read_local)) {
|
|
return false;
|
|
}
|
|
*bytes_read = bytes_read_local;
|
|
return true;
|
|
}
|
|
|
|
bool WinHttpClient::Close(HttpHandle handle) const {
|
|
assert(handle);
|
|
return !!::WinHttpCloseHandle(ToHINTERNET(handle));
|
|
}
|
|
|
|
DWORD WinHttpClient::MapAccessType(DWORD access_type) {
|
|
switch (static_cast<AccessType>(access_type)) {
|
|
case ACCESS_TYPE_PRECONFIG:
|
|
default:
|
|
return WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
|
|
case ACCESS_TYPE_DIRECT:
|
|
return WINHTTP_ACCESS_TYPE_NO_PROXY;
|
|
case ACCESS_TYPE_PROXY:
|
|
return WINHTTP_ACCESS_TYPE_NAMED_PROXY;
|
|
}
|
|
}
|
|
|
|
|
|
HINTERNET WinHttpClient::ToHINTERNET(HttpHandle handle) {
|
|
return static_cast<HINTERNET>(handle);
|
|
}
|
|
|
|
HttpHandle WinHttpClient::FromHINTERNET(HINTERNET handle) {
|
|
return static_cast<HttpHandle>(handle);
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
HttpClient* CreateWinHttpClient(const TCHAR* url) {
|
|
assert(url);
|
|
|
|
internal::WinHttpClient winhttp;
|
|
wchar_t scheme[16] = {0};
|
|
wchar_t host[256] = {0};
|
|
wchar_t path[256] = {0};
|
|
int port = 0;
|
|
|
|
if (!winhttp.CrackUrl(url,
|
|
0,
|
|
scheme,
|
|
sizeof(scheme)/sizeof(scheme[0]),
|
|
host,
|
|
sizeof(host)/sizeof(host[0]),
|
|
path,
|
|
sizeof(path)/sizeof(path[0]),
|
|
&port)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (_wcsicmp(scheme, L"https") == 0) {
|
|
// Winhttp under WINE doesn't support wildcard certificates, so avoid
|
|
// to use it if the scheme is https. The caller should fall back to
|
|
// use wininet if NULL is returned.
|
|
return NULL;
|
|
}
|
|
|
|
return new internal::WinHttpClient();
|
|
}
|
|
|
|
} // namespace crash
|