1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/tools/dump_cache/cache_dumper.h" 6 7 #include "base/file_util.h" 8 #include "base/strings/utf_string_conversions.h" 9 #include "net/base/io_buffer.h" 10 #include "net/base/net_errors.h" 11 #include "net/disk_cache/entry_impl.h" 12 #include "net/http/http_cache.h" 13 #include "net/http/http_response_headers.h" 14 #include "net/http/http_response_info.h" 15 #include "net/tools/dump_cache/url_to_filename_encoder.h" 16 17 CacheDumper::CacheDumper(disk_cache::Backend* cache) 18 : cache_(cache) { 19 } 20 21 int CacheDumper::CreateEntry(const std::string& key, 22 disk_cache::Entry** entry, 23 const net::CompletionCallback& callback) { 24 return cache_->CreateEntry(key, entry, callback); 25 } 26 27 int CacheDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset, 28 net::IOBuffer* buf, int buf_len, 29 const net::CompletionCallback& callback) { 30 return entry->WriteData(index, offset, buf, buf_len, callback, false); 31 } 32 33 void CacheDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used, 34 base::Time last_modified) { 35 if (entry) { 36 static_cast<disk_cache::EntryImpl*>(entry)->SetTimes(last_used, 37 last_modified); 38 entry->Close(); 39 } 40 } 41 42 // A version of CreateDirectory which supports lengthy filenames. 43 // Returns true on success, false on failure. 44 bool SafeCreateDirectory(const base::FilePath& path) { 45 #ifdef WIN32_LARGE_FILENAME_SUPPORT 46 // Due to large paths on windows, it can't simply do a 47 // CreateDirectory("a/b/c"). Instead, create each subdirectory manually. 48 bool rv = false; 49 std::wstring::size_type pos(0); 50 std::wstring backslash(L"\\"); 51 52 // If the path starts with the long file header, skip over that 53 const std::wstring kLargeFilenamePrefix(L"\\\\?\\"); 54 std::wstring header(kLargeFilenamePrefix); 55 if (path.value().find(header) == 0) 56 pos = 4; 57 58 // Create the subdirectories individually 59 while ((pos = path.value().find(backslash, pos)) != std::wstring::npos) { 60 base::FilePath::StringType subdir = path.value().substr(0, pos); 61 CreateDirectoryW(subdir.c_str(), NULL); 62 // we keep going even if directory creation failed. 63 pos++; 64 } 65 // Now create the full path 66 return CreateDirectoryW(path.value().c_str(), NULL) == TRUE; 67 #else 68 return file_util::CreateDirectory(path); 69 #endif 70 } 71 72 DiskDumper::DiskDumper(const base::FilePath& path) 73 : path_(path), entry_(NULL) { 74 file_util::CreateDirectory(path); 75 } 76 77 int DiskDumper::CreateEntry(const std::string& key, 78 disk_cache::Entry** entry, 79 const net::CompletionCallback& callback) { 80 // The URL may not start with a valid protocol; search for it. 81 int urlpos = key.find("http"); 82 std::string url = urlpos > 0 ? key.substr(urlpos) : key; 83 std::string base_path = path_.MaybeAsASCII(); 84 std::string new_path = 85 net::UrlToFilenameEncoder::Encode(url, base_path, false); 86 entry_path_ = base::FilePath::FromUTF8Unsafe(new_path); 87 88 #ifdef WIN32_LARGE_FILENAME_SUPPORT 89 // In order for long filenames to work, we'll need to prepend 90 // the windows magic token. 91 const std::wstring kLongFilenamePrefix(L"\\\\?\\"); 92 // There is no way to prepend to a filename. We simply *have* 93 // to convert to a wstring to do this. 94 std::wstring name = kLongFilenamePrefix; 95 name.append(entry_path_.value()); 96 entry_path_ = base::FilePath(name); 97 #endif 98 99 entry_url_ = key; 100 101 SafeCreateDirectory(entry_path_.DirName()); 102 103 base::FilePath::StringType file = entry_path_.value(); 104 #ifdef WIN32_LARGE_FILENAME_SUPPORT 105 entry_ = CreateFileW(file.c_str(), GENERIC_WRITE|GENERIC_READ, 0, 0, 106 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); 107 if (entry_ == INVALID_HANDLE_VALUE) 108 wprintf(L"CreateFileW (%s) failed: %d\n", file.c_str(), GetLastError()); 109 return (entry_ != INVALID_HANDLE_VALUE) ? net::OK : net::ERR_FAILED; 110 #else 111 entry_ = file_util::OpenFile(entry_path_, "w+"); 112 return (entry_ != NULL) ? net::OK : net::ERR_FAILED; 113 #endif 114 } 115 116 // Utility Function to create a normalized header string from a 117 // HttpResponseInfo. The output will be formatted exactly 118 // like so: 119 // HTTP/<version> <status_code> <status_text>\n 120 // [<header-name>: <header-values>\n]* 121 // meaning, each line is \n-terminated, and there is no extra whitespace 122 // beyond the single space separators shown (of course, values can contain 123 // whitespace within them). If a given header-name appears more than once 124 // in the set of headers, they are combined into a single line like so: 125 // <header-name>: <header-value1>, <header-value2>, ...<header-valueN>\n 126 // 127 // DANGER: For some headers (e.g., "Set-Cookie"), the normalized form can be 128 // a lossy format. This is due to the fact that some servers generate 129 // Set-Cookie headers that contain unquoted commas (usually as part of the 130 // value of an "expires" attribute). So, use this function with caution. Do 131 // not expect to be able to re-parse Set-Cookie headers from this output. 132 // 133 // NOTE: Do not make any assumptions about the encoding of this output 134 // string. It may be non-ASCII, and the encoding used by the server is not 135 // necessarily known to us. Do not assume that this output is UTF-8! 136 void GetNormalizedHeaders(const net::HttpResponseInfo& info, 137 std::string* output) { 138 // Start with the status line 139 output->assign(info.headers->GetStatusLine()); 140 output->append("\r\n"); 141 142 // Enumerate the headers 143 void* iter = 0; 144 std::string name, value; 145 while (info.headers->EnumerateHeaderLines(&iter, &name, &value)) { 146 output->append(name); 147 output->append(": "); 148 output->append(value); 149 output->append("\r\n"); 150 } 151 152 // Mark the end of headers 153 output->append("\r\n"); 154 } 155 156 int DiskDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset, 157 net::IOBuffer* buf, int buf_len, 158 const net::CompletionCallback& callback) { 159 if (!entry_) 160 return 0; 161 162 std::string headers; 163 const char *data; 164 size_t len; 165 if (index == 0) { // Stream 0 is the headers. 166 net::HttpResponseInfo response_info; 167 bool truncated; 168 if (!net::HttpCache::ParseResponseInfo(buf->data(), buf_len, 169 &response_info, &truncated)) 170 return 0; 171 172 // Skip this entry if it was truncated (results in an empty file). 173 if (truncated) 174 return buf_len; 175 176 // Remove the size headers. 177 response_info.headers->RemoveHeader("transfer-encoding"); 178 response_info.headers->RemoveHeader("content-length"); 179 response_info.headers->RemoveHeader("x-original-url"); 180 181 // Convert the headers into a string ending with LF. 182 GetNormalizedHeaders(response_info, &headers); 183 184 // Append a header for the original URL. 185 std::string url = entry_url_; 186 // strip off the "XXGET" which may be in the key. 187 std::string::size_type pos(0); 188 if ((pos = url.find("http")) != 0) { 189 if (pos != std::string::npos) 190 url = url.substr(pos); 191 } 192 std::string x_original_url = "X-Original-Url: " + url + "\r\n"; 193 // we know that the last two bytes are CRLF. 194 headers.replace(headers.length() - 2, 0, x_original_url); 195 196 data = headers.c_str(); 197 len = headers.size(); 198 } else if (index == 1) { 199 data = buf->data(); 200 len = buf_len; 201 } else { 202 return 0; 203 } 204 205 #ifdef WIN32_LARGE_FILENAME_SUPPORT 206 DWORD bytes; 207 if (!WriteFile(entry_, data, len, &bytes, 0)) 208 return 0; 209 210 return bytes; 211 #else 212 return fwrite(data, 1, len, entry_); 213 #endif 214 } 215 216 void DiskDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used, 217 base::Time last_modified) { 218 #ifdef WIN32_LARGE_FILENAME_SUPPORT 219 CloseHandle(entry_); 220 #else 221 file_util::CloseFile(entry_); 222 #endif 223 } 224
