OLD | NEW |
| (Empty) |
1 // Copyright 2014 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 "components/component_updater/update_response.h" | |
6 | |
7 #include <algorithm> | |
8 | |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "base/stl_util.h" | |
11 #include "base/strings/string_number_conversions.h" | |
12 #include "base/strings/string_util.h" | |
13 #include "base/strings/stringprintf.h" | |
14 #include "base/version.h" | |
15 #include "libxml/tree.h" | |
16 #include "third_party/libxml/chromium/libxml_utils.h" | |
17 | |
18 namespace component_updater { | |
19 | |
20 static const char* kExpectedResponseProtocol = "3.0"; | |
21 | |
22 UpdateResponse::UpdateResponse() {} | |
23 UpdateResponse::~UpdateResponse() {} | |
24 | |
25 UpdateResponse::Results::Results() : daystart_elapsed_seconds(kNoDaystart) {} | |
26 UpdateResponse::Results::~Results() {} | |
27 | |
28 UpdateResponse::Result::Result() {} | |
29 | |
30 UpdateResponse::Result::~Result() {} | |
31 | |
32 UpdateResponse::Result::Manifest::Manifest() {} | |
33 UpdateResponse::Result::Manifest::~Manifest() {} | |
34 | |
35 UpdateResponse::Result::Manifest::Package::Package() : size(0), sizediff(0) {} | |
36 UpdateResponse::Result::Manifest::Package::~Package() {} | |
37 | |
38 void UpdateResponse::ParseError(const char* details, ...) { | |
39 va_list args; | |
40 va_start(args, details); | |
41 | |
42 if (!errors_.empty()) { | |
43 errors_ += "\r\n"; | |
44 } | |
45 | |
46 base::StringAppendV(&errors_, details, args); | |
47 va_end(args); | |
48 } | |
49 | |
50 // Checks whether a given node's name matches |expected_name|. | |
51 static bool TagNameEquals(const xmlNode* node, const char* expected_name) { | |
52 return 0 == strcmp(expected_name, reinterpret_cast<const char*>(node->name)); | |
53 } | |
54 | |
55 // Returns child nodes of |root| with name |name|. | |
56 static std::vector<xmlNode*> GetChildren(xmlNode* root, const char* name) { | |
57 std::vector<xmlNode*> result; | |
58 for (xmlNode* child = root->children; child != NULL; child = child->next) { | |
59 if (!TagNameEquals(child, name)) { | |
60 continue; | |
61 } | |
62 result.push_back(child); | |
63 } | |
64 return result; | |
65 } | |
66 | |
67 // Returns the value of a named attribute, or the empty string. | |
68 static std::string GetAttribute(xmlNode* node, const char* attribute_name) { | |
69 const xmlChar* name = reinterpret_cast<const xmlChar*>(attribute_name); | |
70 for (xmlAttr* attr = node->properties; attr != NULL; attr = attr->next) { | |
71 if (!xmlStrcmp(attr->name, name) && attr->children && | |
72 attr->children->content) { | |
73 return std::string( | |
74 reinterpret_cast<const char*>(attr->children->content)); | |
75 } | |
76 } | |
77 return std::string(); | |
78 } | |
79 | |
80 // This is used for the xml parser to report errors. This assumes the context | |
81 // is a pointer to a std::string where the error message should be appended. | |
82 static void XmlErrorFunc(void* context, const char* message, ...) { | |
83 va_list args; | |
84 va_start(args, message); | |
85 std::string* error = static_cast<std::string*>(context); | |
86 base::StringAppendV(error, message, args); | |
87 va_end(args); | |
88 } | |
89 | |
90 // Utility class for cleaning up the xml document when leaving a scope. | |
91 class ScopedXmlDocument { | |
92 public: | |
93 explicit ScopedXmlDocument(xmlDocPtr document) : document_(document) {} | |
94 ~ScopedXmlDocument() { | |
95 if (document_) | |
96 xmlFreeDoc(document_); | |
97 } | |
98 | |
99 xmlDocPtr get() { return document_; } | |
100 | |
101 private: | |
102 xmlDocPtr document_; | |
103 }; | |
104 | |
105 // Parses the <package> tag. | |
106 bool ParsePackageTag(xmlNode* package, | |
107 UpdateResponse::Result* result, | |
108 std::string* error) { | |
109 UpdateResponse::Result::Manifest::Package p; | |
110 p.name = GetAttribute(package, "name"); | |
111 if (p.name.empty()) { | |
112 *error = "Missing name for package."; | |
113 return false; | |
114 } | |
115 | |
116 p.namediff = GetAttribute(package, "namediff"); | |
117 | |
118 // package_fingerprint is optional. It identifies the package, preferably | |
119 // with a modified sha256 hash of the package in hex format. | |
120 p.fingerprint = GetAttribute(package, "fp"); | |
121 | |
122 p.hash_sha256 = GetAttribute(package, "hash_sha256"); | |
123 int size = 0; | |
124 if (base::StringToInt(GetAttribute(package, "size"), &size)) { | |
125 p.size = size; | |
126 } | |
127 | |
128 p.hashdiff_sha256 = GetAttribute(package, "hashdiff_sha256"); | |
129 int sizediff = 0; | |
130 if (base::StringToInt(GetAttribute(package, "sizediff"), &sizediff)) { | |
131 p.sizediff = sizediff; | |
132 } | |
133 | |
134 result->manifest.packages.push_back(p); | |
135 | |
136 return true; | |
137 } | |
138 | |
139 // Parses the <manifest> tag. | |
140 bool ParseManifestTag(xmlNode* manifest, | |
141 UpdateResponse::Result* result, | |
142 std::string* error) { | |
143 // Get the version. | |
144 result->manifest.version = GetAttribute(manifest, "version"); | |
145 if (result->manifest.version.empty()) { | |
146 *error = "Missing version for manifest."; | |
147 return false; | |
148 } | |
149 Version version(result->manifest.version); | |
150 if (!version.IsValid()) { | |
151 *error = "Invalid version: '"; | |
152 *error += result->manifest.version; | |
153 *error += "'."; | |
154 return false; | |
155 } | |
156 | |
157 // Get the minimum browser version (not required). | |
158 result->manifest.browser_min_version = | |
159 GetAttribute(manifest, "prodversionmin"); | |
160 if (result->manifest.browser_min_version.length()) { | |
161 Version browser_min_version(result->manifest.browser_min_version); | |
162 if (!browser_min_version.IsValid()) { | |
163 *error = "Invalid prodversionmin: '"; | |
164 *error += result->manifest.browser_min_version; | |
165 *error += "'."; | |
166 return false; | |
167 } | |
168 } | |
169 | |
170 // Get the <packages> node. | |
171 std::vector<xmlNode*> packages = GetChildren(manifest, "packages"); | |
172 if (packages.empty()) { | |
173 *error = "Missing packages tag on manifest."; | |
174 return false; | |
175 } | |
176 | |
177 // Parse each of the <package> tags. | |
178 std::vector<xmlNode*> package = GetChildren(packages[0], "package"); | |
179 for (size_t i = 0; i != package.size(); ++i) { | |
180 if (!ParsePackageTag(package[i], result, error)) | |
181 return false; | |
182 } | |
183 | |
184 return true; | |
185 } | |
186 | |
187 // Parses the <urls> tag and its children in the <updatecheck>. | |
188 bool ParseUrlsTag(xmlNode* urls, | |
189 UpdateResponse::Result* result, | |
190 std::string* error) { | |
191 // Get the url nodes. | |
192 std::vector<xmlNode*> url = GetChildren(urls, "url"); | |
193 if (url.empty()) { | |
194 *error = "Missing url tags on urls."; | |
195 return false; | |
196 } | |
197 | |
198 // Get the list of urls for full and optionally, for diff updates. | |
199 // There can only be either a codebase or a codebasediff attribute in a tag. | |
200 for (size_t i = 0; i != url.size(); ++i) { | |
201 // Find the url to the crx file. | |
202 const GURL crx_url(GetAttribute(url[i], "codebase")); | |
203 if (crx_url.is_valid()) { | |
204 result->crx_urls.push_back(crx_url); | |
205 continue; | |
206 } | |
207 const GURL crx_diffurl(GetAttribute(url[i], "codebasediff")); | |
208 if (crx_diffurl.is_valid()) { | |
209 result->crx_diffurls.push_back(crx_diffurl); | |
210 continue; | |
211 } | |
212 } | |
213 | |
214 // Expect at least one url for full update. | |
215 if (result->crx_urls.empty()) { | |
216 *error = "Missing valid url for full update."; | |
217 return false; | |
218 } | |
219 | |
220 return true; | |
221 } | |
222 | |
223 // Parses the <updatecheck> tag. | |
224 bool ParseUpdateCheckTag(xmlNode* updatecheck, | |
225 UpdateResponse::Result* result, | |
226 std::string* error) { | |
227 if (GetAttribute(updatecheck, "status") == "noupdate") { | |
228 return true; | |
229 } | |
230 | |
231 // Get the <urls> tag. | |
232 std::vector<xmlNode*> urls = GetChildren(updatecheck, "urls"); | |
233 if (urls.empty()) { | |
234 *error = "Missing urls on updatecheck."; | |
235 return false; | |
236 } | |
237 | |
238 if (!ParseUrlsTag(urls[0], result, error)) { | |
239 return false; | |
240 } | |
241 | |
242 std::vector<xmlNode*> manifests = GetChildren(updatecheck, "manifest"); | |
243 if (urls.empty()) { | |
244 *error = "Missing urls on updatecheck."; | |
245 return false; | |
246 } | |
247 | |
248 return ParseManifestTag(manifests[0], result, error); | |
249 } | |
250 | |
251 // Parses a single <app> tag. | |
252 bool ParseAppTag(xmlNode* app, | |
253 UpdateResponse::Result* result, | |
254 std::string* error) { | |
255 // Read the crx id. | |
256 result->extension_id = GetAttribute(app, "appid"); | |
257 if (result->extension_id.empty()) { | |
258 *error = "Missing appid on app node"; | |
259 return false; | |
260 } | |
261 | |
262 // Get the <updatecheck> tag. | |
263 std::vector<xmlNode*> updates = GetChildren(app, "updatecheck"); | |
264 if (updates.empty()) { | |
265 *error = "Missing updatecheck on app."; | |
266 return false; | |
267 } | |
268 | |
269 return ParseUpdateCheckTag(updates[0], result, error); | |
270 } | |
271 | |
272 bool UpdateResponse::Parse(const std::string& response_xml) { | |
273 results_.daystart_elapsed_seconds = kNoDaystart; | |
274 results_.list.clear(); | |
275 errors_.clear(); | |
276 | |
277 if (response_xml.length() < 1) { | |
278 ParseError("Empty xml"); | |
279 return false; | |
280 } | |
281 | |
282 std::string xml_errors; | |
283 ScopedXmlErrorFunc error_func(&xml_errors, &XmlErrorFunc); | |
284 | |
285 // Start up the xml parser with the manifest_xml contents. | |
286 ScopedXmlDocument document( | |
287 xmlParseDoc(reinterpret_cast<const xmlChar*>(response_xml.c_str()))); | |
288 if (!document.get()) { | |
289 ParseError("%s", xml_errors.c_str()); | |
290 return false; | |
291 } | |
292 | |
293 xmlNode* root = xmlDocGetRootElement(document.get()); | |
294 if (!root) { | |
295 ParseError("Missing root node"); | |
296 return false; | |
297 } | |
298 | |
299 if (!TagNameEquals(root, "response")) { | |
300 ParseError("Missing response tag"); | |
301 return false; | |
302 } | |
303 | |
304 // Check for the response "protocol" attribute. | |
305 if (GetAttribute(root, "protocol") != kExpectedResponseProtocol) { | |
306 ParseError( | |
307 "Missing/incorrect protocol on response tag " | |
308 "(expected '%s')", | |
309 kExpectedResponseProtocol); | |
310 return false; | |
311 } | |
312 | |
313 // Parse the first <daystart> if it is present. | |
314 std::vector<xmlNode*> daystarts = GetChildren(root, "daystart"); | |
315 if (!daystarts.empty()) { | |
316 xmlNode* first = daystarts[0]; | |
317 std::string elapsed_seconds = GetAttribute(first, "elapsed_seconds"); | |
318 int parsed_elapsed = kNoDaystart; | |
319 if (base::StringToInt(elapsed_seconds, &parsed_elapsed)) { | |
320 results_.daystart_elapsed_seconds = parsed_elapsed; | |
321 } | |
322 } | |
323 | |
324 // Parse each of the <app> tags. | |
325 std::vector<xmlNode*> apps = GetChildren(root, "app"); | |
326 for (size_t i = 0; i != apps.size(); ++i) { | |
327 Result result; | |
328 std::string error; | |
329 if (ParseAppTag(apps[i], &result, &error)) { | |
330 results_.list.push_back(result); | |
331 } else { | |
332 ParseError("%s", error.c_str()); | |
333 } | |
334 } | |
335 | |
336 return true; | |
337 } | |
338 | |
339 } // namespace component_updater | |
OLD | NEW |