private HttpClient getClient() {
if (client == null) {
HttpClientBuilder clientBuilder = HttpClients.custom();
RequestConfig.Builder configBuilder = RequestConfig.custom();
if (proxy != null && !Proxy.NO_PROXY.equals(proxy)) {
isUsingProxy = true;
InetSocketAddress adr = (InetSocketAddress) proxy.address();
clientBuilder.setProxy(new HttpHost(adr.getHostName(), adr.getPort()));
}
if (timeout != null) {
configBuilder.setConnectTimeout(timeout.intValue());
}
if (readTimeout != null) {
configBuilder.setSocketTimeout(readTimeout.intValue());
}
if (followRedirects != null) {
configBuilder.setRedirectsEnabled(followRedirects.booleanValue());
}
if (hostnameverifier != null) {
SSLConnectionSocketFactory sslConnectionFactory =
new SSLConnectionSocketFactory(getSSLContext(), hostnameverifier);
clientBuilder.setSSLSocketFactory(sslConnectionFactory);
Registry<ConnectionSocketFactory> registry =
RegistryBuilder.<ConnectionSocketFactory>create()
.register("https", sslConnectionFactory)
.register("http", PlainConnectionSocketFactory.INSTANCE)
.build();
clientBuilder.setConnectionManager(new BasicHttpClientConnectionManager(registry));
}
clientBuilder.setDefaultRequestConfig(configBuilder.build());
client = clientBuilder.build();
}
return client;
}
public static HttpURLConnection getConnection(String urlStr) throws IOException {
URL url = new URL(urlStr);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
if (null == activeNetworkInfo) {
Log.w(TAG, "No active network available!");
return null;
}
Proxy p = getProxy();
String extra = activeNetworkInfo.getExtraInfo();
// chinese mobile network
if (activeNetworkInfo.getType() == ConnectivityManager.TYPE_MOBILE && p != null) {
// cmwap, uniwap, 3gwap
if (extra != null
&& (extra.startsWith("cmwap")
|| extra.startsWith("uniwap")
|| extra.startsWith("3gwap"))) {
HttpURLConnection conn =
(HttpURLConnection)
new URL("http://" + p.address().toString() + url.getPath()).openConnection();
conn.setRequestProperty(
"X-Online-Host", url.getHost() + ":" + (url.getPort() == -1 ? "80" : url.getPort()));
return conn;
}
}
if (null != p) {
// through proxy
return (HttpURLConnection) url.openConnection(p);
} else {
return (HttpURLConnection) url.openConnection();
}
}
/**
* Setup proxy based on JAVA_OPTS if necessary
*/
static boolean isProxyValid() {
//Setting up proxy if necessary
System.setProperty("java.net.useSystemProxies","true");
List<Proxy> proxies;
try {
proxies = ProxySelector.getDefault().select(new URI("http://www.google.com"));
} catch ( URISyntaxException e) {
log.error("Failed to create URI." + e);
return false;
}
for (Proxy proxy : proxies) {
if (proxy.type() == Proxy.Type.DIRECT) {
log.info("Proxy is DIRECT CONNECTION");
return true;
}
log.info("Proxy setting: host=" + System.getProperty("http.proxyHost") +
"port=" + System.getProperty("http.proxyPort") +
"user="******"http.proxyUser") +
"password="******"http.proxyPassword"));
if (System.getProperty("http.proxyHost") != null &&
System.getProperty("http.proxyPort") != null &&
System.getProperty("http.proxyUser") != null ) return true;
log.error("Proxy is incorrect: host=" + System.getProperty("http.proxyHost") +
"port=" + System.getProperty("http.proxyPort") +
"user="******"http.proxyUser") +
"password="******"http.proxyPassword"));
return false;
}
return false;
}
// Result host and port are returned in a string in the format host:port
public static String[] getProxyForURL(String target) {
String[] proxyInfo = new String[0];
List<String> proxies = new ArrayList<String>();
URI uri = null;
try {
ProxySelector defaultProxySelector = ProxySelector.getDefault();
uri = new URI(target);
List<Proxy> proxyList = defaultProxySelector.select(uri);
Proxy proxy = proxyList.get(0);
if (proxy.equals(Proxy.NO_PROXY)) {
System.out.println("DalvikProxySelector.getProxyForURL(): No proxy found");
return null;
}
SocketAddress address = proxy.address();
InetSocketAddress inetSocketAddress = (InetSocketAddress) address;
String host = inetSocketAddress.getHostName();
int port = inetSocketAddress.getPort();
if (host == null) {
System.out.println("DalvikProxySelector.getProxyForURL(): No proxy found");
return null;
}
proxies.add(host); // even index, host
proxies.add(Integer.toString(port)); // odd index, port
System.out.println("DalvikProxySelector.getProxyForURL(): host=" + host + " port=" + port);
return proxies.toArray(new String[0]);
} catch (Exception e) {
System.out.println(
"DalvikProxySelector.getProxyForURL(): exception(ignored): " + e.toString());
return null;
}
}
/** Get or create the http client to be used to fetch all the map data. */
public HttpClient getHttpClient(URI uri) {
MultiThreadedHttpConnectionManager connectionManager = getConnectionManager();
HttpClient httpClient = new HttpClient(connectionManager);
// httpclient is a bit pesky about loading everything in memory...
// disabling the warnings.
Logger.getLogger(HttpMethodBase.class).setLevel(Level.ERROR);
// configure proxies for URI
ProxySelector selector = ProxySelector.getDefault();
List<Proxy> proxyList = selector.select(uri);
Proxy proxy = proxyList.get(0);
if (!proxy.equals(Proxy.NO_PROXY)) {
InetSocketAddress socketAddress = (InetSocketAddress) proxy.address();
String hostName = socketAddress.getHostName();
int port = socketAddress.getPort();
httpClient.getHostConfiguration().setProxy(hostName, port);
}
for (SecurityStrategy sec : security)
if (sec.matches(uri)) {
sec.configure(uri, httpClient);
break;
}
return httpClient;
}
/** Prepares the socket addresses to attempt for the current proxy or host. */
private void resetNextInetSocketAddress(Proxy proxy) throws UnknownHostException {
// Clear the addresses. Necessary if getAllByName() below throws!
inetSocketAddresses = new ArrayList<InetSocketAddress>();
String socketHost;
int socketPort;
if (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.SOCKS) {
socketHost = address.getUriHost();
socketPort = getEffectivePort(uri);
} else {
SocketAddress proxyAddress = proxy.address();
if (!(proxyAddress instanceof InetSocketAddress)) {
throw new IllegalArgumentException(
"Proxy.address() is not an " + "InetSocketAddress: " + proxyAddress.getClass());
}
InetSocketAddress proxySocketAddress = (InetSocketAddress) proxyAddress;
socketHost = getHostString(proxySocketAddress);
socketPort = proxySocketAddress.getPort();
}
// Try each address for best behavior in mixed IPv4/IPv6 environments.
for (InetAddress inetAddress : network.resolveInetAddresses(socketHost)) {
inetSocketAddresses.add(new InetSocketAddress(inetAddress, socketPort));
}
nextInetSocketAddressIndex = 0;
}
public static boolean lowLevelPingHost(Proxy proxy) {
int exitValue;
Runtime runtime = Runtime.getRuntime();
Process proc;
String cmdline = null;
String proxyAddress = null;
try {
InetSocketAddress proxySocketAddress = (InetSocketAddress) proxy.address();
proxyAddress = proxySocketAddress.getAddress().getHostAddress();
} catch (Exception e) {
APL.getEventReport()
.send(
new Exception(
"ProxyUtils.lowLevelPingHost() Exception calling getAddress().getHostAddress() on proxySocketAddress : ",
e));
}
if (proxyAddress == null) {
try {
InetSocketAddress proxySocketAddress = (InetSocketAddress) proxy.address();
proxyAddress = proxySocketAddress.toString();
} catch (Exception e) {
APL.getEventReport()
.send(
new Exception(
"ProxyUtils.lowLevelPingHost() Exception calling toString() on proxySocketAddress",
e));
}
}
if (proxyAddress != null) {
cmdline = "ping -c 1 -w 1 " + proxyAddress;
try {
proc = runtime.exec(cmdline);
proc.waitFor();
exitValue = proc.exitValue();
LogWrapper.d(TAG, "Ping exit value: " + exitValue);
if (exitValue == 0) {
return true;
} else {
return false;
}
} catch (IOException e) {
APL.getEventReport().send(new Exception("ProxyUtils.lowLevelPingHost() IOException", e));
} catch (InterruptedException e) {
APL.getEventReport()
.send(new Exception("ProxyUtils.lowLevelPingHost() InterruptedException", e));
}
}
return false;
}
/**
* Get the InetAddress of the connection machine. This is either the address given in the URL or
* the address of the proxy server.
*/
private InetAddress getHostAddress() throws IOException {
if (hostAddress == null) {
// the value was not set yet
if (proxy != null && proxy.type() != Proxy.Type.DIRECT) {
hostAddress = ((InetSocketAddress) proxy.address()).getAddress();
} else {
hostAddress = InetAddress.getByName(url.getHost());
}
}
return hostAddress;
}
public void setProxy(final Proxy proxy) {
final String DELIM = "|";
if (proxy != Proxy.NO_PROXY && proxy.type() != Proxy.Type.DIRECT) {
final StringBuffer sb = new StringBuffer();
sb.append(proxy.type().toString()).append(DELIM);
sb.append(Integer.toString(((InetSocketAddress) proxy.address()).getPort())).append(DELIM);
sb.append(proxy.address().toString());
proxySettings = sb.toString();
} else {
proxySettings = "";
}
}
@Override
public Object getParameter(String name) {
if (name.equals(ConnRouteParams.DEFAULT_PROXY)) {
Proxy proxy = client.getProxy();
if (proxy == null) {
return null;
}
InetSocketAddress address = (InetSocketAddress) proxy.address();
return new HttpHost(address.getHostName(), address.getPort());
}
throw new IllegalArgumentException(name);
}
/**
* Establishes the connection to the remote HTTP server
*
* <p>Any methods that requires a valid connection to the resource will call this method
* implicitly. After the connection is established, <code>connected</code> is set to true.
*
* @see #connected
* @see java.io.IOException
* @see URLStreamHandler
*/
@Override
public void connect() throws IOException {
if (connected) {
return;
}
if (getFromCache()) {
return;
}
try {
uri = url.toURI();
} catch (URISyntaxException e1) {
// ignore
}
// socket to be used for connection
connection = null;
// try to determine: to use the proxy or not
if (proxy != null) {
// try to make the connection to the proxy
// specified in constructor.
// IOException will be thrown in the case of failure
connection = getHTTPConnection(proxy);
} else {
// Use system-wide ProxySelect to select proxy list,
// then try to connect via elements in the proxy list.
ProxySelector selector = ProxySelector.getDefault();
List<Proxy> proxyList = selector.select(uri);
if (proxyList != null) {
for (Proxy selectedProxy : proxyList) {
if (selectedProxy.type() == Proxy.Type.DIRECT) {
// the same as NO_PROXY
continue;
}
try {
connection = getHTTPConnection(selectedProxy);
proxy = selectedProxy;
break; // connected
} catch (IOException e) {
// failed to connect, tell it to the selector
selector.connectFailed(uri, selectedProxy.address(), e);
}
}
}
}
if (connection == null) {
// make direct connection
connection = getHTTPConnection(null);
}
connection.setSoTimeout(getReadTimeout());
setUpTransportIO(connection);
connected = true;
}
/*
* Enabled aggressive block sorting
*/
@Override
public Request authenticateProxy(Proxy object, Response object2) throws IOException {
List<Challenge> list = object2.challenges();
object2 = object2.request();
URL uRL = object2.url();
int n2 = 0;
int n3 = list.size();
while (n2 < n3) {
InetSocketAddress inetSocketAddress;
Object object3 = list.get(n2);
if ("Basic".equalsIgnoreCase(object3.getScheme())
&& (object3 =
java.net.Authenticator.requestPasswordAuthentication(
(inetSocketAddress = (InetSocketAddress) object.address()).getHostName(),
this.getConnectToInetAddress((Proxy) object, uRL),
inetSocketAddress.getPort(),
uRL.getProtocol(),
object3.getRealm(),
object3.getScheme(),
uRL,
Authenticator.RequestorType.PROXY))
!= null) {
object = Credentials.basic(object3.getUserName(), new String(object3.getPassword()));
return object2.newBuilder().header("Proxy-Authorization", (String) object).build();
}
++n2;
}
return null;
}
public Request authenticateProxy(Proxy paramProxy, Response paramResponse) {
List localList = paramResponse.challenges();
paramResponse = paramResponse.request();
URL localURL = paramResponse.url();
int i = 0;
int j = localList.size();
while (i < j) {
Object localObject = (Challenge) localList.get(i);
if ("Basic".equalsIgnoreCase(((Challenge) localObject).getScheme())) {
InetSocketAddress localInetSocketAddress = (InetSocketAddress) paramProxy.address();
localObject =
java.net.Authenticator.requestPasswordAuthentication(
localInetSocketAddress.getHostName(),
getConnectToInetAddress(paramProxy, localURL),
localInetSocketAddress.getPort(),
localURL.getProtocol(),
((Challenge) localObject).getRealm(),
((Challenge) localObject).getScheme(),
localURL,
Authenticator.RequestorType.PROXY);
if (localObject != null) {
paramProxy =
Credentials.basic(
((PasswordAuthentication) localObject).getUserName(),
new String(((PasswordAuthentication) localObject).getPassword()));
return paramResponse.newBuilder().header("Proxy-Authorization", paramProxy).build();
}
}
i += 1;
}
return null;
}
public boolean connect() {
ExpCoordinator.printer.print("NCCPConnection.connect", 3);
if (host.length() == 0) {
ExpCoordinator.printer.print("NCCPConnection.connect host is not set", 6);
return false;
}
if (proxy == null && nonProxy == null) {
ExpCoordinator.printer.print("NCCPConnection.connect proxy null");
return false;
}
if (ExpCoordinator.isSPPMon()) return (connectSPPMon());
if (state == ConnectionEvent.CONNECTION_CLOSED || state == ConnectionEvent.CONNECTION_FAILED) {
state = ConnectionEvent.CONNECTION_PENDING;
if (proxy != null) {
proxy.openConnection(this);
}
}
/*
if (nonProxy != null && proxy == null)
{
return (nonProxy.connect());
}
*/
return true;
}
public void write(ONL.Writer wrtr) throws java.io.IOException {
wrtr.writeString(host);
wrtr.writeInt(port);
short cid = 0;
if (proxy != null) cid = proxy.getConnectionID(this);
wrtr.writeShort(cid);
}
/** Gets the SOCKS proxy server port. */
private int socksGetServerPort() {
// get socks server port from proxy. It is unnecessary to check
// "socksProxyPort" property, since proxy setting should only be
// determined by ProxySelector.
InetSocketAddress addr = (InetSocketAddress) proxy.address();
return addr.getPort();
}
private static void setToUseSystemProxies() {
final String JAVA_NET_USESYSTEMPROXIES = "java.net.useSystemProxies";
System.setProperty(JAVA_NET_USESYSTEMPROXIES, "true");
List<Proxy> proxyList = null;
try {
final ProxySelector def = ProxySelector.getDefault();
if (def != null) {
proxyList = def.select(new URI("http://sourceforge.net/"));
ProxySelector.setDefault(null);
if (proxyList != null && !proxyList.isEmpty()) {
final Proxy proxy = proxyList.get(0);
final InetSocketAddress address = (InetSocketAddress) proxy.address();
if (address != null) {
final String host = address.getHostName();
final int port = address.getPort();
System.setProperty(HTTP_PROXYHOST, host);
System.setProperty(HTTP_PROXYPORT, Integer.toString(port));
System.setProperty(PROXY_HOST, host);
System.setProperty(PROXY_PORT, Integer.toString(port));
} else {
System.clearProperty(HTTP_PROXYHOST);
System.clearProperty(HTTP_PROXYPORT);
System.clearProperty(PROXY_HOST);
System.clearProperty(PROXY_PORT);
}
}
} else {
final String host = System.getProperty(PROXY_HOST);
final String port = System.getProperty(PROXY_PORT);
if (host == null) System.clearProperty(HTTP_PROXYHOST);
else System.setProperty(HTTP_PROXYHOST, host);
if (port == null) System.clearProperty(HTTP_PROXYPORT);
else {
try {
Integer.parseInt(port);
System.setProperty(HTTP_PROXYPORT, port);
} catch (final NumberFormatException nfe) {
// nothing
}
}
}
} catch (final Exception e) {
e.printStackTrace();
} finally {
System.setProperty(JAVA_NET_USESYSTEMPROXIES, "false");
}
}
private synchronized Socket getOrCreateSocket(boolean resend) throws NetworkIOException {
if (reconnectPolicy.shouldReconnect()) {
logger.debug("Reconnecting due to reconnectPolicy dictating it");
UILogger.getInstance().add("Reconnecting due to reconnectPolicy dictating it");
Utilities.close(socket);
socket = null;
}
if (socket == null || socket.isClosed()) {
try {
if (proxy == null) {
socket = factory.createSocket(host, port);
logger.debug("Connected new socket {}", socket);
UILogger.getInstance().add("Connected new socket" + socket.toString());
} else if (proxy.type() == Proxy.Type.HTTP) {
TlsTunnelBuilder tunnelBuilder = new TlsTunnelBuilder();
socket =
tunnelBuilder.build(
(SSLSocketFactory) factory, proxy, proxyUsername, proxyPassword, host, port);
logger.debug("Connected new socket through http tunnel {}", socket);
UILogger.getInstance()
.add("Connected new socket through http tunnel " + socket.toString());
} else {
boolean success = false;
Socket proxySocket = null;
try {
proxySocket = new Socket(proxy);
proxySocket.connect(new InetSocketAddress(host, port), connectTimeout);
socket = ((SSLSocketFactory) factory).createSocket(proxySocket, host, port, false);
success = true;
} finally {
if (!success) {
Utilities.close(proxySocket);
}
}
logger.debug("Connected new socket through socks tunnel {}", socket);
UILogger.getInstance()
.add("Connected new socket through socks tunnel " + socket.toString());
}
socket.setSoTimeout(readTimeout);
socket.setKeepAlive(true);
if (errorDetection) {
monitorSocket(socket);
}
reconnectPolicy.reconnected();
logger.debug("Made a new connection to APNS");
UILogger.getInstance().add("Made a new connection to APNS");
} catch (IOException e) {
logger.error("Couldn't connect to APNS server", e);
UILogger.getInstance().add("Couldn't connect to APNS server" + e.toString());
// indicate to clients whether this is a resend or initial send
throw new NetworkIOException(e, resend);
}
}
return socket;
}
public static void downloadToFile(final Proxy proxy, final URL url, final File file)
throws IOException {
if (proxy != Proxy.NO_PROXY && proxy.type() != Proxy.Type.DIRECT) {
downloadUsingProxy(proxy, url, file);
} else {
FileUtils.copyURLToFile(url, file, 10000, 5000);
}
}
public void read(ONL.Reader rdr) throws java.io.IOException {
setHost(new String(rdr.readString()));
setPort(rdr.readInt());
short cid = (short) rdr.readShort();
ExpCoordinator.print(
new String("NCCPConnection.read host:" + getHost() + " port:" + getPort() + " cid:" + cid),
5);
if (proxy != null) proxy.setConnectionID(this, cid);
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + uriHost.hashCode();
result = 31 * result + uriPort;
result = 31 * result + (proxy != null ? proxy.hashCode() : 0);
result = 31 * result + (requiresTunnel ? 1 : 0);
return result;
}
private ConnectivitySettings proxyToCs(Proxy proxy, URI uri) {
ConnectivitySettings cs = new ConnectivitySettings();
InetSocketAddress isa = (InetSocketAddress) proxy.address();
switch (proxy.type()) {
case HTTP:
setupProxy(cs, ConnectivitySettings.CONNECTION_VIA_HTTPS, isa);
break;
case SOCKS:
setupProxy(cs, ConnectivitySettings.CONNECTION_VIA_SOCKS, isa);
break;
default:
}
String prosyUser = NetworkSettings.getAuthenticationUsername(uri);
if (prosyUser != null && !prosyUser.isEmpty()) {
cs.setProxyUsername(prosyUser);
cs.setProxyPassword(Keyring.read(NetworkSettings.getKeyForAuthenticationPassword(uri)));
}
return cs;
}
/**
* Get the hostname of the connection machine. This is either the name given in the URL or the
* name of the proxy server.
*/
private String getHostName() {
if (hostName == null) {
// the value was not set yet
if (proxy != null) {
hostName = ((InetSocketAddress) proxy.address()).getHostName();
} else {
hostName = url.getHost();
}
}
return hostName;
}
/** Returns connected socket to be used for this HTTP connection. */
protected HttpConnection getHTTPConnection(Proxy proxy) throws IOException {
HttpConnection connection;
if (proxy == null || proxy.type() == Proxy.Type.DIRECT) {
this.proxy = null; // not using proxy
connection = HttpConnectionManager.getDefault().getConnection(uri, getConnectTimeout());
} else {
connection =
HttpConnectionManager.getDefault().getConnection(uri, proxy, getConnectTimeout());
}
return connection;
}
@Override
public final Permission getPermission() throws IOException {
String hostName = getURL().getHost();
int hostPort = Util.getEffectivePort(getURL());
if (usingProxy()) {
InetSocketAddress proxyAddress = (InetSocketAddress) requestedProxy.address();
hostName = proxyAddress.getHostName();
hostPort = proxyAddress.getPort();
}
return new SocketPermission(hostName + ":" + hostPort, "connect, resolve");
}
public static boolean standardAPIPingHost(Proxy proxy) {
try {
InetSocketAddress proxySocketAddress = (InetSocketAddress) proxy.address();
return InetAddress.getByName(proxySocketAddress.toString().split(":")[0]).isReachable(100000);
// return proxySocketAddress.getAddress().isReachable(100000);
} catch (Exception e) {
APL.getEventReport().send(new Exception("ProxyUtils.standardAPIPingHost() Exception", e));
}
return false;
}
// Decide what proxy, if any, to use for a request. Manual settings take precedence,
// then we fall back to using system settings (e.g., Internet Explorer settings on Windows)
// as handled by the ProxySelector class introduced in Java 1.5.
//
// Public so that it can be called from Mathematica.
//
public synchronized String[] getProxyHostAndPort(String url) {
int port = 0;
String host = null;
if (useProxy == PROXY_AUTOMATIC) {
ProxySelector ps = ProxySelector.getDefault(); // Will get MyProxySelector.
try {
URI uri = new URI(url);
List<Proxy> proxyList = ps.select(uri);
int len = proxyList.size();
for (int i = 0; i < len; i++) {
Proxy p = (Proxy) proxyList.get(i);
InetSocketAddress addr = (InetSocketAddress) p.address();
if (addr != null) {
host = addr.getHostName();
port = addr.getPort();
break;
}
}
} catch (Exception e) {
// TODO: Handle?
}
} else if (useProxy == PROXY_MANUAL) {
String protocol;
int colonPos = url.indexOf(':');
if (colonPos != -1) {
protocol = url.substring(0, colonPos).toLowerCase();
} else {
// Shouldn't happen, but might as well do something and let it fail later.
protocol = "http";
}
if (protocol.equals("http")) {
host = httpProxyHost;
port = httpProxyPort;
}
// Don't handle directly Socks calls.
}
return new String[] {host, String.valueOf(port)};
}
public void setConnectionID(short cid) {
ExpCoordinator.print(
new String(
"NCCPConnection.setConnectionID host:"
+ getHost()
+ " port:"
+ getPort()
+ " cid:"
+ cid),
5);
if (proxy != null) proxy.setConnectionID(this, cid);
}
private void resetNextInetSocketAddress(Proxy paramProxy) throws IOException {
this.inetSocketAddresses = new ArrayList();
if ((paramProxy.type() == Proxy.Type.DIRECT) || (paramProxy.type() == Proxy.Type.SOCKS)) {
paramProxy = this.address.getUriHost();
}
Object localObject;
for (int i = this.address.getUriPort();
(i < 1) || (i > 65535);
i = ((InetSocketAddress) localObject).getPort()) {
throw new SocketException("No route to " + paramProxy + ":" + i + "; port is out of range");
paramProxy = paramProxy.address();
if (!(paramProxy instanceof InetSocketAddress)) {
throw new IllegalArgumentException(
"Proxy.address() is not an InetSocketAddress: " + paramProxy.getClass());
}
localObject = (InetSocketAddress) paramProxy;
paramProxy = getHostString((InetSocketAddress) localObject);
}
paramProxy = this.address.getDns().lookup(paramProxy);
int j = 0;
int k = paramProxy.size();
while (j < k) {
localObject = (InetAddress) paramProxy.get(j);
this.inetSocketAddresses.add(new InetSocketAddress((InetAddress) localObject, i));
j += 1;
}
this.nextInetSocketAddressIndex = 0;
}
public void sendMessage(NCCP.Message msg) {
if (isClosed() || isFailed()) connect();
if (isConnected()) {
ExpCoordinator.printer.print("NCCPConnection::sendMessage", 5);
if (proxy != null) proxy.sendMessage(msg, this);
else {
if (nonProxy != null) nonProxy.sendMessage(msg);
}
} else // still can't connect
{
pendingMessages.add(msg);
}
}