Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove libpac usage from Android.

Browse Source 
Android's libpac is replaced with WebView implementation.
This will allow to remove V8 which is used only by libpac.

Bug: 165006496
Test: Manual. Remove libpac and v8 from manifest, check there are no
compilation errors.
Test: atest com.android.cts.devicepolicy.DeviceOwnerTest#testProxyPacProxyTest
Change-Id: Id6b9a223c176ce1b2dd7f7c4dd9ee54001dae1a4

Change-Id: If3ee10fcd0306b4b7a3c8b498e877d59398f642a
This commit is contained in:
Anna Malova
2020-08-27 18:54:57 +01:00
parent 5bb7698d00
commit 8b82c22d00
10 changed files with 15 additions and 409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
core/res/res/values/config.xml
View File

@@ -271,11 +271,6 @@
when there's no network connection. If the scan doesn't timeout, use zero -->
<integer name="config_radioScanningTimeout">0</integer>
<!-- When true, Android uses the PAC implementation included in WebView to handle
networks with PAC scripts.
When false, Android's own implementation of libpac is used.-->
<bool name ="config_useWebViewPacProcessor">true</bool>
<!-- XXXXX NOTE THE FOLLOWING RESOURCES USE THE WRONG NAMING CONVENTION.
Please don't copy them, copy anything else. -->

1
core/res/res/values/symbols.xml
View File

@@ -287,7 +287,6 @@
<java-symbol type="bool" name="config_duplicate_port_omadm_wappush" />
<java-symbol type="bool" name="config_disableTransitionAnimation" />
<java-symbol type="bool" name="config_enableAutoPowerModes" />
<java-symbol type="bool" name="config_useWebViewPacProcessor" />
<java-symbol type="integer" name="config_autoPowerModeThresholdAngle" />
<java-symbol type="integer" name="config_autoPowerModeAnyMotionSensor" />
<java-symbol type="bool" name="config_autoPowerModePreferWristTilt" />

1
packages/services/PacProcessor/Android.bp
View File

