chrome/common/cloud_print/cloud_print_helpers.cc

   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 "chrome/common/cloud_print/cloud_print_helpers.h"
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/logging.h"
   9 #include "base/md5.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/rand_util.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/sys_info.h"
  14 #include "base/values.h"
  15 #include "chrome/common/chrome_version_info.h"
  16 #include "chrome/common/cloud_print/cloud_print_constants.h"
  17 #include "net/base/mime_util.h"
  18 #include "url/gurl.h"
  19
  20 namespace cloud_print {
  21
  22 namespace {
  23
  24 // Returns printer tags generated from |printer_tags| and the default tags
  25 // required by cloud print server.
  26 PrinterTags PreparePrinterTags(const PrinterTags& printer_tags) {
  27   PrinterTags printer_tags_out = printer_tags;
  28   chrome::VersionInfo version_info;
  29   DCHECK(version_info.is_valid());
  30   printer_tags_out[kChromeVersionTagName] =
  31       version_info.CreateVersionString();
  32   printer_tags_out[kSystemNameTagName] =
  33       base::SysInfo::OperatingSystemName();
  34   printer_tags_out[kSystemVersionTagName] =
  35       base::SysInfo::OperatingSystemVersion();
  36   return printer_tags_out;
  37 }
  38
  39 // Returns the hash of |printer_tags|.
  40 std::string HashPrinterTags(const PrinterTags& printer_tags) {
  41   std::string values_list;
  42   PrinterTags::const_iterator it;
  43   for (it = printer_tags.begin(); it != printer_tags.end(); ++it) {
  44     values_list.append(it->first);
  45     values_list.append(it->second);
  46   }
  47   return base::MD5String(values_list);
  48 }
  49
  50 }  // namespace
  51
  52 std::string AppendPathToUrl(const GURL& url, const std::string& path) {
  53   DCHECK_NE(path[0], '/');
  54   std::string ret = url.path();
  55   if (url.has_path() && (ret[ret.length() - 1] != '/'))
  56     ret += '/';
  57   ret += path;
  58   return ret;
  59 }
  60
  61 GURL GetUrlForSearch(const GURL& cloud_print_server_url) {
  62   std::string path(AppendPathToUrl(cloud_print_server_url, "search"));
  63   GURL::Replacements replacements;
  64   replacements.SetPathStr(path);
  65   return cloud_print_server_url.ReplaceComponents(replacements);
  66 }
  67
  68 GURL GetUrlForSubmit(const GURL& cloud_print_server_url) {
  69   std::string path(AppendPathToUrl(cloud_print_server_url, "submit"));
  70   GURL::Replacements replacements;
  71   replacements.SetPathStr(path);
  72   return cloud_print_server_url.ReplaceComponents(replacements);
  73 }
  74
  75 GURL GetUrlForPrinterList(const GURL& cloud_print_server_url,
  76                           const std::string& proxy_id) {
  77   std::string path(AppendPathToUrl(cloud_print_server_url, "list"));
  78   GURL::Replacements replacements;
  79   replacements.SetPathStr(path);
  80   std::string query = base::StringPrintf("proxy=%s", proxy_id.c_str());
  81   replacements.SetQueryStr(query);
  82   return cloud_print_server_url.ReplaceComponents(replacements);
  83 }
  84
  85 GURL GetUrlForPrinterRegistration(const GURL& cloud_print_server_url) {
  86   std::string path(AppendPathToUrl(cloud_print_server_url, "register"));
  87   GURL::Replacements replacements;
  88   replacements.SetPathStr(path);
  89   return cloud_print_server_url.ReplaceComponents(replacements);
  90 }
  91
  92 GURL GetUrlForPrinterUpdate(const GURL& cloud_print_server_url,
  93                             const std::string& printer_id) {
  94   std::string path(AppendPathToUrl(cloud_print_server_url, "update"));
  95   GURL::Replacements replacements;
  96   replacements.SetPathStr(path);
  97   std::string query = base::StringPrintf("printerid=%s", printer_id.c_str());
  98   replacements.SetQueryStr(query);
  99   return cloud_print_server_url.ReplaceComponents(replacements);
 100 }
 101
 102 GURL GetUrlForPrinterDelete(const GURL& cloud_print_server_url,
 103                             const std::string& printer_id,
 104                             const std::string& reason) {
 105   std::string path(AppendPathToUrl(cloud_print_server_url, "delete"));
 106   GURL::Replacements replacements;
 107   replacements.SetPathStr(path);
 108   std::string query = base::StringPrintf(
 109       "printerid=%s&reason=%s", printer_id.c_str(), reason.c_str());
 110   replacements.SetQueryStr(query);
 111   return cloud_print_server_url.ReplaceComponents(replacements);
 112 }
 113
 114 GURL GetUrlForJobFetch(const GURL& cloud_print_server_url,
 115                        const std::string& printer_id,
 116                        const std::string& reason) {
 117   std::string path(AppendPathToUrl(cloud_print_server_url, "fetch"));
 118   GURL::Replacements replacements;
 119   replacements.SetPathStr(path);
 120   std::string query = base::StringPrintf(
 121       "printerid=%s&deb=%s", printer_id.c_str(), reason.c_str());
 122   replacements.SetQueryStr(query);
 123   return cloud_print_server_url.ReplaceComponents(replacements);
 124 }
 125
 126 GURL GetUrlForJobCjt(const GURL& cloud_print_server_url,
 127                      const std::string& job_id,
 128                      const std::string& reason) {
 129   std::string path(AppendPathToUrl(cloud_print_server_url, "ticket"));
 130   GURL::Replacements replacements;
 131   replacements.SetPathStr(path);
 132   std::string query = base::StringPrintf(
 133       "jobid=%s&deb=%s&use_cjt=true", job_id.c_str(), reason.c_str());
 134   replacements.SetQueryStr(query);
 135   return cloud_print_server_url.ReplaceComponents(replacements);
 136 }
 137
 138 GURL GetUrlForJobDelete(const GURL& cloud_print_server_url,
 139                         const std::string& job_id) {
 140   std::string path(AppendPathToUrl(cloud_print_server_url, "deletejob"));
 141   GURL::Replacements replacements;
 142   replacements.SetPathStr(path);
 143   std::string query = base::StringPrintf("jobid=%s", job_id.c_str());
 144   replacements.SetQueryStr(query);
 145   return cloud_print_server_url.ReplaceComponents(replacements);
 146 }
 147
 148 GURL GetUrlForJobStatusUpdate(const GURL& cloud_print_server_url,
 149                               const std::string& job_id,
 150                               const std::string& status_string,
 151                               int connector_code) {
 152   std::string path(AppendPathToUrl(cloud_print_server_url, "control"));
 153   GURL::Replacements replacements;
 154   replacements.SetPathStr(path);
 155   std::string query = base::StringPrintf(
 156       "jobid=%s&status=%s&connector_code=%d", job_id.c_str(),
 157       status_string.c_str(), connector_code);
 158   replacements.SetQueryStr(query);
 159   return cloud_print_server_url.ReplaceComponents(replacements);
 160 }
 161
 162 GURL GetUrlForUserMessage(const GURL& cloud_print_server_url,
 163                           const std::string& message_id) {
 164   std::string path(AppendPathToUrl(cloud_print_server_url, "message"));
 165   GURL::Replacements replacements;
 166   replacements.SetPathStr(path);
 167   std::string query = base::StringPrintf("code=%s", message_id.c_str());
 168   replacements.SetQueryStr(query);
 169   return cloud_print_server_url.ReplaceComponents(replacements);
 170 }
 171
 172 GURL GetUrlForGetAuthCode(const GURL& cloud_print_server_url,
 173                           const std::string& oauth_client_id,
 174                           const std::string& proxy_id) {
 175   // We use the internal API "createrobot" instead of "getauthcode". This API
 176   // will add the robot as owner to all the existing printers for this user.
 177   std::string path(AppendPathToUrl(cloud_print_server_url, "createrobot"));
 178   GURL::Replacements replacements;
 179   replacements.SetPathStr(path);
 180   std::string query = base::StringPrintf("oauth_client_id=%s&proxy=%s",
 181                                           oauth_client_id.c_str(),
 182                                           proxy_id.c_str());
 183   replacements.SetQueryStr(query);
 184   return cloud_print_server_url.ReplaceComponents(replacements);
 185 }
 186
 187 scoped_ptr<base::DictionaryValue> ParseResponseJSON(
 188     const std::string& response_data,
 189     bool* succeeded) {
 190   scoped_ptr<base::Value> message_value(base::JSONReader::Read(response_data));
 191   if (!message_value.get())
 192     return scoped_ptr<base::DictionaryValue>();
 193
 194   if (!message_value->IsType(base::Value::TYPE_DICTIONARY))
 195     return scoped_ptr<base::DictionaryValue>();
 196
 197   scoped_ptr<base::DictionaryValue> response_dict(
 198       static_cast<base::DictionaryValue*>(message_value.release()));
 199   if (succeeded &&
 200       !response_dict->GetBoolean(kSuccessValue, succeeded))
 201     *succeeded = false;
 202   return response_dict.Pass();
 203 }
 204
 205 std::string GetMultipartMimeType(const std::string& mime_boundary) {
 206   return std::string("multipart/form-data; boundary=") + mime_boundary;
 207 }
 208
 209 // Create a MIME boundary marker (27 '-' characters followed by 16 hex digits).
 210 void CreateMimeBoundaryForUpload(std::string* out) {
 211   int r1 = base::RandInt(0, kint32max);
 212   int r2 = base::RandInt(0, kint32max);
 213   base::SStringPrintf(out, "---------------------------%08X%08X", r1, r2);
 214 }
 215
 216 std::string GetHashOfPrinterTags(const PrinterTags& printer_tags) {
 217   return HashPrinterTags(PreparePrinterTags(printer_tags));
 218 }
 219
 220 std::string GetPostDataForPrinterTags(
 221     const PrinterTags& printer_tags,
 222     const std::string& mime_boundary,
 223     const std::string& proxy_tag_prefix,
 224     const std::string& tags_hash_tag_name) {
 225   PrinterTags printer_tags_prepared = PreparePrinterTags(printer_tags);
 226   std::string post_data;
 227   for (PrinterTags::const_iterator it = printer_tags_prepared.begin();
 228        it != printer_tags_prepared.end(); ++it) {
 229     // TODO(gene) Escape '=' char from name. Warning for now.
 230     if (it->first.find('=') != std::string::npos) {
 231       LOG(WARNING) <<
 232           "CP_PROXY: Printer option name contains '=' character";
 233       NOTREACHED();
 234     }
 235     // All our tags have a special prefix to identify them as such.
 236     std::string msg = base::StringPrintf("%s%s=%s",
 237         proxy_tag_prefix.c_str(), it->first.c_str(), it->second.c_str());
 238     net::AddMultipartValueForUpload(kPrinterTagValue, msg, mime_boundary,
 239         std::string(), &post_data);
 240   }
 241   std::string tags_hash_msg = base::StringPrintf("%s=%s",
 242       tags_hash_tag_name.c_str(),
 243       HashPrinterTags(printer_tags_prepared).c_str());
 244   net::AddMultipartValueForUpload(kPrinterTagValue, tags_hash_msg,
 245       mime_boundary, std::string(), &post_data);
 246   return post_data;
 247 }
 248
 249 std::string GetCloudPrintAuthHeader(const std::string& auth_token) {
 250   return base::StringPrintf("Authorization: OAuth %s", auth_token.c_str());
 251 }
 252
 253 }  // namespace cloud_print