Attachment #92027 for bug #180921

Lines 39-44 Link Here

(-)src/org/eclipse/core/internal/net/ProxyManager.java (+13 lines)
39		39
40	private static IProxyService proxyManager;	40	private static IProxyService proxyManager;
41		41
		42	private AbstractProxyProvider nativeProxyProvider;
		43
42	ListenerList listeners = new ListenerList(ListenerList.IDENTITY);	44	ListenerList listeners = new ListenerList(ListenerList.IDENTITY);
43	private String[] nonProxiedHosts;	45	private String[] nonProxiedHosts;
44	private final ProxyType[] proxies = new ProxyType[] {	46	private final ProxyType[] proxies = new ProxyType[] {
Lines 48-53 Link Here
48	};	50	};
49		51
50	private boolean migrated = false;	52	private boolean migrated = false;
		53
		54	private ProxyManager()
		55	{
		56	try {
		57	nativeProxyProvider = (AbstractProxyProvider)Class.forName("org.eclipse.core.net.ProxyProvider").newInstance(); //$NON-NLS-1$
		58	} catch (ClassNotFoundException e) {
		59	// no class found
		60	} catch (Exception e) {
		61	Activator.logInfo("noNativeProxyProvider", e); //$NON-NLS-1$
		62	}
		63	}
51		64
52	/**	65	/**
53	* Return the proxy manager.	66	* Return the proxy manager.




	private String password;
	private boolean requiresAuthentication;

	public ProxyData(String type, String host, int port,
			boolean requiresAuthentication) {
		this.type = type;
		this.host = host;
		this.port = port;

		requiresAuthentication = false;
	}

	public String toString() {
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("host: "); //$NON-NLS-1$
		stringBuffer.append(host);
		stringBuffer.append(" port: "); //$NON-NLS-1$
		stringBuffer.append(port);
		stringBuffer.append(" user: "); //$NON-NLS-1$
		stringBuffer.append(user);
		stringBuffer.append(" password: "); //$NON-NLS-1$
		stringBuffer.append(password);
		stringBuffer.append(" reqAuth: "); //$NON-NLS-1$
		stringBuffer.append(requiresAuthentication);
		return stringBuffer.toString(); 
	}

}




/*******************************************************************************
 * Copyright (c) 2008 Oakland Software Incorporated and others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Oakland Software Incorporated - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.internal.net;

import java.net.URI;

import org.eclipse.core.net.proxy.IProxyData;

/**
 * Returns eligible proxies based on the hosts configuration.
 * 
 * Subclasses implement the native code required to get the proxy information.
 * 
 * This intentionally has semantics similar to the Java ProxySelector class. The
 * idea is that when we drop support for Java versions earlier than 1.5 we can
 * easily re-implement this using the native Java support and remove the native
 * code associated with this implementation.
 * 
 * This is not intended to be subclassed by clients. This is not intended to be
 * instantiated by clients.
 * 
 * @since 3.4
 * 
 */
public abstract class AbstractProxyProvider {

	/**
	 * Return the IProxyData(s) that can be used with the given URI.
	 * 
	 * This considers the native proxy settings on the host. It includes the
	 * consideration of hosts for which no proxying is desired.
	 * 
	 * @param uri
	 *            the URI to for with the proxy is generated
	 * @return an array of IProxyData which are the applicable proxies for the
	 *         specified URI
	 * 
	 * @since 3.4
	 */
	public IProxyData[] select(URI uri) {
		String[] nonProxyHosts = getNonProxiedHosts();
		String host = uri.getHost();

		if (nonProxyHosts != null) {
			for (int npIndex = 0; npIndex < nonProxyHosts.length; npIndex++) {
				if (host.equals(nonProxyHosts[npIndex])) {
					return new IProxyData[0];
				}
			}
		}

		return getProxyData(uri);
	}

	protected abstract IProxyData[] getProxyData(URI uri);

	protected String[] getNonProxiedHosts() {
		// Default implementation, subclasses may override
		return new String[] {};
	}

}

Added Link Here

(-)natives/unix/Debug/sources.mk (+17 lines)
1	################################################################################
2	# Automatically-generated file. Do not edit!
3	################################################################################
4
5	O_SRCS :=
6	C_SRCS :=
7	S_SRCS :=
8	OBJ_SRCS :=
9	ASM_SRCS :=
10	OBJS :=
11	C_DEPS :=
12	LIBRARIES :=
13
14	# Every subdirectory with source files must be described here
15	SUBDIRS := \
16	. \
17




package org.eclipse.core.internal.net;

import java.net.URI;

import org.eclipse.core.net.proxy.IProxyData;