@@ -19,7 +19,6 @@ android_app {
srcs: ["src/**/*.java"],
platform_apis: true,
certificate: "platform",
jni_libs: ["libjni_pacprocessor"],
}
filegroup {

43
packages/services/PacProcessor/jni/Android.bp
View File

@@ -1,43 +0,0 @@
//
// Copyright (C) 2013 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
cc_library_shared {
name: "libjni_pacprocessor",
srcs: [
"jni_init.cpp",
"com_android_pacprocessor_PacNative.cpp",
],
shared_libs: [
"libandroidfw",
"libandroid_runtime",
"liblog",
"libutils",
"libnativehelper",
"libpac",
],
cflags: [
"-Wall",
"-Werror",
"-Wunused",
"-Wunreachable-code",
],
sanitize: {
cfi: true,
},
}

133
packages/services/PacProcessor/jni/com_android_pacprocessor_PacNative.cpp
View File

@@ -1,133 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "PacProcessor"
#include <stdlib.h>
#include <string>
#include <utils/Log.h>
#include <utils/Mutex.h>
#include "android_runtime/AndroidRuntime.h"
#include "jni.h"
#include <nativehelper/JNIHelp.h>
#include "proxy_resolver_v8_wrapper.h"
namespace android {
ProxyResolverV8Handle* proxyResolver = NULL;
bool pacSet = false;
std::u16string jstringToString16(JNIEnv* env, jstring jstr) {
const jchar* str = env->GetStringCritical(jstr, 0);
std::u16string str16(reinterpret_cast<const char16_t*>(str),
env->GetStringLength(jstr));
env->ReleaseStringCritical(jstr, str);
return str16;
}
jstring string16ToJstring(JNIEnv* env, std::u16string string) {
const char16_t* str = string.data();
size_t len = string.length();
return env->NewString(reinterpret_cast<const jchar*>(str), len);
}
static jboolean com_android_pacprocessor_PacNative_createV8ParserNativeLocked(JNIEnv* /* env */,
jobject) {
if (proxyResolver == NULL) {
proxyResolver = ProxyResolverV8Handle_new();
pacSet = false;
return JNI_FALSE;
}
return JNI_TRUE;
}
static jboolean com_android_pacprocessor_PacNative_destroyV8ParserNativeLocked(JNIEnv* /* env */,
jobject) {
if (proxyResolver != NULL) {
ProxyResolverV8Handle_delete(proxyResolver);
proxyResolver = NULL;
return JNI_FALSE;
}
return JNI_TRUE;
}
static jboolean com_android_pacprocessor_PacNative_setProxyScriptNativeLocked(JNIEnv* env, jobject,
jstring script) {
std::u16string script16 = jstringToString16(env, script);
if (proxyResolver == NULL) {
ALOGE("V8 Parser not started when setting PAC script");
return JNI_TRUE;
}
if (ProxyResolverV8Handle_SetPacScript(proxyResolver, script16.data()) != OK) {
ALOGE("Unable to set PAC script");
return JNI_TRUE;
}
pacSet = true;
return JNI_FALSE;
}
static jstring com_android_pacprocessor_PacNative_makeProxyRequestNativeLocked(JNIEnv* env, jobject,
jstring url, jstring host) {
std::u16string url16 = jstringToString16(env, url);
std::u16string host16 = jstringToString16(env, host);
if (proxyResolver == NULL) {
ALOGE("V8 Parser not initialized when running PAC script");
return NULL;
}
if (!pacSet) {
ALOGW("Attempting to run PAC with no script set");
return NULL;
}
std::unique_ptr<char16_t, decltype(&free)> result = std::unique_ptr<char16_t, decltype(&free)>(
ProxyResolverV8Handle_GetProxyForURL(proxyResolver, url16.data(), host16.data()), &free);
if (result.get() == NULL) {
ALOGE("Error Running PAC");
return NULL;
}
std::u16string ret(result.get());
jstring jret = string16ToJstring(env, ret);
return jret;
}
static const JNINativeMethod gMethods[] = {
{ "createV8ParserNativeLocked", "()Z",
(void*)com_android_pacprocessor_PacNative_createV8ParserNativeLocked},
{ "destroyV8ParserNativeLocked", "()Z",
(void*)com_android_pacprocessor_PacNative_destroyV8ParserNativeLocked},
{ "setProxyScriptNativeLocked", "(Ljava/lang/String;)Z",
(void*)com_android_pacprocessor_PacNative_setProxyScriptNativeLocked},
{ "makeProxyRequestNativeLocked", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
(void*)com_android_pacprocessor_PacNative_makeProxyRequestNativeLocked},
};
int register_com_android_pacprocessor_PacNative(JNIEnv* env) {
return jniRegisterNativeMethods(env, "com/android/pacprocessor/PacNative",
gMethods, NELEM(gMethods));
}
} /* namespace android */

38
packages/services/PacProcessor/jni/jni_init.cpp
View File

@@ -1,38 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "PacProcessor"
#include <utils/Log.h>
#include "jni.h"
namespace android {
extern int register_com_android_pacprocessor_PacNative(JNIEnv *env);
}
using namespace android;
extern "C" jint JNI_OnLoad(JavaVM* vm, void* /* reserved */) {
JNIEnv *env;
if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
ALOGE("ERROR: GetEnv failed");
return -1;
}
register_com_android_pacprocessor_PacNative(env);
return JNI_VERSION_1_6;
}

34
packages/services/PacProcessor/src/com/android/pacprocessor/LibpacInterface.java
View File

@@ -1,34 +0,0 @@
/*
* Copyright 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.pacprocessor;
/**
* Common interface for both Android's and WebView's implementation of PAC processor.
*
* @hide
*/
interface LibpacInterface {
default boolean startPacSupport() {
return true;
}
default boolean stopPacSupport() {
return true;
}
boolean setCurrentProxyScript(String script);
String makeProxyRequest(String url, String host);
}

96
packages/services/PacProcessor/src/com/android/pacprocessor/PacNative.java
View File

