1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.net;
18
19import java.net.InetAddress;
20import java.net.Inet4Address;
21import java.net.Inet6Address;
22import java.net.UnknownHostException;
23import java.util.Collection;
24
25import android.util.Log;
26
27/**
28 * Native methods for managing network interfaces.
29 *
30 * {@hide}
31 */
32public class NetworkUtils {
33
34    private static final String TAG = "NetworkUtils";
35
36    /** Bring the named network interface up. */
37    public native static int enableInterface(String interfaceName);
38
39    /** Bring the named network interface down. */
40    public native static int disableInterface(String interfaceName);
41
42    /** Setting bit 0 indicates reseting of IPv4 addresses required */
43    public static final int RESET_IPV4_ADDRESSES = 0x01;
44
45    /** Setting bit 1 indicates reseting of IPv4 addresses required */
46    public static final int RESET_IPV6_ADDRESSES = 0x02;
47
48    /** Reset all addresses */
49    public static final int RESET_ALL_ADDRESSES = RESET_IPV4_ADDRESSES | RESET_IPV6_ADDRESSES;
50
51    /**
52     * Reset IPv6 or IPv4 sockets that are connected via the named interface.
53     *
54     * @param interfaceName is the interface to reset
55     * @param mask {@see #RESET_IPV4_ADDRESSES} and {@see #RESET_IPV6_ADDRESSES}
56     */
57    public native static int resetConnections(String interfaceName, int mask);
58
59    /**
60     * Start the DHCP client daemon, in order to have it request addresses
61     * for the named interface, and then configure the interface with those
62     * addresses. This call blocks until it obtains a result (either success
63     * or failure) from the daemon.
64     * @param interfaceName the name of the interface to configure
65     * @param ipInfo if the request succeeds, this object is filled in with
66     * the IP address information.
67     * @return {@code true} for success, {@code false} for failure
68     */
69    public native static boolean runDhcp(String interfaceName, DhcpInfoInternal ipInfo);
70
71    /**
72     * Initiate renewal on the Dhcp client daemon. This call blocks until it obtains
73     * a result (either success or failure) from the daemon.
74     * @param interfaceName the name of the interface to configure
75     * @param ipInfo if the request succeeds, this object is filled in with
76     * the IP address information.
77     * @return {@code true} for success, {@code false} for failure
78     */
79    public native static boolean runDhcpRenew(String interfaceName, DhcpInfoInternal ipInfo);
80
81    /**
82     * Shut down the DHCP client daemon.
83     * @param interfaceName the name of the interface for which the daemon
84     * should be stopped
85     * @return {@code true} for success, {@code false} for failure
86     */
87    public native static boolean stopDhcp(String interfaceName);
88
89    /**
90     * Release the current DHCP lease.
91     * @param interfaceName the name of the interface for which the lease should
92     * be released
93     * @return {@code true} for success, {@code false} for failure
94     */
95    public native static boolean releaseDhcpLease(String interfaceName);
96
97    /**
98     * Return the last DHCP-related error message that was recorded.
99     * <p/>NOTE: This string is not localized, but currently it is only
100     * used in logging.
101     * @return the most recent error message, if any
102     */
103    public native static String getDhcpError();
104
105    /**
106     * Convert a IPv4 address from an integer to an InetAddress.
107     * @param hostAddress an int corresponding to the IPv4 address in network byte order
108     */
109    public static InetAddress intToInetAddress(int hostAddress) {
110        byte[] addressBytes = { (byte)(0xff & hostAddress),
111                                (byte)(0xff & (hostAddress >> 8)),
112                                (byte)(0xff & (hostAddress >> 16)),
113                                (byte)(0xff & (hostAddress >> 24)) };
114
115        try {
116           return InetAddress.getByAddress(addressBytes);
117        } catch (UnknownHostException e) {
118           throw new AssertionError();
119        }
120    }
121
122    /**
123     * Convert a IPv4 address from an InetAddress to an integer
124     * @param inetAddr is an InetAddress corresponding to the IPv4 address
125     * @return the IP address as an integer in network byte order
126     */
127    public static int inetAddressToInt(InetAddress inetAddr)
128            throws IllegalArgumentException {
129        byte [] addr = inetAddr.getAddress();
130        if (addr.length != 4) {
131            throw new IllegalArgumentException("Not an IPv4 address");
132        }
133        return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |
134                ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);
135    }
136
137    /**
138     * Convert a network prefix length to an IPv4 netmask integer
139     * @param prefixLength
140     * @return the IPv4 netmask as an integer in network byte order
141     */
142    public static int prefixLengthToNetmaskInt(int prefixLength)
143            throws IllegalArgumentException {
144        if (prefixLength < 0 || prefixLength > 32) {
145            throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)");
146        }
147        int value = 0xffffffff << (32 - prefixLength);
148        return Integer.reverseBytes(value);
149    }
150
151    /**
152     * Convert a IPv4 netmask integer to a prefix length
153     * @param netmask as an integer in network byte order
154     * @return the network prefix length
155     */
156    public static int netmaskIntToPrefixLength(int netmask) {
157        return Integer.bitCount(netmask);
158    }
159
160    /**
161     * Create an InetAddress from a string where the string must be a standard
162     * representation of a V4 or V6 address.  Avoids doing a DNS lookup on failure
163     * but it will throw an IllegalArgumentException in that case.
164     * @param addrString
165     * @return the InetAddress
166     * @hide
167     */
168    public static InetAddress numericToInetAddress(String addrString)
169            throws IllegalArgumentException {
170        return InetAddress.parseNumericAddress(addrString);
171    }
172
173    /**
174     * Get InetAddress masked with prefixLength.  Will never return null.
175     * @param IP address which will be masked with specified prefixLength
176     * @param prefixLength the prefixLength used to mask the IP
177     */
178    public static InetAddress getNetworkPart(InetAddress address, int prefixLength) {
179        if (address == null) {
180            throw new RuntimeException("getNetworkPart doesn't accept null address");
181        }
182
183        byte[] array = address.getAddress();
184
185        if (prefixLength < 0 || prefixLength > array.length * 8) {
186            throw new RuntimeException("getNetworkPart - bad prefixLength");
187        }
188
189        int offset = prefixLength / 8;
190        int reminder = prefixLength % 8;
191        byte mask = (byte)(0xFF << (8 - reminder));
192
193        if (offset < array.length) array[offset] = (byte)(array[offset] & mask);
194
195        offset++;
196
197        for (; offset < array.length; offset++) {
198            array[offset] = 0;
199        }
200
201        InetAddress netPart = null;
202        try {
203            netPart = InetAddress.getByAddress(array);
204        } catch (UnknownHostException e) {
205            throw new RuntimeException("getNetworkPart error - " + e.toString());
206        }
207        return netPart;
208    }
209
210    /**
211     * Check if IP address type is consistent between two InetAddress.
212     * @return true if both are the same type.  False otherwise.
213     */
214    public static boolean addressTypeMatches(InetAddress left, InetAddress right) {
215        return (((left instanceof Inet4Address) && (right instanceof Inet4Address)) ||
216                ((left instanceof Inet6Address) && (right instanceof Inet6Address)));
217    }
218
219    /**
220     * Convert a 32 char hex string into a Inet6Address.
221     * throws a runtime exception if the string isn't 32 chars, isn't hex or can't be
222     * made into an Inet6Address
223     * @param addrHexString a 32 character hex string representing an IPv6 addr
224     * @return addr an InetAddress representation for the string
225     */
226    public static InetAddress hexToInet6Address(String addrHexString)
227            throws IllegalArgumentException {
228        try {
229            return numericToInetAddress(String.format("%s:%s:%s:%s:%s:%s:%s:%s",
230                    addrHexString.substring(0,4),   addrHexString.substring(4,8),
231                    addrHexString.substring(8,12),  addrHexString.substring(12,16),
232                    addrHexString.substring(16,20), addrHexString.substring(20,24),
233                    addrHexString.substring(24,28), addrHexString.substring(28,32)));
234        } catch (Exception e) {
235            Log.e("NetworkUtils", "error in hexToInet6Address(" + addrHexString + "): " + e);
236            throw new IllegalArgumentException(e);
237        }
238    }
239
240    /**
241     * Create a string array of host addresses from a collection of InetAddresses
242     * @param addrs a Collection of InetAddresses
243     * @return an array of Strings containing their host addresses
244     */
245    public static String[] makeStrings(Collection<InetAddress> addrs) {
246        String[] result = new String[addrs.size()];
247        int i = 0;
248        for (InetAddress addr : addrs) {
249            result[i++] = addr.getHostAddress();
250        }
251        return result;
252    }
253
254    /**
255     * Trim leading zeros from IPv4 address strings
256     * Our base libraries will interpret that as octel..
257     * Must leave non v4 addresses and host names alone.
258     * For example, 192.168.000.010 -> 192.168.0.10
259     * TODO - fix base libraries and remove this function
260     * @param addr a string representing an ip addr
261     * @return a string propertly trimmed
262     */
263    public static String trimV4AddrZeros(String addr) {
264        if (addr == null) return null;
265        String[] octets = addr.split("\\.");
266        if (octets.length != 4) return addr;
267        StringBuilder builder = new StringBuilder(16);
268        String result = null;
269        for (int i = 0; i < 4; i++) {
270            try {
271                if (octets[i].length() > 3) return addr;
272                builder.append(Integer.parseInt(octets[i]));
273            } catch (NumberFormatException e) {
274                return addr;
275            }
276            if (i < 3) builder.append('.');
277        }
278        result = builder.toString();
279        return result;
280    }
281}
282