The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2008, The Android Open Source Project |
| 3 | * |
Elliott Hughes | dd66bcb | 2011-04-12 11:28:59 -0700 | [diff] [blame] | 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 |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 7 | * |
Elliott Hughes | dd66bcb | 2011-04-12 11:28:59 -0700 | [diff] [blame] | 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 9 | * |
Elliott Hughes | dd66bcb | 2011-04-12 11:28:59 -0700 | [diff] [blame] | 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 |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #define LOG_TAG "NetUtils" |
| 18 | |
| 19 | #include "jni.h" |
Chad Brubaker | 12324b4 | 2013-07-11 13:30:36 -0700 | [diff] [blame] | 20 | #include "JNIHelp.h" |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 21 | #include "NetdClient.h" |
| 22 | #include "resolv_netid.h" |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 23 | #include <utils/misc.h> |
| 24 | #include <android_runtime/AndroidRuntime.h> |
| 25 | #include <utils/Log.h> |
| 26 | #include <arpa/inet.h> |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 27 | #include <cutils/properties.h> |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 28 | |
| 29 | extern "C" { |
Mike Lockwood | 0900f36 | 2009-07-10 17:24:07 -0400 | [diff] [blame] | 30 | int ifc_enable(const char *ifname); |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 31 | int ifc_disable(const char *ifname); |
Wink Saville | 8171e6f | 2011-07-07 16:17:06 -0700 | [diff] [blame] | 32 | int ifc_reset_connections(const char *ifname, int reset_mask); |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 33 | |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 34 | int dhcp_do_request(const char * const ifname, |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 35 | const char *ipaddr, |
| 36 | const char *gateway, |
Jeff Sharkey | 77b87ba | 2012-04-18 21:55:14 -0700 | [diff] [blame] | 37 | uint32_t *prefixLength, |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 38 | const char *dns[], |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 39 | const char *server, |
Jeff Sharkey | 77b87ba | 2012-04-18 21:55:14 -0700 | [diff] [blame] | 40 | uint32_t *lease, |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 41 | const char *vendorInfo, |
Dmitry Shmidt | ec90545 | 2013-07-24 17:42:56 -0700 | [diff] [blame] | 42 | const char *domains, |
| 43 | const char *mtu); |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 44 | |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 45 | int dhcp_do_request_renew(const char * const ifname, |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 46 | const char *ipaddr, |
| 47 | const char *gateway, |
Jeff Sharkey | 77b87ba | 2012-04-18 21:55:14 -0700 | [diff] [blame] | 48 | uint32_t *prefixLength, |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 49 | const char *dns[], |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 50 | const char *server, |
Jeff Sharkey | 77b87ba | 2012-04-18 21:55:14 -0700 | [diff] [blame] | 51 | uint32_t *lease, |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 52 | const char *vendorInfo, |
Dmitry Shmidt | ec90545 | 2013-07-24 17:42:56 -0700 | [diff] [blame] | 53 | const char *domains, |
| 54 | const char *mtu); |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 55 | |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 56 | int dhcp_stop(const char *ifname); |
| 57 | int dhcp_release_lease(const char *ifname); |
| 58 | char *dhcp_get_errmsg(); |
| 59 | } |
| 60 | |
| 61 | #define NETUTILS_PKG_NAME "android/net/NetworkUtils" |
| 62 | |
| 63 | namespace 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 | */ |
| 70 | static struct fieldIds { |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 71 | jmethodID clear; |
| 72 | jmethodID setInterfaceName; |
| 73 | jmethodID addLinkAddress; |
| 74 | jmethodID addGateway; |
| 75 | jmethodID addDns; |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 76 | jmethodID setDomains; |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 77 | jmethodID setServerAddress; |
| 78 | jmethodID setLeaseDuration; |
| 79 | jmethodID setVendorInfo; |
| 80 | } dhcpResultsFieldIds; |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 81 | |
Wink Saville | 8171e6f | 2011-07-07 16:17:06 -0700 | [diff] [blame] | 82 | static jint android_net_utils_resetConnections(JNIEnv* env, jobject clazz, |
| 83 | jstring ifname, jint mask) |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 84 | { |
| 85 | int result; |
| 86 | |
| 87 | const char *nameStr = env->GetStringUTFChars(ifname, NULL); |
Wink Saville | 8171e6f | 2011-07-07 16:17:06 -0700 | [diff] [blame] | 88 | |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 89 | ALOGD("android_net_utils_resetConnections in env=%p clazz=%p iface=%s mask=0x%x\n", |
Wink Saville | 8171e6f | 2011-07-07 16:17:06 -0700 | [diff] [blame] | 90 | env, clazz, nameStr, mask); |
| 91 | |
| 92 | result = ::ifc_reset_connections(nameStr, mask); |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 93 | env->ReleaseStringUTFChars(ifname, nameStr); |
| 94 | return (jint)result; |
| 95 | } |
| 96 | |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 97 | static jboolean android_net_utils_runDhcpCommon(JNIEnv* env, jobject clazz, jstring ifname, |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 98 | jobject dhcpResults, bool renew) |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 99 | { |
| 100 | int result; |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 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]; |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 106 | char dns3[PROPERTY_VALUE_MAX]; |
| 107 | char dns4[PROPERTY_VALUE_MAX]; |
| 108 | const char *dns[5] = {dns1, dns2, dns3, dns4, NULL}; |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 109 | char server[PROPERTY_VALUE_MAX]; |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 110 | uint32_t lease; |
Jeff Sharkey | 77b87ba | 2012-04-18 21:55:14 -0700 | [diff] [blame] | 111 | char vendorInfo[PROPERTY_VALUE_MAX]; |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 112 | char domains[PROPERTY_VALUE_MAX]; |
Dmitry Shmidt | ec90545 | 2013-07-24 17:42:56 -0700 | [diff] [blame] | 113 | char mtu[PROPERTY_VALUE_MAX]; |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 114 | |
| 115 | const char *nameStr = env->GetStringUTFChars(ifname, NULL); |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 116 | if (nameStr == NULL) return (jboolean)false; |
| 117 | |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 118 | if (renew) { |
| 119 | result = ::dhcp_do_request_renew(nameStr, ipaddr, gateway, &prefixLength, |
Dmitry Shmidt | ec90545 | 2013-07-24 17:42:56 -0700 | [diff] [blame] | 120 | dns, server, &lease, vendorInfo, domains, mtu); |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 121 | } else { |
| 122 | result = ::dhcp_do_request(nameStr, ipaddr, gateway, &prefixLength, |
Dmitry Shmidt | ec90545 | 2013-07-24 17:42:56 -0700 | [diff] [blame] | 123 | dns, server, &lease, vendorInfo, domains, mtu); |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 124 | } |
Robert Greenwalt | 28cdf1d | 2013-03-15 10:48:46 -0700 | [diff] [blame] | 125 | if (result != 0) { |
Vinit Deshapnde | c249c2c | 2013-08-08 10:38:53 -0700 | [diff] [blame] | 126 | ALOGD("dhcp_do_request failed : %s (%s)", nameStr, renew ? "renew" : "new"); |
Robert Greenwalt | 28cdf1d | 2013-03-15 10:48:46 -0700 | [diff] [blame] | 127 | } |
| 128 | |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 129 | env->ReleaseStringUTFChars(ifname, nameStr); |
Brian Carlstrom | 46e18c11 | 2011-04-05 22:44:45 -0700 | [diff] [blame] | 130 | if (result == 0) { |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 131 | env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.clear); |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 132 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 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) { |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 144 | // set the gateway |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 145 | // dhcpResults->addGateway(gateway) |
| 146 | result = env->CallBooleanMethod(dhcpResults, |
| 147 | dhcpResultsFieldIds.addGateway, env->NewStringUTF(gateway)); |
| 148 | } |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 149 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 150 | if (result == 0) { |
| 151 | // dhcpResults->addDns(new InetAddress(dns1)) |
| 152 | result = env->CallBooleanMethod(dhcpResults, |
| 153 | dhcpResultsFieldIds.addDns, env->NewStringUTF(dns1)); |
| 154 | } |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 155 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 156 | if (result == 0) { |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 157 | env->CallVoidMethod(dhcpResults, dhcpResultsFieldIds.setDomains, |
| 158 | env->NewStringUTF(domains)); |
| 159 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 160 | result = env->CallBooleanMethod(dhcpResults, |
| 161 | dhcpResultsFieldIds.addDns, env->NewStringUTF(dns2)); |
Robert Greenwalt | 3c97f94 | 2013-01-09 16:28:19 -0800 | [diff] [blame] | 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 | } |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 171 | } |
Robert Greenwalt | aa70f10 | 2011-04-28 14:28:50 -0700 | [diff] [blame] | 172 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 173 | if (result == 0) { |
| 174 | // dhcpResults->setServerAddress(new InetAddress(server)) |
| 175 | result = env->CallBooleanMethod(dhcpResults, dhcpResultsFieldIds.setServerAddress, |
Robert Greenwalt | 0216e61 | 2011-01-14 16:29:58 -0800 | [diff] [blame] | 176 | env->NewStringUTF(server)); |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 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)); |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 187 | } |
| 188 | return (jboolean)(result == 0); |
| 189 | } |
| 190 | |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 191 | |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 192 | static 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 | |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 197 | static jboolean android_net_utils_runDhcpRenew(JNIEnv* env, jobject clazz, jstring ifname, |
| 198 | jobject info) |
Irfan Sheriff | 31be7cf | 2011-04-28 10:25:31 -0700 | [diff] [blame] | 199 | { |
| 200 | return android_net_utils_runDhcpCommon(env, clazz, ifname, info, true); |
| 201 | } |
| 202 | |
| 203 | |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 204 | static 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 | |
| 214 | static 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 | |
| 224 | static jstring android_net_utils_getDhcpError(JNIEnv* env, jobject clazz) |
| 225 | { |
| 226 | return env->NewStringUTF(::dhcp_get_errmsg()); |
| 227 | } |
| 228 | |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 229 | static jboolean android_net_utils_bindProcessToNetwork(JNIEnv *env, jobject thiz, jint netId) |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 230 | { |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 231 | return (jboolean) !setNetworkForProcess(netId); |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 232 | } |
| 233 | |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 234 | static jint android_net_utils_getNetworkBoundToProcess(JNIEnv *env, jobject thiz) |
| 235 | { |
| 236 | return getNetworkForProcess(); |
| 237 | } |
| 238 | |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 239 | static jboolean android_net_utils_bindProcessToNetworkForHostResolution(JNIEnv *env, jobject thiz, |
| 240 | jint netId) |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 241 | { |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 242 | return (jboolean) !setNetworkForResolv(netId); |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 243 | } |
| 244 | |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 245 | static jboolean android_net_utils_bindSocketToNetwork(JNIEnv *env, jobject thiz, jint socket, |
| 246 | jint netId) |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 247 | { |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 248 | return (jboolean) !setNetworkForSocket(netId, socket); |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 249 | } |
| 250 | |
Paul Jensen | 6bc2c2c | 2014-05-07 15:27:40 -0400 | [diff] [blame] | 251 | static jboolean android_net_utils_protectFromVpn(JNIEnv *env, jobject thiz, jint socket) |
| 252 | { |
| 253 | return (jboolean) !protectFromVpn(socket); |
| 254 | } |
| 255 | |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 256 | // ---------------------------------------------------------------------------- |
| 257 | |
| 258 | /* |
| 259 | * JNI registration. |
| 260 | */ |
| 261 | static JNINativeMethod gNetworkUtilMethods[] = { |
| 262 | /* name, signature, funcPtr */ |
Wink Saville | 8171e6f | 2011-07-07 16:17:06 -0700 | [diff] [blame] | 263 | { "resetConnections", "(Ljava/lang/String;I)I", (void *)android_net_utils_resetConnections }, |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 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 }, |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 266 | { "stopDhcp", "(Ljava/lang/String;)Z", (void *)android_net_utils_stopDhcp }, |
| 267 | { "releaseDhcpLease", "(Ljava/lang/String;)Z", (void *)android_net_utils_releaseDhcpLease }, |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 268 | { "getDhcpError", "()Ljava/lang/String;", (void*) android_net_utils_getDhcpError }, |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 269 | { "bindProcessToNetwork", "(I)Z", (void*) android_net_utils_bindProcessToNetwork }, |
Paul Jensen | 3876495 | 2014-05-20 11:25:35 -0400 | [diff] [blame] | 270 | { "getNetworkBoundToProcess", "()I", (void*) android_net_utils_getNetworkBoundToProcess }, |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 271 | { "bindProcessToNetworkForHostResolution", "(I)Z", (void*) android_net_utils_bindProcessToNetworkForHostResolution }, |
Paul Jensen | 32a58f0 | 2014-06-20 13:58:14 -0400 | [diff] [blame] | 272 | { "bindSocketToNetwork", "(II)Z", (void*) android_net_utils_bindSocketToNetwork }, |
Paul Jensen | 6bc2c2c | 2014-05-07 15:27:40 -0400 | [diff] [blame] | 273 | { "protectFromVpn", "(I)Z", (void*)android_net_utils_protectFromVpn }, |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 274 | }; |
| 275 | |
| 276 | int register_android_net_NetworkUtils(JNIEnv* env) |
| 277 | { |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 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"); |
Robert Greenwalt | 8058f62 | 2012-11-09 10:52:27 -0800 | [diff] [blame] | 290 | dhcpResultsFieldIds.setDomains = |
| 291 | env->GetMethodID(dhcpResultsClass, "setDomains", "(Ljava/lang/String;)V"); |
Robert Greenwalt | 4717c26 | 2012-10-31 14:32:53 -0700 | [diff] [blame] | 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"); |
The Android Open Source Project | 9066cfe | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 298 | |
| 299 | return AndroidRuntime::registerNativeMethods(env, |
| 300 | NETUTILS_PKG_NAME, gNetworkUtilMethods, NELEM(gNetworkUtilMethods)); |
| 301 | } |
| 302 | |
| 303 | }; // namespace android |