1// Copyright (c) 2017, 2018 lumi <lumi@pew.im>
2// Copyright (c) 2017, 2018, 2019 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
3// Copyright (c) 2017, 2018, 2019 Maxime “pep” Buquet <pep@bouah.net>
4// Copyright (c) 2017, 2018 Astro <astro@spaceboyz.net>
5// Copyright (c) 2017 Bastien Orivel <eijebong@bananium.fr>
6//
7// This Source Code Form is subject to the terms of the Mozilla Public
8// License, v. 2.0. If a copy of the MPL was not distributed with this
9// file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#![no_std]
12#![deny(missing_docs)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14#![cfg_attr(docsrs, doc(auto_cfg))]
15
16//! Represents XMPP addresses, also known as JabberIDs (JIDs) for the [XMPP](https://xmpp.org/)
17//! protocol. A [`Jid`] can have between one and three parts in the form `node@domain/resource`:
18//! - the (optional) node part designates a specific account/service on a server, for example
19//! `username@server.com`
20//! - the domain part designates a server, for example `irc.jabberfr.org`
21//! - the (optional) resource part designates a more specific client, such as a participant in a
22//! groupchat (`jabberfr@chat.jabberfr.org/user`) or a specific client device associated with an
23//! account (`user@example.com/dino`)
24//!
25//! The [`Jid`] enum can be one of two variants, containing a more specific type:
26//! - [`BareJid`] (`Jid::Bare` variant): a JID without a resource
27//! - [`FullJid`] (`Jid::Full` variant): a JID with a resource
28//!
29//! Jids as per the XMPP protocol only ever contain valid UTF-8. However, creating any form of Jid
30//! can fail in one of the following cases:
31//! - wrong syntax: creating a Jid with an empty (yet declared) node or resource part, such as
32//! `@example.com` or `user@example.com/`
33//! - stringprep error: some characters were invalid according to the stringprep algorithm, such as
34//! mixing left-to-write and right-to-left characters
35
36extern crate alloc;
37
38#[cfg(test)]
39extern crate std;
40
41use alloc::borrow::Cow;
42use alloc::format;
43use alloc::string::{String, ToString};
44use core::borrow::Borrow;
45use core::cmp::Ordering;
46use core::fmt;
47use core::hash::{Hash, Hasher};
48use core::mem;
49use core::net::{Ipv4Addr, Ipv6Addr};
50use core::num::NonZeroU16;
51use core::ops::Deref;
52use core::str::FromStr;
53
54use memchr::memchr2_iter;
55
56use idna::uts46::{AsciiDenyList, DnsLength, Hyphens, Uts46};
57use stringprep::{nameprep, nodeprep, resourceprep};
58
59#[cfg(feature = "serde")]
60use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
61
62#[cfg(feature = "quote")]
63use proc_macro2::TokenStream;
64#[cfg(feature = "quote")]
65use quote::{quote, ToTokens};
66
67#[cfg(feature = "minidom")]
68use minidom::{IntoAttributeValue, Node};
69
70mod error;
71mod parts;
72
73pub use crate::error::Error;
74pub use parts::{DomainPart, DomainRef, NodePart, NodeRef, ResourcePart, ResourceRef};
75
76fn length_check(len: usize, error_empty: Error, error_too_long: Error) -> Result<(), Error> {
77 if len == 0 {
78 Err(error_empty)
79 } else if len > 1023 {
80 Err(error_too_long)
81 } else {
82 Ok(())
83 }
84}
85
86fn node_check(node: &str) -> Result<Cow<'_, str>, Error> {
87 let node = nodeprep(node).map_err(|_| Error::NodePrep)?;
88 length_check(node.len(), Error::NodeEmpty, Error::NodeTooLong)?;
89 Ok(node)
90}
91
92fn resource_check(resource: &str) -> Result<Cow<'_, str>, Error> {
93 let resource = resourceprep(resource).map_err(|_| Error::ResourcePrep)?;
94 length_check(resource.len(), Error::ResourceEmpty, Error::ResourceTooLong)?;
95 Ok(resource)
96}
97
98fn domain_check(mut domain: &str) -> Result<Cow<'_, str>, Error> {
99 // First, check if this is an IPv4 address.
100 if Ipv4Addr::from_str(domain).is_ok() {
101 return Ok(Cow::Borrowed(domain));
102 }
103
104 // Then if this is an IPv6 address.
105 if domain.starts_with('[')
106 && domain.ends_with(']')
107 && Ipv6Addr::from_str(&domain[1..domain.len() - 1]).is_ok()
108 {
109 return Ok(Cow::Borrowed(domain));
110 }
111
112 // idna can handle the root dot for us, but we still want to remove it for normalization
113 // purposes.
114 if domain.ends_with('.') {
115 domain = &domain[..domain.len() - 1];
116 }
117
118 Uts46::new()
119 .to_ascii(
120 domain.as_bytes(),
121 AsciiDenyList::URL,
122 Hyphens::Check,
123 DnsLength::Verify,
124 )
125 .map_err(|_| Error::Idna)?;
126 let domain = nameprep(domain).map_err(|_| Error::NamePrep)?;
127 Ok(domain)
128}
129
130/// A struct representing a Jabber ID (JID).
131///
132/// This JID can either be "bare" (without a `/resource` suffix) or full (with
133/// a resource suffix).
134///
135/// In many APIs, it is appropriate to use the more specific types
136/// ([`BareJid`] or [`FullJid`]) instead, as these two JID types are generally
137/// used in different contexts within XMPP.
138///
139/// This dynamic type on the other hand can be used in contexts where it is
140/// not known, at compile-time, whether a JID is full or bare.
141#[derive(Clone, Eq)]
142pub struct Jid {
143 normalized: String,
144 at: Option<NonZeroU16>,
145 slash: Option<NonZeroU16>,
146}
147
148impl PartialEq for Jid {
149 fn eq(&self, other: &Jid) -> bool {
150 self.normalized == other.normalized
151 }
152}
153
154impl PartialOrd for Jid {
155 fn partial_cmp(&self, other: &Jid) -> Option<Ordering> {
156 Some(self.cmp(other))
157 }
158}
159
160impl Ord for Jid {
161 fn cmp(&self, other: &Jid) -> Ordering {
162 self.normalized.cmp(&other.normalized)
163 }
164}
165
166impl Hash for Jid {
167 fn hash<H: Hasher>(&self, state: &mut H) {
168 self.normalized.hash(state)
169 }
170}
171
172impl FromStr for Jid {
173 type Err = Error;
174
175 fn from_str(s: &str) -> Result<Self, Self::Err> {
176 Self::new(s)
177 }
178}
179
180impl From<BareJid> for Jid {
181 fn from(other: BareJid) -> Self {
182 other.inner
183 }
184}
185
186impl From<FullJid> for Jid {
187 fn from(other: FullJid) -> Self {
188 other.inner
189 }
190}
191
192impl fmt::Display for Jid {
193 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
194 fmt.write_str(&self.normalized)
195 }
196}
197
198impl Jid {
199 /// Constructs a Jabber ID from a string. This is of the form
200 /// `node`@`domain`/`resource`, where node and resource parts are optional.
201 /// If you want a non-fallible version, use [`Jid::from_parts`] instead.
202 ///
203 /// # Examples
204 ///
205 /// ```
206 /// use jid::Jid;
207 /// # use jid::Error;
208 ///
209 /// # fn main() -> Result<(), Error> {
210 /// let jid = Jid::new("node@domain/resource")?;
211 ///
212 /// assert_eq!(jid.node().map(|x| x.as_str()), Some("node"));
213 /// assert_eq!(jid.domain().as_str(), "domain");
214 /// assert_eq!(jid.resource().map(|x| x.as_str()), Some("resource"));
215 /// # Ok(())
216 /// # }
217 /// ```
218 pub fn new(unnormalized: &str) -> Result<Jid, Error> {
219 let bytes = unnormalized.as_bytes();
220 let orig_at;
221 let orig_slash;
222 let mut iter = memchr2_iter(b'@', b'/', bytes);
223 let normalized = if let Some(first_index) = iter.next() {
224 let byte = bytes[first_index];
225 if byte == b'@' {
226 if let Some(second_index) = iter.next() {
227 let byte = bytes[second_index];
228 if byte == b'/' {
229 let node = node_check(&unnormalized[..first_index])?;
230 let domain = domain_check(&unnormalized[first_index + 1..second_index])?;
231 let resource = resource_check(&unnormalized[second_index + 1..])?;
232
233 orig_at = Some(node.len());
234 orig_slash = Some(node.len() + domain.len() + 1);
235 match (node, domain, resource) {
236 (Cow::Borrowed(_), Cow::Borrowed(_), Cow::Borrowed(_)) => {
237 unnormalized.to_string()
238 }
239 (node, domain, resource) => format!("{node}@{domain}/{resource}"),
240 }
241 } else
242 /* This is another '@' character. */
243 {
244 return Err(Error::TooManyAts);
245 }
246 } else {
247 // That is a node@domain JID.
248
249 let node = node_check(&unnormalized[..first_index])?;
250 let domain = domain_check(&unnormalized[first_index + 1..])?;
251
252 orig_at = Some(node.len());
253 orig_slash = None;
254 match (node, domain) {
255 (Cow::Borrowed(_), Cow::Borrowed(_)) => unnormalized.to_string(),
256 (node, domain) => format!("{node}@{domain}"),
257 }
258 }
259 } else
260 /* This is a '/' character. */
261 {
262 // The JID is of the form domain/resource, we can stop looking for further
263 // characters.
264
265 let domain = domain_check(&unnormalized[..first_index])?;
266 let resource = resource_check(&unnormalized[first_index + 1..])?;
267
268 orig_at = None;
269 orig_slash = Some(domain.len());
270 match (domain, resource) {
271 (Cow::Borrowed(_), Cow::Borrowed(_)) => unnormalized.to_string(),
272 (domain, resource) => format!("{domain}/{resource}"),
273 }
274 }
275 } else {
276 // Last possible case, just a domain JID.
277 let domain = domain_check(unnormalized)?;
278
279 orig_at = None;
280 orig_slash = None;
281 domain.into_owned()
282 };
283
284 Ok(Self {
285 normalized,
286 at: orig_at.and_then(|x| NonZeroU16::new(x as u16)),
287 slash: orig_slash.and_then(|x| NonZeroU16::new(x as u16)),
288 })
289 }
290
291 /// Returns the inner String of this JID.
292 pub fn into_inner(self) -> String {
293 self.normalized
294 }
295
296 /// Build a [`Jid`] from typed parts. This method cannot fail because it uses parts that have
297 /// already been parsed and stringprepped into [`NodePart`], [`DomainPart`], and [`ResourcePart`].
298 ///
299 /// This method allocates and does not consume the typed parts. To avoid
300 /// allocation if both `node` and `resource` are known to be `None` and
301 /// `domain` is owned, you can use `domain.into()`.
302 pub fn from_parts(
303 node: Option<&NodeRef>,
304 domain: &DomainRef,
305 resource: Option<&ResourceRef>,
306 ) -> Self {
307 match resource {
308 Some(resource) => FullJid::from_parts(node, domain, resource).into(),
309 None => BareJid::from_parts(node, domain).into(),
310 }
311 }
312
313 /// The optional node part of the JID as reference.
314 pub fn node(&self) -> Option<&NodeRef> {
315 self.at.map(|at| {
316 let at = u16::from(at) as usize;
317 NodeRef::from_str_unchecked(&self.normalized[..at])
318 })
319 }
320
321 /// The domain part of the JID as reference
322 pub fn domain(&self) -> &DomainRef {
323 match (self.at, self.slash) {
324 (Some(at), Some(slash)) => {
325 let at = u16::from(at) as usize;
326 let slash = u16::from(slash) as usize;
327 DomainRef::from_str_unchecked(&self.normalized[at + 1..slash])
328 }
329 (Some(at), None) => {
330 let at = u16::from(at) as usize;
331 DomainRef::from_str_unchecked(&self.normalized[at + 1..])
332 }
333 (None, Some(slash)) => {
334 let slash = u16::from(slash) as usize;
335 DomainRef::from_str_unchecked(&self.normalized[..slash])
336 }
337 (None, None) => DomainRef::from_str_unchecked(&self.normalized),
338 }
339 }
340
341 /// The optional resource of the Jabber ID. It is guaranteed to be present when the JID is
342 /// a Full variant, which you can check with [`Jid::is_full`].
343 pub fn resource(&self) -> Option<&ResourceRef> {
344 self.slash.map(|slash| {
345 let slash = u16::from(slash) as usize;
346 ResourceRef::from_str_unchecked(&self.normalized[slash + 1..])
347 })
348 }
349
350 /// Allocate a new [`BareJid`] from this JID, discarding the resource.
351 pub fn to_bare(&self) -> BareJid {
352 BareJid::from_parts(self.node(), self.domain())
353 }
354
355 /// Transforms this JID into a [`BareJid`], throwing away the resource.
356 ///
357 /// ```
358 /// # use jid::{BareJid, Jid};
359 /// let jid: Jid = "foo@bar/baz".parse().unwrap();
360 /// let bare = jid.into_bare();
361 /// assert_eq!(bare.to_string(), "foo@bar");
362 /// ```
363 pub fn into_bare(mut self) -> BareJid {
364 if let Some(slash) = self.slash {
365 // truncate the string
366 self.normalized.truncate(slash.get() as usize);
367 self.slash = None;
368 }
369 BareJid { inner: self }
370 }
371
372 /// Checks if the JID is a full JID.
373 pub fn is_full(&self) -> bool {
374 self.slash.is_some()
375 }
376
377 /// Checks if the JID is a bare JID.
378 pub fn is_bare(&self) -> bool {
379 self.slash.is_none()
380 }
381
382 /// Return a reference to the canonical string representation of the JID.
383 pub fn as_str(&self) -> &str {
384 &self.normalized
385 }
386
387 /// Try to convert this Jid to a [`FullJid`] if it contains a resource
388 /// and return a [`BareJid`] otherwise.
389 ///
390 /// This is useful for match blocks:
391 ///
392 /// ```
393 /// # use jid::Jid;
394 /// let jid: Jid = "foo@bar".parse().unwrap();
395 /// match jid.try_into_full() {
396 /// Ok(full) => println!("it is full: {:?}", full),
397 /// Err(bare) => println!("it is bare: {:?}", bare),
398 /// }
399 /// ```
400 pub fn try_into_full(self) -> Result<FullJid, BareJid> {
401 if self.slash.is_some() {
402 Ok(FullJid { inner: self })
403 } else {
404 Err(BareJid { inner: self })
405 }
406 }
407
408 /// Try to convert this Jid reference to a [`&FullJid`][`FullJid`] if it
409 /// contains a resource and return a [`&BareJid`][`BareJid`] otherwise.
410 ///
411 /// This is useful for match blocks:
412 ///
413 /// ```
414 /// # use jid::Jid;
415 /// let jid: Jid = "foo@bar".parse().unwrap();
416 /// match jid.try_as_full() {
417 /// Ok(full) => println!("it is full: {:?}", full),
418 /// Err(bare) => println!("it is bare: {:?}", bare),
419 /// }
420 /// ```
421 pub fn try_as_full(&self) -> Result<&FullJid, &BareJid> {
422 if self.slash.is_some() {
423 Ok(unsafe {
424 // SAFETY: FullJid is #[repr(transparent)] of Jid
425 // SOUNDNESS: we asserted that self.slash is set above
426 mem::transmute::<&Jid, &FullJid>(self)
427 })
428 } else {
429 Err(unsafe {
430 // SAFETY: BareJid is #[repr(transparent)] of Jid
431 // SOUNDNESS: we asserted that self.slash is unset above
432 mem::transmute::<&Jid, &BareJid>(self)
433 })
434 }
435 }
436
437 /// Try to convert this mutable Jid reference to a
438 /// [`&mut FullJid`][`FullJid`] if it contains a resource and return a
439 /// [`&mut BareJid`][`BareJid`] otherwise.
440 pub fn try_as_full_mut(&mut self) -> Result<&mut FullJid, &mut BareJid> {
441 if self.slash.is_some() {
442 Ok(unsafe {
443 // SAFETY: FullJid is #[repr(transparent)] of Jid
444 // SOUNDNESS: we asserted that self.slash is set above
445 mem::transmute::<&mut Jid, &mut FullJid>(self)
446 })
447 } else {
448 Err(unsafe {
449 // SAFETY: BareJid is #[repr(transparent)] of Jid
450 // SOUNDNESS: we asserted that self.slash is unset above
451 mem::transmute::<&mut Jid, &mut BareJid>(self)
452 })
453 }
454 }
455
456 #[doc(hidden)]
457 #[allow(non_snake_case)]
458 #[deprecated(
459 since = "0.11.0",
460 note = "use Jid::from (for construction of Jid values) or Jid::try_into_full/Jid::try_as_full (for match blocks) instead"
461 )]
462 pub fn Bare(other: BareJid) -> Self {
463 Self::from(other)
464 }
465
466 #[doc(hidden)]
467 #[allow(non_snake_case)]
468 #[deprecated(
469 since = "0.11.0",
470 note = "use Jid::from (for construction of Jid values) or Jid::try_into_full/Jid::try_as_full (for match blocks) instead"
471 )]
472 pub fn Full(other: FullJid) -> Self {
473 Self::from(other)
474 }
475}
476
477impl TryFrom<Jid> for FullJid {
478 type Error = Error;
479
480 fn try_from(inner: Jid) -> Result<Self, Self::Error> {
481 if inner.slash.is_none() {
482 return Err(Error::ResourceMissingInFullJid);
483 }
484 Ok(Self { inner })
485 }
486}
487
488impl TryFrom<Jid> for BareJid {
489 type Error = Error;
490
491 fn try_from(inner: Jid) -> Result<Self, Self::Error> {
492 if inner.slash.is_some() {
493 return Err(Error::ResourceInBareJid);
494 }
495 Ok(Self { inner })
496 }
497}
498
499impl PartialEq<Jid> for FullJid {
500 fn eq(&self, other: &Jid) -> bool {
501 &self.inner == other
502 }
503}
504
505impl PartialEq<Jid> for BareJid {
506 fn eq(&self, other: &Jid) -> bool {
507 &self.inner == other
508 }
509}
510
511impl PartialEq<FullJid> for Jid {
512 fn eq(&self, other: &FullJid) -> bool {
513 self == &other.inner
514 }
515}
516
517impl PartialEq<BareJid> for Jid {
518 fn eq(&self, other: &BareJid) -> bool {
519 self == &other.inner
520 }
521}
522
523/// A struct representing a full Jabber ID, with a resource part.
524///
525/// A full JID is composed of 3 components, of which only the node is optional:
526///
527/// - the (optional) node part is the part before the (optional) `@`.
528/// - the domain part is the mandatory part between the (optional) `@` and before the `/`.
529/// - the resource part after the `/`.
530///
531/// Unlike a [`BareJid`], it always contains a resource, and should only be used when you are
532/// certain there is no case where a resource can be missing. Otherwise, use a [`Jid`] or
533/// [`BareJid`].
534#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
535#[repr(transparent)] // WARNING: Jid::try_as_* relies on this for safety!
536pub struct FullJid {
537 inner: Jid,
538}
539
540/// A struct representing a bare Jabber ID, without a resource part.
541///
542/// A bare JID is composed of 2 components, of which only the node is optional:
543/// - the (optional) node part is the part before the (optional) `@`.
544/// - the domain part is the mandatory part between the (optional) `@` and before the `/`.
545///
546/// Unlike a [`FullJid`], it can’t contain a resource, and should only be used when you are certain
547/// there is no case where a resource can be set. Otherwise, use a [`Jid`] or [`FullJid`].
548#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
549#[repr(transparent)] // WARNING: Jid::try_as_* relies on this for safety!
550pub struct BareJid {
551 inner: Jid,
552}
553
554impl Deref for FullJid {
555 type Target = Jid;
556
557 fn deref(&self) -> &Self::Target {
558 &self.inner
559 }
560}
561
562impl Deref for BareJid {
563 type Target = Jid;
564
565 fn deref(&self) -> &Self::Target {
566 &self.inner
567 }
568}
569
570impl Borrow<Jid> for FullJid {
571 fn borrow(&self) -> &Jid {
572 &self.inner
573 }
574}
575
576impl Borrow<Jid> for BareJid {
577 fn borrow(&self) -> &Jid {
578 &self.inner
579 }
580}
581
582impl fmt::Debug for Jid {
583 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
584 fmt.debug_tuple("Jid").field(&self.normalized).finish()
585 }
586}
587
588impl fmt::Debug for FullJid {
589 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
590 fmt.debug_tuple("FullJid")
591 .field(&self.inner.normalized)
592 .finish()
593 }
594}
595
596impl fmt::Debug for BareJid {
597 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
598 fmt.debug_tuple("BareJid")
599 .field(&self.inner.normalized)
600 .finish()
601 }
602}
603
604impl fmt::Display for FullJid {
605 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
606 fmt::Display::fmt(&self.inner, fmt)
607 }
608}
609
610impl fmt::Display for BareJid {
611 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
612 fmt::Display::fmt(&self.inner, fmt)
613 }
614}
615
616#[cfg(feature = "serde")]
617impl Serialize for Jid {
618 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
619 where
620 S: Serializer,
621 {
622 serializer.serialize_str(&self.normalized)
623 }
624}
625
626#[cfg(feature = "serde")]
627impl Serialize for FullJid {
628 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
629 where
630 S: Serializer,
631 {
632 self.inner.serialize(serializer)
633 }
634}
635
636#[cfg(feature = "serde")]
637impl Serialize for BareJid {
638 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
639 where
640 S: Serializer,
641 {
642 self.inner.serialize(serializer)
643 }
644}
645
646impl FromStr for FullJid {
647 type Err = Error;
648
649 fn from_str(s: &str) -> Result<Self, Self::Err> {
650 Self::new(s)
651 }
652}
653
654#[cfg(feature = "serde")]
655impl<'de> Deserialize<'de> for Jid {
656 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
657 where
658 D: Deserializer<'de>,
659 {
660 let s = String::deserialize(deserializer)?;
661 Jid::new(&s).map_err(de::Error::custom)
662 }
663}
664
665#[cfg(feature = "serde")]
666impl<'de> Deserialize<'de> for FullJid {
667 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
668 where
669 D: Deserializer<'de>,
670 {
671 let jid = Jid::deserialize(deserializer)?;
672 jid.try_into().map_err(de::Error::custom)
673 }
674}
675
676#[cfg(feature = "serde")]
677impl<'de> Deserialize<'de> for BareJid {
678 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
679 where
680 D: Deserializer<'de>,
681 {
682 let jid = Jid::deserialize(deserializer)?;
683 jid.try_into().map_err(de::Error::custom)
684 }
685}
686
687#[cfg(feature = "quote")]
688impl ToTokens for Jid {
689 fn to_tokens(&self, tokens: &mut TokenStream) {
690 let s = &self.normalized;
691 tokens.extend(quote! {
692 jid::Jid::new(#s).unwrap()
693 });
694 }
695}
696
697#[cfg(feature = "quote")]
698impl ToTokens for FullJid {
699 fn to_tokens(&self, tokens: &mut TokenStream) {
700 let s = &self.inner.normalized;
701 tokens.extend(quote! {
702 jid::FullJid::new(#s).unwrap()
703 });
704 }
705}
706
707#[cfg(feature = "quote")]
708impl ToTokens for BareJid {
709 fn to_tokens(&self, tokens: &mut TokenStream) {
710 let s = &self.inner.normalized;
711 tokens.extend(quote! {
712 jid::BareJid::new(#s).unwrap()
713 });
714 }
715}
716
717impl FullJid {
718 /// Constructs a full Jabber ID containing all three components. This is of the form
719 /// `node@domain/resource`, where node part is optional.
720 /// If you want a non-fallible version, use [`FullJid::from_parts`] instead.
721 ///
722 /// # Examples
723 ///
724 /// ```
725 /// use jid::FullJid;
726 /// # use jid::Error;
727 ///
728 /// # fn main() -> Result<(), Error> {
729 /// let jid = FullJid::new("node@domain/resource")?;
730 ///
731 /// assert_eq!(jid.node().map(|x| x.as_str()), Some("node"));
732 /// assert_eq!(jid.domain().as_str(), "domain");
733 /// assert_eq!(jid.resource().as_str(), "resource");
734 /// # Ok(())
735 /// # }
736 /// ```
737 pub fn new(unnormalized: &str) -> Result<Self, Error> {
738 Jid::new(unnormalized)?.try_into()
739 }
740
741 /// Build a [`FullJid`] from typed parts. This method cannot fail because it uses parts that have
742 /// already been parsed and stringprepped into [`NodePart`], [`DomainPart`], and [`ResourcePart`].
743 /// This method allocates and does not consume the typed parts.
744 pub fn from_parts(
745 node: Option<&NodeRef>,
746 domain: &DomainRef,
747 resource: &ResourceRef,
748 ) -> FullJid {
749 let (at, slash, normalized);
750
751 if let Some(node) = node {
752 // Parts are never empty so len > 0 for NonZeroU16::new is always Some
753 at = NonZeroU16::new(node.len() as u16);
754 slash = NonZeroU16::new((node.len() + 1 + domain.len()) as u16);
755 normalized = format!("{node}@{domain}/{resource}");
756 } else {
757 at = None;
758 slash = NonZeroU16::new(domain.len() as u16);
759 normalized = format!("{domain}/{resource}");
760 }
761
762 let inner = Jid {
763 normalized,
764 at,
765 slash,
766 };
767
768 Self { inner }
769 }
770
771 /// The optional resource of the Jabber ID. Since this is a full JID it is always present.
772 pub fn resource(&self) -> &ResourceRef {
773 self.inner.resource().unwrap()
774 }
775
776 /// Return the inner String of this full JID.
777 pub fn into_inner(self) -> String {
778 self.inner.into_inner()
779 }
780
781 /// Transforms this full JID into a [`BareJid`], throwing away the
782 /// resource.
783 ///
784 /// ```
785 /// # use jid::{BareJid, FullJid};
786 /// let jid: FullJid = "foo@bar/baz".parse().unwrap();
787 /// let bare = jid.into_bare();
788 /// assert_eq!(bare.to_string(), "foo@bar");
789 /// ```
790 pub fn into_bare(self) -> BareJid {
791 self.inner.into_bare()
792 }
793}
794
795impl FromStr for BareJid {
796 type Err = Error;
797
798 fn from_str(s: &str) -> Result<Self, Self::Err> {
799 Self::new(s)
800 }
801}
802
803impl BareJid {
804 /// Constructs a bare Jabber ID, containing two components. This is of the form
805 /// `node`@`domain`, where node part is optional.
806 /// If you want a non-fallible version, use [`BareJid::from_parts`] instead.
807 ///
808 /// # Examples
809 ///
810 /// ```
811 /// use jid::BareJid;
812 /// # use jid::Error;
813 ///
814 /// # fn main() -> Result<(), Error> {
815 /// let jid = BareJid::new("node@domain")?;
816 ///
817 /// assert_eq!(jid.node().map(|x| x.as_str()), Some("node"));
818 /// assert_eq!(jid.domain().as_str(), "domain");
819 /// # Ok(())
820 /// # }
821 /// ```
822 pub fn new(unnormalized: &str) -> Result<Self, Error> {
823 Jid::new(unnormalized)?.try_into()
824 }
825
826 /// Build a [`BareJid`] from typed parts. This method cannot fail because it uses parts that have
827 /// already been parsed and stringprepped into [`NodePart`] and [`DomainPart`].
828 ///
829 /// This method allocates and does not consume the typed parts. To avoid
830 /// allocation if `node` is known to be `None` and `domain` is owned, you
831 /// can use `domain.into()`.
832 pub fn from_parts(node: Option<&NodeRef>, domain: &DomainRef) -> Self {
833 let (at, normalized);
834
835 if let Some(node) = node {
836 // Parts are never empty so len > 0 for NonZeroU16::new is always Some
837 at = NonZeroU16::new(node.len() as u16);
838 normalized = format!("{node}@{domain}");
839 } else {
840 at = None;
841 normalized = domain.to_string();
842 }
843
844 let inner = Jid {
845 normalized,
846 at,
847 slash: None,
848 };
849
850 Self { inner }
851 }
852
853 /// Constructs a [`BareJid`] from the bare JID, by specifying a [`ResourcePart`].
854 /// If you'd like to specify a stringy resource, use [`BareJid::with_resource_str`] instead.
855 ///
856 /// # Examples
857 ///
858 /// ```
859 /// use jid::{BareJid, ResourcePart};
860 ///
861 /// let resource = ResourcePart::new("resource").unwrap();
862 /// let bare = BareJid::new("node@domain").unwrap();
863 /// let full = bare.with_resource(&resource);
864 ///
865 /// assert_eq!(full.node().map(|x| x.as_str()), Some("node"));
866 /// assert_eq!(full.domain().as_str(), "domain");
867 /// assert_eq!(full.resource().as_str(), "resource");
868 /// ```
869 pub fn with_resource(&self, resource: &ResourceRef) -> FullJid {
870 let slash = NonZeroU16::new(self.inner.normalized.len() as u16);
871 let normalized = format!("{}/{resource}", self.inner.normalized);
872 let inner = Jid {
873 normalized,
874 at: self.inner.at,
875 slash,
876 };
877
878 FullJid { inner }
879 }
880
881 /// Constructs a [`FullJid`] from the bare JID, by specifying a stringy `resource`.
882 /// If your resource has already been parsed into a [`ResourcePart`], use [`BareJid::with_resource`].
883 ///
884 /// # Examples
885 ///
886 /// ```
887 /// use jid::BareJid;
888 ///
889 /// let bare = BareJid::new("node@domain").unwrap();
890 /// let full = bare.with_resource_str("resource").unwrap();
891 ///
892 /// assert_eq!(full.node().map(|x| x.as_str()), Some("node"));
893 /// assert_eq!(full.domain().as_str(), "domain");
894 /// assert_eq!(full.resource().as_str(), "resource");
895 /// ```
896 pub fn with_resource_str(&self, resource: &str) -> Result<FullJid, Error> {
897 let resource = ResourcePart::new(resource)?;
898 Ok(self.with_resource(&resource))
899 }
900
901 /// Return the inner String of this bare JID.
902 pub fn into_inner(self) -> String {
903 self.inner.into_inner()
904 }
905}
906
907#[cfg(feature = "minidom")]
908impl IntoAttributeValue for Jid {
909 fn into_attribute_value(self) -> Option<String> {
910 Some(self.to_string())
911 }
912}
913
914#[cfg(feature = "minidom")]
915impl From<Jid> for Node {
916 fn from(jid: Jid) -> Self {
917 Node::Text(jid.to_string())
918 }
919}
920
921#[cfg(feature = "minidom")]
922impl IntoAttributeValue for FullJid {
923 fn into_attribute_value(self) -> Option<String> {
924 self.inner.into_attribute_value()
925 }
926}
927
928#[cfg(feature = "minidom")]
929impl From<FullJid> for Node {
930 fn from(jid: FullJid) -> Self {
931 jid.inner.into()
932 }
933}
934
935#[cfg(feature = "minidom")]
936impl IntoAttributeValue for BareJid {
937 fn into_attribute_value(self) -> Option<String> {
938 self.inner.into_attribute_value()
939 }
940}
941
942#[cfg(feature = "minidom")]
943impl From<BareJid> for Node {
944 fn from(other: BareJid) -> Self {
945 other.inner.into()
946 }
947}
948
949#[cfg(test)]
950mod tests {
951 use super::*;
952
953 use alloc::{
954 collections::{BTreeMap, BTreeSet},
955 vec::Vec,
956 };
957
958 macro_rules! assert_size (
959 ($t:ty, $sz:expr) => (
960 assert_eq!(::core::mem::size_of::<$t>(), $sz);
961 );
962 );
963
964 #[cfg(target_pointer_width = "32")]
965 #[test]
966 fn test_size() {
967 assert_size!(BareJid, 16);
968 assert_size!(FullJid, 16);
969 assert_size!(Jid, 16);
970 }
971
972 #[cfg(target_pointer_width = "64")]
973 #[test]
974 fn test_size() {
975 assert_size!(BareJid, 32);
976 assert_size!(FullJid, 32);
977 assert_size!(Jid, 32);
978 }
979
980 #[test]
981 fn can_parse_full_jids() {
982 assert_eq!(
983 FullJid::from_str("a@b.c/d"),
984 Ok(FullJid::new("a@b.c/d").unwrap())
985 );
986 assert_eq!(
987 FullJid::from_str("b.c/d"),
988 Ok(FullJid::new("b.c/d").unwrap())
989 );
990
991 assert_eq!(
992 FullJid::from_str("a@b.c"),
993 Err(Error::ResourceMissingInFullJid)
994 );
995 assert_eq!(
996 FullJid::from_str("b.c"),
997 Err(Error::ResourceMissingInFullJid)
998 );
999 }
1000
1001 #[test]
1002 fn can_parse_bare_jids() {
1003 assert_eq!(
1004 BareJid::from_str("a@b.c"),
1005 Ok(BareJid::new("a@b.c").unwrap())
1006 );
1007 assert_eq!(BareJid::from_str("b.c"), Ok(BareJid::new("b.c").unwrap()));
1008 }
1009
1010 #[test]
1011 fn can_parse_jids() {
1012 let full = FullJid::from_str("a@b.c/d").unwrap();
1013 let bare = BareJid::from_str("e@f.g").unwrap();
1014
1015 assert_eq!(Jid::from_str("a@b.c/d").unwrap(), full);
1016 assert_eq!(Jid::from_str("e@f.g").unwrap(), bare);
1017 }
1018
1019 #[test]
1020 fn full_to_bare_jid() {
1021 let bare: BareJid = FullJid::new("a@b.c/d").unwrap().to_bare();
1022 assert_eq!(bare, BareJid::new("a@b.c").unwrap());
1023 }
1024
1025 #[test]
1026 fn bare_to_full_jid_str() {
1027 assert_eq!(
1028 BareJid::new("a@b.c")
1029 .unwrap()
1030 .with_resource_str("d")
1031 .unwrap(),
1032 FullJid::new("a@b.c/d").unwrap()
1033 );
1034 }
1035
1036 #[test]
1037 fn bare_to_full_jid() {
1038 assert_eq!(
1039 BareJid::new("a@b.c")
1040 .unwrap()
1041 .with_resource(&ResourcePart::new("d").unwrap()),
1042 FullJid::new("a@b.c/d").unwrap()
1043 )
1044 }
1045
1046 #[test]
1047 fn node_from_jid() {
1048 let jid = Jid::new("a@b.c/d").unwrap();
1049
1050 assert_eq!(jid.node().map(|x| x.as_str()), Some("a"),);
1051 }
1052
1053 #[test]
1054 fn domain_from_jid() {
1055 let jid = Jid::new("a@b.c").unwrap();
1056
1057 assert_eq!(jid.domain().as_str(), "b.c");
1058 }
1059
1060 #[test]
1061 fn resource_from_jid() {
1062 let jid = Jid::new("a@b.c/d").unwrap();
1063
1064 assert_eq!(jid.resource().map(|x| x.as_str()), Some("d"),);
1065 }
1066
1067 #[test]
1068 fn jid_to_full_bare() {
1069 let full = FullJid::new("a@b.c/d").unwrap();
1070 let bare = BareJid::new("a@b.c").unwrap();
1071
1072 assert_eq!(FullJid::try_from(Jid::from(full.clone())), Ok(full.clone()));
1073 assert_eq!(
1074 FullJid::try_from(Jid::from(bare.clone())),
1075 Err(Error::ResourceMissingInFullJid),
1076 );
1077 assert_eq!(Jid::from(full.clone().to_bare()), bare.clone());
1078 assert_eq!(Jid::from(bare.clone()), bare);
1079 }
1080
1081 #[test]
1082 fn serialise() {
1083 assert_eq!(FullJid::new("a@b/c").unwrap().to_string(), "a@b/c");
1084 assert_eq!(BareJid::new("a@b").unwrap().to_string(), "a@b");
1085 }
1086
1087 #[test]
1088 fn hash() {
1089 let _map: BTreeMap<Jid, String> = BTreeMap::new();
1090 }
1091
1092 #[test]
1093 fn invalid_jids() {
1094 assert_eq!(BareJid::from_str(""), Err(Error::Idna));
1095 assert_eq!(BareJid::from_str("/c"), Err(Error::Idna));
1096 assert_eq!(BareJid::from_str("a@/c"), Err(Error::Idna));
1097 assert_eq!(BareJid::from_str("@b"), Err(Error::NodeEmpty));
1098 assert_eq!(BareJid::from_str("b/"), Err(Error::ResourceEmpty));
1099
1100 assert_eq!(FullJid::from_str(""), Err(Error::Idna));
1101 assert_eq!(FullJid::from_str("/c"), Err(Error::Idna));
1102 assert_eq!(FullJid::from_str("a@/c"), Err(Error::Idna));
1103 assert_eq!(FullJid::from_str("@b"), Err(Error::NodeEmpty));
1104 assert_eq!(FullJid::from_str("b/"), Err(Error::ResourceEmpty));
1105 assert_eq!(
1106 FullJid::from_str("a@b"),
1107 Err(Error::ResourceMissingInFullJid)
1108 );
1109 assert_eq!(BareJid::from_str("a@b/c"), Err(Error::ResourceInBareJid));
1110 assert_eq!(BareJid::from_str("a@b@c"), Err(Error::TooManyAts));
1111 assert_eq!(FullJid::from_str("a@b@c/d"), Err(Error::TooManyAts));
1112 }
1113
1114 #[test]
1115 fn display_jids() {
1116 assert_eq!(FullJid::new("a@b/c").unwrap().to_string(), "a@b/c");
1117 assert_eq!(BareJid::new("a@b").unwrap().to_string(), "a@b");
1118 assert_eq!(
1119 Jid::from(FullJid::new("a@b/c").unwrap()).to_string(),
1120 "a@b/c"
1121 );
1122 assert_eq!(Jid::from(BareJid::new("a@b").unwrap()).to_string(), "a@b");
1123 }
1124
1125 #[cfg(feature = "minidom")]
1126 #[test]
1127 fn minidom() {
1128 let elem: minidom::Element = "<message xmlns='ns1' from='a@b/c'/>".parse().unwrap();
1129 let to: Jid = elem.attr("from").unwrap().parse().unwrap();
1130 assert_eq!(to, Jid::from(FullJid::new("a@b/c").unwrap()));
1131
1132 let elem: minidom::Element = "<message xmlns='ns1' from='a@b'/>".parse().unwrap();
1133 let to: Jid = elem.attr("from").unwrap().parse().unwrap();
1134 assert_eq!(to, Jid::from(BareJid::new("a@b").unwrap()));
1135
1136 let elem: minidom::Element = "<message xmlns='ns1' from='a@b/c'/>".parse().unwrap();
1137 let to: FullJid = elem.attr("from").unwrap().parse().unwrap();
1138 assert_eq!(to, FullJid::new("a@b/c").unwrap());
1139
1140 let elem: minidom::Element = "<message xmlns='ns1' from='a@b'/>".parse().unwrap();
1141 let to: BareJid = elem.attr("from").unwrap().parse().unwrap();
1142 assert_eq!(to, BareJid::new("a@b").unwrap());
1143 }
1144
1145 #[cfg(feature = "minidom")]
1146 #[test]
1147 fn minidom_into_attr() {
1148 let full = FullJid::new("a@b/c").unwrap();
1149 let elem = minidom::Element::builder("message", "jabber:client")
1150 .attr("from".try_into().unwrap(), full.clone())
1151 .build();
1152 assert_eq!(elem.attr("from"), Some(full.to_string().as_str()));
1153
1154 let bare = BareJid::new("a@b").unwrap();
1155 let elem = minidom::Element::builder("message", "jabber:client")
1156 .attr("from".try_into().unwrap(), bare.clone())
1157 .build();
1158 assert_eq!(elem.attr("from"), Some(bare.to_string().as_str()));
1159
1160 let jid = Jid::from(bare.clone());
1161 let _elem = minidom::Element::builder("message", "jabber:client")
1162 .attr("from".try_into().unwrap(), jid)
1163 .build();
1164 assert_eq!(elem.attr("from"), Some(bare.to_string().as_str()));
1165 }
1166
1167 #[test]
1168 fn stringprep() {
1169 let full = FullJid::from_str("Test@☃.coM/Test™").unwrap();
1170 let equiv = FullJid::new("test@☃.com/TestTM").unwrap();
1171 assert_eq!(full, equiv);
1172 }
1173
1174 #[test]
1175 fn invalid_stringprep() {
1176 FullJid::from_str("a@b/🎉").unwrap_err();
1177 }
1178
1179 #[test]
1180 fn idna() {
1181 let bare = BareJid::from_str("Weiß.com.").unwrap();
1182 let equiv = BareJid::new("weiss.com").unwrap();
1183 assert_eq!(bare, equiv);
1184 BareJid::from_str("127.0.0.1").unwrap();
1185 BareJid::from_str("[::1]").unwrap();
1186 BareJid::from_str("domain.tld.").unwrap();
1187 }
1188
1189 #[test]
1190 fn invalid_idna() {
1191 BareJid::from_str("a@b@c").unwrap_err();
1192 FullJid::from_str("a@b@c/d").unwrap_err();
1193 BareJid::from_str("[::1234").unwrap_err();
1194 BareJid::from_str("1::1234]").unwrap_err();
1195 BareJid::from_str("domain.tld:5222").unwrap_err();
1196 BareJid::from_str("-domain.tld").unwrap_err();
1197 BareJid::from_str("domain.tld-").unwrap_err();
1198 BareJid::from_str("domain..tld").unwrap_err();
1199 BareJid::from_str("domain.tld..").unwrap_err();
1200 BareJid::from_str("1234567890123456789012345678901234567890123456789012345678901234.com")
1201 .unwrap_err();
1202 }
1203
1204 #[test]
1205 fn jid_from_parts() {
1206 let node = NodePart::new("node").unwrap();
1207 let domain = DomainPart::new("domain").unwrap();
1208 let resource = ResourcePart::new("resource").unwrap();
1209
1210 let jid = Jid::from_parts(Some(&node), &domain, Some(&resource));
1211 assert_eq!(jid, Jid::new("node@domain/resource").unwrap());
1212
1213 let barejid = BareJid::from_parts(Some(&node), &domain);
1214 assert_eq!(barejid, BareJid::new("node@domain").unwrap());
1215
1216 let fulljid = FullJid::from_parts(Some(&node), &domain, &resource);
1217 assert_eq!(fulljid, FullJid::new("node@domain/resource").unwrap());
1218 }
1219
1220 #[test]
1221 #[cfg(feature = "serde")]
1222 fn jid_ser_de() {
1223 let jid: Jid = Jid::new("node@domain").unwrap();
1224 serde_test::assert_tokens(&jid, &[serde_test::Token::Str("node@domain")]);
1225
1226 let jid: Jid = Jid::new("node@domain/resource").unwrap();
1227 serde_test::assert_tokens(&jid, &[serde_test::Token::Str("node@domain/resource")]);
1228
1229 let jid: BareJid = BareJid::new("node@domain").unwrap();
1230 serde_test::assert_tokens(&jid, &[serde_test::Token::Str("node@domain")]);
1231
1232 let jid: FullJid = FullJid::new("node@domain/resource").unwrap();
1233 serde_test::assert_tokens(&jid, &[serde_test::Token::Str("node@domain/resource")]);
1234 }
1235
1236 #[test]
1237 fn jid_into_parts_and_from_parts() {
1238 let node = NodePart::new("node").unwrap();
1239 let domain = DomainPart::new("domain").unwrap();
1240
1241 let jid1 = domain.with_node(&node);
1242 let jid2 = node.with_domain(&domain);
1243 let jid3 = BareJid::new("node@domain").unwrap();
1244 assert_eq!(jid1, jid2);
1245 assert_eq!(jid2, jid3);
1246 }
1247
1248 #[test]
1249 fn jid_match_replacement_try_as() {
1250 let jid1 = Jid::new("foo@bar").unwrap();
1251 let jid2 = Jid::new("foo@bar/baz").unwrap();
1252
1253 match jid1.try_as_full() {
1254 Err(_) => (),
1255 other => panic!("unexpected result: {:?}", other),
1256 };
1257
1258 match jid2.try_as_full() {
1259 Ok(_) => (),
1260 other => panic!("unexpected result: {:?}", other),
1261 };
1262 }
1263
1264 #[test]
1265 fn jid_match_replacement_try_as_mut() {
1266 let mut jid1 = Jid::new("foo@bar").unwrap();
1267 let mut jid2 = Jid::new("foo@bar/baz").unwrap();
1268
1269 match jid1.try_as_full_mut() {
1270 Err(_) => (),
1271 other => panic!("unexpected result: {:?}", other),
1272 };
1273
1274 match jid2.try_as_full_mut() {
1275 Ok(_) => (),
1276 other => panic!("unexpected result: {:?}", other),
1277 };
1278 }
1279
1280 #[test]
1281 fn jid_match_replacement_try_into() {
1282 let jid1 = Jid::new("foo@bar").unwrap();
1283 let jid2 = Jid::new("foo@bar/baz").unwrap();
1284
1285 match jid1.try_as_full() {
1286 Err(_) => (),
1287 other => panic!("unexpected result: {:?}", other),
1288 };
1289
1290 match jid2.try_as_full() {
1291 Ok(_) => (),
1292 other => panic!("unexpected result: {:?}", other),
1293 };
1294 }
1295
1296 #[test]
1297 fn lookup_jid_by_full_jid() {
1298 let mut map: BTreeSet<Jid> = BTreeSet::new();
1299 let jid1 = Jid::new("foo@bar").unwrap();
1300 let jid2 = Jid::new("foo@bar/baz").unwrap();
1301 let jid3 = FullJid::new("foo@bar/baz").unwrap();
1302
1303 map.insert(jid1);
1304 assert!(!map.contains(&jid2));
1305 assert!(!map.contains(&jid3));
1306 map.insert(jid2);
1307 assert!(map.contains(&jid3));
1308 }
1309
1310 #[test]
1311 fn lookup_full_jid_by_jid() {
1312 let mut map: BTreeSet<FullJid> = BTreeSet::new();
1313 let jid1 = FullJid::new("foo@bar/baz").unwrap();
1314 let jid2 = FullJid::new("foo@bar/fnord").unwrap();
1315 let jid3 = Jid::new("foo@bar/fnord").unwrap();
1316
1317 map.insert(jid1);
1318 assert!(!map.contains(&jid2));
1319 assert!(!map.contains(&jid3));
1320 map.insert(jid2);
1321 assert!(map.contains(&jid3));
1322 }
1323
1324 #[test]
1325 fn lookup_bare_jid_by_jid() {
1326 let mut map: BTreeSet<BareJid> = BTreeSet::new();
1327 let jid1 = BareJid::new("foo@bar").unwrap();
1328 let jid2 = BareJid::new("foo@baz").unwrap();
1329 let jid3 = Jid::new("foo@baz").unwrap();
1330
1331 map.insert(jid1);
1332 assert!(!map.contains(&jid2));
1333 assert!(!map.contains(&jid3));
1334 map.insert(jid2);
1335 assert!(map.contains(&jid3));
1336 }
1337
1338 #[test]
1339 fn normalizes_all_parts() {
1340 assert_eq!(
1341 Jid::new("ßA@IX.test/\u{2168}").unwrap().as_str(),
1342 "ssa@ix.test/IX"
1343 );
1344 }
1345
1346 #[test]
1347 fn rejects_unassigned_codepoints() {
1348 match Jid::new("\u{01f601}@example.com") {
1349 Err(Error::NodePrep) => (),
1350 other => panic!("unexpected result: {:?}", other),
1351 };
1352
1353 match Jid::new("foo@\u{01f601}.example.com") {
1354 Err(Error::NamePrep) => (),
1355 other => panic!("unexpected result: {:?}", other),
1356 };
1357
1358 match Jid::new("foo@example.com/\u{01f601}") {
1359 Err(Error::ResourcePrep) => (),
1360 other => panic!("unexpected result: {:?}", other),
1361 };
1362 }
1363
1364 #[test]
1365 fn accepts_domain_only_jid() {
1366 match Jid::new("example.com") {
1367 Ok(_) => (),
1368 other => panic!("unexpected result: {:?}", other),
1369 };
1370
1371 match BareJid::new("example.com") {
1372 Ok(_) => (),
1373 other => panic!("unexpected result: {:?}", other),
1374 };
1375
1376 match FullJid::new("example.com/x") {
1377 Ok(_) => (),
1378 other => panic!("unexpected result: {:?}", other),
1379 };
1380 }
1381
1382 #[test]
1383 fn is_bare_returns_true_iff_bare() {
1384 let bare = Jid::new("foo@bar").unwrap();
1385 let full = Jid::new("foo@bar/baz").unwrap();
1386
1387 assert!(bare.is_bare());
1388 assert!(!full.is_bare());
1389 }
1390
1391 #[test]
1392 fn is_full_returns_true_iff_full() {
1393 let bare = Jid::new("foo@bar").unwrap();
1394 let full = Jid::new("foo@bar/baz").unwrap();
1395
1396 assert!(!bare.is_full());
1397 assert!(full.is_full());
1398 }
1399
1400 #[test]
1401 fn reject_long_localpart() {
1402 let mut long = Vec::with_capacity(1028);
1403 long.resize(1024, b'a');
1404 let mut long = String::from_utf8(long).unwrap();
1405 long.push_str("@foo");
1406
1407 match Jid::new(&long) {
1408 Err(Error::NodeTooLong) => (),
1409 other => panic!("unexpected result: {:?}", other),
1410 }
1411
1412 match BareJid::new(&long) {
1413 Err(Error::NodeTooLong) => (),
1414 other => panic!("unexpected result: {:?}", other),
1415 }
1416 }
1417
1418 #[test]
1419 fn reject_long_domainpart() {
1420 let mut long = Vec::with_capacity(66);
1421 long.push(b'x');
1422 long.push(b'@');
1423 long.resize(66, b'a');
1424 let long = String::from_utf8(long).unwrap();
1425
1426 Jid::new(&long).unwrap_err();
1427 BareJid::new(&long).unwrap_err();
1428
1429 // A domain can be up to 253 bytes.
1430 let mut long = Vec::with_capacity(256);
1431 long.push(b'x');
1432 long.push(b'@');
1433 long.resize(65, b'a');
1434 long.push(b'.');
1435 long.resize(129, b'b');
1436 long.push(b'.');
1437 long.resize(193, b'c');
1438 long.push(b'.');
1439 long.resize(256, b'd');
1440 let long = String::from_utf8(long).unwrap();
1441
1442 Jid::new(&long).unwrap_err();
1443 BareJid::new(&long).unwrap_err();
1444 }
1445
1446 #[test]
1447 fn reject_long_resourcepart() {
1448 let mut long = Vec::with_capacity(1028);
1449 long.push(b'x');
1450 long.push(b'@');
1451 long.push(b'y');
1452 long.push(b'/');
1453 long.resize(1028, b'a');
1454 let long = String::from_utf8(long).unwrap();
1455
1456 match Jid::new(&long) {
1457 Err(Error::ResourceTooLong) => (),
1458 other => panic!("unexpected result: {:?}", other),
1459 }
1460
1461 match FullJid::new(&long) {
1462 Err(Error::ResourceTooLong) => (),
1463 other => panic!("unexpected result: {:?}", other),
1464 }
1465 }
1466}