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
39namespace buzz {
40
41Jid::Jid() {
42}
43
44Jid::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
71Jid::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
80void 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
96std::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
114Jid::~Jid() {
115}
116
117bool Jid::IsEmpty() const {
118  return (node_name_.empty() && domain_name_.empty() &&
119          resource_name_.empty());
120}
121
122bool Jid::IsValid() const {
123  return !domain_name_.empty();
124}
125
126bool 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
134bool Jid::IsFull() const {
135  return IsValid() && !resource_name_.empty();
136}
137
138Jid 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
146bool Jid::BareEquals(const Jid& other) const {
147  return other.node_name_ == node_name_ &&
148      other.domain_name_ == domain_name_;
149}
150
151void 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
157bool 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
163int 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.
178std::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.
206char 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.
232std::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.
257char 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.
274std::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.
294void 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.
320void 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.
361char 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