public class WindowsProxyProvider extends AbstractProxyProvider {
	
	public WindowsProxyProvider(){
		Activator.logInfo("winProxyProvider initialized", null); //$NON-NLS-1$
	}

	protected IProxyData[] getProxyData(URI uri) {
		// TODO Auto-generated method stub
		return null;
	}

}




The source for getting the native proxy info is in the top level unix directory.  If
there are more specific compile options, makefiles, etc, then they should be moved
to subdirectories, like in org.eclipse.core.filesystem.

The Debug directory actually has the make file; this is the makefile as generated by the CDT.

To build this, go into Debug and type "make", the library will be built in that same
directory.  Then you will need to copy the library to the correct org.eclipse.core.net.*
fragment.

There is no automatic build process for building the native code, instead the binary
shared libraries are checked in for each fragment, just like in org.eclipse.code.filesystem.

Added Link Here

(-)natives/unix/Debug/objects.mk (+7 lines)
1	################################################################################
2	# Automatically-generated file. Do not edit!
3	################################################################################
4
5	USER_OBJS :=
6
7	LIBS := -lgconf-2 -lORBit-2 -lgthread-2.0 -lrt -lgobject-2.0 -lglib-2.0




/*
 * Copyright 2008 Oakland Software Incorporated and others
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Oakland Software Incorporated - initial API and implementation
 */

#include <jni.h>

#include <glib.h>
#include <glib/gslist.h>
#include <gconf/gconf-value.h>
#include <gconf/gconf-client.h>

#ifdef __linux__
#include <string.h>
#else
#include <strings.h>
#endif

static GConfClient *client= NULL;

static jclass proxyInfoClass;
static jclass stringClass;
static jmethodID proxyInfoConstructor;
static jmethodID toString;

static jmethodID hostMethod;
static jmethodID portMethod;
static jmethodID requiresAuthenticationMethod;
static jmethodID userMethod;
static jmethodID passwordMethod;

#define CHECK_NULL(X) { if ((X) == NULL) fprintf (stderr,"JNI error at line %d\n", __LINE__); } 

static void gconfInit(JNIEnv *env) {
	client = gconf_client_get_default();
	jclass cls= NULL;
	CHECK_NULL(cls = (*env)->FindClass(env, "org/eclipse/core/internal/net/ProxyData"));
	proxyInfoClass = (*env)->NewGlobalRef(env, cls);

	CHECK_NULL(cls = (*env)->FindClass(env, "java/lang/String"));
	stringClass = (*env)->NewGlobalRef(env, cls);

	CHECK_NULL(proxyInfoConstructor = (*env)->GetMethodID(env, proxyInfoClass, "<init>", "(Ljava/lang/String;)V"));

	CHECK_NULL(toString = (*env)->GetMethodID(env, proxyInfoClass, "toString", "()Ljava/lang/String;"));

	CHECK_NULL(hostMethod = (*env)->GetMethodID(env, proxyInfoClass, "setHost",
					"(Ljava/lang/String;)V"));
	CHECK_NULL(portMethod = (*env)->GetMethodID(env, proxyInfoClass, "setPort",
					"(I)V"));
	CHECK_NULL(requiresAuthenticationMethod= (*env)->GetMethodID(env, proxyInfoClass, "setRequiresAuthentication",
					"(Z)V"));
	CHECK_NULL(userMethod = (*env)->GetMethodID(env, proxyInfoClass, "setUserid",
					"(Ljava/lang/String;)V"));
	CHECK_NULL(passwordMethod = (*env)->GetMethodID(env, proxyInfoClass, "setPassword",
					"(Ljava/lang/String;)V"));
}

/*
 * Class:     org_eclipse_core_internal_net_UnixProxyProvider
 * Method:    getGConfProxyInfo
 * Signature: ([Ljava/lang/String);
 */
JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getGConfProxyInfo(
		JNIEnv *env, jclass clazz, jstring protocol) {

	jboolean isCopy;
	const char *cprotocol;

	jobject proxyInfo= NULL;

	if (client == NULL) {
		gconfInit(env);
	}

	CHECK_NULL(proxyInfo = (*env)->NewObject(env, proxyInfoClass, proxyInfoConstructor, protocol));

	cprotocol = (*env)->GetStringUTFChars(env, protocol, &isCopy);
	if (cprotocol == NULL)
		return NULL;

	//printf("cprotocol: %s\n", cprotocol);

	if (strcasecmp(cprotocol, "http") == 0) {
		gboolean useProxy = gconf_client_get_bool(client,
				"/system/http_proxy/use_http_proxy", NULL);
		if (!useProxy) {
			proxyInfo = NULL;
			goto exit;
		}

		gchar *host = gconf_client_get_string(client,
				"/system/http_proxy/host", NULL);
		jobject jhost = (*env)->NewStringUTF(env, host);
		(*env)->CallVoidMethod(env, proxyInfo, hostMethod, jhost);

		gint port = gconf_client_get_int(client, "/system/http_proxy/port",
				NULL);
		(*env)->CallVoidMethod(env, proxyInfo, portMethod, port);

		gboolean reqAuth = gconf_client_get_bool(client,
				"/system/http_proxy/use_authentication", NULL);
		(*env)->CallVoidMethod(env, proxyInfo,
				requiresAuthenticationMethod, reqAuth);
		if (reqAuth) {

			gchar *user = gconf_client_get_string(client,
					"/system/http_proxy/authentication_user", NULL);
			jobject juser = (*env)->NewStringUTF(env, user);
			(*env)->CallVoidMethod(env, proxyInfo, userMethod, juser);

			gchar *password = gconf_client_get_string(client,
					"/system/http_proxy/authentication_password", NULL);
			jobject jpassword = (*env)->NewStringUTF(env, password);
			(*env)->CallVoidMethod(env, proxyInfo, passwordMethod,
					jpassword);
		}
		goto exit;
	}

	// Everything else applies only if the system proxy mode is manual
	gchar *mode = gconf_client_get_string(client, "/system/proxy/mode", NULL);
	if (strcasecmp(mode, "manual") != 0) {
		proxyInfo = NULL;
		goto exit;
	}

	char selector[100];

	if (strcasecmp(cprotocol, "https") == 0) {
		strcpy(selector, "/system/proxy/secure_");
	} else if (strcasecmp(cprotocol, "socks") == 0) {
		strcpy(selector, "/system/proxy/socks_");
	} else if (strcasecmp(cprotocol, "ftp") == 0) {
		strcpy(selector, "/system/proxy/ftp_");
	} else {
		proxyInfo = NULL;
		goto exit;
	}

	char useSelector[100];
	strcpy(useSelector, selector);

	gchar *host = gconf_client_get_string(client, strcat(useSelector, "host"),
			NULL);
	jobject jhost = (*env)->NewStringUTF(env, host);
	(*env)->CallVoidMethod(env, proxyInfo, hostMethod, jhost);

	strcpy(useSelector, selector);
	gint port = gconf_client_get_int(client, strcat(useSelector, "port"), NULL);
	(*env)->CallVoidMethod(env, proxyInfo, portMethod, port);

	exit: if (isCopy == JNI_TRUE)
		(*env)->ReleaseStringUTFChars(env, protocol, cprotocol);
	return proxyInfo;
}

typedef struct {
	jobjectArray npHostArray;
	JNIEnv *env;
	int index;
} ListProcContext;

// user_data is the ListProcContext
void listProc(gpointer data, gpointer user_data) {
	ListProcContext *lpc = user_data;
	jobject jnpHost = (*lpc->env)->NewStringUTF(lpc->env, (char *)data);
	(*lpc->env)->SetObjectArrayElement(lpc->env, lpc->npHostArray,
			lpc->index++, jnpHost);
}

/*
 * Class:     org_eclipse_core_internal_net_UnixProxyProvider
 * Method:    getGConfNonProxyHosts
 * Signature: ()[Ljava/lang/String;
 */
JNIEXPORT jobjectArray JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getGConfNonProxyHosts(
		JNIEnv *env, jclass clazz) {

	if (client == NULL) {
		gconfInit(env);
	}

	GSList *npHosts;
	int size;

	npHosts = gconf_client_get_list(client, "/system/http_proxy/ignore_hosts",
			GCONF_VALUE_STRING, NULL);
	size = g_slist_length(npHosts);

	// TODO - I'm not sure this is really valid, it's from the JVM implementation
	// of ProxySelector
	if (size == 0) {
		npHosts = gconf_client_get_list(client, "/system/proxy/no_proxy_for",
				GCONF_VALUE_STRING, NULL);
	}
	size = g_slist_length(npHosts);

	jobjectArray ret = (*env)->NewObjectArray(env, size, stringClass, NULL);

	ListProcContext lpc;
	lpc.env = env;
	lpc.npHostArray = ret;
	lpc.index = 0;

	g_slist_foreach(npHosts, listProc, &lpc);
	return ret;
}

/*
 * Class:     org_eclipse_core_internal_net_UnixProxyProvider
 * Method:    getKdeProxyInfo
 * Signature: ([Ljava/lang/String);
 */
JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getKdeProxyInfo(
		JNIEnv *env, jclass clazz, jstring protocol) {
	//printf("getKdeProxyInfo - not implemented\n");
	return NULL;
}

