NetworkUtils.java revision f5bbb5720454742e0e2f6ae489fa164845261cbf 
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;
23
24import android.util.Log;
25
26/**
27 * Native methods for managing network interfaces.
28 *
29 * {@hide}
30 */
31public class NetworkUtils {
32
33    private static final String TAG = "NetworkUtils";
34
35    /** Bring the named network interface up. */
36    public native static int enableInterface(String interfaceName);
37
38    /** Bring the named network interface down. */
39    public native static int disableInterface(String interfaceName);
40
41    /**
42     * Add a route to the routing table.
43     *
44     * @param interfaceName the interface to route through.
45     * @param dst the network or host to route to. May be IPv4 or IPv6, e.g.
46     * "0.0.0.0" or "2001:4860::".
47     * @param prefixLength the prefix length of the route.
48     * @param gw the gateway to use, e.g., "192.168.251.1". If null,
49     * indicates a directly-connected route.
50     */
51    public native static int addRoute(String interfaceName, String dst,
52          int prefixLength, String gw);
53
54    /** Return the gateway address for the default route for the named interface. */
55    public static InetAddress getDefaultRoute(String interfaceName) {
56        int addr = getDefaultRouteNative(interfaceName);
57        return intToInetAddress(addr);
58    }
59    private native static int getDefaultRouteNative(String interfaceName);
60
61    /** Remove host routes that uses the named interface. */
62    public native static int removeHostRoutes(String interfaceName);
63
64    /** Remove the default route for the named interface. */
65    public native static int removeDefaultRoute(String interfaceName);
66
67    /** Reset any sockets that are connected via the named interface. */
68    public native static int resetConnections(String interfaceName);
69
70    /**
71     * Start the DHCP client daemon, in order to have it request addresses
72     * for the named interface, and then configure the interface with those
73     * addresses. This call blocks until it obtains a result (either success
74     * or failure) from the daemon.
75     * @param interfaceName the name of the interface to configure
76     * @param ipInfo if the request succeeds, this object is filled in with
77     * the IP address information.
78     * @return {@code true} for success, {@code false} for failure
79     */
80    public native static boolean runDhcp(String interfaceName, DhcpInfoInternal ipInfo);
81
82    /**
83     * Shut down the DHCP client daemon.
84     * @param interfaceName the name of the interface for which the daemon
85     * should be stopped
86     * @return {@code true} for success, {@code false} for failure
87     */
88    public native static boolean stopDhcp(String interfaceName);
89
90    /**
91     * Release the current DHCP lease.
92     * @param interfaceName the name of the interface for which the lease should
93     * be released
94     * @return {@code true} for success, {@code false} for failure
95     */
96    public native static boolean releaseDhcpLease(String interfaceName);
97
98    /**
99     * Return the last DHCP-related error message that was recorded.
100     * <p/>NOTE: This string is not localized, but currently it is only
101     * used in logging.
102     * @return the most recent error message, if any
103     */
104    public native static String getDhcpError();
105
106    /**
107     * Convert a IPv4 address from an integer to an InetAddress.
108     * @param hostAddress an int corresponding to the IPv4 address in network byte order
109     */
110    public static InetAddress intToInetAddress(int hostAddress) {
111        byte[] addressBytes = { (byte)(0xff & hostAddress),
112                                (byte)(0xff & (hostAddress >> 8)),
113                                (byte)(0xff & (hostAddress >> 16)),
114                                (byte)(0xff & (hostAddress >> 24)) };
115
116        try {
117           return InetAddress.getByAddress(addressBytes);
118        } catch (UnknownHostException e) {
119           throw new AssertionError();
120        }
121    }
122
123    /**
124     * Convert a IPv4 address from an InetAddress to an integer
125     * @param inetAddr is an InetAddress corresponding to the IPv4 address
126     * @return the IP address as an integer in network byte order
127     */
128    public static int inetAddressToInt(InetAddress inetAddr)
129            throws IllegalArgumentException {
130        byte [] addr = inetAddr.getAddress();
131        if (addr.length != 4) {
132            throw new IllegalArgumentException("Not an IPv4 address");
133        }
134        return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |
135                ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);
136    }
137
138    /**
139     * Convert a network prefix length to an IPv4 netmask integer
140     * @param prefixLength
141     * @return the IPv4 netmask as an integer in network byte order
142     */
143    public static int prefixLengthToNetmaskInt(int prefixLength)
144            throws IllegalArgumentException {
145        if (prefixLength < 0 || prefixLength > 32) {
146            throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)");
147        }
148        int value = 0xffffffff << (32 - prefixLength);
149        return Integer.reverseBytes(value);
150    }
151
152    /**
153     * Create an InetAddress from a string where the string must be a standard
154     * representation of a V4 or V6 address.  Avoids doing a DNS lookup on failure
155     * but it will throw an IllegalArgumentException in that case.
156     * @param addrString
157     * @return the InetAddress
158     * @hide
159     */
160    public static InetAddress numericToInetAddress(String addrString)
161            throws IllegalArgumentException {
162        return InetAddress.parseNumericAddress(addrString);
163    }
164
165    /**
166     * Add a default route through the specified gateway.
167     * @param interfaceName interface on which the route should be added
168     * @param gw the IP address of the gateway to which the route is desired,
169     * @return {@code true} on success, {@code false} on failure
170     */
171    public static boolean addDefaultRoute(String interfaceName, InetAddress gw) {
172        String dstStr;
173        String gwStr = gw.getHostAddress();
174
175        if (gw instanceof Inet4Address) {
176            dstStr = "0.0.0.0";
177        } else if (gw instanceof Inet6Address) {
178            dstStr = "::";
179        } else {
180            Log.w(TAG, "addDefaultRoute failure: address is neither IPv4 nor IPv6" +
181                       "(" + gwStr + ")");
182            return false;
183        }
184        return addRoute(interfaceName, dstStr, 0, gwStr) == 0;
185    }
186
187    /**
188     * Add a host route.
189     * @param interfaceName interface on which the route should be added
190     * @param dst the IP address of the host to which the route is desired,
191     * this should not be null.
192     * @param gw the IP address of the gateway to which the route is desired,
193     * if null, indicates a directly-connected route.
194     * @return {@code true} on success, {@code false} on failure
195     */
196    public static boolean addHostRoute(String interfaceName, InetAddress dst,
197          InetAddress gw) {
198        if (dst == null) {
199            Log.w(TAG, "addHostRoute: dst should not be null");
200            return false;
201        }
202
203        int prefixLength;
204        String dstStr = dst.getHostAddress();
205        String gwStr = (gw != null) ? gw.getHostAddress() : null;
206
207        if (dst instanceof Inet4Address) {
208            prefixLength = 32;
209        } else if (dst instanceof Inet6Address) {
210            prefixLength = 128;
211        } else {
212            Log.w(TAG, "addHostRoute failure: address is neither IPv4 nor IPv6" +
213                       "(" + dst + ")");
214            return false;
215        }
216        return addRoute(interfaceName, dstStr, prefixLength, gwStr) == 0;
217    }
218}
219