View Javadoc
1   /*
2    * ====================================================================
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   * ====================================================================
20   *
21   * This software consists of voluntary contributions made by many
22   * individuals on behalf of the Apache Software Foundation.  For more
23   * information on the Apache Software Foundation, please see
24   * <http://www.apache.org/>.
25   *
26   */
27  
28  package org.apache.hc.core5.net;
29  
30  import java.net.InetAddress;
31  import java.net.InetSocketAddress;
32  import java.net.SocketAddress;
33  import java.net.UnknownHostException;
34  import java.util.regex.Pattern;
35  
36  import org.apache.hc.core5.util.Args;
37  
38  /**
39   * A collection of utilities relating to InetAddresses.
40   *
41   * @since 4.0
42   */
43  public class InetAddressUtils {
44  
45      /**
46       * Represents the ipv4
47       *
48       * @since 5.1
49       */
50      public static final byte IPV4 = 1;
51      /**
52       * Represents the ipv6.
53       *
54       * @since 5.1
55       */
56      public static final byte IPV6 = 4;
57  
58      private InetAddressUtils() {
59      }
60  
61      private static final String IPV4_BASIC_PATTERN_STRING =
62              "(([1-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){1}" + // initial first field, 1-255
63              "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){2}" + // following 2 fields, 0-255 followed by .
64               "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])"; // final field, 0-255
65  
66      private static final Pattern IPV4_PATTERN =
67          Pattern.compile("^" + IPV4_BASIC_PATTERN_STRING + "$");
68  
69      private static final Pattern IPV4_MAPPED_IPV6_PATTERN = // TODO does not allow for redundant leading zeros
70              Pattern.compile("^::[fF]{4}:" + IPV4_BASIC_PATTERN_STRING + "$");
71  
72      private static final Pattern IPV6_STD_PATTERN =
73          Pattern.compile(
74                  "^[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}$");
75  
76      private static final Pattern IPV6_HEX_COMPRESSED_PATTERN =
77          Pattern.compile(
78                  "^(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)" + // 0-6 hex fields
79                   "::" +
80                   "(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)$"); // 0-6 hex fields
81  
82      /*
83       *  The above pattern is not totally rigorous as it allows for more than 7 hex fields in total
84       */
85      private static final char COLON_CHAR = ':';
86  
87      // Must not have more than 7 colons (i.e. 8 fields)
88      private static final int MAX_COLON_COUNT = 7;
89  
90      /**
91       * Checks whether the parameter is a valid IPv4 address
92       *
93       * @param input the address string to check for validity
94       * @return true if the input parameter is a valid IPv4 address
95       */
96      public static boolean isIPv4Address(final String input) {
97          return IPV4_PATTERN.matcher(input).matches();
98      }
99  
100     public static boolean isIPv4MappedIPv64Address(final String input) {
101         return IPV4_MAPPED_IPV6_PATTERN.matcher(input).matches();
102     }
103 
104     static boolean hasValidIPv6ColonCount(final String input) {
105         int colonCount = 0;
106         for (int i = 0; i < input.length(); i++) {
107             if (input.charAt(i) == COLON_CHAR) {
108                 colonCount++;
109             }
110         }
111         // IPv6 address must have at least 2 colons and not more than 7 (i.e. 8 fields)
112         return colonCount >= 2 && colonCount <= MAX_COLON_COUNT;
113     }
114 
115     /**
116      * Checks whether the parameter is a valid standard (non-compressed) IPv6 address
117      *
118      * @param input the address string to check for validity
119      * @return true if the input parameter is a valid standard (non-compressed) IPv6 address
120      */
121     public static boolean isIPv6StdAddress(final String input) {
122         return hasValidIPv6ColonCount(input) && IPV6_STD_PATTERN.matcher(input).matches();
123     }
124 
125     /**
126      * Checks whether the parameter is a valid compressed IPv6 address
127      *
128      * @param input the address string to check for validity
129      * @return true if the input parameter is a valid compressed IPv6 address
130      */
131     public static boolean isIPv6HexCompressedAddress(final String input) {
132         return hasValidIPv6ColonCount(input) && IPV6_HEX_COMPRESSED_PATTERN.matcher(input).matches();
133     }
134 
135     /**
136      * Checks whether the parameter is a valid IPv6 address (including compressed).
137      *
138      * @param input the address string to check for validity
139      * @return true if the input parameter is a valid standard or compressed IPv6 address
140      */
141     public static boolean isIPv6Address(final String input) {
142         return isIPv6StdAddress(input) || isIPv6HexCompressedAddress(input);
143     }
144 
145     /**
146      * Checks whether the parameter is a valid URL formatted bracketed IPv6 address (including compressed).
147      * This matches only bracketed values e.g. {@code [::1]}.
148      *
149      * @param input the address string to check for validity
150      * @return true if the input parameter is a valid URL-formatted bracketed IPv6 address
151      */
152     public static boolean isIPv6URLBracketedAddress(final String input) {
153         return input.startsWith("[") && input.endsWith("]") && isIPv6Address(input.substring(1, input.length() - 1));
154     }
155 
156     /**
157      * Formats {@link SocketAddress} as text.
158      *
159      * @since 5.0
160      */
161     public static void formatAddress(
162             final StringBuilder buffer,
163             final SocketAddress socketAddress) {
164         Args.notNull(buffer, "buffer");
165         if (socketAddress instanceof InetSocketAddress) {
166             final InetSocketAddress socketaddr = (InetSocketAddress) socketAddress;
167             final InetAddress inetaddr = socketaddr.getAddress();
168             if (inetaddr != null) {
169                 buffer.append(inetaddr.getHostAddress()).append(':').append(socketaddr.getPort());
170             } else {
171                 buffer.append(socketAddress);
172             }
173         } else {
174             buffer.append(socketAddress);
175         }
176     }
177 
178     /**
179      * Returns canonical name (fully qualified domain name) of the localhost.
180      *
181      * @since 5.0
182      */
183     public static String getCanonicalLocalHostName() {
184         try {
185             final InetAddress localHost = InetAddress.getLocalHost();
186             return localHost.getCanonicalHostName();
187         } catch (final UnknownHostException ex) {
188             return "localhost";
189         }
190     }
191 
192 }