/*
 * Class:     org_eclipse_core_internal_net_UnixProxyProvider
 * Method:    getKdeNonProxyHosts
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getKdeNonProxyHosts(
		JNIEnv *env, jclass clazz) {
	//printf("getKdeNonProxyHosts - not implemented\n");
	return NULL;
}





package org.eclipse.core.internal.net;

import java.net.URI;
import java.net.URISyntaxException;

import org.eclipse.core.net.proxy.IProxyData;

public class UnixProxyProvider extends AbstractProxyProvider {

	static {
		System.loadLibrary("proxysupport"); //$NON-NLS-1$
	}

	public UnixProxyProvider() {
			Activator.logInfo("linuxProxyProvider initialized", null); //$NON-NLS-1$
	}

	public IProxyData[] getProxyData(URI uri) {
		String protocol = uri.getScheme();

		ProxyData pd = getSystemProxyInfo(protocol);

		if (pd != null) {
			IProxyData[] pds = new IProxyData[1];
			pds[0] = pd;
			return pds;
		}

		return new IProxyData[0];
	}

	protected String[] getNonProxiedHosts() {
		String[] npHosts = getGConfNonProxyHosts();
		if (npHosts != null && npHosts.length > 0)
			return npHosts;
		return getKdeNonProxyHosts();
	}

	// Returns null if something wrong or there is no proxy for the protocol
	protected ProxyData getSystemProxyInfo(String protocol) {
		ProxyData pd;

		// First try the environment variable which is a URL
		String sysHttp = System.getenv(protocol.toLowerCase() + "_proxy"); //$NON-NLS-1$
		if (sysHttp != null) {
			URI uri = null;
			try {
				uri = new URI(sysHttp);
			} catch (URISyntaxException e) {
				return null;
			}
			
			pd = new ProxyData(protocol);
			pd.setHost(uri.getHost());
			pd.setPort(uri.getPort());
			return pd;
		}

		// Then ask Gnome
		pd = getGConfProxyInfo(protocol);
		if (pd != null)
			return pd;

		// Then ask KDE
		pd = getKdeProxyInfo(protocol);
		if (pd != null)
			return pd;

		return null;
	}

	protected static native ProxyData getGConfProxyInfo(String protocol);

	protected static native String[] getGConfNonProxyHosts();

	protected static native ProxyData getKdeProxyInfo(String protocol);

	protected static native String[] getKdeNonProxyHosts();

}




################################################################################
# Automatically-generated file. Do not edit!
################################################################################

# Add inputs and outputs from these tool invocations to the build variables 
C_SRCS += \
../getsystemproxy.c 

OBJS += \
./getsystemproxy.o 

C_DEPS += \
./getsystemproxy.d 


# Each subdirectory must supply rules for building sources it contributes
%.o: ../%.c
	@echo 'Building file: $<'
	@echo 'Invoking: GCC C Compiler'
	gcc -I/usr/include/gconf/2 -I/usr/include/orbit-2.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include/ -O0 -fPIC -g3 -Wall -c -fmessage-length=0 -m32 -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"
	@echo 'Finished building: $<'
	@echo ' '






################################################################################
# Automatically-generated file. Do not edit!
################################################################################

-include ../makefile.init

RM := rm -rf

# All of the sources participating in the build are defined here
-include sources.mk
-include subdir.mk
-include objects.mk

ifneq ($(MAKECMDGOALS),clean)
ifneq ($(strip $(C_DEPS)),)
-include $(C_DEPS)
endif
endif

-include ../makefile.defs

# Add inputs and outputs from these tool invocations to the build variables 

# All Target
all: libproxysupport.so

# Tool invocations
libproxysupport.so: $(OBJS) $(USER_OBJS)
	@echo 'Building target: $@'
	@echo 'Invoking: GCC C Linker'
	gcc -m32 -shared -o"libproxysupport.so" $(OBJS) $(USER_OBJS) $(LIBS)
	@echo 'Finished building target: $@'
	@echo ' '

# Other Targets
clean:
	-$(RM) $(OBJS)$(C_DEPS)$(LIBRARIES) libproxysupport.so
	-@echo ' '

.PHONY: all clean dependents
.SECONDARY:

-include ../makefile.targets

Return to bug 180921

Lines 21-27 Link Here

(-)src/org/eclipse/core/internal/net/ProxyData.java (-1 / +17 lines)
21	private String password;	21	private String password;
22	private boolean requiresAuthentication;	22	private boolean requiresAuthentication;
23		23
24	public ProxyData(String type, String host, int port, boolean requiresAuthentication) {	24	public ProxyData(String type, String host, int port,
		25	boolean requiresAuthentication) {
25	this.type = type;	26	this.type = type;
26	this.host = host;	27	this.host = host;
27	this.port = port;	28	this.port = port;
Lines 83-86 Link Here
83	requiresAuthentication = false;	84	requiresAuthentication = false;
84	}	85	}
85		86
		87	public String toString() {
		88	StringBuffer stringBuffer = new StringBuffer();
		89	stringBuffer.append("host: "); //$NON-NLS-1$
		90	stringBuffer.append(host);
		91	stringBuffer.append(" port: "); //$NON-NLS-1$
		92	stringBuffer.append(port);
		93	stringBuffer.append(" user: "); //$NON-NLS-1$
		94	stringBuffer.append(user);
		95	stringBuffer.append(" password: "); //$NON-NLS-1$
		96	stringBuffer.append(password);
		97	stringBuffer.append(" reqAuth: "); //$NON-NLS-1$
		98	stringBuffer.append(requiresAuthentication);
		99	return stringBuffer.toString();
		100	}
		101
86	}	102	}

Added Link Here

(-)src/org/eclipse/core/internal/net/AbstractProxyProvider.java (+70 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Oakland Software Incorporated and others
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Oakland Software Incorporated - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.core.internal.net;
12
13	import java.net.URI;
14
15	import org.eclipse.core.net.proxy.IProxyData;
16
17	/**
18	* Returns eligible proxies based on the hosts configuration.
19	*
20	* Subclasses implement the native code required to get the proxy information.
21	*
22	* This intentionally has semantics similar to the Java ProxySelector class. The
23	* idea is that when we drop support for Java versions earlier than 1.5 we can
24	* easily re-implement this using the native Java support and remove the native
25	* code associated with this implementation.
26	*
27	* This is not intended to be subclassed by clients. This is not intended to be
28	* instantiated by clients.
29	*
30	* @since 3.4
31	*
32	*/
33	public abstract class AbstractProxyProvider {
34
35	/**
36	* Return the IProxyData(s) that can be used with the given URI.
37	*
38	* This considers the native proxy settings on the host. It includes the
39	* consideration of hosts for which no proxying is desired.
40	*
41	* @param uri
42	* the URI to for with the proxy is generated
43	* @return an array of IProxyData which are the applicable proxies for the
44	* specified URI
45	*
46	* @since 3.4
47	*/
48	public IProxyData[] select(URI uri) {
49	String[] nonProxyHosts = getNonProxiedHosts();
50	String host = uri.getHost();
51
52	if (nonProxyHosts != null) {
53	for (int npIndex = 0; npIndex < nonProxyHosts.length; npIndex++) {
54	if (host.equals(nonProxyHosts[npIndex])) {
55	return new IProxyData[0];
56	}
57	}
58	}
59
60	return getProxyData(uri);
61	}
62
63	protected abstract IProxyData[] getProxyData(URI uri);
64
65	protected String[] getNonProxiedHosts() {
66	// Default implementation, subclasses may override
67	return new String[] {};
68	}
69
70	}

