websocket_extension_parser.cc 3.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150
  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. #include "net/websockets/websocket_extension_parser.h"
  5. #include "base/check_op.h"
  6. #include "base/strings/string_piece.h"
  7. #include "net/http/http_util.h"
  8. namespace net {
  9. WebSocketExtensionParser::WebSocketExtensionParser() = default;
  10. WebSocketExtensionParser::~WebSocketExtensionParser() = default;
  11. bool WebSocketExtensionParser::Parse(const char* data, size_t size) {
  12. current_ = data;
  13. end_ = data + size;
  14. extensions_.clear();
  15. bool failed = false;
  16. do {
  17. WebSocketExtension extension;
  18. if (!ConsumeExtension(&extension)) {
  19. failed = true;
  20. break;
  21. }
  22. extensions_.push_back(extension);
  23. ConsumeSpaces();
  24. } while (ConsumeIfMatch(','));
  25. if (!failed && current_ == end_)
  26. return true;
  27. extensions_.clear();
  28. return false;
  29. }
  30. bool WebSocketExtensionParser::Consume(char c) {
  31. ConsumeSpaces();
  32. if (current_ == end_ || c != *current_)
  33. return false;
  34. ++current_;
  35. return true;
  36. }
  37. bool WebSocketExtensionParser::ConsumeExtension(WebSocketExtension* extension) {
  38. base::StringPiece name;
  39. if (!ConsumeToken(&name))
  40. return false;
  41. *extension = WebSocketExtension(std::string(name));
  42. while (ConsumeIfMatch(';')) {
  43. WebSocketExtension::Parameter parameter((std::string()));
  44. if (!ConsumeExtensionParameter(&parameter))
  45. return false;
  46. extension->Add(parameter);
  47. }
  48. return true;
  49. }
  50. bool WebSocketExtensionParser::ConsumeExtensionParameter(
  51. WebSocketExtension::Parameter* parameter) {
  52. base::StringPiece name, value;
  53. std::string value_string;
  54. if (!ConsumeToken(&name))
  55. return false;
  56. if (!ConsumeIfMatch('=')) {
  57. *parameter = WebSocketExtension::Parameter(std::string(name));
  58. return true;
  59. }
  60. if (Lookahead('\"')) {
  61. if (!ConsumeQuotedToken(&value_string))
  62. return false;
  63. } else {
  64. if (!ConsumeToken(&value))
  65. return false;
  66. value_string = std::string(value);
  67. }
  68. *parameter = WebSocketExtension::Parameter(std::string(name), value_string);
  69. return true;
  70. }
  71. bool WebSocketExtensionParser::ConsumeToken(base::StringPiece* token) {
  72. ConsumeSpaces();
  73. const char* head = current_;
  74. while (current_ < end_ && HttpUtil::IsTokenChar(*current_))
  75. ++current_;
  76. if (current_ == head)
  77. return false;
  78. *token = base::StringPiece(head, current_ - head);
  79. return true;
  80. }
  81. bool WebSocketExtensionParser::ConsumeQuotedToken(std::string* token) {
  82. if (!Consume('"'))
  83. return false;
  84. *token = "";
  85. while (current_ < end_ && *current_ != '"') {
  86. if (*current_ == '\\') {
  87. ++current_;
  88. if (current_ == end_)
  89. return false;
  90. }
  91. if (!HttpUtil::IsTokenChar(*current_))
  92. return false;
  93. *token += *current_;
  94. ++current_;
  95. }
  96. if (current_ == end_)
  97. return false;
  98. DCHECK_EQ(*current_, '"');
  99. ++current_;
  100. return !token->empty();
  101. }
  102. void WebSocketExtensionParser::ConsumeSpaces() {
  103. while (current_ < end_ && (*current_ == ' ' || *current_ == '\t'))
  104. ++current_;
  105. return;
  106. }
  107. bool WebSocketExtensionParser::Lookahead(char c) {
  108. const char* head = current_;
  109. bool result = Consume(c);
  110. current_ = head;
  111. return result;
  112. }
  113. bool WebSocketExtensionParser::ConsumeIfMatch(char c) {
  114. const char* head = current_;
  115. if (!Consume(c)) {
  116. current_ = head;
  117. return false;
  118. }
  119. return true;
  120. }
  121. } // namespace net