net/tools/flip_server/url_to_filename_encoder.h

   1 // Copyright (c) 2010 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 // URL filename encoder goals:
   6 //
   7 // 1. Allow URLs with arbitrary path-segment length, generating filenames
   8 //    with a maximum of 128 characters.
   9 // 2. Provide a somewhat human readable filenames, for easy debugging flow.
  10 // 3. Provide reverse-mapping from filenames back to URLs.
  11 // 4. Be able to distinguish http://x from http://x/ from http://x/index.html.
  12 //    Those can all be different URLs.
  13 // 5. Be able to represent http://a/b/c and http://a/b/c/d, a pattern seen
  14 //    with Facebook Connect.
  15 //
  16 // We need an escape-character for representing characters that are legal
  17 // in URL paths, but not in filenames, such as '?'.
  18 //
  19 // We can pick any legal character as an escape, as long as we escape it too.
  20 // But as we have a goal of having filenames that humans can correlate with
  21 // URLs, we should pick one that doesn't show up frequently in URLs. Candidates
  22 // are ~`!@#$%^&()-=_+{}[],. but we would prefer to avoid characters that are
  23 // shell escapes or that various build tools use.
  24 //
  25 // .#&%-=_+ occur frequently in URLs.
  26 // <>:"/\|?* are illegal in Windows
  27 //   See http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
  28 // ~`!$^&(){}[]'; are special to Unix shells
  29 // In addition, build tools do not like ^@#%
  30 //
  31 // Josh took a quick look at the frequency of some special characters in
  32 // Sadeesh's slurped directory from Fall 09 and found the following occurances:
  33 //
  34 //   ^   3               build tool doesn't like ^ in testdata filenames
  35 //   @   10              build tool doesn't like @ in testdata filenames
  36 //   .   1676            too frequent in URLs
  37 //   ,   76              THE WINNER
  38 //   #   0               build tool doesn't like it
  39 //   &   487             Prefer to avoid shell escapes
  40 //   %   374             g4 doesn't like it
  41 //   =   579             very frequent in URLs -- leave unmodified
  42 //   -   464             very frequent in URLs -- leave unmodified
  43 //   _   798             very frequent in URLs -- leave unmodified
  44 //
  45 //
  46 // The escaping algorithm is:
  47 //  1) Escape all unfriendly symbols as ,XX where XX is the hex code.
  48 //  2) Add a ',' at the end (We do not allow ',' at end of any directory name,
  49 //     so this assures that e.g. /a and /a/b can coexist in the filesystem).
  50 //  3) Go through the path segment by segment (where a segment is one directory
  51 //     or leaf in the path) and
  52 //     3a) If the segment is empty, escape the second slash. i.e. if it was
  53 //         www.foo.com//a then we escape the second / like www.foo.com/,2Fa,
  54 //     3a) If it is "." or ".." prepend with ',' (so that we have a non-
  55 //         empty and non-reserved filename).
  56 //     3b) If it is over 128 characters, break it up into smaller segments by
  57 //         inserting ,-/ (Windows limits paths to 128 chars, other OSes also
  58 //         have limits that would restrict us)
  59 //
  60 // For example:
  61 //     URL               File
  62 //     /                 /,
  63 //     /index.html       /index.html,
  64 //     /.                /.,
  65 //     /a/b              /a/b,
  66 //     /a/b/             /a/b/,
  67 //     /a/b/c            /a/b/c,   Note: no prefix problem
  68 //     /u?foo=bar        /u,3Ffoo=bar,
  69 //     //                /,2F,
  70 //     /./               /,./,
  71 //     /../              /,../,
  72 //     /,                /,2C,
  73 //     /,./              /,2C./,
  74 //     /very...longname/ /very...long,-/name   If very...long is about 126 long.
  75
  76 // NOTE: we avoid using some classes here (like FilePath and GURL) because we
  77 //       share this code with other projects externally.
  78
  79 #ifndef NET_TOOLS_FLIP_SERVER_URL_TO_FILENAME_ENCODER_H_
  80 #define NET_TOOLS_FLIP_SERVER_URL_TO_FILENAME_ENCODER_H_
  81
  82 #include <string>
  83
  84 #include "base/strings/string_util.h"
  85 #include "net/tools/flip_server/url_utilities.h"
  86
  87 namespace net {
  88
  89 // Helper class for converting a URL into a filename.
  90 class UrlToFilenameEncoder {
  91  public:
  92   // Given a |url| and a |base_path|, returns a filename which represents this
  93   // |url|. |url| may include URL escaping such as %21 for !
  94   // |legacy_escape| indicates that this function should use the old-style
  95   // of encoding.
  96   // TODO(mbelshe): delete the legacy_escape code.
  97   static std::string Encode(const std::string& url,
  98                             std::string base_path,
  99                             bool legacy_escape) {
 100     std::string filename;
 101     if (!legacy_escape) {
 102       std::string url_no_scheme = UrlUtilities::GetUrlHostPath(url);
 103       EncodeSegment(base_path, url_no_scheme, '/', &filename);
 104 #ifdef WIN32
 105       ReplaceAll(&filename, "/", "\\");
 106 #endif
 107     } else {
 108       std::string clean_url(url);
 109       if (clean_url.length() && clean_url[clean_url.length() - 1] == '/')
 110         clean_url.append("index.html");
 111
 112       std::string host = UrlUtilities::GetUrlHost(clean_url);
 113       filename.append(base_path);
 114       filename.append(host);
 115 #ifdef WIN32
 116       filename.append("\\");
 117 #else
 118       filename.append("/");
 119 #endif
 120
 121       std::string url_filename = UrlUtilities::GetUrlPath(clean_url);
 122       // Strip the leading '/'.
 123       if (url_filename[0] == '/')
 124         url_filename = url_filename.substr(1);
 125
 126       // Replace '/' with '\'.
 127       ConvertToSlashes(&url_filename);
 128
 129       // Strip double back-slashes ("\\\\").
 130       StripDoubleSlashes(&url_filename);
 131
 132       // Save path as filesystem-safe characters.
 133       url_filename = LegacyEscape(url_filename);
 134       filename.append(url_filename);
 135
 136 #ifndef WIN32
 137       // Last step - convert to native slashes.
 138       const std::string slash("/");
 139       const std::string backslash("\\");
 140       ReplaceAll(&filename, backslash, slash);
 141 #endif
 142     }
 143
 144     return filename;
 145   }
 146
 147   // Rewrite HTML in a form that the SPDY in-memory server
 148   // can read.
 149   // |filename_prefix| is prepended without escaping.
 150   // |escaped_ending| is the URL to be encoded into a filename. It may have URL
 151   // escaped characters (like %21 for !).
 152   // |dir_separator| is "/" on Unix, "\" on Windows.
 153   // |encoded_filename| is the resultant filename.
 154   static void EncodeSegment(const std::string& filename_prefix,
 155                             const std::string& escaped_ending,
 156                             char dir_separator,
 157                             std::string* encoded_filename);
 158
 159   // Decodes a filename that was encoded with EncodeSegment,
 160   // yielding back the original URL.
 161   static bool Decode(const std::string& encoded_filename,
 162                      char dir_separator,
 163                      std::string* decoded_url);
 164
 165   static const char kEscapeChar;
 166   static const char kTruncationChar;
 167   static const size_t kMaximumSubdirectoryLength;
 168
 169   friend class UrlToFilenameEncoderTest;
 170
 171  private:
 172   // Appends a segment of the path, special-casing "." and "..", and
 173   // ensuring that the segment does not exceed the path length.  If it does,
 174   // it chops the end off the segment, writes the segment with a separator of
 175   // ",-/", and then rewrites segment to contain just the truncated piece so
 176   // it can be used in the next iteration.
 177   // |segment| is a read/write parameter containing segment to write
 178   // Note: this should not be called with empty segment.
 179   static void AppendSegment(std::string* segment, std::string* dest);
 180
 181   // Allow reading of old slurped files.
 182   static std::string LegacyEscape(const std::string& path);
 183
 184   // Replace all instances of |from| within |str| as |to|.
 185   static void ReplaceAll(std::string* str,
 186                          const std::string& from,
 187                          const std::string& to) {
 188     std::string::size_type pos(0);
 189     while ((pos = str->find(from, pos)) != std::string::npos) {
 190       str->replace(pos, from.size(), to);
 191       pos += from.size();
 192     }
 193   }
 194
 195   // Replace all instances of "/" with "\" in |path|.
 196   static void ConvertToSlashes(std::string* path) {
 197     const std::string slash("/");
 198     const std::string backslash("\\");
 199     ReplaceAll(path, slash, backslash);
 200   }
 201
 202   // Replace all instances of "\\" with "%5C%5C" in |path|.
 203   static void StripDoubleSlashes(std::string* path) {
 204     const std::string doubleslash("\\\\");
 205     const std::string escaped_doubleslash("%5C%5C");
 206     ReplaceAll(path, doubleslash, escaped_doubleslash);
 207   }
 208 };
 209
 210 }  // namespace net
 211
 212 #endif  // NET_TOOLS_FLIP_SERVER_URL_TO_FILENAME_ENCODER_H_