1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Functions for canonicalizing "file:" URLs.
#include "url/url_canon.h"
#include "url/url_canon_internal.h"
#include "url/url_file.h"
#include "url/url_parse_internal.h"
namespace url_canon {
namespace {
#ifdef WIN32
// Given a pointer into the spec, this copies and canonicalizes the drive
// letter and colon to the output, if one is found. If there is not a drive
// spec, it won't do anything. The index of the next character in the input
// spec is returned (after the colon when a drive spec is found, the begin
// offset if one is not).
template<typename CHAR>
int FileDoDriveSpec(const CHAR* spec, int begin, int end,
CanonOutput* output) {
// The path could be one of several things: /foo/bar, c:/foo/bar, /c:/foo,
// (with backslashes instead of slashes as well).
int num_slashes = url_parse::CountConsecutiveSlashes(spec, begin, end);
int after_slashes = begin + num_slashes;
if (!url_parse::DoesBeginWindowsDriveSpec(spec, after_slashes, end))
return begin; // Haven't consumed any characters
// A drive spec is the start of a path, so we need to add a slash for the
// authority terminator (typically the third slash).
output->push_back('/');
// DoesBeginWindowsDriveSpec will ensure that the drive letter is valid
// and that it is followed by a colon/pipe.
// Normalize Windows drive letters to uppercase
if (spec[after_slashes] >= 'a' && spec[after_slashes] <= 'z')
output->push_back(spec[after_slashes] - 'a' + 'A');
else
output->push_back(static_cast<char>(spec[after_slashes]));
// Normalize the character following it to a colon rather than pipe.
output->push_back(':');
return after_slashes + 2;
}
#endif // WIN32
template<typename CHAR, typename UCHAR>
bool DoFileCanonicalizePath(const CHAR* spec,
const url_parse::Component& path,
CanonOutput* output,
url_parse::Component* out_path) {
// Copies and normalizes the "c:" at the beginning, if present.
out_path->begin = output->length();
int after_drive;
#ifdef WIN32
after_drive = FileDoDriveSpec(spec, path.begin, path.end(), output);
#else
after_drive = path.begin;
#endif
// Copies the rest of the path, starting from the slash following the
// drive colon (if any, Windows only), or the first slash of the path.
bool success = true;
if (after_drive < path.end()) {
// Use the regular path canonicalizer to canonicalize the rest of the
// path. Give it a fake output component to write into. DoCanonicalizeFile
// will compute the full path component.
url_parse::Component sub_path =
url_parse::MakeRange(after_drive, path.end());
url_parse::Component fake_output_path;
success = CanonicalizePath(spec, sub_path, output, &fake_output_path);
} else {
// No input path, canonicalize to a slash.
output->push_back('/');
}
out_path->len = output->length() - out_path->begin;
return success;
}
template<typename CHAR, typename UCHAR>
bool DoCanonicalizeFileURL(const URLComponentSource<CHAR>& source,
const url_parse::Parsed& parsed,
CharsetConverter* query_converter,
CanonOutput* output,
url_parse::Parsed* new_parsed) {
// Things we don't set in file: URLs.
new_parsed->username = url_parse::Component();
new_parsed->password = url_parse::Component();
new_parsed->port = url_parse::Component();
// Scheme (known, so we don't bother running it through the more
// complicated scheme canonicalizer).
new_parsed->scheme.begin = output->length();
output->Append("file://", 7);
new_parsed->scheme.len = 4;
// Append the host. For many file URLs, this will be empty. For UNC, this
// will be present.
// TODO(brettw) This doesn't do any checking for host name validity. We
// should probably handle validity checking of UNC hosts differently than
// for regular IP hosts.
bool success = CanonicalizeHost(source.host, parsed.host,
output, &new_parsed->host);
success &= DoFileCanonicalizePath<CHAR, UCHAR>(source.path, parsed.path,
output, &new_parsed->path);
CanonicalizeQuery(source.query, parsed.query, query_converter,
output, &new_parsed->query);
// Ignore failure for refs since the URL can probably still be loaded.
CanonicalizeRef(source.ref, parsed.ref, output, &new_parsed->ref);
return success;
}
} // namespace
bool CanonicalizeFileURL(const char* spec,
int spec_len,
const url_parse::Parsed& parsed,
CharsetConverter* query_converter,
CanonOutput* output,
url_parse::Parsed* new_parsed) {
return DoCanonicalizeFileURL<char, unsigned char>(
URLComponentSource<char>(spec), parsed, query_converter,
output, new_parsed);
}
bool CanonicalizeFileURL(const base::char16* spec,
int spec_len,
const url_parse::Parsed& parsed,
CharsetConverter* query_converter,
CanonOutput* output,
url_parse::Parsed* new_parsed) {
return DoCanonicalizeFileURL<base::char16, base::char16>(
URLComponentSource<base::char16>(spec), parsed, query_converter,
output, new_parsed);
}
bool FileCanonicalizePath(const char* spec,
const url_parse::Component& path,
CanonOutput* output,
url_parse::Component* out_path) {
return DoFileCanonicalizePath<char, unsigned char>(spec, path,
output, out_path);
}
bool FileCanonicalizePath(const base::char16* spec,
const url_parse::Component& path,
CanonOutput* output,
url_parse::Component* out_path) {
return DoFileCanonicalizePath<base::char16, base::char16>(spec, path,
output, out_path);
}
bool ReplaceFileURL(const char* base,
const url_parse::Parsed& base_parsed,
const Replacements<char>& replacements,
CharsetConverter* query_converter,
CanonOutput* output,
url_parse::Parsed* new_parsed) {
URLComponentSource<char> source(base);
url_parse::Parsed parsed(base_parsed);
SetupOverrideComponents(base, replacements, &source, &parsed);
return DoCanonicalizeFileURL<char, unsigned char>(
source, parsed, query_converter, output, new_parsed);
}
bool ReplaceFileURL(const char* base,
const url_parse::Parsed& base_parsed,
const Replacements<base::char16>& replacements,
CharsetConverter* query_converter,
CanonOutput* output,
url_parse::Parsed* new_parsed) {
RawCanonOutput<1024> utf8;
URLComponentSource<char> source(base);
url_parse::Parsed parsed(base_parsed);
SetupUTF16OverrideComponents(base, replacements, &utf8, &source, &parsed);
return DoCanonicalizeFileURL<char, unsigned char>(
source, parsed, query_converter, output, new_parsed);
}
} // namespace url_canon
|
