net/websockets/websocket_extension_parser.cc

   1 // Copyright 2013 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 "net/websockets/websocket_extension_parser.h"
   6
   7 #include "base/strings/string_util.h"
   8
   9 namespace net {
  10
  11 WebSocketExtensionParser::WebSocketExtensionParser() {}
  12
  13 WebSocketExtensionParser::~WebSocketExtensionParser() {}
  14
  15 bool WebSocketExtensionParser::Parse(const char* data, size_t size) {
  16   current_ = data;
  17   end_ = data + size;
  18   extensions_.clear();
  19
  20   bool failed = false;
  21
  22   while (true) {
  23     WebSocketExtension extension;
  24     if (!ConsumeExtension(&extension)) {
  25       failed = true;
  26       break;
  27     }
  28     extensions_.push_back(extension);
  29
  30     ConsumeSpaces();
  31
  32     if (!ConsumeIfMatch(',')) {
  33       break;
  34     }
  35   }
  36
  37   if (!failed && current_ == end_)
  38     return true;
  39
  40   extensions_.clear();
  41   return false;
  42 }
  43
  44 bool WebSocketExtensionParser::Consume(char c) {
  45   ConsumeSpaces();
  46   if (current_ == end_ || c != current_[0]) {
  47     return false;
  48   }
  49   ++current_;
  50   return true;
  51 }
  52
  53 bool WebSocketExtensionParser::ConsumeExtension(WebSocketExtension* extension) {
  54   base::StringPiece name;
  55   if (!ConsumeToken(&name))
  56     return false;
  57   *extension = WebSocketExtension(name.as_string());
  58
  59   while (ConsumeIfMatch(';')) {
  60     WebSocketExtension::Parameter parameter((std::string()));
  61     if (!ConsumeExtensionParameter(&parameter))
  62       return false;
  63     extension->Add(parameter);
  64   }
  65
  66   return true;
  67 }
  68
  69 bool WebSocketExtensionParser::ConsumeExtensionParameter(
  70     WebSocketExtension::Parameter* parameter) {
  71   base::StringPiece name, value;
  72   std::string value_string;
  73
  74   if (!ConsumeToken(&name))
  75     return false;
  76
  77   if (!ConsumeIfMatch('=')) {
  78     *parameter = WebSocketExtension::Parameter(name.as_string());
  79     return true;
  80   }
  81
  82   if (Lookahead('\"')) {
  83     if (!ConsumeQuotedToken(&value_string))
  84       return false;
  85   } else {
  86     if (!ConsumeToken(&value))
  87       return false;
  88     value_string = value.as_string();
  89   }
  90   *parameter = WebSocketExtension::Parameter(name.as_string(), value_string);
  91   return true;
  92 }
  93
  94 bool WebSocketExtensionParser::ConsumeToken(base::StringPiece* token) {
  95   ConsumeSpaces();
  96   const char* head = current_;
  97   while (current_ < end_ &&
  98          !IsControl(current_[0]) && !IsSeparator(current_[0]))
  99     ++current_;
 100   if (current_ == head) {
 101     return false;
 102   }
 103   *token = base::StringPiece(head, current_ - head);
 104   return true;
 105 }
 106
 107 bool WebSocketExtensionParser::ConsumeQuotedToken(std::string* token) {
 108   if (!Consume('"'))
 109     return false;
 110
 111   *token = "";
 112   while (current_ < end_ && !IsControl(current_[0])) {
 113     if (UnconsumedBytes() >= 2 && current_[0] == '\\') {
 114       char next = current_[1];
 115       if (IsControl(next) || IsSeparator(next)) break;
 116       *token += next;
 117       current_ += 2;
 118     } else if (IsSeparator(current_[0])) {
 119       break;
 120     } else {
 121       *token += current_[0];
 122       ++current_;
 123     }
 124   }
 125   // We can't use Consume here because we don't want to consume spaces.
 126   if (current_ >= end_ || current_[0] != '"')
 127     return false;
 128
 129   ++current_;
 130
 131   return !token->empty();
 132 }
 133
 134 void WebSocketExtensionParser::ConsumeSpaces() {
 135   while (current_ < end_ && (current_[0] == ' ' || current_[0] == '\t'))
 136     ++current_;
 137   return;
 138 }
 139
 140 bool WebSocketExtensionParser::Lookahead(char c) {
 141   const char* head = current_;
 142   bool result = Consume(c);
 143   current_ = head;
 144   return result;
 145 }
 146
 147 bool WebSocketExtensionParser::ConsumeIfMatch(char c) {
 148   const char* head = current_;
 149   if (!Consume(c)) {
 150     current_ = head;
 151     return false;
 152   }
 153
 154   return true;
 155 }
 156
 157 // static
 158 bool WebSocketExtensionParser::IsControl(char c) {
 159   return (0 <= c && c <= 31) || c == 127;
 160 }
 161
 162 // static
 163 bool WebSocketExtensionParser::IsSeparator(char c) {
 164   const char separators[] = "()<>@,;:\\\"/[]?={} \t";
 165   return strchr(separators, c) != NULL;
 166 }
 167
 168 }  // namespace net