Added Link Here

(-)src/org/eclipse/core/internal/net/WindowsProxyProvider.java (+18 lines)
1	package org.eclipse.core.internal.net;
2
3	import java.net.URI;
4
5	import org.eclipse.core.net.proxy.IProxyData;
6
7	public class WindowsProxyProvider extends AbstractProxyProvider {
8
9	public WindowsProxyProvider(){
10	Activator.logInfo("winProxyProvider initialized", null); //$NON-NLS-1$
11	}
12
13	protected IProxyData[] getProxyData(URI uri) {
14	// TODO Auto-generated method stub
15	return null;
16	}
17
18	}

Added Link Here

(-)natives/unix/README.txt (+12 lines)
1	The source for getting the native proxy info is in the top level unix directory. If
2	there are more specific compile options, makefiles, etc, then they should be moved
3	to subdirectories, like in org.eclipse.core.filesystem.
4
5	The Debug directory actually has the make file; this is the makefile as generated by the CDT.
6
7	To build this, go into Debug and type "make", the library will be built in that same
8	directory. Then you will need to copy the library to the correct org.eclipse.core.net.*
9	fragment.
10
11	There is no automatic build process for building the native code, instead the binary
12	shared libraries are checked in for each fragment, just like in org.eclipse.code.filesystem.

Added Link Here

