extensions/common/update_manifest.cc

   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 "extensions/common/update_manifest.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 static const char* kExpectedGupdateProtocol = "2.0";
  19 static const char* kExpectedGupdateXmlns =
  20     "http://www.google.com/update2/response";
  21
  22 UpdateManifest::Result::Result()
  23     : size(0),
  24       diff_size(0) {}
  25
  26 UpdateManifest::Result::~Result() {}
  27
  28 UpdateManifest::Results::Results() : daystart_elapsed_seconds(kNoDaystart) {}
  29
  30 UpdateManifest::Results::~Results() {}
  31
  32 UpdateManifest::UpdateManifest() {
  33 }
  34
  35 UpdateManifest::~UpdateManifest() {}
  36
  37 void UpdateManifest::ParseError(const char* details, ...) {
  38   va_list args;
  39   va_start(args, details);
  40
  41   if (errors_.length() > 0) {
  42     // TODO(asargent) make a platform abstracted newline?
  43     errors_ += "\r\n";
  44   }
  45   base::StringAppendV(&errors_, details, args);
  46   va_end(args);
  47 }
  48
  49 // Checks whether a given node's name matches |expected_name| and
  50 // |expected_namespace|.
  51 static bool TagNameEquals(const xmlNode* node, const char* expected_name,
  52                           const xmlNs* expected_namespace) {
  53   if (node->ns != expected_namespace) {
  54     return false;
  55   }
  56   return 0 == strcmp(expected_name, reinterpret_cast<const char*>(node->name));
  57 }
  58
  59 // Returns child nodes of |root| with name |name| in namespace |xml_namespace|.
  60 static std::vector<xmlNode*> GetChildren(xmlNode* root, xmlNs* xml_namespace,
  61                                          const char* name) {
  62   std::vector<xmlNode*> result;
  63   for (xmlNode* child = root->children; child != NULL; child = child->next) {
  64     if (!TagNameEquals(child, name, xml_namespace)) {
  65       continue;
  66     }
  67     result.push_back(child);
  68   }
  69   return result;
  70 }
  71
  72 // Returns the value of a named attribute, or the empty string.
  73 static std::string GetAttribute(xmlNode* node, const char* attribute_name) {
  74   const xmlChar* name = reinterpret_cast<const xmlChar*>(attribute_name);
  75   for (xmlAttr* attr = node->properties; attr != NULL; attr = attr->next) {
  76     if (!xmlStrcmp(attr->name, name) && attr->children &&
  77         attr->children->content) {
  78       return std::string(reinterpret_cast<const char*>(
  79           attr->children->content));
  80     }
  81   }
  82   return std::string();
  83 }
  84
  85 // This is used for the xml parser to report errors. This assumes the context
  86 // is a pointer to a std::string where the error message should be appended.
  87 static void XmlErrorFunc(void *context, const char *message, ...) {
  88   va_list args;
  89   va_start(args, message);
  90   std::string* error = static_cast<std::string*>(context);
  91   base::StringAppendV(error, message, args);
  92   va_end(args);
  93 }
  94
  95 // Utility class for cleaning up the xml document when leaving a scope.
  96 class ScopedXmlDocument {
  97  public:
  98   explicit ScopedXmlDocument(xmlDocPtr document) : document_(document) {}
  99   ~ScopedXmlDocument() {
 100     if (document_)
 101       xmlFreeDoc(document_);
 102   }
 103
 104   xmlDocPtr get() {
 105     return document_;
 106   }
 107
 108  private:
 109   xmlDocPtr document_;
 110 };
 111
 112 // Returns a pointer to the xmlNs on |node| with the |expected_href|, or
 113 // NULL if there isn't one with that href.
 114 static xmlNs* GetNamespace(xmlNode* node, const char* expected_href) {
 115   const xmlChar* href = reinterpret_cast<const xmlChar*>(expected_href);
 116   for (xmlNs* ns = node->ns; ns != NULL; ns = ns->next) {
 117     if (ns->href && !xmlStrcmp(ns->href, href)) {
 118       return ns;
 119     }
 120   }
 121   return NULL;
 122 }
 123
 124
 125 // Helper function that reads in values for a single <app> tag. It returns a
 126 // boolean indicating success or failure. On failure, it writes a error message
 127 // into |error_detail|.
 128 static bool ParseSingleAppTag(xmlNode* app_node, xmlNs* xml_namespace,
 129                               UpdateManifest::Result* result,
 130                               std::string *error_detail) {
 131   // Read the extension id.
 132   result->extension_id = GetAttribute(app_node, "appid");
 133   if (result->extension_id.length() == 0) {
 134     *error_detail = "Missing appid on app node";
 135     return false;
 136   }
 137
 138   // Get the updatecheck node.
 139   std::vector<xmlNode*> updates = GetChildren(app_node, xml_namespace,
 140                                               "updatecheck");
 141   if (updates.size() > 1) {
 142     *error_detail = "Too many updatecheck tags on app (expecting only 1).";
 143     return false;
 144   }
 145   if (updates.empty()) {
 146     *error_detail = "Missing updatecheck on app.";
 147     return false;
 148   }
 149   xmlNode *updatecheck = updates[0];
 150
 151   if (GetAttribute(updatecheck, "status") == "noupdate") {
 152     return true;
 153   }
 154
 155   // Find the url to the crx file.
 156   result->crx_url = GURL(GetAttribute(updatecheck, "codebase"));
 157   if (!result->crx_url.is_valid()) {
 158     *error_detail = "Invalid codebase url: '";
 159     *error_detail += result->crx_url.possibly_invalid_spec();
 160     *error_detail += "'.";
 161     return false;
 162   }
 163
 164   // Get the version.
 165   result->version = GetAttribute(updatecheck, "version");
 166   if (result->version.length() == 0) {
 167     *error_detail = "Missing version for updatecheck.";
 168     return false;
 169   }
 170   Version version(result->version);
 171   if (!version.IsValid()) {
 172     *error_detail = "Invalid version: '";
 173     *error_detail += result->version;
 174     *error_detail += "'.";
 175     return false;
 176   }
 177
 178   // Get the minimum browser version (not required).
 179   result->browser_min_version = GetAttribute(updatecheck, "prodversionmin");
 180   if (result->browser_min_version.length()) {
 181     Version browser_min_version(result->browser_min_version);
 182     if (!browser_min_version.IsValid()) {
 183       *error_detail = "Invalid prodversionmin: '";
 184       *error_detail += result->browser_min_version;
 185       *error_detail += "'.";
 186       return false;
 187     }
 188   }
 189
 190   // package_hash is optional. It is only required for blacklist. It is a
 191   // sha256 hash of the package in hex format.
 192   result->package_hash = GetAttribute(updatecheck, "hash");
 193
 194   int size = 0;
 195   if (base::StringToInt(GetAttribute(updatecheck, "size"), &size)) {
 196     result->size = size;
 197   }
 198
 199   // package_fingerprint is optional. It identifies the package, preferably
 200   // with a modified sha256 hash of the package in hex format.
 201   result->package_fingerprint = GetAttribute(updatecheck, "fp");
 202
 203   // Differential update information is optional.
 204   result->diff_crx_url = GURL(GetAttribute(updatecheck, "codebasediff"));
 205   result->diff_package_hash = GetAttribute(updatecheck, "hashdiff");
 206   int sizediff = 0;
 207   if (base::StringToInt(GetAttribute(updatecheck, "sizediff"), &sizediff)) {
 208     result->diff_size = sizediff;
 209   }
 210
 211   return true;
 212 }
 213
 214
 215 bool UpdateManifest::Parse(const std::string& manifest_xml) {
 216   results_.list.resize(0);
 217   results_.daystart_elapsed_seconds = kNoDaystart;
 218   errors_ = "";
 219
 220   if (manifest_xml.length() < 1) {
 221      ParseError("Empty xml");
 222     return false;
 223   }
 224
 225   std::string xml_errors;
 226   ScopedXmlErrorFunc error_func(&xml_errors, &XmlErrorFunc);
 227
 228   // Start up the xml parser with the manifest_xml contents.
 229   ScopedXmlDocument document(xmlParseDoc(
 230       reinterpret_cast<const xmlChar*>(manifest_xml.c_str())));
 231   if (!document.get()) {
 232     ParseError("%s", xml_errors.c_str());
 233     return false;
 234   }
 235
 236   xmlNode *root = xmlDocGetRootElement(document.get());
 237   if (!root) {
 238     ParseError("Missing root node");
 239     return false;
 240   }
 241
 242   // Look for the required namespace declaration.
 243   xmlNs* gupdate_ns = GetNamespace(root, kExpectedGupdateXmlns);
 244   if (!gupdate_ns) {
 245     ParseError("Missing or incorrect xmlns on gupdate tag");
 246     return false;
 247   }
 248
 249   if (!TagNameEquals(root, "gupdate", gupdate_ns)) {
 250     ParseError("Missing gupdate tag");
 251     return false;
 252   }
 253
 254   // Check for the gupdate "protocol" attribute.
 255   if (GetAttribute(root, "protocol") != kExpectedGupdateProtocol) {
 256     ParseError("Missing/incorrect protocol on gupdate tag "
 257         "(expected '%s')", kExpectedGupdateProtocol);
 258     return false;
 259   }
 260
 261   // Parse the first <daystart> if it's present.
 262   std::vector<xmlNode*> daystarts = GetChildren(root, gupdate_ns, "daystart");
 263   if (!daystarts.empty()) {
 264     xmlNode* first = daystarts[0];
 265     std::string elapsed_seconds = GetAttribute(first, "elapsed_seconds");
 266     int parsed_elapsed = kNoDaystart;
 267     if (base::StringToInt(elapsed_seconds, &parsed_elapsed)) {
 268       results_.daystart_elapsed_seconds = parsed_elapsed;
 269     }
 270   }
 271
 272   // Parse each of the <app> tags.
 273   std::vector<xmlNode*> apps = GetChildren(root, gupdate_ns, "app");
 274   for (unsigned int i = 0; i < apps.size(); i++) {
 275     Result current;
 276     std::string error;
 277     if (!ParseSingleAppTag(apps[i], gupdate_ns, &current, &error)) {
 278       ParseError("%s", error.c_str());
 279     } else {
 280       results_.list.push_back(current);
 281     }
 282   }
 283
 284   return true;
 285 }