RemoteXmppTcpConnectionEndpoints.java

  1. /**
  2.  *
  3.  * Copyright 2015-2020 Florian Schmaus.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smack.tcp.rce;

  19. import java.net.InetAddress;
  20. import java.util.ArrayList;
  21. import java.util.Collection;
  22. import java.util.Collections;
  23. import java.util.List;
  24. import java.util.logging.Level;
  25. import java.util.logging.Logger;

  27. import org.jivesoftware.smack.ConnectionConfiguration;
  28. import org.jivesoftware.smack.ConnectionConfiguration.DnssecMode;
  29. import org.jivesoftware.smack.datatypes.UInt16;
  30. import org.jivesoftware.smack.util.DNSUtil;
  31. import org.jivesoftware.smack.util.dns.DNSResolver;
  32. import org.jivesoftware.smack.util.rce.RemoteConnectionEndpoint;
  33. import org.jivesoftware.smack.util.rce.RemoteConnectionEndpointLookupFailure;

  35. import org.minidns.dnsname.DnsName;
  36. import org.minidns.record.InternetAddressRR;
  37. import org.minidns.record.SRV;
  38. import org.minidns.util.SrvUtil;

  40. public class RemoteXmppTcpConnectionEndpoints {

  42.     private static final Logger LOGGER = Logger.getLogger(RemoteXmppTcpConnectionEndpoints.class.getName());

  44.     public static final String XMPP_CLIENT_DNS_SRV_PREFIX = "_xmpp-client._tcp";
  45.     public static final String XMPP_SERVER_DNS_SRV_PREFIX = "_xmpp-server._tcp";

  47.     /**
  48.      * Lookups remote connection endpoints on the server for XMPP connections over TCP taking A, AAAA and SRV resource
  49.      * records into account. If no host address was configured and all lookups failed, for example with NX_DOMAIN, then
  50.      * result will be populated with the empty list.
  51.      *
  52.      * @param config the connection configuration to lookup the endpoints for.
  53.      * @return a lookup result.
  54.      */
  55.     public static Result<Rfc6120TcpRemoteConnectionEndpoint> lookup(ConnectionConfiguration config) {
  56.         List<Rfc6120TcpRemoteConnectionEndpoint> discoveredRemoteConnectionEndpoints;
  57.         List<RemoteConnectionEndpointLookupFailure> lookupFailures;

  59.         final InetAddress hostAddress = config.getHostAddress();
  60.         final DnsName host = config.getHost();

  62.         if (hostAddress != null) {
  63.             lookupFailures = Collections.emptyList();

  65.             IpTcpRemoteConnectionEndpoint<InternetAddressRR<?>> connectionEndpoint = IpTcpRemoteConnectionEndpoint.from(
  66.                             hostAddress.toString(), config.getPort(), hostAddress);
  67.             discoveredRemoteConnectionEndpoints = Collections.singletonList(connectionEndpoint);
  68.         } else if (host != null) {
  69.             lookupFailures = new ArrayList<>(1);

  71.             List<InetAddress> hostAddresses = DNSUtil.getDNSResolver().lookupHostAddress(host,
  72.                             lookupFailures, config.getDnssecMode());

  74.             if (hostAddresses != null) {
  75.                 discoveredRemoteConnectionEndpoints = new ArrayList<>(hostAddresses.size());
  76.                 UInt16 port = config.getPort();
  77.                 for (InetAddress inetAddress : hostAddresses) {
  78.                     IpTcpRemoteConnectionEndpoint<InternetAddressRR<?>> connectionEndpoint = IpTcpRemoteConnectionEndpoint.from(
  79.                                     host, port, inetAddress);
  80.                     discoveredRemoteConnectionEndpoints.add(connectionEndpoint);
  81.                 }
  82.             } else {
  83.                 discoveredRemoteConnectionEndpoints = Collections.emptyList();
  84.             }
  85.         } else {
  86.             lookupFailures = new ArrayList<>();

  88.             // N.B.: Important to use config.serviceName and not AbstractXMPPConnection.serviceName
  89.             DnsName dnsName = config.getXmppServiceDomainAsDnsNameIfPossible();
  90.             if (dnsName == null) {
  91.                 // TODO: ConnectionConfiguration should check on construction time that either the given XMPP service
  92.                 // name is also a valid DNS name, or that a host is explicitly configured.
  93.                 throw new IllegalStateException();
  94.             }
  95.             discoveredRemoteConnectionEndpoints = resolveXmppServiceDomain(dnsName, lookupFailures, config.getDnssecMode());
  96.         }

  98.         // Either the populated host addresses are not empty *or* there must be at least one failed address.
  99.         assert !discoveredRemoteConnectionEndpoints.isEmpty() || !lookupFailures.isEmpty();

  101.         return new Result<>(discoveredRemoteConnectionEndpoints, lookupFailures);
  102.     }

  104.     public static final class Result<RCE extends RemoteConnectionEndpoint> {
  105.         public final List<RCE> discoveredRemoteConnectionEndpoints;
  106.         public final List<RemoteConnectionEndpointLookupFailure> lookupFailures;

  108.         private Result(List<RCE> discoveredRemoteConnectionEndpoints, List<RemoteConnectionEndpointLookupFailure> lookupFailures) {
  109.             this.discoveredRemoteConnectionEndpoints = discoveredRemoteConnectionEndpoints;
  110.             this.lookupFailures = lookupFailures;
  111.         }
  112.     }

  114.     @SuppressWarnings("ImmutableEnumChecker")
  115.     enum DomainType {
  116.         server(XMPP_SERVER_DNS_SRV_PREFIX),
  117.         client(XMPP_CLIENT_DNS_SRV_PREFIX),
  118.         ;
  119.         public final DnsName srvPrefix;

  121.         DomainType(String srvPrefixString) {
  122.             srvPrefix = DnsName.from(srvPrefixString);
  123.         }
  124.     }

  126.     /**
  127.      * Returns a list of HostAddresses under which the specified XMPP server can be reached at for client-to-server
  128.      * communication. A DNS lookup for a SRV record in the form "_xmpp-client._tcp.example.com" is attempted, according
  129.      * to section 3.2.1 of RFC 6120. If that lookup fails, it's assumed that the XMPP server lives at the host resolved
  130.      * by a DNS lookup at the specified domain on the default port of 5222.
  131.      * <p>
  132.      * As an example, a lookup for "example.com" may return "im.example.com:5269".
  133.      * </p>
  134.      *
  135.      * @param domain the domain.
  136.      * @param lookupFailures on optional list that will be populated with host addresses that failed to resolve.
  137.      * @param dnssecMode DNSSec mode.
  138.      * @return List of HostAddress, which encompasses the hostname and port that the
  139.      *      XMPP server can be reached at for the specified domain.
  140.      */
  141.     public static List<Rfc6120TcpRemoteConnectionEndpoint> resolveXmppServiceDomain(DnsName domain,
  142.                     List<RemoteConnectionEndpointLookupFailure> lookupFailures, DnssecMode dnssecMode) {
  143.         DNSResolver dnsResolver = getDnsResolverOrThrow();
  144.         return resolveDomain(domain, DomainType.client, lookupFailures, dnssecMode, dnsResolver);
  145.     }

  147.     /**
  148.      * Returns a list of HostAddresses under which the specified XMPP server can be reached at for server-to-server
  149.      * communication. A DNS lookup for a SRV record in the form "_xmpp-server._tcp.example.com" is attempted, according
  150.      * to section 3.2.1 of RFC 6120. If that lookup fails , it's assumed that the XMPP server lives at the host resolved
  151.      * by a DNS lookup at the specified domain on the default port of 5269.
  152.      * <p>
  153.      * As an example, a lookup for "example.com" may return "im.example.com:5269".
  154.      * </p>
  155.      *
  156.      * @param domain the domain.
  157.      * @param lookupFailures a list that will be populated with host addresses that failed to resolve.
  158.      * @param dnssecMode DNSSec mode.
  159.      * @return List of HostAddress, which encompasses the hostname and port that the
  160.      *      XMPP server can be reached at for the specified domain.
  161.      */
  162.     public static List<Rfc6120TcpRemoteConnectionEndpoint> resolveXmppServerDomain(DnsName domain,
  163.                     List<RemoteConnectionEndpointLookupFailure> lookupFailures, DnssecMode dnssecMode) {
  164.         DNSResolver dnsResolver = getDnsResolverOrThrow();
  165.         return resolveDomain(domain, DomainType.server, lookupFailures, dnssecMode, dnsResolver);
  166.     }

  168.     /**
  169.      *
  170.      * @param domain the domain.
  171.      * @param domainType the XMPP domain type, server or client.
  172.      * @param lookupFailures a list that will be populated with all failures that occurred during lookup.
  173.      * @param dnssecMode the DNSSEC mode.
  174.      * @param dnsResolver the DNS resolver to use.
  175.      * @return a list of resolved host addresses for this domain.
  176.      */
  177.     private static List<Rfc6120TcpRemoteConnectionEndpoint> resolveDomain(DnsName domain, DomainType domainType,
  178.                     List<RemoteConnectionEndpointLookupFailure> lookupFailures, DnssecMode dnssecMode, DNSResolver dnsResolver) {
  179.         List<Rfc6120TcpRemoteConnectionEndpoint> endpoints = new ArrayList<>();

  181.         // Step one: Do SRV lookups
  182.         DnsName srvDomain = DnsName.from(domainType.srvPrefix, domain);

  184.         Collection<SRV> srvRecords = dnsResolver.lookupSrvRecords(srvDomain, lookupFailures, dnssecMode);
  185.         if (srvRecords != null && !srvRecords.isEmpty()) {
  186.             if (LOGGER.isLoggable(Level.FINE)) {
  187.                 String logMessage = "Resolved SRV RR for " + srvDomain + ":";
  188.                 for (SRV r : srvRecords)
  189.                     logMessage += " " + r;
  190.                 LOGGER.fine(logMessage);
  191.             }

  193.             List<SRV> sortedSrvRecords = SrvUtil.sortSrvRecords(srvRecords);

  195.             for (SRV srv : sortedSrvRecords) {
  196.                 List<InetAddress> targetInetAddresses = dnsResolver.lookupHostAddress(srv.target, lookupFailures, dnssecMode);
  197.                 if (targetInetAddresses != null) {
  198.                     SrvXmppRemoteConnectionEndpoint endpoint = new SrvXmppRemoteConnectionEndpoint(srv, targetInetAddresses);
  199.                     endpoints.add(endpoint);
  200.                 }
  201.             }
  202.         } else {
  203.             LOGGER.info("Could not resolve DNS SRV resource records for " + srvDomain + ". Consider adding those.");
  204.         }

  206.         UInt16 defaultPort;
  207.         switch (domainType) {
  208.         case client:
  209.             defaultPort = UInt16.from(5222);
  210.             break;
  211.         case server:
  212.             defaultPort = UInt16.from(5269);
  213.             break;
  214.         default:
  215.             throw new AssertionError();
  216.         }

  218.         // Step two: Add the hostname to the end of the list
  219.         List<InetAddress> hostAddresses = dnsResolver.lookupHostAddress(domain, lookupFailures, dnssecMode);
  220.         if (hostAddresses != null) {
  221.             for (InetAddress inetAddress : hostAddresses) {
  222.                 IpTcpRemoteConnectionEndpoint<InternetAddressRR<?>> endpoint = IpTcpRemoteConnectionEndpoint.from(domain, defaultPort, inetAddress);
  223.                 endpoints.add(endpoint);
  224.             }
  225.         }

  227.         return endpoints;
  228.     }

  230.     private static DNSResolver getDnsResolverOrThrow() {
  231.         final DNSResolver dnsResolver = DNSUtil.getDNSResolver();
  232.         if (dnsResolver == null) {
  233.             throw new IllegalStateException("No DNS resolver configured in Smack");
  234.         }
  235.         return dnsResolver;
  236.     }
  237. }
Created with JaCoCo 0.8.6.202009150832