android_net_NetUtils.cpp revision 03666c705ddabe0e7c5869ab69c2ca8b964164e9 
1/*
2 * Copyright 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
17#define LOG_TAG "NetUtils"
18
19#include "jni.h"
20#include "JNIHelp.h"
21#include "NetdClient.h"
22#include "resolv_netid.h"
23#include <utils/misc.h>
24#include <android_runtime/AndroidRuntime.h>
25#include <utils/Log.h>
26#include <arpa/inet.h>
27#include <cutils/properties.h>
28
29extern "C" {
30int ifc_enable(const char *ifname);
31int ifc_disable(const char *ifname);
32int ifc_reset_connections(const char *ifname, int reset_mask);
33
34int dhcp_do_request(const char * const ifname,
35                    const char *ipaddr,
36                    const char *gateway,
37                    uint32_t *prefixLength,
38                    const char *dns[],
39                    const char *server,
40                    uint32_t *lease,
41                    const char *vendorInfo,
42                    const char *domains,
43                    const char *mtu);
44
45int dhcp_do_request_renew(const char * const ifname,
46                    const char *ipaddr,
47                    const char *gateway,
48                    uint32_t *prefixLength,
49                    const char *dns[],
50                    const char *server,
51                    uint32_t *lease,
52                    const char *vendorInfo,
53                    const char *domains,
54                    const char *mtu);
55
56int dhcp_stop(const char *ifname);
57int dhcp_release_lease(const char *ifname);
58char *dhcp_get_errmsg();
59}
60
61#define NETUTILS_PKG_NAME "android/net/NetworkUtils"
62
63namespace android {
64
65/*
66 * The following remembers the jfieldID's of the fields
67 * of the DhcpInfo Java object, so that we don't have
68 * to look them up every time.
69 */
70static struct fieldIds {
71    jmethodID clear;
72    jmethodID setInterfaceName;
73    jmethodID addLinkAddress;
74    jmethodID addGateway;
75    jmethodID addDns;
76    jmethodID setDomains;
77    jmethodID setServerAddress;
78    jmethodID setLeaseDuration;
79    jmethodID setVendorInfo;
80} dhcpResultsFieldIds;
81
82static jint android_net_utils_resetConnections(JNIEnv* env, jobject clazz,
83      jstring ifname, jint mask)
84{
85    int result;
86
87    const char *nameStr = env->GetStringUTFChars(ifname, NULL);
88
89    ALOGD("android_net_utils_resetConnections in env=%p clazz=%p iface=%s mask=0x%x\n",
90          env, clazz, nameStr, mask);
91
92    result = ::ifc_reset_connections(nameStr, mask);
93    env->ReleaseStringUTFChars(ifname, nameStr);
94    return (jint)result;
95}
96
97static jboolean android_net_utils_runDhcpCommon(JNIEnv* env, jobject clazz, jstring ifname,
98        jobject dhcpResults, bool renew)
99{
100    int result;
101    char  ipaddr[PROPERTY_VALUE_MAX];
102    uint32_t prefixLength;
103    char gateway[PROPERTY_VALUE_MAX];
104    char    dns1[PROPERTY_VALUE_MAX];
105    char    dns2[PROPERTY_VALUE_MAX];
106    char    dns3[PROPERTY_VALUE_MAX];
107    char    dns4[PROPERTY_VALUE_MAX];
108    const char *dns[5] = {dns1, dns2, dns3, dns4, NULL};
109    char  server[PROPERTY_VALUE_MAX];
110    uint32_t lease;
111    char vendorInfo[PROPERTY_VALUE_MAX];
112    char domains[PROPERTY_VALUE_MAX];
113    char mtu[PROPERTY_VALUE_MAX];
114
115    const char *nameStr = env->GetStringUTFChars(ifname, NULL);
116    if (nameStr == NULL) return (jboolean)false;
117
118    if (renew) {
119        result = ::dhcp_do_request_renew(nameStr, ipaddr, gateway, &prefixLength,
120                dns, server, &lease, vendorInfo, domains, mtu);
121    } else {
122        result = ::dhcp_do_request(nameStr, ipaddr, gateway, &prefixLength,
123                dns, server, &lease, vendorInfo, domains, mtu);
124    }
125    if (result != 0) {
126        ALOGD("dhcp_do_request failed : %s (%s)", nameStr, renew ? "renew" : "new");
127    }
128
129    env->ReleaseStringUTFChars(ifname, nameStr);
130    if (result == 0) {
131        env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.clear);
132
133        // set mIfaceName
134        // dhcpResults->setInterfaceName(ifname)
135        env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.setInterfaceName, ifname);
136
137        // set the linkAddress
138        // dhcpResults->addLinkAddress(inetAddress, prefixLength)
139        result = env->CallBooleanMethod(dhcpResults, dhcpResultsFieldIds.addLinkAddress,
140                env->NewStringUTF(ipaddr), prefixLength);
141    }
142
143    if (result == 0) {
144        // set the gateway
145        // dhcpResults->addGateway(gateway)
146        result = env->CallBooleanMethod(dhcpResults,
147                dhcpResultsFieldIds.addGateway, env->NewStringUTF(gateway));
148    }
149
150    if (result == 0) {
151        // dhcpResults->addDns(new InetAddress(dns1))
152        result = env->CallBooleanMethod(dhcpResults,
153                dhcpResultsFieldIds.addDns, env->NewStringUTF(dns1));
154    }
155
156    if (result == 0) {
157        env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.setDomains,
158                env->NewStringUTF(domains));
159
160        result = env->CallBooleanMethod(dhcpResults,
161                dhcpResultsFieldIds.addDns, env->NewStringUTF(dns2));
162
163        if (result == 0) {
164            result = env->CallBooleanMethod(dhcpResults,
165                    dhcpResultsFieldIds.addDns, env->NewStringUTF(dns3));
166            if (result == 0) {
167                result = env->CallBooleanMethod(dhcpResults,
168                        dhcpResultsFieldIds.addDns, env->NewStringUTF(dns4));
169            }
170        }
171    }
172
173    if (result == 0) {
174        // dhcpResults->setServerAddress(new InetAddress(server))
175        result = env->CallBooleanMethod(dhcpResults, dhcpResultsFieldIds.setServerAddress,
176                env->NewStringUTF(server));
177    }
178
179    if (result == 0) {
180        // dhcpResults->setLeaseDuration(lease)
181        env->CallVoidMethod(dhcpResults,
182                dhcpResultsFieldIds.setLeaseDuration, lease);
183
184        // dhcpResults->setVendorInfo(vendorInfo)
185        env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.setVendorInfo,
186                env->NewStringUTF(vendorInfo));
187    }
188    return (jboolean)(result == 0);
189}
190
191
192static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info)
193{
194    return android_net_utils_runDhcpCommon(env, clazz, ifname, info, false);
195}
196
197static jboolean android_net_utils_runDhcpRenew(JNIEnv* env, jobject clazz, jstring ifname,
198        jobject info)
199{
200    return android_net_utils_runDhcpCommon(env, clazz, ifname, info, true);
201}
202
203
204static jboolean android_net_utils_stopDhcp(JNIEnv* env, jobject clazz, jstring ifname)
205{
206    int result;
207
208    const char *nameStr = env->GetStringUTFChars(ifname, NULL);
209    result = ::dhcp_stop(nameStr);
210    env->ReleaseStringUTFChars(ifname, nameStr);
211    return (jboolean)(result == 0);
212}
213
214static jboolean android_net_utils_releaseDhcpLease(JNIEnv* env, jobject clazz, jstring ifname)
215{
216    int result;
217
218    const char *nameStr = env->GetStringUTFChars(ifname, NULL);
219    result = ::dhcp_release_lease(nameStr);
220    env->ReleaseStringUTFChars(ifname, nameStr);
221    return (jboolean)(result == 0);
222}
223
224static jstring android_net_utils_getDhcpError(JNIEnv* env, jobject clazz)
225{
226    return env->NewStringUTF(::dhcp_get_errmsg());
227}
228
229static jboolean android_net_utils_bindProcessToNetwork(JNIEnv *env, jobject thiz, jint netId)
230{
231    return (jboolean) !setNetworkForProcess(netId);
232}
233
234static jint android_net_utils_getNetworkBoundToProcess(JNIEnv *env, jobject thiz)
235{
236    return getNetworkForProcess();
237}
238
239static jboolean android_net_utils_bindProcessToNetworkForHostResolution(JNIEnv *env, jobject thiz,
240        jint netId)
241{
242    return (jboolean) !setNetworkForResolv(netId);
243}
244
245static jboolean android_net_utils_bindSocketToNetwork(JNIEnv *env, jobject thiz, jint socket,
246        jint netId)
247{
248    return (jboolean) !setNetworkForSocket(netId, socket);
249}
250
251static jboolean android_net_utils_protectFromVpn(JNIEnv *env, jobject thiz, jint socket)
252{
253    return (jboolean) !protectFromVpn(socket);
254}
255
256// ----------------------------------------------------------------------------
257
258/*
259 * JNI registration.
260 */
261static JNINativeMethod gNetworkUtilMethods[] = {
262    /* name, signature, funcPtr */
263    { "resetConnections", "(Ljava/lang/String;I)I",  (void *)android_net_utils_resetConnections },
264    { "runDhcp", "(Ljava/lang/String;Landroid/net/DhcpResults;)Z",  (void *)android_net_utils_runDhcp },
265    { "runDhcpRenew", "(Ljava/lang/String;Landroid/net/DhcpResults;)Z",  (void *)android_net_utils_runDhcpRenew },
266    { "stopDhcp", "(Ljava/lang/String;)Z",  (void *)android_net_utils_stopDhcp },
267    { "releaseDhcpLease", "(Ljava/lang/String;)Z",  (void *)android_net_utils_releaseDhcpLease },
268    { "getDhcpError", "()Ljava/lang/String;", (void*) android_net_utils_getDhcpError },
269    { "bindProcessToNetwork", "(I)Z", (void*) android_net_utils_bindProcessToNetwork },
270    { "getNetworkBoundToProcess", "()I", (void*) android_net_utils_getNetworkBoundToProcess },
271    { "bindProcessToNetworkForHostResolution", "(I)Z", (void*) android_net_utils_bindProcessToNetworkForHostResolution },
272    { "bindSocketToNetwork", "(II)Z", (void*) android_net_utils_bindSocketToNetwork },
273    { "protectFromVpn", "(I)Z", (void*)android_net_utils_protectFromVpn },
274};
275
276int register_android_net_NetworkUtils(JNIEnv* env)
277{
278    jclass dhcpResultsClass = env->FindClass("android/net/DhcpResults");
279    LOG_FATAL_IF(dhcpResultsClass == NULL, "Unable to find class android/net/DhcpResults");
280    dhcpResultsFieldIds.clear =
281            env->GetMethodID(dhcpResultsClass, "clear", "()V");
282    dhcpResultsFieldIds.setInterfaceName =
283            env->GetMethodID(dhcpResultsClass, "setInterfaceName", "(Ljava/lang/String;)V");
284    dhcpResultsFieldIds.addLinkAddress =
285            env->GetMethodID(dhcpResultsClass, "addLinkAddress", "(Ljava/lang/String;I)Z");
286    dhcpResultsFieldIds.addGateway =
287            env->GetMethodID(dhcpResultsClass, "addGateway", "(Ljava/lang/String;)Z");
288    dhcpResultsFieldIds.addDns =
289            env->GetMethodID(dhcpResultsClass, "addDns", "(Ljava/lang/String;)Z");
290    dhcpResultsFieldIds.setDomains =
291            env->GetMethodID(dhcpResultsClass, "setDomains", "(Ljava/lang/String;)V");
292    dhcpResultsFieldIds.setServerAddress =
293            env->GetMethodID(dhcpResultsClass, "setServerAddress", "(Ljava/lang/String;)Z");
294    dhcpResultsFieldIds.setLeaseDuration =
295            env->GetMethodID(dhcpResultsClass, "setLeaseDuration", "(I)V");
296    dhcpResultsFieldIds.setVendorInfo =
297            env->GetMethodID(dhcpResultsClass, "setVendorInfo", "(Ljava/lang/String;)V");
298
299    return AndroidRuntime::registerNativeMethods(env,
300            NETUTILS_PKG_NAME, gNetworkUtilMethods, NELEM(gNetworkUtilMethods));
301}
302
303}; // namespace android
304