+ *+ * + * @return True, if the JID is a full JID; otherwise false. + */ + @Override + public final boolean isFullJid() { + return getResource() != null; + } + + /** + * Checks if the JID is a bare JID. + *The term "full JID" refers to an XMPP address of the form <localpart@domainpart/resourcepart> (for a particular authorized client or device associated with an account) or of the form <domainpart/resourcepart> (for a particular resource or script associated with a server).
+ *
+ *+ * + * @return True, if the JID is a bare JID; otherwise false. + */ + @Override + public final boolean isBareJid() { + return getResource() == null; + } + + @Override + public final boolean isDomainJid() { + return getLocal() == null; + } + + @Override + public final boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof Jid)) { + return false; + } + Jid other = (Jid) o; + + return (getLocal() == other.getLocal() || getLocal() != null && getLocal().equals(other.getLocal())) + && (getDomain() == other.getDomain() || getDomain() != null && getDomain().equals(other.getDomain())) + && (getResource() == other.getResource() || getResource() != null && getResource().equals(other.getResource())); + } + + @Override + public final int hashCode() { + return Arrays.hashCode(new String[]{getLocal(), getDomain(), getResource()}); + } + + /** + * Compares this JID with another JID. First domain parts are compared. If these are equal, local parts are compared + * and if these are equal, too, resource parts are compared. + * + * @param o The other JID. + * @return The comparison result. + */ + @Override + public final int compareTo(Jid o) { + + if (this == o) { + return 0; + } + + if (o != null) { + final Collator collator = Collator.getInstance(); + int result; + // First compare domain parts. + if (getDomain() != null) { + result = o.getDomain() != null ? collator.compare(getDomain(), o.getDomain()) : -1; + } else { + result = o.getDomain() != null ? 1 : 0; + } + // If the domains are equal, compare local parts. + if (result == 0) { + if (getLocal() != null) { + // If this local part is not null, but the other is null, move this down (1). + result = o.getLocal() != null ? collator.compare(getLocal(), o.getLocal()) : 1; + } else { + // If this local part is null, but the other is not, move this up (-1). + result = o.getLocal() != null ? -1 : 0; + } + } + // If the local parts are equal, compare resource parts. + if (result == 0) { + if (getResource() != null) { + // If this resource part is not null, but the other is null, move this down (1). + return o.getResource() != null ? collator.compare(getResource(), o.getResource()) : 1; + } else { + // If this resource part is null, but the other is not, move this up (-1). + return o.getResource() != null ? -1 : 0; + } + } + return result; + } else { + return -1; + } + } + + @Override + public final int length() { + return toString().length(); + } + + @Override + public final char charAt(int index) { + return toString().charAt(index); + } + + @Override + public final CharSequence subSequence(int start, int end) { + return toString().subSequence(start, end); + } + + /** + * Returns the JID in its string representation, i.e. [ localpart "@" ] domainpart [ "/" resourcepart ]. + * + * @return The JID. + * @see #toEscapedString() + */ + @Override + public final String toString() { + return toString(getLocal(), getDomain(), getResource()); + } + + @Override + public final String toEscapedString() { + return toString(getEscapedLocal(), getDomain(), getResource()); + } + + static String toString(String local, String domain, String resource) { + StringBuilder sb = new StringBuilder(); + if (local != null) { + sb.append(local).append('@'); + } + sb.append(domain); + if (resource != null) { + sb.append('/').append(resource); + } + return sb.toString(); + } +} diff --git a/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/FullJid.java b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/FullJid.java new file mode 100644 index 000000000..24130fd1b --- /dev/null +++ b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/FullJid.java @@ -0,0 +1,498 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014-2017 Christian Schudt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package rocks.xmpp.addr; + +import rocks.xmpp.precis.PrecisProfile; +import rocks.xmpp.precis.PrecisProfiles; +import rocks.xmpp.util.cache.LruCache; + +import java.net.IDN; +import java.nio.charset.Charset; +import java.text.Normalizer; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * The implementation of the JID as described in Extensible Messaging and Presence Protocol (XMPP): Address Format. + *The term "bare JID" refers to an XMPP address of the form <localpart@domainpart> (for an account at a server) or of the form <domainpart> (for a server).
+ *
+ * This class is thread-safe and immutable.
+ *
+ * @author Christian Schudt
+ * @see RFC 7622 - Extensible Messaging and Presence Protocol (XMPP): Address Format
+ */
+final class FullJid extends AbstractJid {
+
+ /**
+ * Escapes all disallowed characters and also backslash, when followed by a defined hex code for escaping. See 4. Business Rules.
+ */
+ private static final Pattern ESCAPE_PATTERN = Pattern.compile("[ \"&'/:<>@]|\\\\(?=20|22|26|27|2f|3a|3c|3e|40|5c)");
+
+ private static final Pattern UNESCAPE_PATTERN = Pattern.compile("\\\\(20|22|26|27|2f|3a|3c|3e|40|5c)");
+
+ private static final Pattern JID = Pattern.compile("^((.*?)@)?([^/@]+)(/(.*))?$");
+
+ private static final IDNProfile IDN_PROFILE = new IDNProfile();
+
+ /**
+ * Whenever dots are used as label separators, the following characters MUST be recognized as dots: U+002E (full stop), U+3002 (ideographic full stop), U+FF0E (fullwidth full stop), U+FF61 (halfwidth ideographic full stop).
+ */
+ private static final String DOTS = "[.\u3002\uFF0E\uFF61]";
+
+ /**
+ * Label separators for domain labels, which should be mapped to "." (dot): IDEOGRAPHIC FULL STOP character (U+3002)
+ */
+ private static final Pattern LABEL_SEPARATOR = Pattern.compile(DOTS);
+
+ private static final Pattern LABEL_SEPARATOR_FINAL = Pattern.compile(DOTS + "$");
+
+ /**
+ * Caches the escaped JIDs.
+ */
+ private static final Map [ localpart "@" ] domainpart [ "/" resourcepart ] The term "bare JID" refers to an XMPP address of the form <localpart@domainpart> (for an account at a server) or of the form <domainpart> (for a server). The localpart of a JID is an optional identifier placed before the
+ * domainpart and separated from the latter by the '@' character.
+ * Typically, a localpart uniquely identifies the entity requesting and
+ * using network access provided by a server (i.e., a local account),
+ * although it can also represent other kinds of entities (e.g., a
+ * chatroom associated with a multi-user chat service [XEP-0045]). The
+ * entity represented by an XMPP localpart is addressed within the
+ * context of a specific domain (i.e., <localpart@domainpart>). The domainpart is the primary identifier and is the only REQUIRED
+ * element of a JID (a mere domainpart is a valid JID). Typically,
+ * a domainpart identifies the "home" server to which clients connect
+ * for XML routing and data management functionality. The resourcepart of a JID is an optional identifier placed after the
+ * domainpart and separated from the latter by the '/' character. A
+ * resourcepart can modify either a <localpart@domainpart> address or a
+ * mere <domainpart> address. Typically, a resourcepart uniquely
+ * identifies a specific connection (e.g., a device or location) or
+ * object (e.g., an occupant in a multi-user chatroom [XEP-0045])
+ * belonging to the entity associated with an XMPP localpart at a domain
+ * (i.e., <localpart@domainpart/resourcepart>).
+ * A JID consists of three parts:
+ *
+ * [ localpart "@" ] domainpart [ "/" resourcepart ]
+ *
+ * Implementations of this interface should be thread-safe and immutable.
+ *
+ * @author Christian Schudt
+ * @see RFC 7622 - Extensible Messaging and Presence Protocol (XMPP): Address Format
+ */
+@XmlJavaTypeAdapter(JidAdapter.class)
+public interface Jid extends Comparable Each allowable portion of a JID (localpart, domainpart, and
+ * resourcepart) is 1 to 1023 octets in length, resulting in a maximum
+ * total size (including the '@' and '/' separators) of 3071 octets.
+ * [ localpart "@" ] domainpart [ "/" resourcepart ] [ localpart "@" ] domainpart [ "/" resourcepart ] The term "full JID" refers to an XMPP address of the form <localpart@domainpart/resourcepart> (for a particular authorized client or device associated with an account) or of the form <domainpart/resourcepart> (for a particular resource or script associated with a server). The term "bare JID" refers to an XMPP address of the form <localpart@domainpart> (for an account at a server) or of the form <domainpart> (for a server). The term "bare JID" refers to an XMPP address of the form <localpart@domainpart> (for an account at a server) or of the form <domainpart> (for a server). The localpart of a JID is an optional identifier placed before the
+ * domainpart and separated from the latter by the '@' character.
+ * Typically, a localpart uniquely identifies the entity requesting and
+ * using network access provided by a server (i.e., a local account),
+ * although it can also represent other kinds of entities (e.g., a
+ * chatroom associated with a multi-user chat service [XEP-0045]). The
+ * entity represented by an XMPP localpart is addressed within the
+ * context of a specific domain (i.e., <localpart@domainpart>). The domainpart is the primary identifier and is the only REQUIRED
+ * element of a JID (a mere domainpart is a valid JID). Typically,
+ * a domainpart identifies the "home" server to which clients connect
+ * for XML routing and data management functionality. The resourcepart of a JID is an optional identifier placed after the
+ * domainpart and separated from the latter by the '/' character. A
+ * resourcepart can modify either a <localpart@domainpart> address or a
+ * mere <domainpart> address. Typically, a resourcepart uniquely
+ * identifies a specific connection (e.g., a device or location) or
+ * object (e.g., an occupant in a multi-user chatroom [XEP-0045])
+ * belonging to the entity associated with an XMPP localpart at a domain
+ * (i.e., <localpart@domainpart/resourcepart>).
+ * This class is not intended to be publicly instantiable, but is used for malformed JIDs during parsing automatically.
+ *
+ * @author Christian Schudt
+ * @see RFC 6120, 8.3.3.8. jid-malformed
+ */
+public final class MalformedJid extends AbstractJid {
+
+ private static final long serialVersionUID = -2896737611021417985L;
+
+ private final String localPart;
+
+ private final String domainPart;
+
+ private final String resourcePart;
+
+ private final Throwable cause;
+
+ static MalformedJid of(final String jid, final Throwable cause) {
+ // Do some basic parsing without any further checks or validation.
+ final StringBuilder sb = new StringBuilder(jid);
+ // 1. Remove any portion from the first '/' character to the end of the
+ // string (if there is a '/' character present).
+ final int indexOfResourceDelimiter = jid.indexOf('/');
+ final String resourcePart;
+ if (indexOfResourceDelimiter > -1) {
+ resourcePart = sb.substring(indexOfResourceDelimiter + 1);
+ sb.delete(indexOfResourceDelimiter, sb.length());
+ } else {
+ resourcePart = null;
+ }
+ // 2. Remove any portion from the beginning of the string to the first
+ // '@' character (if there is an '@' character present).
+ final int indexOfAt = jid.indexOf('@');
+ final String localPart;
+ if (indexOfAt > -1) {
+ localPart = sb.substring(0, indexOfAt);
+ sb.delete(0, indexOfAt + 1);
+ } else {
+ localPart = null;
+ }
+ return new MalformedJid(localPart, sb.toString(), resourcePart, cause);
+ }
+
+ private MalformedJid(final String localPart, final String domainPart, final String resourcePart, final Throwable cause) {
+ this.localPart = localPart;
+ this.domainPart = domainPart;
+ this.resourcePart = resourcePart;
+ this.cause = cause;
+ }
+
+ @Override
+ public final Jid asBareJid() {
+ return new MalformedJid(localPart, domainPart, null, cause);
+ }
+
+ @Override
+ public Jid withLocal(CharSequence local) {
+ return new MalformedJid(local.toString(), domainPart, resourcePart, cause);
+ }
+
+ @Override
+ public Jid withResource(CharSequence resource) {
+ return new MalformedJid(localPart, domainPart, resource.toString(), cause);
+ }
+
+ @Override
+ public Jid atSubdomain(CharSequence subdomain) {
+ if (subdomain == null) {
+ throw new NullPointerException();
+ }
+ return new MalformedJid(localPart, subdomain + "." + domainPart, resourcePart, cause);
+ }
+
+ @Override
+ public final String getLocal() {
+ return localPart;
+ }
+
+ @Override
+ public final String getEscapedLocal() {
+ return localPart;
+ }
+
+ @Override
+ public final String getDomain() {
+ return domainPart;
+ }
+
+ @Override
+ public final String getResource() {
+ return resourcePart;
+ }
+
+ /**
+ * Gets the cause why the JID is malformed.
+ *
+ * @return The cause.
+ */
+ public final Throwable getCause() {
+ return cause;
+ }
+}
diff --git a/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/package-info.java b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/package-info.java
new file mode 100644
index 000000000..e12485d5f
--- /dev/null
+++ b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2016 Christian Schudt
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * Provides classes for the XMPP Address Format (JID).
+ *
+ * @see Extensible Messaging and Presence Protocol (XMPP): Address Format
+ */
+package rocks.xmpp.addr;
+
diff --git a/libs/xmpp-addr/src/main/java/rocks/xmpp/util/cache/DirectoryCache.java b/libs/xmpp-addr/src/main/java/rocks/xmpp/util/cache/DirectoryCache.java
new file mode 100644
index 000000000..9b7d66d04
--- /dev/null
+++ b/libs/xmpp-addr/src/main/java/rocks/xmpp/util/cache/DirectoryCache.java
@@ -0,0 +1,192 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2016 Christian Schudt
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package rocks.xmpp.util.cache;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * A simple directory based cache for caching of persistent items like avatars or entity capabilities.
+ *
+ * @author Christian Schudt
+ */
+public final class DirectoryCache implements Map
+ * This cache is keeps a maximal number of items in memory and removes the least-recently-used item, when new items are added.
+ *
+ * @param
+ *
+ * @param jid The JID.
+ * @param doUnescape If the jid parameter will be unescaped.
+ * @return The JID.
+ * @throws NullPointerException If the jid is null.
+ * @throws IllegalArgumentException If the jid could not be parsed or is not valid.
+ * @see XEP-0106: JID Escaping
+ */
+ static Jid of(String jid, final boolean doUnescape) {
+ if (jid == null) {
+ throw new NullPointerException("jid must not be null.");
+ }
+
+ jid = jid.trim();
+
+ if (jid.isEmpty()) {
+ throw new IllegalArgumentException("jid must not be empty.");
+ }
+
+ Jid result;
+ if (doUnescape) {
+ result = UNESCAPED_CACHE.get(jid);
+ } else {
+ result = ESCAPED_CACHE.get(jid);
+ }
+
+ if (result != null) {
+ return result;
+ }
+
+ Matcher matcher = JID.matcher(jid);
+ if (matcher.matches()) {
+ Jid jidValue = new FullJid(matcher.group(2), matcher.group(3), matcher.group(5), doUnescape, null);
+ if (doUnescape) {
+ UNESCAPED_CACHE.put(jid, jidValue);
+ } else {
+ ESCAPED_CACHE.put(jid, jidValue);
+ }
+ return jidValue;
+ } else {
+ throw new IllegalArgumentException("Could not parse JID: " + jid);
+ }
+ }
+
+ /**
+ * Escapes a local part. The characters {@code "&'/:<>@} (+ whitespace) are replaced with their respective escape characters.
+ *
+ * @param localPart The local part.
+ * @return The escaped local part or null.
+ * @see XEP-0106: JID Escaping
+ */
+ private static String escape(final CharSequence localPart) {
+ if (localPart != null) {
+ final Matcher matcher = ESCAPE_PATTERN.matcher(localPart);
+ final StringBuffer sb = new StringBuffer();
+ while (matcher.find()) {
+ matcher.appendReplacement(sb, "\\\\" + Integer.toHexString(matcher.group().charAt(0)));
+ }
+ matcher.appendTail(sb);
+ return sb.toString();
+ }
+ return null;
+ }
+
+ private static String unescape(final CharSequence localPart) {
+ if (localPart != null) {
+ final Matcher matcher = UNESCAPE_PATTERN.matcher(localPart);
+ final StringBuffer sb = new StringBuffer();
+ while (matcher.find()) {
+ final char c = (char) Integer.parseInt(matcher.group(1), 16);
+ if (c == '\\') {
+ matcher.appendReplacement(sb, "\\\\");
+ } else {
+ matcher.appendReplacement(sb, String.valueOf(c));
+ }
+ }
+ matcher.appendTail(sb);
+ return sb.toString();
+ }
+ return null;
+ }
+
+ private static void validateDomain(String domain) {
+ if (domain == null) {
+ throw new NullPointerException("domain must not be null.");
+ }
+ if (domain.contains("@")) {
+ // Prevent misuse of API.
+ throw new IllegalArgumentException("domain must not contain a '@' sign");
+ }
+ validateLength(domain, "domain");
+ }
+
+ /**
+ * Validates that the length of a local, domain or resource part is not longer than 1023 characters.
+ *
+ * @param value The value.
+ * @param part The part, only used to produce an exception message.
+ */
+ private static void validateLength(CharSequence value, CharSequence part) {
+ if (value != null) {
+ if (value.length() == 0) {
+ throw new IllegalArgumentException(part + " must not be empty.");
+ }
+ if (value.toString().getBytes(Charset.forName("UTF-8")).length > 1023) {
+ throw new IllegalArgumentException(part + " must not be greater than 1023 bytes.");
+ }
+ }
+ }
+
+ /**
+ * Converts this JID into a bare JID, i.e. removes the resource part.
+ *
+ *
+ *
+ * @return The bare JID.
+ * @see #withResource(CharSequence)
+ */
+ @Override
+ public final Jid asBareJid() {
+ return bareJid;
+ }
+
+ /**
+ * Gets the local part of the JID, also known as the name or node.
+ *
+ *
+ *
+ *
+ * @return The local part or null.
+ */
+ @Override
+ public final String getLocal() {
+ return local;
+ }
+
+ @Override
+ public final String getEscapedLocal() {
+ return escapedLocal;
+ }
+
+ /**
+ * Gets the domain part.
+ *
+ *
+ *
+ *
+ * @return The domain part.
+ */
+ @Override
+ public final String getDomain() {
+ return domain;
+ }
+
+ /**
+ * Gets the resource part.
+ *
+ *
+ *
+ *
+ * @return The resource part or null.
+ */
+ @Override
+ public final String getResource() {
+ return resource;
+ }
+
+ /**
+ * Creates a new JID with a new local part and the same domain and resource part of the current JID.
+ *
+ * @param local The local part.
+ * @return The JID with a new local part.
+ * @throws IllegalArgumentException If the local is not a valid local part.
+ * @see #withResource(CharSequence)
+ */
+ @Override
+ public final Jid withLocal(CharSequence local) {
+ if (local == this.getLocal() || local != null && local.equals(this.getLocal())) {
+ return this;
+ }
+ return new FullJid(local, getDomain(), getResource(), false, null);
+ }
+
+ /**
+ * Creates a new full JID with a resource and the same local and domain part of the current JID.
+ *
+ * @param resource The resource.
+ * @return The full JID with a resource.
+ * @throws IllegalArgumentException If the resource is not a valid resource part.
+ * @see #asBareJid()
+ * @see #withLocal(CharSequence)
+ */
+ @Override
+ public final Jid withResource(CharSequence resource) {
+ if (resource == this.getResource() || resource != null && resource.equals(this.getResource())) {
+ return this;
+ }
+ return new FullJid(getLocal(), getDomain(), resource, false, asBareJid());
+ }
+
+ /**
+ * Creates a new JID at a subdomain and at the same domain as this JID.
+ *
+ * @param subdomain The subdomain.
+ * @return The JID at a subdomain.
+ * @throws NullPointerException If subdomain is null.
+ * @throws IllegalArgumentException If subdomain is not a valid subdomain name.
+ */
+ @Override
+ public final Jid atSubdomain(CharSequence subdomain) {
+ if (subdomain != null) {
+ throw new NullPointerException();
+ }
+ return new FullJid(getLocal(), subdomain + "." + getDomain(), getResource(), false, null);
+ }
+
+ /**
+ * A profile for applying the rules for IDN as in RFC 5895. Although IDN doesn't use Precis, it's still very similar so that we can use the base class.
+ *
+ * @see RFC 5895
+ */
+ private static final class IDNProfile extends PrecisProfile {
+
+ private IDNProfile() {
+ super(false);
+ }
+
+ @Override
+ public String prepare(CharSequence input) {
+ return IDN.toUnicode(input.toString(), IDN.USE_STD3_ASCII_RULES);
+ }
+
+ @Override
+ public String enforce(CharSequence input) {
+ // 4. Map IDEOGRAPHIC FULL STOP character (U+3002) to dot.
+ return applyAdditionalMappingRule(
+ // 3. All characters are mapped using Unicode Normalization Form C (NFC).
+ applyNormalizationRule(
+ // 2. Fullwidth and halfwidth characters (those defined with
+ // Decomposition Types equals() and hashCode(), so that different instances with the same value are equal:
+ * ```java
+ * Jid.of("romeo@capulet.lit/balcony").equals(Jid.of("romeo@capulet.lit/balcony")); // true
+ * ```
+ * The default implementation of this class also supports XEP-0106: JID Escaping, i.e.
+ * ```java
+ * Jid.of("d'artagnan@musketeers.lit")
+ * ```
+ * is escaped as d\\27artagnan@musketeers.lit.
+ *
+ *
+ *
+ * Note that the length is based on bytes, not characters.
+ *
+ * @see #MAX_BARE_JID_LENGTH
+ */
+ int MAX_FULL_JID_LENGTH = 3071;
+
+ /**
+ * The maximal length of a bare JID, which is 2047 (1023 + 1 + 1023).
+ * Note that the length is based on bytes, not characters.
+ *
+ * @see #MAX_FULL_JID_LENGTH
+ */
+ int MAX_BARE_JID_LENGTH = 2047;
+
+ /**
+ * The service discovery feature used for determining support of JID escaping (jid\20escaping).
+ */
+ String ESCAPING_FEATURE = "jid\\20escaping";
+
+ /**
+ * Returns a full JID with a domain and resource part, e.g. capulet.com/balcony
+ *
+ * @param local The local part.
+ * @param domain The domain.
+ * @param resource The resource part.
+ * @return The JID.
+ * @throws NullPointerException If the domain is null.
+ * @throws IllegalArgumentException If the domain, local or resource part are not valid.
+ */
+ static Jid of(CharSequence local, CharSequence domain, CharSequence resource) {
+ return new FullJid(local, domain, resource);
+ }
+
+ /**
+ * Creates a bare JID with only the domain part, e.g. capulet.com
+ *
+ * @param domain The domain.
+ * @return The JID.
+ * @throws NullPointerException If the domain is null.
+ * @throws IllegalArgumentException If the domain or local part are not valid.
+ */
+ static Jid ofDomain(CharSequence domain) {
+ return new FullJid(null, domain, null);
+ }
+
+ /**
+ * Creates a bare JID with a local and domain part, e.g. juliet@capulet.com
+ *
+ * @param local The local part.
+ * @param domain The domain.
+ * @return The JID.
+ * @throws NullPointerException If the domain is null.
+ * @throws IllegalArgumentException If the domain or local part are not valid.
+ */
+ static Jid ofLocalAndDomain(CharSequence local, CharSequence domain) {
+ return new FullJid(local, domain, null);
+ }
+
+ /**
+ * Creates a full JID with a domain and resource part, e.g. capulet.com/balcony
+ *
+ * @param domain The domain.
+ * @param resource The resource part.
+ * @return The JID.
+ * @throws NullPointerException If the domain is null.
+ * @throws IllegalArgumentException If the domain or resource are not valid.
+ */
+ static Jid ofDomainAndResource(CharSequence domain, CharSequence resource) {
+ return new FullJid(null, domain, resource);
+ }
+
+ /**
+ * Creates a JID from an unescaped string. The format must be
+ *
+ * The input string will be escaped.
+ *
+ * @param jid The JID.
+ * @return The JID.
+ * @throws NullPointerException If the jid is null.
+ * @throws IllegalArgumentException If the jid could not be parsed or is not valid.
+ * @see XEP-0106: JID Escaping
+ */
+ static Jid of(CharSequence jid) {
+ if (jid instanceof Jid) {
+ return (Jid) jid;
+ }
+ return FullJid.of(jid.toString(), false);
+ }
+
+ /**
+ * Creates a JID from a escaped JID string. The format must be
+ *
+ * This method should be used, when parsing JIDs from the XMPP stream.
+ *
+ * @param jid The JID.
+ * @return The JID.
+ * @throws NullPointerException If the jid is null.
+ * @throws IllegalArgumentException If the jid could not be parsed or is not valid.
+ * @see XEP-0106: JID Escaping
+ */
+ static Jid ofEscaped(CharSequence jid) {
+ return FullJid.of(jid.toString(), true);
+ }
+
+ /**
+ * Checks if the JID is a full JID.
+ *
+ *
+ *
+ * @return True, if the JID is a full JID; otherwise false.
+ */
+ boolean isFullJid();
+
+ /**
+ * Checks if the JID is a bare JID.
+ *
+ *
+ *
+ * @return True, if the JID is a bare JID; otherwise false.
+ */
+ boolean isBareJid();
+
+ /**
+ * Checks if the JID is a domain JID, i.e. if it has no local part.
+ *
+ * @return True, if the JID is a domain JID, i.e. if it has no local part.
+ */
+ boolean isDomainJid();
+
+ /**
+ * Gets the bare JID representation of this JID, i.e. removes the resource part.
+ *
+ *
+ *
+ * @return The bare JID.
+ * @see #withResource(CharSequence)
+ */
+ Jid asBareJid();
+
+ /**
+ * Creates a new JID with a new local part and the same domain and resource part of the current JID.
+ *
+ * @param local The local part.
+ * @return The JID with a new local part.
+ * @throws IllegalArgumentException If the local is not a valid local part.
+ * @see #withResource(CharSequence)
+ */
+ Jid withLocal(CharSequence local);
+
+ /**
+ * Creates a new full JID with a resource and the same local and domain part of the current JID.
+ *
+ * @param resource The resource.
+ * @return The full JID with a resource.
+ * @throws IllegalArgumentException If the resource is not a valid resource part.
+ * @see #asBareJid()
+ * @see #withLocal(CharSequence)
+ */
+ Jid withResource(CharSequence resource);
+
+ /**
+ * Creates a new JID at a subdomain and at the same domain as this JID.
+ *
+ * @param subdomain The subdomain.
+ * @return The JID at a subdomain.
+ * @throws NullPointerException If subdomain is null.
+ * @throws IllegalArgumentException If subdomain is not a valid subdomain name.
+ */
+ Jid atSubdomain(CharSequence subdomain);
+
+ /**
+ * Gets the local part of the JID, also known as the name or node.
+ *
+ *
+ *
+ *
+ * @return The local part or null.
+ * @see #getEscapedLocal()
+ */
+ String getLocal();
+
+ /**
+ * Gets the escaped local part of the JID.
+ *
+ * @return The escaped local part or null.
+ * @see #getLocal()
+ * @since 0.8.0
+ */
+ String getEscapedLocal();
+
+ /**
+ * Gets the domain part.
+ *
+ *
+ *
+ *
+ * @return The domain part.
+ */
+ String getDomain();
+
+ /**
+ * Gets the resource part.
+ *
+ *
+ *
+ *
+ * @return The resource part or null.
+ */
+ String getResource();
+
+ /**
+ * Returns the JID in escaped form as described in XEP-0106: JID Escaping.
+ *
+ * @return The escaped JID.
+ * @see #toString()
+ */
+ String toEscapedString();
+}
diff --git a/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/JidAdapter.java b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/JidAdapter.java
new file mode 100644
index 000000000..dcd981e68
--- /dev/null
+++ b/libs/xmpp-addr/src/main/java/rocks/xmpp/addr/JidAdapter.java
@@ -0,0 +1,53 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2016 Christian Schudt
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package rocks.xmpp.addr;
+
+import javax.xml.bind.annotation.adapters.XmlAdapter;
+
+/**
+ * Converts a String representation of a JID to JID object and vice a versa.
+ */
+final class JidAdapter extends XmlAdapterjid-malformed error.
+ *