(-)natives/unix/getsystemproxy.c (+237 lines)
1	/*
2	* Copyright 2008 Oakland Software Incorporated and others
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Oakland Software Incorporated - initial API and implementation
10	*/
11
12	#include <jni.h>
13
14	#include <glib.h>
15	#include <glib/gslist.h>
16	#include <gconf/gconf-value.h>
17	#include <gconf/gconf-client.h>
18
19	#ifdef __linux__
20	#include <string.h>
21	#else
22	#include <strings.h>
23	#endif
24
25	static GConfClient *client= NULL;
26
27	static jclass proxyInfoClass;
28	static jclass stringClass;
29	static jmethodID proxyInfoConstructor;
30	static jmethodID toString;
31
32	static jmethodID hostMethod;
33	static jmethodID portMethod;
34	static jmethodID requiresAuthenticationMethod;
35	static jmethodID userMethod;
36	static jmethodID passwordMethod;
37
38	#define CHECK_NULL(X) { if ((X) == NULL) fprintf (stderr,"JNI error at line %d\n", __LINE__); }
39
40	static void gconfInit(JNIEnv *env) {
41	client = gconf_client_get_default();
42	jclass cls= NULL;
43	CHECK_NULL(cls = (*env)->FindClass(env, "org/eclipse/core/internal/net/ProxyData"));
44	proxyInfoClass = (*env)->NewGlobalRef(env, cls);
45
46	CHECK_NULL(cls = (*env)->FindClass(env, "java/lang/String"));
47	stringClass = (*env)->NewGlobalRef(env, cls);
48
49	CHECK_NULL(proxyInfoConstructor = (*env)->GetMethodID(env, proxyInfoClass, "<init>", "(Ljava/lang/String;)V"));
50
51	CHECK_NULL(toString = (*env)->GetMethodID(env, proxyInfoClass, "toString", "()Ljava/lang/String;"));
52
53	CHECK_NULL(hostMethod = (*env)->GetMethodID(env, proxyInfoClass, "setHost",
54	"(Ljava/lang/String;)V"));
55	CHECK_NULL(portMethod = (*env)->GetMethodID(env, proxyInfoClass, "setPort",
56	"(I)V"));
57	CHECK_NULL(requiresAuthenticationMethod= (*env)->GetMethodID(env, proxyInfoClass, "setRequiresAuthentication",
58	"(Z)V"));
59	CHECK_NULL(userMethod = (*env)->GetMethodID(env, proxyInfoClass, "setUserid",
60	"(Ljava/lang/String;)V"));
61	CHECK_NULL(passwordMethod = (*env)->GetMethodID(env, proxyInfoClass, "setPassword",
62	"(Ljava/lang/String;)V"));
63	}
64
65	/*
66	* Class: org_eclipse_core_internal_net_UnixProxyProvider
67	* Method: getGConfProxyInfo
68	* Signature: ([Ljava/lang/String);
69	*/
70	JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getGConfProxyInfo(
71	JNIEnv *env, jclass clazz, jstring protocol) {
72
73	jboolean isCopy;
74	const char *cprotocol;
75
76	jobject proxyInfo= NULL;
77
78	if (client == NULL) {
79	gconfInit(env);
80	}
81
82	CHECK_NULL(proxyInfo = (*env)->NewObject(env, proxyInfoClass, proxyInfoConstructor, protocol));
83
84	cprotocol = (*env)->GetStringUTFChars(env, protocol, &isCopy);
85	if (cprotocol == NULL)
86	return NULL;
87
88	//printf("cprotocol: %s\n", cprotocol);
89
90	if (strcasecmp(cprotocol, "http") == 0) {
91	gboolean useProxy = gconf_client_get_bool(client,
92	"/system/http_proxy/use_http_proxy", NULL);
93	if (!useProxy) {
94	proxyInfo = NULL;
95	goto exit;
96	}
97
98	gchar *host = gconf_client_get_string(client,
99	"/system/http_proxy/host", NULL);
100	jobject jhost = (*env)->NewStringUTF(env, host);
101	(*env)->CallVoidMethod(env, proxyInfo, hostMethod, jhost);
102
103	gint port = gconf_client_get_int(client, "/system/http_proxy/port",
104	NULL);
105	(*env)->CallVoidMethod(env, proxyInfo, portMethod, port);
106
107	gboolean reqAuth = gconf_client_get_bool(client,
108	"/system/http_proxy/use_authentication", NULL);
109	(*env)->CallVoidMethod(env, proxyInfo,
110	requiresAuthenticationMethod, reqAuth);
111	if (reqAuth) {
112
113	gchar *user = gconf_client_get_string(client,
114	"/system/http_proxy/authentication_user", NULL);
115	jobject juser = (*env)->NewStringUTF(env, user);
116	(*env)->CallVoidMethod(env, proxyInfo, userMethod, juser);
117
118	gchar *password = gconf_client_get_string(client,
119	"/system/http_proxy/authentication_password", NULL);
120	jobject jpassword = (*env)->NewStringUTF(env, password);
121	(*env)->CallVoidMethod(env, proxyInfo, passwordMethod,
122	jpassword);
123	}
124	goto exit;
125	}
126
127	// Everything else applies only if the system proxy mode is manual
128	gchar *mode = gconf_client_get_string(client, "/system/proxy/mode", NULL);
129	if (strcasecmp(mode, "manual") != 0) {
130	proxyInfo = NULL;
131	goto exit;
132	}
133
134	char selector[100];
135
136	if (strcasecmp(cprotocol, "https") == 0) {
137	strcpy(selector, "/system/proxy/secure_");
138	} else if (strcasecmp(cprotocol, "socks") == 0) {
139	strcpy(selector, "/system/proxy/socks_");
140	} else if (strcasecmp(cprotocol, "ftp") == 0) {
141	strcpy(selector, "/system/proxy/ftp_");
142	} else {
143	proxyInfo = NULL;
144	goto exit;
145	}
146
147	char useSelector[100];
148	strcpy(useSelector, selector);
149
150	gchar *host = gconf_client_get_string(client, strcat(useSelector, "host"),
151	NULL);
152	jobject jhost = (*env)->NewStringUTF(env, host);
153	(*env)->CallVoidMethod(env, proxyInfo, hostMethod, jhost);
154
155	strcpy(useSelector, selector);
156	gint port = gconf_client_get_int(client, strcat(useSelector, "port"), NULL);
157	(*env)->CallVoidMethod(env, proxyInfo, portMethod, port);
158
159	exit: if (isCopy == JNI_TRUE)
160	(*env)->ReleaseStringUTFChars(env, protocol, cprotocol);
161	return proxyInfo;
162	}
163
164	typedef struct {
165	jobjectArray npHostArray;
166	JNIEnv *env;
167	int index;
168	} ListProcContext;
169
170	// user_data is the ListProcContext
171	void listProc(gpointer data, gpointer user_data) {
172	ListProcContext *lpc = user_data;
173	jobject jnpHost = (lpc->env)->NewStringUTF(lpc->env, (char )data);
174	(*lpc->env)->SetObjectArrayElement(lpc->env, lpc->npHostArray,
175	lpc->index++, jnpHost);
176	}
177
178	/*
179	* Class: org_eclipse_core_internal_net_UnixProxyProvider
180	* Method: getGConfNonProxyHosts
181	* Signature: ()[Ljava/lang/String;
182	*/
183	JNIEXPORT jobjectArray JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getGConfNonProxyHosts(
184	JNIEnv *env, jclass clazz) {
185
186	if (client == NULL) {
187	gconfInit(env);
188	}
189
190	GSList *npHosts;
191	int size;
192
193	npHosts = gconf_client_get_list(client, "/system/http_proxy/ignore_hosts",
194	GCONF_VALUE_STRING, NULL);
195	size = g_slist_length(npHosts);
196
197	// TODO - I'm not sure this is really valid, it's from the JVM implementation
198	// of ProxySelector
199	if (size == 0) {
200	npHosts = gconf_client_get_list(client, "/system/proxy/no_proxy_for",
201	GCONF_VALUE_STRING, NULL);
202	}
203	size = g_slist_length(npHosts);
204
205	jobjectArray ret = (*env)->NewObjectArray(env, size, stringClass, NULL);
206
207	ListProcContext lpc;
208	lpc.env = env;
209	lpc.npHostArray = ret;
210	lpc.index = 0;
211
212	g_slist_foreach(npHosts, listProc, &lpc);
213	return ret;
214	}
215
216	/*
217	* Class: org_eclipse_core_internal_net_UnixProxyProvider
218	* Method: getKdeProxyInfo
219	* Signature: ([Ljava/lang/String);
220	*/
221	JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getKdeProxyInfo(
222	JNIEnv *env, jclass clazz, jstring protocol) {
223	//printf("getKdeProxyInfo - not implemented\n");
224	return NULL;
225	}
226
227	/*
228	* Class: org_eclipse_core_internal_net_UnixProxyProvider
229	* Method: getKdeNonProxyHosts
230	* Signature: ()Ljava/lang/String;
231	*/
232	JNIEXPORT jobject JNICALL Java_org_eclipse_core_internal_net_UnixProxyProvider_getKdeNonProxyHosts(
233	JNIEnv *env, jclass clazz) {
234	//printf("getKdeNonProxyHosts - not implemented\n");
235	return NULL;
236	}
237

