Index: webrtc/libjingle/xmpp/jid.cc |
diff --git a/webrtc/libjingle/xmpp/jid.cc b/webrtc/libjingle/xmpp/jid.cc |
deleted file mode 100644 |
index ad053805688c6f1ba8df57168cea42d3ca44c403..0000000000000000000000000000000000000000 |
--- a/webrtc/libjingle/xmpp/jid.cc |
+++ /dev/null |
@@ -1,379 +0,0 @@ |
-/* |
- * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
- * |
- * Use of this source code is governed by a BSD-style license |
- * that can be found in the LICENSE file in the root of the source |
- * tree. An additional intellectual property rights grant can be found |
- * in the file PATENTS. All contributing project authors may |
- * be found in the AUTHORS file in the root of the source tree. |
- */ |
- |
-#include "webrtc/libjingle/xmpp/jid.h" |
- |
-#include <ctype.h> |
- |
-#include <algorithm> |
-#include <string> |
- |
-#include "webrtc/libjingle/xmpp/constants.h" |
-#include "webrtc/base/common.h" |
-#include "webrtc/base/logging.h" |
- |
-namespace buzz { |
- |
-Jid::Jid() { |
-} |
- |
-Jid::Jid(const std::string& jid_string) { |
- if (jid_string.empty()) |
- return; |
- |
- // First find the slash and slice off that part |
- size_t slash = jid_string.find('/'); |
- resource_name_ = (slash == std::string::npos ? STR_EMPTY : |
- jid_string.substr(slash + 1)); |
- |
- // Now look for the node |
- size_t at = jid_string.find('@'); |
- size_t domain_begin; |
- if (at < slash && at != std::string::npos) { |
- node_name_ = jid_string.substr(0, at); |
- domain_begin = at + 1; |
- } else { |
- domain_begin = 0; |
- } |
- |
- // Now take what is left as the domain |
- size_t domain_length = (slash == std::string::npos) ? |
- (jid_string.length() - domain_begin) : (slash - domain_begin); |
- domain_name_ = jid_string.substr(domain_begin, domain_length); |
- |
- ValidateOrReset(); |
-} |
- |
-Jid::Jid(const std::string& node_name, |
- const std::string& domain_name, |
- const std::string& resource_name) |
- : node_name_(node_name), |
- domain_name_(domain_name), |
- resource_name_(resource_name) { |
- ValidateOrReset(); |
-} |
- |
-void Jid::ValidateOrReset() { |
- bool valid_node; |
- bool valid_domain; |
- bool valid_resource; |
- |
- node_name_ = PrepNode(node_name_, &valid_node); |
- domain_name_ = PrepDomain(domain_name_, &valid_domain); |
- resource_name_ = PrepResource(resource_name_, &valid_resource); |
- |
- if (!valid_node || !valid_domain || !valid_resource) { |
- node_name_.clear(); |
- domain_name_.clear(); |
- resource_name_.clear(); |
- } |
-} |
- |
-std::string Jid::Str() const { |
- if (!IsValid()) |
- return STR_EMPTY; |
- |
- std::string ret; |
- |
- if (!node_name_.empty()) |
- ret = node_name_ + "@"; |
- |
- ASSERT(domain_name_ != STR_EMPTY); |
- ret += domain_name_; |
- |
- if (!resource_name_.empty()) |
- ret += "/" + resource_name_; |
- |
- return ret; |
-} |
- |
-Jid::~Jid() { |
-} |
- |
-bool Jid::IsEmpty() const { |
- return (node_name_.empty() && domain_name_.empty() && |
- resource_name_.empty()); |
-} |
- |
-bool Jid::IsValid() const { |
- return !domain_name_.empty(); |
-} |
- |
-bool Jid::IsBare() const { |
- if (IsEmpty()) { |
- LOG(LS_VERBOSE) << "Warning: Calling IsBare() on the empty jid."; |
- return true; |
- } |
- return IsValid() && resource_name_.empty(); |
-} |
- |
-bool Jid::IsFull() const { |
- return IsValid() && !resource_name_.empty(); |
-} |
- |
-Jid Jid::BareJid() const { |
- if (!IsValid()) |
- return Jid(); |
- if (!IsFull()) |
- return *this; |
- return Jid(node_name_, domain_name_, STR_EMPTY); |
-} |
- |
-bool Jid::BareEquals(const Jid& other) const { |
- return other.node_name_ == node_name_ && |
- other.domain_name_ == domain_name_; |
-} |
- |
-void Jid::CopyFrom(const Jid& jid) { |
- this->node_name_ = jid.node_name_; |
- this->domain_name_ = jid.domain_name_; |
- this->resource_name_ = jid.resource_name_; |
-} |
- |
-bool Jid::operator==(const Jid& other) const { |
- return other.node_name_ == node_name_ && |
- other.domain_name_ == domain_name_ && |
- other.resource_name_ == resource_name_; |
-} |
- |
-int Jid::Compare(const Jid& other) const { |
- int compare_result; |
- compare_result = node_name_.compare(other.node_name_); |
- if (0 != compare_result) |
- return compare_result; |
- compare_result = domain_name_.compare(other.domain_name_); |
- if (0 != compare_result) |
- return compare_result; |
- compare_result = resource_name_.compare(other.resource_name_); |
- return compare_result; |
-} |
- |
-// --- JID parsing code: --- |
- |
-// Checks and normalizes the node part of a JID. |
-std::string Jid::PrepNode(const std::string& node, bool* valid) { |
- *valid = false; |
- std::string result; |
- |
- for (std::string::const_iterator i = node.begin(); i < node.end(); ++i) { |
- bool char_valid = true; |
- unsigned char ch = *i; |
- if (ch <= 0x7F) { |
- result += PrepNodeAscii(ch, &char_valid); |
- } |
- else { |
- // TODO: implement the correct stringprep protocol for these |
- result += tolower(ch); |
- } |
- if (!char_valid) { |
- return STR_EMPTY; |
- } |
- } |
- |
- if (result.length() > 1023) { |
- return STR_EMPTY; |
- } |
- *valid = true; |
- return result; |
-} |
- |
- |
-// Returns the appropriate mapping for an ASCII character in a node. |
-char Jid::PrepNodeAscii(char ch, bool* valid) { |
- *valid = true; |
- switch (ch) { |
- case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': |
- case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': |
- case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': |
- case 'V': case 'W': case 'X': case 'Y': case 'Z': |
- return (char)(ch + ('a' - 'A')); |
- |
- case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: |
- case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: |
- case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11: |
- case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: |
- case ' ': case '&': case '/': case ':': case '<': case '>': case '@': |
- case '\"': case '\'': |
- case 0x7F: |
- *valid = false; |
- return 0; |
- |
- default: |
- return ch; |
- } |
-} |
- |
- |
-// Checks and normalizes the resource part of a JID. |
-std::string Jid::PrepResource(const std::string& resource, bool* valid) { |
- *valid = false; |
- std::string result; |
- |
- for (std::string::const_iterator i = resource.begin(); |
- i < resource.end(); ++i) { |
- bool char_valid = true; |
- unsigned char ch = *i; |
- if (ch <= 0x7F) { |
- result += PrepResourceAscii(ch, &char_valid); |
- } |
- else { |
- // TODO: implement the correct stringprep protocol for these |
- result += ch; |
- } |
- } |
- |
- if (result.length() > 1023) { |
- return STR_EMPTY; |
- } |
- *valid = true; |
- return result; |
-} |
- |
-// Returns the appropriate mapping for an ASCII character in a resource. |
-char Jid::PrepResourceAscii(char ch, bool* valid) { |
- *valid = true; |
- switch (ch) { |
- case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: |
- case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: |
- case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11: |
- case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: |
- case 0x7F: |
- *valid = false; |
- return 0; |
- |
- default: |
- return ch; |
- } |
-} |
- |
-// Checks and normalizes the domain part of a JID. |
-std::string Jid::PrepDomain(const std::string& domain, bool* valid) { |
- *valid = false; |
- std::string result; |
- |
- // TODO: if the domain contains a ':', then we should parse it |
- // as an IPv6 address rather than giving an error about illegal domain. |
- PrepDomain(domain, &result, valid); |
- if (!*valid) { |
- return STR_EMPTY; |
- } |
- |
- if (result.length() > 1023) { |
- return STR_EMPTY; |
- } |
- *valid = true; |
- return result; |
-} |
- |
- |
-// Checks and normalizes an IDNA domain. |
-void Jid::PrepDomain(const std::string& domain, std::string* buf, bool* valid) { |
- *valid = false; |
- std::string::const_iterator last = domain.begin(); |
- for (std::string::const_iterator i = domain.begin(); i < domain.end(); ++i) { |
- bool label_valid = true; |
- char ch = *i; |
- switch (ch) { |
- case 0x002E: |
-#if 0 // FIX: This isn't UTF-8-aware. |
- case 0x3002: |
- case 0xFF0E: |
- case 0xFF61: |
-#endif |
- PrepDomainLabel(last, i, buf, &label_valid); |
- *buf += '.'; |
- last = i + 1; |
- break; |
- } |
- if (!label_valid) { |
- return; |
- } |
- } |
- PrepDomainLabel(last, domain.end(), buf, valid); |
-} |
- |
-// Checks and normalizes a domain label. |
-void Jid::PrepDomainLabel( |
- std::string::const_iterator start, std::string::const_iterator end, |
- std::string* buf, bool* valid) { |
- *valid = false; |
- |
- int start_len = static_cast<int>(buf->length()); |
- for (std::string::const_iterator i = start; i < end; ++i) { |
- bool char_valid = true; |
- unsigned char ch = *i; |
- if (ch <= 0x7F) { |
- *buf += PrepDomainLabelAscii(ch, &char_valid); |
- } |
- else { |
- // TODO: implement ToASCII for these |
- *buf += ch; |
- } |
- if (!char_valid) { |
- return; |
- } |
- } |
- |
- int count = static_cast<int>(buf->length() - start_len); |
- if (count == 0) { |
- return; |
- } |
- else if (count > 63) { |
- return; |
- } |
- |
- // Is this check needed? See comment in PrepDomainLabelAscii. |
- if ((*buf)[start_len] == '-') { |
- return; |
- } |
- if ((*buf)[buf->length() - 1] == '-') { |
- return; |
- } |
- *valid = true; |
-} |
- |
- |
-// Returns the appropriate mapping for an ASCII character in a domain label. |
-char Jid::PrepDomainLabelAscii(char ch, bool* valid) { |
- *valid = true; |
- // TODO: A literal reading of the spec seems to say that we do |
- // not need to check for these illegal characters (an "internationalized |
- // domain label" runs ToASCII with UseSTD3... set to false). But that |
- // can't be right. We should at least be checking that there are no '/' |
- // or '@' characters in the domain. Perhaps we should see what others |
- // do in this case. |
- |
- switch (ch) { |
- case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': |
- case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': |
- case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': |
- case 'V': case 'W': case 'X': case 'Y': case 'Z': |
- return (char)(ch + ('a' - 'A')); |
- |
- case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: |
- case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: |
- case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11: |
- case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: |
- case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: |
- case 0x1E: case 0x1F: case 0x20: case 0x21: case 0x22: case 0x23: |
- case 0x24: case 0x25: case 0x26: case 0x27: case 0x28: case 0x29: |
- case 0x2A: case 0x2B: case 0x2C: case 0x2E: case 0x2F: case 0x3A: |
- case 0x3B: case 0x3C: case 0x3D: case 0x3E: case 0x3F: case 0x40: |
- case 0x5B: case 0x5C: case 0x5D: case 0x5E: case 0x5F: case 0x60: |
- case 0x7B: case 0x7C: case 0x7D: case 0x7E: case 0x7F: |
- *valid = false; |
- return 0; |
- |
- default: |
- return ch; |
- } |
-} |
- |
-} // namespace buzz |