Home | History | Annotate | Download | only in xmpp 
      1 /*
      2  * libjingle
      3  * Copyright 2004--2005, Google Inc.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are met:
      7  *
      8  *  1. Redistributions of source code must retain the above copyright notice,
      9  *     this list of conditions and the following disclaimer.
     10  *  2. Redistributions in binary form must reproduce the above copyright notice,
     11  *     this list of conditions and the following disclaimer in the documentation
     12  *     and/or other materials provided with the distribution.
     13  *  3. The name of the author may not be used to endorse or promote products
     14  *     derived from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #include "talk/xmpp/jid.h"
     29 
     30 #include <ctype.h>
     31 
     32 #include <algorithm>
     33 #include <string>
     34 
     35 #include "talk/xmpp/constants.h"
     36 #include "webrtc/base/common.h"
     37 #include "webrtc/base/logging.h"
     38 
     39 namespace buzz {
     40 
     41 Jid::Jid() {
     42 }
     43 
     44 Jid::Jid(const std::string& jid_string) {
     45   if (jid_string.empty())
     46     return;
     47 
     48   // First find the slash and slice off that part
     49   size_t slash = jid_string.find('/');
     50   resource_name_ = (slash == std::string::npos ? STR_EMPTY :
     51                     jid_string.substr(slash + 1));
     52 
     53   // Now look for the node
     54   size_t at = jid_string.find('@');
     55   size_t domain_begin;
     56   if (at < slash && at != std::string::npos) {
     57     node_name_ = jid_string.substr(0, at);
     58     domain_begin = at + 1;
     59   } else {
     60     domain_begin = 0;
     61   }
     62 
     63   // Now take what is left as the domain
     64   size_t domain_length = (slash == std::string::npos) ?
     65       (jid_string.length() - domain_begin) : (slash - domain_begin);
     66   domain_name_ = jid_string.substr(domain_begin, domain_length);
     67 
     68   ValidateOrReset();
     69 }
     70 
     71 Jid::Jid(const std::string& node_name,
     72          const std::string& domain_name,
     73          const std::string& resource_name)
     74     :  node_name_(node_name),
     75        domain_name_(domain_name),
     76        resource_name_(resource_name) {
     77   ValidateOrReset();
     78 }
     79 
     80 void Jid::ValidateOrReset() {
     81   bool valid_node;
     82   bool valid_domain;
     83   bool valid_resource;
     84 
     85   node_name_ = PrepNode(node_name_, &valid_node);
     86   domain_name_ = PrepDomain(domain_name_, &valid_domain);
     87   resource_name_ = PrepResource(resource_name_, &valid_resource);
     88 
     89   if (!valid_node || !valid_domain || !valid_resource) {
     90     node_name_.clear();
     91     domain_name_.clear();
     92     resource_name_.clear();
     93   }
     94 }
     95 
     96 std::string Jid::Str() const {
     97   if (!IsValid())
     98     return STR_EMPTY;
     99 
    100   std::string ret;
    101 
    102   if (!node_name_.empty())
    103     ret = node_name_ + "@";
    104 
    105   ASSERT(domain_name_ != STR_EMPTY);
    106   ret += domain_name_;
    107 
    108   if (!resource_name_.empty())
    109     ret += "/" + resource_name_;
    110 
    111   return ret;
    112 }
    113 
    114 Jid::~Jid() {
    115 }
    116 
    117 bool Jid::IsEmpty() const {
    118   return (node_name_.empty() && domain_name_.empty() &&
    119           resource_name_.empty());
    120 }
    121 
    122 bool Jid::IsValid() const {
    123   return !domain_name_.empty();
    124 }
    125 
    126 bool Jid::IsBare() const {
    127   if (IsEmpty()) {
    128     LOG(LS_VERBOSE) << "Warning: Calling IsBare() on the empty jid.";
    129     return true;
    130   }
    131   return IsValid() && resource_name_.empty();
    132 }
    133 
    134 bool Jid::IsFull() const {
    135   return IsValid() && !resource_name_.empty();
    136 }
    137 
    138 Jid Jid::BareJid() const {
    139   if (!IsValid())
    140     return Jid();
    141   if (!IsFull())
    142     return *this;
    143   return Jid(node_name_, domain_name_, STR_EMPTY);
    144 }
    145 
    146 bool Jid::BareEquals(const Jid& other) const {
    147   return other.node_name_ == node_name_ &&
    148       other.domain_name_ == domain_name_;
    149 }
    150 
    151 void Jid::CopyFrom(const Jid& jid) {
    152   this->node_name_ = jid.node_name_;
    153   this->domain_name_ = jid.domain_name_;
    154   this->resource_name_ = jid.resource_name_;
    155 }
    156 
    157 bool Jid::operator==(const Jid& other) const {
    158   return other.node_name_ == node_name_ &&
    159       other.domain_name_ == domain_name_ &&
    160       other.resource_name_ == resource_name_;
    161 }
    162 
    163 int Jid::Compare(const Jid& other) const {
    164   int compare_result;
    165   compare_result = node_name_.compare(other.node_name_);
    166   if (0 != compare_result)
    167     return compare_result;
    168   compare_result = domain_name_.compare(other.domain_name_);
    169   if (0 != compare_result)
    170     return compare_result;
    171   compare_result = resource_name_.compare(other.resource_name_);
    172   return compare_result;
    173 }
    174 
    175 // --- JID parsing code: ---
    176 
    177 // Checks and normalizes the node part of a JID.
    178 std::string Jid::PrepNode(const std::string& node, bool* valid) {
    179   *valid = false;
    180   std::string result;
    181 
    182   for (std::string::const_iterator i = node.begin(); i < node.end(); ++i) {
    183     bool char_valid = true;
    184     unsigned char ch = *i;
    185     if (ch <= 0x7F) {
    186       result += PrepNodeAscii(ch, &char_valid);
    187     }
    188     else {
    189       // TODO: implement the correct stringprep protocol for these
    190       result += tolower(ch);
    191     }
    192     if (!char_valid) {
    193       return STR_EMPTY;
    194     }
    195   }
    196 
    197   if (result.length() > 1023) {
    198     return STR_EMPTY;
    199   }
    200   *valid = true;
    201   return result;
    202 }
    203 
    204 
    205 // Returns the appropriate mapping for an ASCII character in a node.
    206 char Jid::PrepNodeAscii(char ch, bool* valid) {
    207   *valid = true;
    208   switch (ch) {
    209     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
    210     case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
    211     case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
    212     case 'V': case 'W': case 'X': case 'Y': case 'Z':
    213       return (char)(ch + ('a' - 'A'));
    214 
    215     case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05:
    216     case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B:
    217     case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11:
    218     case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
    219     case ' ': case '&': case '/': case ':': case '<': case '>': case '@':
    220     case '\"': case '\'':
    221     case 0x7F:
    222       *valid = false;
    223       return 0;
    224 
    225     default:
    226       return ch;
    227   }
    228 }
    229 
    230 
    231 // Checks and normalizes the resource part of a JID.
    232 std::string Jid::PrepResource(const std::string& resource, bool* valid) {
    233   *valid = false;
    234   std::string result;
    235 
    236   for (std::string::const_iterator i = resource.begin();
    237        i < resource.end(); ++i) {
    238     bool char_valid = true;
    239     unsigned char ch = *i;
    240     if (ch <= 0x7F) {
    241       result += PrepResourceAscii(ch, &char_valid);
    242     }
    243     else {
    244       // TODO: implement the correct stringprep protocol for these
    245       result += ch;
    246     }
    247   }
    248 
    249   if (result.length() > 1023) {
    250     return STR_EMPTY;
    251   }
    252   *valid = true;
    253   return result;
    254 }
    255 
    256 // Returns the appropriate mapping for an ASCII character in a resource.
    257 char Jid::PrepResourceAscii(char ch, bool* valid) {
    258   *valid = true;
    259   switch (ch) {
    260     case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05:
    261     case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B:
    262     case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11:
    263     case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
    264     case 0x7F:
    265       *valid = false;
    266       return 0;
    267 
    268     default:
    269       return ch;
    270   }
    271 }
    272 
    273 // Checks and normalizes the domain part of a JID.
    274 std::string Jid::PrepDomain(const std::string& domain, bool* valid) {
    275   *valid = false;
    276   std::string result;
    277 
    278   // TODO: if the domain contains a ':', then we should parse it
    279   // as an IPv6 address rather than giving an error about illegal domain.
    280   PrepDomain(domain, &result, valid);
    281   if (!*valid) {
    282     return STR_EMPTY;
    283   }
    284 
    285   if (result.length() > 1023) {
    286     return STR_EMPTY;
    287   }
    288   *valid = true;
    289   return result;
    290 }
    291 
    292 
    293 // Checks and normalizes an IDNA domain.
    294 void Jid::PrepDomain(const std::string& domain, std::string* buf, bool* valid) {
    295   *valid = false;
    296   std::string::const_iterator last = domain.begin();
    297   for (std::string::const_iterator i = domain.begin(); i < domain.end(); ++i) {
    298     bool label_valid = true;
    299     char ch = *i;
    300     switch (ch) {
    301       case 0x002E:
    302 #if 0 // FIX: This isn't UTF-8-aware.
    303       case 0x3002:
    304       case 0xFF0E:
    305       case 0xFF61:
    306 #endif
    307         PrepDomainLabel(last, i, buf, &label_valid);
    308         *buf += '.';
    309         last = i + 1;
    310         break;
    311     }
    312     if (!label_valid) {
    313       return;
    314     }
    315   }
    316   PrepDomainLabel(last, domain.end(), buf, valid);
    317 }
    318 
    319 // Checks and normalizes a domain label.
    320 void Jid::PrepDomainLabel(
    321     std::string::const_iterator start, std::string::const_iterator end,
    322     std::string* buf, bool* valid) {
    323   *valid = false;
    324 
    325   int start_len = static_cast<int>(buf->length());
    326   for (std::string::const_iterator i = start; i < end; ++i) {
    327     bool char_valid = true;
    328     unsigned char ch = *i;
    329     if (ch <= 0x7F) {
    330       *buf += PrepDomainLabelAscii(ch, &char_valid);
    331     }
    332     else {
    333       // TODO: implement ToASCII for these
    334       *buf += ch;
    335     }
    336     if (!char_valid) {
    337       return;
    338     }
    339   }
    340 
    341   int count = static_cast<int>(buf->length() - start_len);
    342   if (count == 0) {
    343     return;
    344   }
    345   else if (count > 63) {
    346     return;
    347   }
    348 
    349   // Is this check needed? See comment in PrepDomainLabelAscii.
    350   if ((*buf)[start_len] == '-') {
    351     return;
    352   }
    353   if ((*buf)[buf->length() - 1] == '-') {
    354     return;
    355   }
    356   *valid = true;
    357 }
    358 
    359 
    360 // Returns the appropriate mapping for an ASCII character in a domain label.
    361 char Jid::PrepDomainLabelAscii(char ch, bool* valid) {
    362   *valid = true;
    363   // TODO: A literal reading of the spec seems to say that we do
    364   // not need to check for these illegal characters (an "internationalized
    365   // domain label" runs ToASCII with UseSTD3... set to false).  But that
    366   // can't be right.  We should at least be checking that there are no '/'
    367   // or '@' characters in the domain.  Perhaps we should see what others
    368   // do in this case.
    369 
    370   switch (ch) {
    371     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
    372     case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
    373     case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
    374     case 'V': case 'W': case 'X': case 'Y': case 'Z':
    375       return (char)(ch + ('a' - 'A'));
    376 
    377     case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05:
    378     case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B:
    379     case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11:
    380     case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
    381     case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D:
    382     case 0x1E: case 0x1F: case 0x20: case 0x21: case 0x22: case 0x23:
    383     case 0x24: case 0x25: case 0x26: case 0x27: case 0x28: case 0x29:
    384     case 0x2A: case 0x2B: case 0x2C: case 0x2E: case 0x2F: case 0x3A:
    385     case 0x3B: case 0x3C: case 0x3D: case 0x3E: case 0x3F: case 0x40:
    386     case 0x5B: case 0x5C: case 0x5D: case 0x5E: case 0x5F: case 0x60:
    387     case 0x7B: case 0x7C: case 0x7D: case 0x7E: case 0x7F:
    388       *valid = false;
    389       return 0;
    390 
    391     default:
    392       return ch;
    393   }
    394 }
    395 
    396 }  // namespace buzz
    397