Added Link Here

(-)src/org/eclipse/core/internal/net/UnixProxyProvider.java (+80 lines)
1	package org.eclipse.core.internal.net;
2
3	import java.net.URI;
4	import java.net.URISyntaxException;
5
6	import org.eclipse.core.net.proxy.IProxyData;
7
8	public class UnixProxyProvider extends AbstractProxyProvider {
9
10	static {
11	System.loadLibrary("proxysupport"); //$NON-NLS-1$
12	}
13
14	public UnixProxyProvider() {
15	Activator.logInfo("linuxProxyProvider initialized", null); //$NON-NLS-1$
16	}
17
18	public IProxyData[] getProxyData(URI uri) {
19	String protocol = uri.getScheme();
20
21	ProxyData pd = getSystemProxyInfo(protocol);
22
23	if (pd != null) {
24	IProxyData[] pds = new IProxyData[1];
25	pds[0] = pd;
26	return pds;
27	}
28
29	return new IProxyData[0];
30	}
31
32	protected String[] getNonProxiedHosts() {
33	String[] npHosts = getGConfNonProxyHosts();
34	if (npHosts != null && npHosts.length > 0)
35	return npHosts;
36	return getKdeNonProxyHosts();
37	}
38
39	// Returns null if something wrong or there is no proxy for the protocol
40	protected ProxyData getSystemProxyInfo(String protocol) {
41	ProxyData pd;
42
43	// First try the environment variable which is a URL
44	String sysHttp = System.getenv(protocol.toLowerCase() + "_proxy"); //$NON-NLS-1$
45	if (sysHttp != null) {
46	URI uri = null;
47	try {
48	uri = new URI(sysHttp);
49	} catch (URISyntaxException e) {
50	return null;
51	}
52
53	pd = new ProxyData(protocol);
54	pd.setHost(uri.getHost());
55	pd.setPort(uri.getPort());
56	return pd;
57	}
58
59	// Then ask Gnome
60	pd = getGConfProxyInfo(protocol);
61	if (pd != null)
62	return pd;
63
64	// Then ask KDE
65	pd = getKdeProxyInfo(protocol);
66	if (pd != null)
67	return pd;
68
69	return null;
70	}
71
72	protected static native ProxyData getGConfProxyInfo(String protocol);
73
74	protected static native String[] getGConfNonProxyHosts();
75
76	protected static native ProxyData getKdeProxyInfo(String protocol);
77
78	protected static native String[] getKdeNonProxyHosts();
79
80	}

