src/common/windows/http_upload.cc - breakpad - Git at Google

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // 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 Inc. 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 <assert.h>

 // Disable exception handler warnings.
 #pragma warning(disable:4530)

 #include <fstream>
 #include <vector>

 #include "common/windows/string_utils-inl.h"

 #include "common/windows/http_upload.h"

 namespace {
   using std::string;
   using std::wstring;
   using std::map;
   using std::vector;
   using std::ifstream;
   using std::ios;

   const wchar_t kUserAgent[] = L"Breakpad/1.0 (Windows)";

   // Helper class which closes an internet handle when it goes away
   class AutoInternetHandle {
   public:
     explicit AutoInternetHandle(HINTERNET handle) : handle_(handle) {}
     ~AutoInternetHandle() {
       if (handle_) {
         InternetCloseHandle(handle_);
       }
     }

     HINTERNET get() { return handle_; }

   private:
     HINTERNET handle_;
   };

   bool GetFileContents(const wstring &filename, vector<char> *contents) {
     bool rv = false;
     // The "open" method on pre-MSVC8 ifstream implementations doesn't accept a
     // wchar_t* filename, so use _wfopen directly in that case.  For VC8 and
     // later, _wfopen has been deprecated in favor of _wfopen_s, which does
     // not exist in earlier versions, so let the ifstream open the file itself.
     // GCC doesn't support wide file name and opening on FILE* requires ugly
     // hacks, so fallback to multi byte file.
 #ifdef _MSC_VER
     ifstream file;
     file.open(filename.c_str(), ios::binary);
 #else // GCC
     ifstream file(WideToMBCP(filename, CP_ACP).c_str(), ios::binary);
 #endif  // _MSC_VER >= 1400
     if (file.is_open()) {
       file.seekg(0, ios::end);
       std::streamoff length = file.tellg();
       // Check for loss of data when converting lenght from std::streamoff into
       // std::vector<char>::size_type
       std::vector<char>::size_type vector_size =
         static_cast<std::vector<char>::size_type>(length);
       if (static_cast<std::streamoff>(vector_size) == length) {
         contents->resize(vector_size);
         if (length != 0) {
           file.seekg(0, ios::beg);
           file.read(&((*contents)[0]), length);
         }
         rv = true;
       }
       file.close();
     }
     return rv;
   }

   wstring UTF8ToWide(const string &utf8) {
     if (utf8.length() == 0) {
       return wstring();
     }

     // compute the length of the buffer we'll need
     int charcount = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, NULL, 0);

     if (charcount == 0) {
       return wstring();
     }

     // convert
     wchar_t* buf = new wchar_t[charcount];
     MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, buf, charcount);
     wstring result(buf);
     delete[] buf;
     return result;
   }

   string WideToMBCP(const wstring &wide, unsigned int cp) {
     if (wide.length() == 0) {
       return string();
     }

     // compute the length of the buffer we'll need
     int charcount = WideCharToMultiByte(cp, 0, wide.c_str(), -1,
         NULL, 0, NULL, NULL);
     if (charcount == 0) {
       return string();
     }

     // convert
     char *buf = new char[charcount];
     WideCharToMultiByte(cp, 0, wide.c_str(), -1, buf, charcount,
         NULL, NULL);

     string result(buf);
     delete[] buf;
     return result;
   }

   bool CheckParameters(const map<wstring, wstring> &parameters) {
     for (map<wstring, wstring>::const_iterator pos = parameters.begin();
           pos != parameters.end(); ++pos) {
       const wstring &str = pos->first;
       if (str.size() == 0) {
         return false;  // disallow empty parameter names
       }
       for (unsigned int i = 0; i < str.size(); ++i) {
         wchar_t c = str[i];
         if (c < 32 || c == '"' || c > 127) {
           return false;
         }
       }
     }
     return true;
   }

   // Converts a UTF16 string to UTF8.
   string WideToUTF8(const wstring &wide) {
     return WideToMBCP(wide, CP_UTF8);
   }

   bool ReadResponse(HINTERNET request, wstring *response) {
     bool has_content_length_header = false;
     wchar_t content_length[32];
     DWORD content_length_size = sizeof(content_length);
     DWORD claimed_size = 0;
     string response_body;

     if (HttpQueryInfo(request, HTTP_QUERY_CONTENT_LENGTH,
         static_cast<LPVOID>(&content_length),
         &content_length_size, 0)) {
       has_content_length_header = true;
       claimed_size = wcstol(content_length, NULL, 10);
       response_body.reserve(claimed_size);
     }

     DWORD bytes_available;
     DWORD total_read = 0;
     BOOL return_code;

     while (((return_code = InternetQueryDataAvailable(request, &bytes_available,
         0, 0)) != 0) && bytes_available > 0) {
       vector<char> response_buffer(bytes_available);
       DWORD size_read;

       return_code = InternetReadFile(request,
           &response_buffer[0],
           bytes_available, &size_read);

       if (return_code && size_read > 0) {
         total_read += size_read;
         response_body.append(&response_buffer[0], size_read);
       }
       else {
         break;
       }
     }

     bool succeeded = return_code && (!has_content_length_header ||
         (total_read == claimed_size));
     if (succeeded && response) {
       *response = UTF8ToWide(response_body);
     }

     return succeeded;
   }

   bool SendRequestInner(
       const wstring& url,
       const wstring& http_method,
       const wstring& content_type_header,
       const string& request_body,
       int* timeout_ms,
       wstring* response_body,
       int* response_code) {
     if (response_code) {
       *response_code = 0;
     }

     // Break up the URL and make sure we can handle it
     wchar_t scheme[16], host[256], path[1024];
     URL_COMPONENTS components;
     memset(&components, 0, sizeof(components));
     components.dwStructSize = sizeof(components);
     components.lpszScheme = scheme;
     components.dwSchemeLength = sizeof(scheme) / sizeof(scheme[0]);
     components.lpszHostName = host;
     components.dwHostNameLength = sizeof(host) / sizeof(host[0]);
     components.lpszUrlPath = path;
     components.dwUrlPathLength = sizeof(path) / sizeof(path[0]);
     if (!InternetCrackUrl(url.c_str(), static_cast<DWORD>(url.size()),
         0, &components)) {
       DWORD err = GetLastError();
       wprintf(L"%d\n", err);
       return false;
     }
     bool secure = false;
     if (wcscmp(scheme, L"https") == 0) {
       secure = true;
     }
     else if (wcscmp(scheme, L"http") != 0) {
       return false;
     }

     AutoInternetHandle internet(InternetOpen(kUserAgent,
         INTERNET_OPEN_TYPE_PRECONFIG,
         NULL,  // proxy name
         NULL,  // proxy bypass
         0));   // flags
     if (!internet.get()) {
       return false;
     }

     AutoInternetHandle connection(InternetConnect(internet.get(),
         host,
         components.nPort,
         NULL,    // user name
         NULL,    // password
         INTERNET_SERVICE_HTTP,
         0,       // flags
         NULL));  // context
     if (!connection.get()) {
       return false;
     }

     DWORD http_open_flags = secure ? INTERNET_FLAG_SECURE : 0;
     http_open_flags |= INTERNET_FLAG_NO_COOKIES;
     AutoInternetHandle request(HttpOpenRequest(connection.get(),
         http_method.c_str(),
         path,
         NULL,    // version
         NULL,    // referer
         NULL,    // agent type
         http_open_flags,
         NULL));  // context
     if (!request.get()) {
       return false;
     }

     if (!content_type_header.empty()) {
       HttpAddRequestHeaders(request.get(),
           content_type_header.c_str(),
           static_cast<DWORD>(-1),
           HTTP_ADDREQ_FLAG_ADD);
     }

     if (timeout_ms) {
       if (!InternetSetOption(request.get(),
           INTERNET_OPTION_SEND_TIMEOUT,
           timeout_ms,
           sizeof(*timeout_ms))) {
         fwprintf(stderr, L"Could not unset send timeout, continuing...\n");
       }

       if (!InternetSetOption(request.get(),
           INTERNET_OPTION_RECEIVE_TIMEOUT,
           timeout_ms,
           sizeof(*timeout_ms))) {
         fwprintf(stderr, L"Could not unset receive timeout, continuing...\n");
       }
     }

     if (!HttpSendRequest(request.get(), NULL, 0,
         const_cast<char *>(request_body.data()),
         static_cast<DWORD>(request_body.size()))) {
       return false;
     }

     // The server indicates a successful upload with HTTP status 200.
     wchar_t http_status[4];
     DWORD http_status_size = sizeof(http_status);
     if (!HttpQueryInfo(request.get(), HTTP_QUERY_STATUS_CODE,
         static_cast<LPVOID>(&http_status), &http_status_size,
         0)) {
       return false;
     }

     int http_response = wcstol(http_status, NULL, 10);
     if (response_code) {
       *response_code = http_response;
     }

     bool result = (http_response == 200);

     if (result) {
       result = ReadResponse(request.get(), response_body);
     }

     return result;
   }

   wstring GenerateMultipartBoundary() {
     // The boundary has 27 '-' characters followed by 16 hex digits
     static const wchar_t kBoundaryPrefix[] = L"---------------------------";
     static const int kBoundaryLength = 27 + 16 + 1;

     // Generate some random numbers to fill out the boundary
     int r0 = rand();
     int r1 = rand();

     wchar_t temp[kBoundaryLength];
     swprintf(temp, kBoundaryLength, L"%s%08X%08X", kBoundaryPrefix, r0, r1);

     // remove when VC++7.1 is no longer supported
     temp[kBoundaryLength - 1] = L'\0';

     return wstring(temp);
   }

   wstring GenerateMultipartPostRequestHeader(const wstring &boundary) {
     wstring header = L"Content-Type: multipart/form-data; boundary=";
     header += boundary;
     return header;
   }

   bool AppendFileToRequestBody(
       const wstring& file_part_name,
       const wstring& filename,
       string* request_body) {
     string file_part_name_utf8 = WideToUTF8(file_part_name);
     if (file_part_name_utf8.empty()) {
       return false;
     }

     string filename_utf8 = WideToUTF8(filename);
     if (filename_utf8.empty()) {
       return false;
     }

     request_body->append("Content-Disposition: form-data; "
         "name=\"" + file_part_name_utf8 + "\"; "
         "filename=\"" + filename_utf8 + "\"\r\n");
     request_body->append("Content-Type: application/octet-stream\r\n");
     request_body->append("\r\n");

     vector<char> contents;
     if (!GetFileContents(filename, &contents)) {
       return false;
     }

     if (!contents.empty()) {
       request_body->append(&(contents[0]), contents.size());
     }
     request_body->append("\r\n");

     return true;
   }

   bool GenerateRequestBody(const map<wstring, wstring> &parameters,
       const map<wstring, wstring> &files,
       const wstring &boundary,
       string *request_body) {
     string boundary_str = WideToUTF8(boundary);
     if (boundary_str.empty()) {
       return false;
     }

     request_body->clear();

     // Append each of the parameter pairs as a form-data part
     for (map<wstring, wstring>::const_iterator pos = parameters.begin();
         pos != parameters.end(); ++pos) {
       request_body->append("--" + boundary_str + "\r\n");
       request_body->append("Content-Disposition: form-data; name=\"" +
           WideToUTF8(pos->first) + "\"\r\n\r\n" +
           WideToUTF8(pos->second) + "\r\n");
     }

     // Now append each upload file as a binary (octet-stream) part
     for (map<wstring, wstring>::const_iterator pos = files.begin();
         pos != files.end(); ++pos) {
       request_body->append("--" + boundary_str + "\r\n");

       if (!AppendFileToRequestBody(pos->first, pos->second, request_body)) {
         return false;
       }
     }
     request_body->append("--" + boundary_str + "--\r\n");
     return true;
   }
 }

 namespace google_breakpad {
   bool HTTPUpload::SendPutRequest(
       const wstring& url,
       const wstring& path,
       int* timeout_ms,
       wstring* response_body,
       int* response_code) {
     string request_body;
     if (!AppendFileToRequestBody(L"symbol_file", path, &request_body)) {
       return false;
     }

     return SendRequestInner(
         url,
         L"PUT",
         L"",
         request_body,
         timeout_ms,
         response_body,
         response_code);
   }

   bool HTTPUpload::SendGetRequest(
       const wstring& url,
       int* timeout_ms,
       wstring* response_body,
       int* response_code) {
     return SendRequestInner(
         url,
         L"GET",
         L"",
         "",
         timeout_ms,
         response_body,
         response_code);
   }

   bool HTTPUpload::SendMultipartPostRequest(
       const wstring& url,
       const map<wstring, wstring>& parameters,
       const map<wstring, wstring>& files,
       int* timeout_ms,
       wstring* response_body,
       int* response_code) {
     // TODO(bryner): support non-ASCII parameter names
     if (!CheckParameters(parameters)) {
       return false;
     }

     wstring boundary = GenerateMultipartBoundary();
     wstring content_type_header = GenerateMultipartPostRequestHeader(boundary);

     string request_body;
     if (!GenerateRequestBody(parameters, files, boundary, &request_body)) {
       return false;
     }

     return SendRequestInner(
         url,
         L"POST",
         content_type_header,
         request_body,
         timeout_ms,
         response_body,
         response_code);
   }

   bool HTTPUpload::SendSimplePostRequest(
       const wstring& url,
       const wstring& body,
       const wstring& content_type,
       int *timeout_ms,
       wstring *response_body,
       int *response_code) {
     return SendRequestInner(
         url,
         L"POST",
         content_type,
         WideToUTF8(body),
         timeout_ms,
         response_body,
         response_code);
   }
 }  // namespace google_breakpad
	// Copyright (c) 2006, Google Inc.
	// All rights reserved.
	//
	// 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 Inc. 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 <assert.h>

	// Disable exception handler warnings.
	#pragma warning(disable:4530)

	#include <fstream>
	#include <vector>

	#include "common/windows/string_utils-inl.h"

	#include "common/windows/http_upload.h"

	namespace {
	using std::string;
	using std::wstring;
	using std::map;
	using std::vector;
	using std::ifstream;
	using std::ios;

	const wchar_t kUserAgent[] = L"Breakpad/1.0 (Windows)";

	// Helper class which closes an internet handle when it goes away
	class AutoInternetHandle {
	public:
	explicit AutoInternetHandle(HINTERNET handle) : handle_(handle) {}
	~AutoInternetHandle() {
	if (handle_) {
	InternetCloseHandle(handle_);
	}
	}

	HINTERNET get() { return handle_; }

	private:
	HINTERNET handle_;
	};

	bool GetFileContents(const wstring &filename, vector<char> *contents) {
	bool rv = false;
	// The "open" method on pre-MSVC8 ifstream implementations doesn't accept a
	// wchar_t* filename, so use _wfopen directly in that case. For VC8 and
	// later, _wfopen has been deprecated in favor of _wfopen_s, which does
	// not exist in earlier versions, so let the ifstream open the file itself.
	// GCC doesn't support wide file name and opening on FILE* requires ugly
	// hacks, so fallback to multi byte file.
	#ifdef _MSC_VER
	ifstream file;
	file.open(filename.c_str(), ios::binary);
	#else // GCC
	ifstream file(WideToMBCP(filename, CP_ACP).c_str(), ios::binary);
	#endif // _MSC_VER >= 1400
	if (file.is_open()) {
	file.seekg(0, ios::end);
	std::streamoff length = file.tellg();
	// Check for loss of data when converting lenght from std::streamoff into
	// std::vector<char>::size_type
	std::vector<char>::size_type vector_size =
	static_cast<std::vector<char>::size_type>(length);
	if (static_cast<std::streamoff>(vector_size) == length) {
	contents->resize(vector_size);
	if (length != 0) {
	file.seekg(0, ios::beg);
	file.read(&((*contents)[0]), length);
	}
	rv = true;
	}
	file.close();
	}
	return rv;
	}

	wstring UTF8ToWide(const string &utf8) {
	if (utf8.length() == 0) {
	return wstring();
	}

	// compute the length of the buffer we'll need
	int charcount = MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, NULL, 0);

	if (charcount == 0) {
	return wstring();
	}

	// convert
	wchar_t* buf = new wchar_t[charcount];
	MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), -1, buf, charcount);
	wstring result(buf);
	delete[] buf;
	return result;
	}

	string WideToMBCP(const wstring &wide, unsigned int cp) {
	if (wide.length() == 0) {
	return string();
	}

	// compute the length of the buffer we'll need
	int charcount = WideCharToMultiByte(cp, 0, wide.c_str(), -1,
	NULL, 0, NULL, NULL);
	if (charcount == 0) {
	return string();
	}

	// convert
	char *buf = new char[charcount];
	WideCharToMultiByte(cp, 0, wide.c_str(), -1, buf, charcount,
	NULL, NULL);

	string result(buf);
	delete[] buf;
	return result;
	}

	bool CheckParameters(const map<wstring, wstring> &parameters) {
	for (map<wstring, wstring>::const_iterator pos = parameters.begin();
	pos != parameters.end(); ++pos) {
	const wstring &str = pos->first;
	if (str.size() == 0) {
	return false; // disallow empty parameter names
	}
	for (unsigned int i = 0; i < str.size(); ++i) {
	wchar_t c = str[i];
	if (c < 32 \|\| c == '"' \|\| c > 127) {
	return false;
	}
	}
	}
	return true;
	}

	// Converts a UTF16 string to UTF8.
	string WideToUTF8(const wstring &wide) {
	return WideToMBCP(wide, CP_UTF8);
	}

	bool ReadResponse(HINTERNET request, wstring *response) {
	bool has_content_length_header = false;
	wchar_t content_length[32];
	DWORD content_length_size = sizeof(content_length);
	DWORD claimed_size = 0;
	string response_body;

	if (HttpQueryInfo(request, HTTP_QUERY_CONTENT_LENGTH,
	static_cast<LPVOID>(&content_length),
	&content_length_size, 0)) {
	has_content_length_header = true;
	claimed_size = wcstol(content_length, NULL, 10);
	response_body.reserve(claimed_size);
	}

	DWORD bytes_available;
	DWORD total_read = 0;
	BOOL return_code;

	while (((return_code = InternetQueryDataAvailable(request, &bytes_available,
	0, 0)) != 0) && bytes_available > 0) {
	vector<char> response_buffer(bytes_available);
	DWORD size_read;

	return_code = InternetReadFile(request,
	&response_buffer[0],
	bytes_available, &size_read);

	if (return_code && size_read > 0) {
	total_read += size_read;
	response_body.append(&response_buffer[0], size_read);
	}
	else {
	break;
	}
	}

	bool succeeded = return_code && (!has_content_length_header \|\|
	(total_read == claimed_size));
	if (succeeded && response) {
	*response = UTF8ToWide(response_body);
	}

	return succeeded;
	}

	bool SendRequestInner(
	const wstring& url,
	const wstring& http_method,
	const wstring& content_type_header,
	const string& request_body,
	int* timeout_ms,
	wstring* response_body,
	int* response_code) {
	if (response_code) {
	*response_code = 0;
	}

	// Break up the URL and make sure we can handle it
	wchar_t scheme[16], host[256], path[1024];
	URL_COMPONENTS components;
	memset(&components, 0, sizeof(components));
	components.dwStructSize = sizeof(components);
	components.lpszScheme = scheme;
	components.dwSchemeLength = sizeof(scheme) / sizeof(scheme[0]);
	components.lpszHostName = host;
	components.dwHostNameLength = sizeof(host) / sizeof(host[0]);
	components.lpszUrlPath = path;
	components.dwUrlPathLength = sizeof(path) / sizeof(path[0]);
	if (!InternetCrackUrl(url.c_str(), static_cast<DWORD>(url.size()),
	0, &components)) {
	DWORD err = GetLastError();
	wprintf(L"%d\n", err);
	return false;
	}
	bool secure = false;
	if (wcscmp(scheme, L"https") == 0) {
	secure = true;
	}
	else if (wcscmp(scheme, L"http") != 0) {
	return false;
	}

	AutoInternetHandle internet(InternetOpen(kUserAgent,
	INTERNET_OPEN_TYPE_PRECONFIG,
	NULL, // proxy name
	NULL, // proxy bypass
	0)); // flags
	if (!internet.get()) {
	return false;
	}

	AutoInternetHandle connection(InternetConnect(internet.get(),
	host,
	components.nPort,
	NULL, // user name
	NULL, // password
	INTERNET_SERVICE_HTTP,
	0, // flags
	NULL)); // context
	if (!connection.get()) {
	return false;
	}

	DWORD http_open_flags = secure ? INTERNET_FLAG_SECURE : 0;
	http_open_flags \|= INTERNET_FLAG_NO_COOKIES;
	AutoInternetHandle request(HttpOpenRequest(connection.get(),
	http_method.c_str(),
	path,
	NULL, // version
	NULL, // referer
	NULL, // agent type
	http_open_flags,
	NULL)); // context
	if (!request.get()) {
	return false;
	}

	if (!content_type_header.empty()) {
	HttpAddRequestHeaders(request.get(),
	content_type_header.c_str(),
	static_cast<DWORD>(-1),
	HTTP_ADDREQ_FLAG_ADD);
	}

	if (timeout_ms) {
	if (!InternetSetOption(request.get(),
	INTERNET_OPTION_SEND_TIMEOUT,
	timeout_ms,
	sizeof(*timeout_ms))) {
	fwprintf(stderr, L"Could not unset send timeout, continuing...\n");
	}

	if (!InternetSetOption(request.get(),
	INTERNET_OPTION_RECEIVE_TIMEOUT,
	timeout_ms,
	sizeof(*timeout_ms))) {
	fwprintf(stderr, L"Could not unset receive timeout, continuing...\n");
	}
	}

	if (!HttpSendRequest(request.get(), NULL, 0,
	const_cast<char *>(request_body.data()),
	static_cast<DWORD>(request_body.size()))) {
	return false;
	}

	// The server indicates a successful upload with HTTP status 200.
	wchar_t http_status[4];
	DWORD http_status_size = sizeof(http_status);
	if (!HttpQueryInfo(request.get(), HTTP_QUERY_STATUS_CODE,
	static_cast<LPVOID>(&http_status), &http_status_size,
	0)) {
	return false;
	}

	int http_response = wcstol(http_status, NULL, 10);
	if (response_code) {
	*response_code = http_response;
	}

	bool result = (http_response == 200);

	if (result) {
	result = ReadResponse(request.get(), response_body);
	}

	return result;
	}

	wstring GenerateMultipartBoundary() {
	// The boundary has 27 '-' characters followed by 16 hex digits
	static const wchar_t kBoundaryPrefix[] = L"---------------------------";
	static const int kBoundaryLength = 27 + 16 + 1;

	// Generate some random numbers to fill out the boundary
	int r0 = rand();
	int r1 = rand();

	wchar_t temp[kBoundaryLength];
	swprintf(temp, kBoundaryLength, L"%s%08X%08X", kBoundaryPrefix, r0, r1);

	// remove when VC++7.1 is no longer supported
	temp[kBoundaryLength - 1] = L'\0';

	return wstring(temp);
	}

	wstring GenerateMultipartPostRequestHeader(const wstring &boundary) {
	wstring header = L"Content-Type: multipart/form-data; boundary=";
	header += boundary;
	return header;
	}

	bool AppendFileToRequestBody(
	const wstring& file_part_name,
	const wstring& filename,
	string* request_body) {
	string file_part_name_utf8 = WideToUTF8(file_part_name);
	if (file_part_name_utf8.empty()) {
	return false;
	}

	string filename_utf8 = WideToUTF8(filename);
	if (filename_utf8.empty()) {
	return false;
	}

	request_body->append("Content-Disposition: form-data; "
	"name=\"" + file_part_name_utf8 + "\"; "
	"filename=\"" + filename_utf8 + "\"\r\n");
	request_body->append("Content-Type: application/octet-stream\r\n");
	request_body->append("\r\n");

	vector<char> contents;
	if (!GetFileContents(filename, &contents)) {
	return false;
	}

	if (!contents.empty()) {
	request_body->append(&(contents[0]), contents.size());
	}
	request_body->append("\r\n");

	return true;
	}

	bool GenerateRequestBody(const map<wstring, wstring> &parameters,
	const map<wstring, wstring> &files,
	const wstring &boundary,
	string *request_body) {
	string boundary_str = WideToUTF8(boundary);
	if (boundary_str.empty()) {
	return false;
	}

	request_body->clear();

	// Append each of the parameter pairs as a form-data part
	for (map<wstring, wstring>::const_iterator pos = parameters.begin();
	pos != parameters.end(); ++pos) {
	request_body->append("--" + boundary_str + "\r\n");
	request_body->append("Content-Disposition: form-data; name=\"" +
	WideToUTF8(pos->first) + "\"\r\n\r\n" +
	WideToUTF8(pos->second) + "\r\n");
	}

	// Now append each upload file as a binary (octet-stream) part
	for (map<wstring, wstring>::const_iterator pos = files.begin();
	pos != files.end(); ++pos) {
	request_body->append("--" + boundary_str + "\r\n");

	if (!AppendFileToRequestBody(pos->first, pos->second, request_body)) {
	return false;
	}
	}
	request_body->append("--" + boundary_str + "--\r\n");
	return true;
	}
	}

	namespace google_breakpad {
	bool HTTPUpload::SendPutRequest(
	const wstring& url,
	const wstring& path,
	int* timeout_ms,
	wstring* response_body,
	int* response_code) {
	string request_body;
	if (!AppendFileToRequestBody(L"symbol_file", path, &request_body)) {
	return false;
	}

	return SendRequestInner(
	url,
	L"PUT",
	L"",
	request_body,
	timeout_ms,
	response_body,
	response_code);
	}

	bool HTTPUpload::SendGetRequest(
	const wstring& url,
	int* timeout_ms,
	wstring* response_body,
	int* response_code) {
	return SendRequestInner(
	url,
	L"GET",
	L"",
	"",
	timeout_ms,
	response_body,
	response_code);
	}

	bool HTTPUpload::SendMultipartPostRequest(
	const wstring& url,
	const map<wstring, wstring>& parameters,
	const map<wstring, wstring>& files,
	int* timeout_ms,
	wstring* response_body,
	int* response_code) {
	// TODO(bryner): support non-ASCII parameter names
	if (!CheckParameters(parameters)) {
	return false;
	}

	wstring boundary = GenerateMultipartBoundary();
	wstring content_type_header = GenerateMultipartPostRequestHeader(boundary);

	string request_body;
	if (!GenerateRequestBody(parameters, files, boundary, &request_body)) {
	return false;
	}

	return SendRequestInner(
	url,
	L"POST",
	content_type_header,
	request_body,
	timeout_ms,
	response_body,
	response_code);
	}

	bool HTTPUpload::SendSimplePostRequest(
	const wstring& url,
	const wstring& body,
	const wstring& content_type,
	int *timeout_ms,
	wstring *response_body,
	int *response_code) {
	return SendRequestInner(
	url,
	L"POST",
	content_type,
	WideToUTF8(body),
	timeout_ms,
	response_body,
	response_code);
	}
	} // namespace google_breakpad