@@ -1,96 +0,0 @@
/**
* Copyright (c) 2013, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.pacprocessor;
import android.util.Log;
/**
* @hide
*/
public class PacNative implements LibpacInterface {
private static final String TAG = "PacProxy";
private static final PacNative sInstance = new PacNative();
private String mCurrentPac;
private boolean mIsActive;
// Only make native calls from inside synchronized blocks.
private native boolean createV8ParserNativeLocked();
private native boolean destroyV8ParserNativeLocked();
private native boolean setProxyScriptNativeLocked(String script);
private native String makeProxyRequestNativeLocked(String url, String host);
static {
System.loadLibrary("jni_pacprocessor");
}
private PacNative() {
}
public static PacNative getInstance() {
return sInstance;
}
@Override
public synchronized boolean startPacSupport() {
if (createV8ParserNativeLocked()) {
Log.e(TAG, "Unable to Create v8 Proxy Parser.");
return false;
}
mIsActive = true;
return true;
}
@Override
public synchronized boolean stopPacSupport() {
if (mIsActive) {
if (destroyV8ParserNativeLocked()) {
Log.e(TAG, "Unable to Destroy v8 Proxy Parser.");
return false;
}
mIsActive = false;
}
return true;
}
@Override
public synchronized boolean setCurrentProxyScript(String script) {
if (setProxyScriptNativeLocked(script)) {
Log.e(TAG, "Unable to parse proxy script.");
return false;
}
return true;
}
@Override
public synchronized String makeProxyRequest(String url, String host) {
String ret = makeProxyRequestNativeLocked(url, host);
if ((ret == null) || (ret.length() == 0)) {
Log.e(TAG, "v8 Proxy request failed.");
ret = null;
}
return ret;
}
public synchronized boolean isActive() {
return mIsActive;
}
}

25
packages/services/PacProcessor/src/com/android/pacprocessor/PacService.java
View File

@@ -17,13 +17,14 @@ package com.android.pacprocessor;
import android.app.Service;
import android.content.Intent;
import android.content.res.Resources;
import android.os.Binder;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteException;
import android.util.Log;
import android.webkit.PacProcessor;
import com.android.internal.annotations.GuardedBy;
import com.android.net.IProxyService;
import java.net.MalformedURLException;
@@ -31,24 +32,21 @@ import java.net.URL;
public class PacService extends Service {
private static final String TAG = "PacService";
private static final boolean sUseWebViewPacProcessor = Resources.getSystem().getBoolean(
com.android.internal.R.bool.config_useWebViewPacProcessor);
private final LibpacInterface mLibpac = sUseWebViewPacProcessor
? PacWebView.getInstance()
: PacNative.getInstance();
private Object mLock = new Object();
@GuardedBy("mLock")
private final PacProcessor mPacProcessor = PacProcessor.getInstance();
private ProxyServiceStub mStub = new ProxyServiceStub();
@Override
public void onCreate() {
super.onCreate();
mLibpac.startPacSupport();
}
@Override
public void onDestroy() {
mLibpac.stopPacSupport();
super.onDestroy();
}
@@ -74,7 +72,10 @@ public class PacService extends Service {
throw new IllegalArgumentException("Invalid host was passed");
}
}
return mLibpac.makeProxyRequest(url, host);
synchronized (mLock) {
return mPacProcessor.findProxyForUrl(url);
}
} catch (MalformedURLException e) {
throw new IllegalArgumentException("Invalid URL was passed");
}
@@ -86,7 +87,11 @@ public class PacService extends Service {
Log.e(TAG, "Only system user is allowed to call setPacFile");
throw new SecurityException();
}
mLibpac.setCurrentProxyScript(script);
synchronized (mLock) {
if (!mPacProcessor.setProxyScript(script)) {
Log.e(TAG, "Unable to parse proxy script.");
}
}
}
}
}

48
packages/services/PacProcessor/src/com/android/pacprocessor/PacWebView.java
View File

@@ -1,48 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.pacprocessor;
import android.util.Log;
import android.webkit.PacProcessor;
/**
* @hide
*/
public class PacWebView implements LibpacInterface {
private static final String TAG = "PacWebView";
private static final PacWebView sInstance = new PacWebView();
private PacProcessor mProcessor = PacProcessor.getInstance();
public static PacWebView getInstance() {
return sInstance;
}
@Override
public synchronized boolean setCurrentProxyScript(String script) {
if (!mProcessor.setProxyScript(script)) {
Log.e(TAG, "Unable to parse proxy script.");
return false;
}
return true;
}
@Override
public synchronized String makeProxyRequest(String url, String host) {
return mProcessor.findProxyForUrl(url);
}
}