Added Link Here

(-)natives/unix/Debug/subdir.mk (+24 lines)
1	################################################################################
2	# Automatically-generated file. Do not edit!
3	################################################################################
4
5	# Add inputs and outputs from these tool invocations to the build variables
6	C_SRCS += \
7	../getsystemproxy.c
8
9	OBJS += \
10	./getsystemproxy.o
11
12	C_DEPS += \
13	./getsystemproxy.d
14
15
16	# Each subdirectory must supply rules for building sources it contributes
17	%.o: ../%.c
18	@echo 'Building file: $<'
19	@echo 'Invoking: GCC C Compiler'
20	gcc -I/usr/include/gconf/2 -I/usr/include/orbit-2.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include/ -O0 -fPIC -g3 -Wall -c -fmessage-length=0 -m32 -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"
21	@echo 'Finished building: $<'
22	@echo ' '
23
24

Added Link Here

(-)natives/unix/Debug/makefile (+43 lines)
1	################################################################################
2	# Automatically-generated file. Do not edit!
3	################################################################################
4
5	-include ../makefile.init
6
7	RM := rm -rf
8
9	# All of the sources participating in the build are defined here
10	-include sources.mk
11	-include subdir.mk
12	-include objects.mk
13
14	ifneq ($(MAKECMDGOALS),clean)
15	ifneq ($(strip $(C_DEPS)),)
16	-include $(C_DEPS)
17	endif
18	endif
19
20	-include ../makefile.defs
21
22	# Add inputs and outputs from these tool invocations to the build variables
23
24	# All Target
25	all: libproxysupport.so
26
27	# Tool invocations
28	libproxysupport.so: $(OBJS) $(USER_OBJS)
29	@echo 'Building target: $@'
30	@echo 'Invoking: GCC C Linker'
31	gcc -m32 -shared -o"libproxysupport.so" $(OBJS) $(USER_OBJS) $(LIBS)
32	@echo 'Finished building target: $@'
33	@echo ' '
34
35	# Other Targets
36	clean:
37	-$(RM) $(OBJS)$(C_DEPS)$(LIBRARIES) libproxysupport.so
38	-@echo ' '
39
40	.PHONY: all clean dependents
41	.SECONDARY:
42
43	-include ../makefile.targets