jid/
lib.rs

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

jid/
lib.rs
