1719 lines
71 KiB
Java
1719 lines
71 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.net.HttpUtil
|
|
* com.tridium.sys.Nre
|
|
* com.tridium.sys.license.Brand
|
|
* com.tridium.sys.registry.NAgentInfo
|
|
* com.tridium.util.BSessionInfo
|
|
* javax.baja.agent.AgentFilter
|
|
* javax.baja.agent.AgentInfo
|
|
* javax.baja.agent.AgentList
|
|
* javax.baja.file.FilePath
|
|
* javax.baja.license.Feature
|
|
* javax.baja.license.FeatureNotLicensedException
|
|
* javax.baja.log.Log
|
|
* javax.baja.naming.BHost
|
|
* javax.baja.naming.BISession
|
|
* javax.baja.naming.BIpHost
|
|
* javax.baja.naming.BLocalHost
|
|
* javax.baja.naming.BOrd
|
|
* javax.baja.naming.BSession
|
|
* javax.baja.naming.OrdQuery
|
|
* javax.baja.nav.BINavNode
|
|
* javax.baja.nav.BNavRoot
|
|
* javax.baja.nav.NavEvent
|
|
* javax.baja.net.BInternetAddress
|
|
* javax.baja.net.Http
|
|
* javax.baja.net.HttpConnection
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.registry.TypeInfo
|
|
* javax.baja.security.AuthenticationException
|
|
* javax.baja.security.AuthenticationRealm
|
|
* javax.baja.security.BICredentials
|
|
* javax.baja.security.BIUserCredentials
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BObject
|
|
* javax.baja.sys.BajaRuntimeException
|
|
* javax.baja.sys.Clock
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.LocalizableRuntimeException
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Type
|
|
* javax.baja.sys.TypeNotFoundException
|
|
* javax.baja.util.Lexicon
|
|
* javax.baja.util.LexiconText
|
|
* javax.baja.util.Version
|
|
* javax.baja.xml.XElem
|
|
* javax.baja.xml.XParser
|
|
*/
|
|
package com.tridium.platform.daemon;
|
|
|
|
import com.tridium.net.HttpUtil;
|
|
import com.tridium.platform.BOperatingSystemEnum;
|
|
import com.tridium.platform.BPlatform;
|
|
import com.tridium.platform.BPlatformSSLSettings;
|
|
import com.tridium.platform.BSessionNavNode;
|
|
import com.tridium.platform.BSessionNavNodeFactory;
|
|
import com.tridium.platform.daemon.Authenticator;
|
|
import com.tridium.platform.daemon.BDaemonScheme;
|
|
import com.tridium.platform.daemon.BHostProperties;
|
|
import com.tridium.platform.daemon.DaemonResponseException;
|
|
import com.tridium.platform.daemon.DaemonSSLRequiredException;
|
|
import com.tridium.platform.daemon.DaemonSessionListener;
|
|
import com.tridium.platform.daemon.DaemonText;
|
|
import com.tridium.platform.daemon.LocalSessionUtil;
|
|
import com.tridium.platform.daemon.PostOutputStream;
|
|
import com.tridium.platform.daemon.file.BDefaultDaemonFileSpace;
|
|
import com.tridium.platform.daemon.message.DaemonMessage;
|
|
import com.tridium.platform.daemon.message.GetDirectoryMessage;
|
|
import com.tridium.platform.daemon.message.XmlResponseMessage;
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.license.Brand;
|
|
import com.tridium.sys.registry.NAgentInfo;
|
|
import com.tridium.util.BSessionInfo;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.EOFException;
|
|
import java.io.File;
|
|
import java.io.FilterInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InterruptedIOException;
|
|
import java.io.OutputStream;
|
|
import java.net.ConnectException;
|
|
import java.net.SocketException;
|
|
import java.net.UnknownHostException;
|
|
import java.util.Comparator;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Properties;
|
|
import javax.baja.agent.AgentFilter;
|
|
import javax.baja.agent.AgentInfo;
|
|
import javax.baja.agent.AgentList;
|
|
import javax.baja.file.FilePath;
|
|
import javax.baja.license.Feature;
|
|
import javax.baja.license.FeatureNotLicensedException;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BHost;
|
|
import javax.baja.naming.BISession;
|
|
import javax.baja.naming.BIpHost;
|
|
import javax.baja.naming.BLocalHost;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.BSession;
|
|
import javax.baja.naming.OrdQuery;
|
|
import javax.baja.nav.BINavNode;
|
|
import javax.baja.nav.BNavRoot;
|
|
import javax.baja.nav.NavEvent;
|
|
import javax.baja.net.BInternetAddress;
|
|
import javax.baja.net.Http;
|
|
import javax.baja.net.HttpConnection;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.platform.ICancelHint;
|
|
import javax.baja.registry.TypeInfo;
|
|
import javax.baja.security.AuthenticationException;
|
|
import javax.baja.security.AuthenticationRealm;
|
|
import javax.baja.security.BICredentials;
|
|
import javax.baja.security.BIUserCredentials;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.Clock;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.LocalizableRuntimeException;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.sys.TypeNotFoundException;
|
|
import javax.baja.util.Lexicon;
|
|
import javax.baja.util.LexiconText;
|
|
import javax.baja.util.Version;
|
|
import javax.baja.xml.XElem;
|
|
import javax.baja.xml.XParser;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BDaemonSession
|
|
extends BSession {
|
|
public static final Type TYPE;
|
|
private static final BIcon iconConnected;
|
|
private static final BIcon iconDisconnected;
|
|
private static final BIcon tunnelIconConnected;
|
|
private static final BIcon tunnelIconDisconnected;
|
|
public static boolean debug;
|
|
public static final int INFINITE_TIMEOUT = 0;
|
|
public static int DEFAULT_TIMEOUT;
|
|
private static final long FIVE_MINUTES = 300000L;
|
|
public static final int STATION_OVERRIDE_NONE = 0;
|
|
public static final int STATION_OVERRIDE_START = 1;
|
|
public static final int STATION_OVERRIDE_STOP = 2;
|
|
public static final int PORT_UNKNOWN = -1;
|
|
public static final int UNKNOWN_CONTENT_LENGTH = -1;
|
|
private static Version requiredVersion;
|
|
private static Version requiredVersionForTunnel;
|
|
private static RebootMessage rebootMessage;
|
|
private static RebootMessage forceRebootMessage;
|
|
private static String[] brandIdHolder;
|
|
public static final int FLAGS_NONE = 0;
|
|
public static final int FLAGS_NO_CONNECTED_NOTIFY = 1;
|
|
public static final int FLAGS_NO_AUTH_NOTIFY = 2;
|
|
public static final int FLAGS_DISCONNECT = 4;
|
|
public static final int FLAGS_CLOSE = 8;
|
|
public static final int FLAGS_CLEAR_CREDENTIALS = 16;
|
|
public static final int FLAGS_EXPECT_CONTINUE = 32;
|
|
private static final int MAX_REDIRECT_PAYLOAD = 75;
|
|
public static Log log;
|
|
private AgentList agentList;
|
|
protected String[] tunnelAuthorities;
|
|
private Properties cachedNonceValue;
|
|
private BHost host;
|
|
private int port;
|
|
private BOrd ordInHost;
|
|
private BOrd absOrd;
|
|
private Authenticator authenticator;
|
|
private BHostProperties hostProperties;
|
|
private boolean localEnvironment;
|
|
private long lastConnectTicks;
|
|
private long lastConnectedTime;
|
|
protected BSessionNavNodeFactory[] navFactories;
|
|
private boolean connected;
|
|
private boolean inInit;
|
|
private HashSet listeners;
|
|
static /* synthetic */ Class class$com$tridium$platform$daemon$BDaemonSession;
|
|
static /* synthetic */ Class class$javax$baja$nav$BINavNode;
|
|
|
|
public static BDaemonSession make(BHost bHost, int n) {
|
|
return BDaemonSession.make(bHost, n, null);
|
|
}
|
|
|
|
public static BDaemonSession make(BHost bHost, int n, String string) {
|
|
String[] stringArray = null;
|
|
if (string != null) {
|
|
stringArray = new String[]{string};
|
|
}
|
|
return BDaemonSession.make(bHost, n, stringArray);
|
|
}
|
|
|
|
public static BDaemonSession make(BHost bHost, int n, String[] stringArray) {
|
|
BDaemonSession bDaemonSession;
|
|
StringBuffer stringBuffer = new StringBuffer("platform");
|
|
if (n != 3011) {
|
|
stringBuffer.append(":").append(n);
|
|
}
|
|
if (stringArray != null) {
|
|
int n2 = 0;
|
|
while (n2 < stringArray.length) {
|
|
if (stringArray[n2] != null) {
|
|
stringBuffer.append("/").append(stringArray[n2]);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
if ((bDaemonSession = (BDaemonSession)bHost.getNavChild(stringBuffer.toString())) == null) {
|
|
bDaemonSession = new BDaemonSession(stringBuffer.toString(), bHost, n, stringArray);
|
|
bHost.addNavChild((BINavNode)bDaemonSession);
|
|
}
|
|
return bDaemonSession;
|
|
}
|
|
|
|
public static BDaemonSession makeIgnoringCache(BHost bHost, int n, String[] stringArray) {
|
|
StringBuffer stringBuffer = new StringBuffer("noCache:platform");
|
|
if (n != 3011) {
|
|
stringBuffer.append(":").append(n);
|
|
}
|
|
if (stringArray != null) {
|
|
int n2 = 0;
|
|
while (n2 < stringArray.length) {
|
|
if (stringArray[n2] != null) {
|
|
stringBuffer.append("/").append(stringArray[n2]);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
return new BDaemonSession(stringBuffer.toString(), bHost, n, stringArray);
|
|
}
|
|
|
|
public BDaemonSession newSession(int n) {
|
|
String[] stringArray = null;
|
|
if (this.getTunnelAuthorities() != null && this.getTunnelAuthorities().length > 0) {
|
|
stringArray = this.getTunnelAuthorities();
|
|
int n2 = stringArray.length - 1;
|
|
BInternetAddress bInternetAddress = new BInternetAddress(stringArray[n2]);
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
stringBuffer.append(bInternetAddress.getHost());
|
|
if (n != this.getDefaultPort()) {
|
|
stringBuffer.append(":" + n);
|
|
}
|
|
stringArray[n2] = stringBuffer.toString();
|
|
}
|
|
return this.makeNewSession(this.getHost(), n, stringArray);
|
|
}
|
|
|
|
protected BDaemonSession makeNewSession(BHost bHost, int n, String[] stringArray) {
|
|
return BDaemonSession.make(bHost, n, stringArray);
|
|
}
|
|
|
|
public void close() {
|
|
this.disconnect(true);
|
|
this.host.removeNavChild((BINavNode)this);
|
|
}
|
|
|
|
public synchronized void connect() throws Exception {
|
|
this.connect(DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
public synchronized void connect(int n) throws Exception {
|
|
if (!this.isConnected() || Clock.ticks() - this.lastConnectTicks > 300000L) {
|
|
this.initHostProperties(true, n);
|
|
}
|
|
this.notifyConnected();
|
|
}
|
|
|
|
public synchronized void disconnect() {
|
|
this.disconnect(true);
|
|
}
|
|
|
|
public synchronized void disconnect(boolean bl) {
|
|
if (this.isConnected()) {
|
|
this.lastConnectTicks = 0L;
|
|
this.connected = false;
|
|
this.agentList = null;
|
|
if (bl && this.authenticator != null) {
|
|
this.cachedNonceValue = null;
|
|
this.authenticator.setCredentials(null);
|
|
}
|
|
this.hostProperties.reset();
|
|
BINavNode[] bINavNodeArray = super.getNavChildren();
|
|
int n = 0;
|
|
while (n < bINavNodeArray.length) {
|
|
this.removeNavChild(bINavNodeArray[n]);
|
|
++n;
|
|
}
|
|
if (this.navFactories != null) {
|
|
n = 0;
|
|
while (n < this.navFactories.length) {
|
|
this.navFactories[n].disconnect();
|
|
Array array = this.navFactories[n].getNavNodes();
|
|
int n2 = 0;
|
|
while (n2 < array.size()) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeRemoved((BOrd)this.getNavOrd(), (String)((BINavNode)array.get(n2)).getNavName(), null));
|
|
++n2;
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
if (this.getNavParent() != null) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeReplaced((BINavNode)this.getNavParent(), (String)this.getNavName(), null));
|
|
}
|
|
this.notifyDisconnected();
|
|
}
|
|
}
|
|
|
|
public BICredentials getCredentials() {
|
|
return this.authenticator == null ? null : this.authenticator.getCredentials();
|
|
}
|
|
|
|
public int getPort() {
|
|
return this.port;
|
|
}
|
|
|
|
public int getRemotePort() {
|
|
if (this.tunnelAuthorities == null || this.tunnelAuthorities.length == 0) {
|
|
return this.getPort();
|
|
}
|
|
return HttpUtil.parsePort((String)this.tunnelAuthorities[this.tunnelAuthorities.length - 1], (int)3011);
|
|
}
|
|
|
|
public BHost getRemoteHost() {
|
|
if (this.tunnelAuthorities == null || this.tunnelAuthorities.length == 0) {
|
|
return this.getHost();
|
|
}
|
|
return new BIpHost(HttpUtil.parseHost((String)this.tunnelAuthorities[this.tunnelAuthorities.length - 1]));
|
|
}
|
|
|
|
public String[] getTunnelAuthorities() {
|
|
return this.tunnelAuthorities;
|
|
}
|
|
|
|
public boolean isConnected() {
|
|
return this.connected;
|
|
}
|
|
|
|
public BICredentials makeCredentials() throws ConnectException {
|
|
return this.makeCredentials(DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
public BICredentials makeCredentials(int n) throws ConnectException {
|
|
return this.getAuthenticator(true, n).makeCredentials();
|
|
}
|
|
|
|
public void setCredentials(BICredentials bICredentials) {
|
|
try {
|
|
this.setCredentials(bICredentials, false);
|
|
}
|
|
catch (ConnectException connectException) {}
|
|
}
|
|
|
|
public void setCredentials(BICredentials bICredentials, boolean bl) throws ConnectException {
|
|
this.setCredentials(bICredentials, bl, DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
public void setCredentials(BICredentials bICredentials, boolean bl, int n) throws ConnectException {
|
|
BICredentials bICredentials2;
|
|
this.getAuthenticator(bl, n);
|
|
if (this.authenticator != null && bICredentials != null && (bICredentials2 = this.authenticator.makeCredentials()).getClass().isAssignableFrom(bICredentials.getClass())) {
|
|
this.authenticator.setCredentials(bICredentials);
|
|
}
|
|
}
|
|
|
|
public BSessionInfo getSessionInfo() {
|
|
BHost bHost = this.getHost();
|
|
if (bHost != null) {
|
|
String string = null;
|
|
if (this.getCredentials() instanceof BIUserCredentials) {
|
|
string = ((BIUserCredentials)this.getCredentials()).getUsername();
|
|
}
|
|
return BSessionInfo.make((String)bHost.getHostname(), (BAbsTime)this.getLastConnectedAbsTime(), null, (String)string);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected BAbsTime getLastConnectedAbsTime() {
|
|
return BAbsTime.make((long)this.lastConnectedTime);
|
|
}
|
|
|
|
public BOrd getAbsoluteOrd() {
|
|
return this.absOrd;
|
|
}
|
|
|
|
public BHost getHost() {
|
|
return this.host;
|
|
}
|
|
|
|
public BINavNode getNavChild(String string) {
|
|
if (!this.isConnected()) {
|
|
return null;
|
|
}
|
|
BSessionNavNode bSessionNavNode = this.getNavNode(string);
|
|
return bSessionNavNode == null ? super.getNavChild(string) : bSessionNavNode;
|
|
}
|
|
|
|
public BINavNode[] getNavChildren() {
|
|
if (!this.isConnected()) {
|
|
return new BINavNode[0];
|
|
}
|
|
if (Sys.getStation() == null) {
|
|
if (this.navFactories == null) {
|
|
this.navFactories = BSessionNavNodeFactory.makeFor((BISession)this);
|
|
}
|
|
this.getFileSpace();
|
|
Class clazz = class$javax$baja$nav$BINavNode;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$nav$BINavNode = BDaemonSession.class("[Ljavax.baja.nav.BINavNode;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
int n = 0;
|
|
while (n < this.navFactories.length) {
|
|
array.addAll(this.navFactories[n].getNavNodes());
|
|
++n;
|
|
}
|
|
array = array.sort(BSessionNavNodeFactory.NAV_NODE_COMPARATOR);
|
|
array.addAll((Object[])super.getNavChildren());
|
|
return (BINavNode[])array.trim();
|
|
}
|
|
this.getFileSpace();
|
|
return super.getNavChildren();
|
|
}
|
|
|
|
public String getNavDisplayName(Context context) {
|
|
String string = this.isConnected() ? this.getLexiconValue("connected") : this.getLexiconValue("disconnected");
|
|
if (this.tunnelAuthorities == null) {
|
|
if (this.port == this.getDefaultPort()) {
|
|
return this.getLexiconValue("navDisplayName", new Object[]{super.getNavDisplayName(context), string});
|
|
}
|
|
return this.getLexiconValue("navDisplayNameWithPort", new Object[]{super.getNavDisplayName(context), String.valueOf(this.port), string});
|
|
}
|
|
return this.getLexiconValue("tunneledNavDisplayName", new Object[]{super.getNavDisplayName(context), String.valueOf(this.getRemoteAddressString()), string});
|
|
}
|
|
|
|
protected String getLexiconPrefix() {
|
|
return "DaemonSession.";
|
|
}
|
|
|
|
private final String getLexiconValue(String string) {
|
|
return this.getLexiconValue(string, null);
|
|
}
|
|
|
|
private final String getLexiconValue(String string, Object[] objectArray) {
|
|
if (objectArray == null) {
|
|
return this.getLexicon().getText(this.getLexiconPrefix() + string);
|
|
}
|
|
return this.getLexicon().getText(this.getLexiconPrefix() + string, objectArray);
|
|
}
|
|
|
|
public BSessionNavNode getNavNode(String string) {
|
|
if (Sys.getStation() == null) {
|
|
if (this.navFactories == null) {
|
|
this.navFactories = BSessionNavNodeFactory.makeFor((BISession)this);
|
|
}
|
|
BSessionNavNode bSessionNavNode = null;
|
|
int n = 0;
|
|
while (bSessionNavNode == null && n < this.navFactories.length) {
|
|
bSessionNavNode = this.navFactories[n].getNavNode(string);
|
|
++n;
|
|
}
|
|
return bSessionNavNode;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public BOrd getNavOrd() {
|
|
return this.getAbsoluteOrd();
|
|
}
|
|
|
|
public BOrd getOrdInHost() {
|
|
return this.ordInHost;
|
|
}
|
|
|
|
public boolean hasNavChildren() {
|
|
return this.isConnected();
|
|
}
|
|
|
|
public String getAddressString() {
|
|
return this.getAddressString(this.getHost(), this.getPort());
|
|
}
|
|
|
|
public String getRemoteAddressString() {
|
|
return this.getAddressString(this.getRemoteHost(), this.getRemotePort());
|
|
}
|
|
|
|
public String getAddressString(BHost bHost, int n) {
|
|
if (n == -1 || n == this.getDefaultPort()) {
|
|
return bHost.getHostname();
|
|
}
|
|
return bHost.getHostname() + ':' + n;
|
|
}
|
|
|
|
protected int getDefaultPort() {
|
|
return 3011;
|
|
}
|
|
|
|
public static void processException(Exception exception) throws ConnectException {
|
|
BDaemonSession.processException(exception, (RuntimeException)new BajaRuntimeException((Throwable)exception));
|
|
}
|
|
|
|
public static void processException(Exception exception, RuntimeException runtimeException) throws ConnectException {
|
|
if (exception instanceof ConnectException) {
|
|
throw (ConnectException)exception;
|
|
}
|
|
if (exception instanceof SocketException) {
|
|
throw new ConnectException(exception.getMessage());
|
|
}
|
|
if (exception instanceof EOFException) {
|
|
throw new ConnectException();
|
|
}
|
|
if (exception instanceof InterruptedIOException) {
|
|
throw new ConnectException(exception.getMessage());
|
|
}
|
|
if (exception instanceof UnknownHostException) {
|
|
throw new ConnectException(exception.getMessage());
|
|
}
|
|
if (exception instanceof RuntimeException) {
|
|
throw (RuntimeException)exception;
|
|
}
|
|
throw runtimeException;
|
|
}
|
|
|
|
public boolean usesLocalNiagaraEnvironment() {
|
|
return this.localEnvironment;
|
|
}
|
|
|
|
public synchronized BHostProperties getHostProperties() {
|
|
return this.getHostProperties(DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
public synchronized BHostProperties getHostProperties(int n) {
|
|
if (this.isConnected()) {
|
|
try {
|
|
this.initHostProperties(false, n);
|
|
}
|
|
catch (ConnectException connectException) {}
|
|
}
|
|
return this.hostProperties;
|
|
}
|
|
|
|
private final void initHostProperties(boolean bl) throws AuthenticationException, ConnectException {
|
|
this.initHostProperties(bl, DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
/*
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
private final void initHostProperties(boolean bl, int n) throws AuthenticationException, ConnectException {
|
|
if (this.inInit) {
|
|
return;
|
|
}
|
|
this.inInit = true;
|
|
try {
|
|
if (bl || this.hostProperties.getIsDirty()) {
|
|
this.hostProperties.setIsDirty(false);
|
|
HttpConnection httpConnection = this.getConnection("/platformInfo", "GET", -1, n, null, 1);
|
|
try {
|
|
block24: {
|
|
Object object;
|
|
block22: {
|
|
XElem xElem = XParser.make((InputStream)httpConnection.getInputStream()).parse();
|
|
if (httpConnection != null) {
|
|
httpConnection.close();
|
|
}
|
|
this.hostProperties.load(xElem);
|
|
try {
|
|
try {
|
|
httpConnection = this.getConnection("/servlets", "GET", -1, n, null, 1);
|
|
object = XParser.make((InputStream)httpConnection.getInputStream()).parse();
|
|
this.hostProperties.loadServletsInfo((XElem)object);
|
|
}
|
|
catch (Exception exception) {
|
|
BDaemonSession.processException(exception, (RuntimeException)new LocalizableRuntimeException("platform", "DaemonSession.exception.badServletInfo", new Object[]{this.getAddressString()}, (Throwable)exception));
|
|
}
|
|
Object var8_10 = null;
|
|
if (httpConnection == null) break block22;
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var8_9 = null;
|
|
if (httpConnection == null) throw throwable;
|
|
httpConnection.close();
|
|
throw throwable;
|
|
}
|
|
httpConnection.close();
|
|
}
|
|
if (this.hostProperties.getHostId().equals(Nre.getHostId())) {
|
|
object = this.getInputStream((DaemonMessage)new GetDirectoryMessage(new FilePath("!"), false, false, true, this.getFileSpace()), n);
|
|
if (object == null) {
|
|
throw new ConnectException("Cannot connect to remote host");
|
|
}
|
|
try {
|
|
block23: {
|
|
try {
|
|
XElem xElem = XParser.make((InputStream)object).parse();
|
|
String string = xElem.get("path").replace('/', File.separatorChar);
|
|
String string2 = Sys.getBajaHome().getAbsolutePath().replace('/', File.separatorChar);
|
|
if (!BOperatingSystemEnum.isOS(BOperatingSystemEnum.windows)) {
|
|
this.localEnvironment = string2.equals(string);
|
|
break block23;
|
|
}
|
|
this.localEnvironment = string2.equalsIgnoreCase(string);
|
|
}
|
|
catch (Exception exception) {
|
|
BDaemonSession.processException(exception);
|
|
}
|
|
}
|
|
Object var11_17 = null;
|
|
if (object == null) break block24;
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var11_16 = null;
|
|
if (object == null) throw throwable;
|
|
((InputStream)object).close();
|
|
throw throwable;
|
|
}
|
|
((InputStream)object).close();
|
|
} else {
|
|
this.localEnvironment = false;
|
|
}
|
|
}
|
|
this.doConnected();
|
|
}
|
|
catch (Exception exception) {
|
|
this.hostProperties.reset();
|
|
BDaemonSession.processException(exception, (RuntimeException)new LocalizableRuntimeException("platform", "DaemonSession.exception.badHostInfo", new Object[]{this.getAddressString()}, (Throwable)exception));
|
|
}
|
|
}
|
|
Object var4_20 = null;
|
|
this.inInit = false;
|
|
return;
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var4_19 = null;
|
|
this.inInit = false;
|
|
throw throwable;
|
|
}
|
|
}
|
|
|
|
public void reloadHostProperties(int n) throws AuthenticationException, ConnectException {
|
|
this.hostProperties.reset();
|
|
this.initHostProperties(true, n);
|
|
}
|
|
|
|
public void reloadHostProperties() throws AuthenticationException, ConnectException {
|
|
this.reloadHostProperties(DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
public BHostProperties updateHostProperties() {
|
|
return this.updateHostProperties(DEFAULT_TIMEOUT);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public BHostProperties updateHostProperties(int n) {
|
|
try {
|
|
boolean bl = this.hostProperties.getIsDirty() ^ true;
|
|
this.initHostProperties(false);
|
|
if (!bl) return this.hostProperties;
|
|
HttpConnection httpConnection = this.getConnection("/platformInfo", "GET", -1, DEFAULT_TIMEOUT, null, 1);
|
|
try {
|
|
try {
|
|
XElem xElem = XParser.make((InputStream)httpConnection.getInputStream()).parse();
|
|
this.getHostProperties().update(xElem);
|
|
}
|
|
catch (Exception exception) {
|
|
try {
|
|
BDaemonSession.processException(exception);
|
|
}
|
|
catch (ConnectException connectException) {}
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var5_7 = null;
|
|
httpConnection.close();
|
|
throw throwable;
|
|
}
|
|
{
|
|
Object var5_8 = null;
|
|
httpConnection.close();
|
|
return this.hostProperties;
|
|
}
|
|
}
|
|
catch (ConnectException connectException) {}
|
|
return this.hostProperties;
|
|
}
|
|
|
|
public BDefaultDaemonFileSpace getFileSpace() {
|
|
BDefaultDaemonFileSpace bDefaultDaemonFileSpace = (BDefaultDaemonFileSpace)this.getNavChild("file");
|
|
if (bDefaultDaemonFileSpace == null) {
|
|
if (this == LocalSessionUtil.getLocalSession()) {
|
|
bDefaultDaemonFileSpace = new BDefaultDaemonFileSpace();
|
|
this.addNavChild((BINavNode)bDefaultDaemonFileSpace);
|
|
return bDefaultDaemonFileSpace;
|
|
}
|
|
return (BDefaultDaemonFileSpace)BOrd.make((String)"file:").get((BObject)this);
|
|
}
|
|
return bDefaultDaemonFileSpace;
|
|
}
|
|
|
|
public String getErrorText(XmlResponseMessage xmlResponseMessage) throws Exception {
|
|
this.sendMessages(new XmlResponseMessage[]{xmlResponseMessage}, DEFAULT_TIMEOUT);
|
|
return xmlResponseMessage.getErrorMessage();
|
|
}
|
|
|
|
public InputStream getInputStream(DaemonMessage daemonMessage) throws ConnectException, AuthenticationException {
|
|
return this.getInputStream(daemonMessage.getMessageString(), DEFAULT_TIMEOUT, null, null);
|
|
}
|
|
|
|
public XElem post(DaemonMessage daemonMessage) throws Exception {
|
|
if (daemonMessage != null && daemonMessage.getMethod().equals("POST")) {
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
daemonMessage.write(byteArrayOutputStream);
|
|
HttpConnection httpConnection = this.getConnection(daemonMessage.getMessageString(), daemonMessage.getMethod(), byteArrayOutputStream.size(), DEFAULT_TIMEOUT, null, 32);
|
|
if (httpConnection != null && byteArrayOutputStream != null) {
|
|
OutputStream outputStream = httpConnection.getOutputStream();
|
|
outputStream.write(byteArrayOutputStream.toByteArray());
|
|
outputStream.flush();
|
|
int n = httpConnection.postComplete();
|
|
if (n == 500) {
|
|
return null;
|
|
}
|
|
XElem xElem = XParser.make((InputStream)httpConnection.getInputStream()).parse();
|
|
httpConnection.close();
|
|
return xElem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public InputStream getInputStream(DaemonMessage daemonMessage, int n) throws ConnectException, AuthenticationException {
|
|
return this.getInputStream(daemonMessage.getMessageString(), n, null, null);
|
|
}
|
|
|
|
public InputStream getInputStream(DaemonMessage daemonMessage, String string) throws ConnectException, AuthenticationException {
|
|
return this.getInputStream(daemonMessage.getMessageString(), DEFAULT_TIMEOUT, string, null);
|
|
}
|
|
|
|
public InputStream getInputStream(DaemonMessage daemonMessage, int n, String string) throws ConnectException, AuthenticationException {
|
|
return this.getInputStream(daemonMessage.getMessageString(), n, string, null);
|
|
}
|
|
|
|
public InputStream getInputStream(DaemonMessage daemonMessage, int n, String string, HttpConnection httpConnection) throws ConnectException, AuthenticationException {
|
|
return this.getInputStream(daemonMessage.getMessageString(), n, string, httpConnection);
|
|
}
|
|
|
|
public InputStream getInputStream(String string, int n, String string2, HttpConnection httpConnection) throws ConnectException, AuthenticationException {
|
|
httpConnection = this.getConnection(string, "GET", -1, DEFAULT_TIMEOUT, httpConnection, 0);
|
|
try {
|
|
if (httpConnection == null) {
|
|
return null;
|
|
}
|
|
httpConnection.setTimeout(n);
|
|
String string3 = httpConnection.getResponseHeader("Content-Type");
|
|
if (!(string2 == null || string3 != null && string3.equals(string2))) {
|
|
httpConnection.close();
|
|
return null;
|
|
}
|
|
return new Stream(httpConnection);
|
|
}
|
|
catch (Exception exception) {
|
|
if (httpConnection != null) {
|
|
httpConnection.close();
|
|
}
|
|
log.error("error sending message to daemon", (Throwable)exception);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public OutputStream getOutputStream(DaemonMessage daemonMessage, long l, ICancelHint iCancelHint) throws ConnectException, AuthenticationException {
|
|
return this.getOutputStream(daemonMessage, l, DEFAULT_TIMEOUT, iCancelHint);
|
|
}
|
|
|
|
public OutputStream getOutputStream(DaemonMessage daemonMessage, long l, int n, ICancelHint iCancelHint) throws ConnectException, AuthenticationException {
|
|
if (BDaemonSession.canceled(iCancelHint)) {
|
|
throw new ICancelHint.CanceledException();
|
|
}
|
|
HttpConnection httpConnection = this.getConnection(daemonMessage.getMessageString(), "POST", l, n, null, 32);
|
|
try {
|
|
return httpConnection == null ? null : new PostOutputStream(httpConnection, iCancelHint);
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("error posting message to daemon", (Throwable)exception);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public boolean sendMessage(DaemonMessage daemonMessage) throws ConnectException, AuthenticationException {
|
|
return this.sendMessage(daemonMessage.getMessageString(), daemonMessage.getMethod(), DEFAULT_TIMEOUT, daemonMessage.getConnectionFlags());
|
|
}
|
|
|
|
public boolean sendMessage(DaemonMessage daemonMessage, int n) throws ConnectException, AuthenticationException {
|
|
return this.sendMessage(daemonMessage.getMessageString(), daemonMessage.getMethod(), n, daemonMessage.getConnectionFlags());
|
|
}
|
|
|
|
public synchronized XmlResponseMessage[] sendMessages(XmlResponseMessage[] xmlResponseMessageArray, int n) throws Exception {
|
|
if (this.getHostProperties().supportsServlet("batch")) {
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
int n2 = 32;
|
|
int n3 = 0;
|
|
while (n3 < xmlResponseMessageArray.length) {
|
|
stringBuffer.append("/");
|
|
stringBuffer.append(xmlResponseMessageArray[n3].getMessageString());
|
|
stringBuffer.append("\r\n");
|
|
n2 |= xmlResponseMessageArray[n3].getConnectionFlags();
|
|
++n3;
|
|
}
|
|
stringBuffer.append("\r\n");
|
|
HttpConnection httpConnection = this.getConnection("batch", "POST", stringBuffer.length(), n, null, n2);
|
|
httpConnection.getOutputStream().write(stringBuffer.toString().getBytes());
|
|
httpConnection.postComplete();
|
|
XElem[] xElemArray = XParser.make((InputStream)httpConnection.getInputStream()).parse().elems();
|
|
httpConnection.close();
|
|
int n4 = 0;
|
|
while (n4 < xElemArray.length) {
|
|
xmlResponseMessageArray[n4].setResponse(xElemArray[n4]);
|
|
++n4;
|
|
}
|
|
} else {
|
|
int n5 = 0;
|
|
while (n5 < xmlResponseMessageArray.length) {
|
|
try {
|
|
Stream stream = (Stream)this.getInputStream((DaemonMessage)xmlResponseMessageArray[n5], n);
|
|
if (stream.getContentType() != null && stream.getContentType().equals("text/xml")) {
|
|
xmlResponseMessageArray[n5].setResponse(XParser.make((InputStream)stream).parse());
|
|
} else {
|
|
xmlResponseMessageArray[n5].setResponse(new XElem("success"));
|
|
stream.close();
|
|
}
|
|
}
|
|
catch (DaemonResponseException daemonResponseException) {
|
|
xmlResponseMessageArray[n5].setErrorMessage(daemonResponseException.getMessage());
|
|
}
|
|
++n5;
|
|
}
|
|
}
|
|
return xmlResponseMessageArray;
|
|
}
|
|
|
|
public synchronized boolean sendRebootRequest() throws AuthenticationException {
|
|
return this.sendRebootRequest(true);
|
|
}
|
|
|
|
public synchronized void sendForceRebootRequest() throws AuthenticationException {
|
|
if (!this.getHostProperties().supportsServlet("reboot")) {
|
|
return;
|
|
}
|
|
if (Boolean.valueOf(System.getProperty("niagara.daemonsession.bypassReboot", "false")).booleanValue()) {
|
|
this.disconnect(true);
|
|
} else {
|
|
try {
|
|
this.sendMessage(forceRebootMessage.getMessageString(), forceRebootMessage.getMethod(), 0, forceRebootMessage.getConnectionFlags());
|
|
this.disconnect(true);
|
|
}
|
|
catch (SocketException socketException) {
|
|
this.disconnect(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public synchronized boolean sendRebootRequest(boolean bl) throws AuthenticationException {
|
|
if (!this.getHostProperties().supportsServlet("reboot")) {
|
|
BPlatform.log.trace("sendRebootRequest returning false: reboot servlet not supported");
|
|
return false;
|
|
}
|
|
if (Boolean.valueOf(System.getProperty("niagara.daemonsession.bypassReboot", "false")).booleanValue()) {
|
|
BPlatform.log.trace("sendRebootRequest returning true: bypassReboot property set");
|
|
this.disconnect(bl);
|
|
return true;
|
|
}
|
|
try {
|
|
if (this.sendMessage(rebootMessage.getMessageString(), rebootMessage.getMethod(), 0, rebootMessage.getConnectionFlags())) {
|
|
BPlatform.log.trace("sendRebootRequest returning true: request succeeded");
|
|
this.disconnect(bl);
|
|
return true;
|
|
}
|
|
BPlatform.log.trace("sendRebootRequest returning false: request failed");
|
|
return false;
|
|
}
|
|
catch (DaemonResponseException daemonResponseException) {
|
|
if (daemonResponseException.responseCode == 409) {
|
|
BPlatform.log.trace("sendRebootRequest returning false: received SC_CONFLICT response");
|
|
return false;
|
|
}
|
|
throw daemonResponseException;
|
|
}
|
|
catch (SocketException socketException) {
|
|
BPlatform.log.trace("sendRebootRequest returning true: encountered SocketException");
|
|
this.disconnect(bl);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public String getAuthenticationRealmName() {
|
|
return this.authenticator == null ? null : this.authenticator.getAuthenticationRealmName();
|
|
}
|
|
|
|
private final Authenticator getAuthenticator() {
|
|
try {
|
|
return this.getAuthenticator(false, DEFAULT_TIMEOUT);
|
|
}
|
|
catch (ConnectException connectException) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private final Authenticator getAuthenticator(boolean bl, int n) throws ConnectException {
|
|
if (this.authenticator == null && bl) {
|
|
try {
|
|
this.sendMessage("/", "GET", n, 2);
|
|
}
|
|
catch (AuthenticationException authenticationException) {}
|
|
}
|
|
return this.authenticator;
|
|
}
|
|
|
|
private final void initAuthenticator(HttpConnection httpConnection) throws ConnectException {
|
|
this.authenticator = Authenticator.make(this.getAuthenticator(), this.getHost(), this.getPort(), this.getAbsoluteOrd().toString(), httpConnection);
|
|
}
|
|
|
|
private static final String getBrandId() {
|
|
if (brandIdHolder == null) {
|
|
try {
|
|
Feature feature = Sys.getLicenseManager().checkFeature("tridium", "platformClient");
|
|
brandIdHolder = feature.getb("useBrand", true) ? new String[]{Brand.getBrandId()} : new String[1];
|
|
}
|
|
catch (FeatureNotLicensedException featureNotLicensedException) {
|
|
brandIdHolder = new String[]{Brand.getBrandId()};
|
|
}
|
|
}
|
|
return brandIdHolder[0];
|
|
}
|
|
|
|
private static final void addBrandHeader(HttpConnection httpConnection) {
|
|
String string = BDaemonSession.getBrandId();
|
|
if (string != null) {
|
|
if (Sys.getStation() == null) {
|
|
httpConnection.setRequestHeader("Baja-Wb-Brand", string);
|
|
} else {
|
|
httpConnection.setRequestHeader("Baja-Station-Brand", string);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final void checkServerBrand(HttpConnection httpConnection) {
|
|
String string;
|
|
if (BDaemonSession.getBrandId() != null && (string = httpConnection.getResponseHeader("Baja-Station-Brand")) != null && string.trim().length() > 0) {
|
|
if (Sys.getStation() == null) {
|
|
Brand.checkWbOut((String)string);
|
|
} else {
|
|
Brand.checkStationOut((String)string);
|
|
}
|
|
}
|
|
}
|
|
|
|
private final synchronized void doConnected() {
|
|
if (!this.isConnected()) {
|
|
this.agentList = null;
|
|
this.connected = true;
|
|
this.lastConnectedTime = Clock.millis();
|
|
if (this.navFactories != null) {
|
|
Class clazz = class$javax$baja$nav$BINavNode;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$nav$BINavNode = BDaemonSession.class("[Ljavax.baja.nav.BINavNode;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
int n = 0;
|
|
while (n < this.navFactories.length) {
|
|
this.navFactories[n].connect();
|
|
array.addAll(this.navFactories[n].getNavNodes());
|
|
++n;
|
|
}
|
|
array = array.sort(BSessionNavNodeFactory.NAV_NODE_COMPARATOR);
|
|
n = 0;
|
|
while (n < array.size()) {
|
|
BNavRoot.INSTANCE.fireNavEvent(NavEvent.makeAdded((BOrd)this.getNavOrd(), (String)((BINavNode)array.get(n)).getNavName(), null));
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
this.lastConnectTicks = Clock.ticks();
|
|
}
|
|
|
|
boolean sendMessage(String string, int n) throws ConnectException, AuthenticationException {
|
|
return this.sendMessage(string, "GET", n, 0);
|
|
}
|
|
|
|
boolean sendMessage(String string, String string2, int n) throws ConnectException, AuthenticationException {
|
|
return this.sendMessage(string, string2, n, 0);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
boolean sendMessage(String string, String string2, int n, int n2) throws ConnectException, AuthenticationException {
|
|
HttpConnection httpConnection = this.getConnection(string, string2, -1, n, null, n2);
|
|
if (httpConnection == null) {
|
|
return false;
|
|
}
|
|
try {
|
|
try {
|
|
byte[] byArray = new byte[1024];
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(httpConnection.getInputStream());
|
|
while (bufferedInputStream.read(byArray, 0, 1024) > 0) {
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
BDaemonSession.processException(exception);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var7_10 = null;
|
|
httpConnection.close();
|
|
throw throwable;
|
|
}
|
|
{
|
|
Object var7_11 = null;
|
|
}
|
|
httpConnection.close();
|
|
return true;
|
|
}
|
|
|
|
synchronized HttpConnection getConnection(String string, String string2, int n) throws ConnectException, AuthenticationException {
|
|
return this.getConnection(string, string2, -1, n, null, 0);
|
|
}
|
|
|
|
synchronized HttpConnection getConnection(String string, String string2, int n, HttpConnection httpConnection) throws ConnectException, AuthenticationException {
|
|
return this.getConnection(string, string2, -1, n, httpConnection, 0);
|
|
}
|
|
|
|
synchronized HttpConnection getConnection(String string, String string2, long l, int n) throws ConnectException, AuthenticationException {
|
|
return this.getConnection(string, string2, l, n, null, 0);
|
|
}
|
|
|
|
synchronized HttpConnection getConnection(String string, String string2, long l, int n, HttpConnection httpConnection) throws ConnectException, AuthenticationException {
|
|
return this.getConnection(string, string2, l, n, httpConnection, 0);
|
|
}
|
|
|
|
synchronized HttpConnection getConnection(String string, String string2, long l, int n, HttpConnection httpConnection, int n2) throws ConnectException, AuthenticationException {
|
|
int n3 = -1;
|
|
String string3 = string.charAt(0) == '/' ? string : "/" + string;
|
|
boolean bl = false;
|
|
boolean bl2 = false;
|
|
int n4 = 0;
|
|
long l2 = Clock.ticks();
|
|
log.trace("getConnection " + string2 + ' ' + string + " (" + n + ')');
|
|
while (true) {
|
|
String string4;
|
|
try {
|
|
if (this.tunnelAuthorities != null) {
|
|
string3 = this.parseTunnelAuthorities(string3);
|
|
}
|
|
if (httpConnection == null) {
|
|
httpConnection = this.createNewConnection(string2, l, n, n2, string3);
|
|
if (this.cachedNonceValue != null) {
|
|
this.setAuthOnConnection(httpConnection, string3);
|
|
this.addHeaders(string2, l, n, httpConnection, n2);
|
|
}
|
|
if ((n3 = this.connect(httpConnection)) == 302) {
|
|
this.redirect(string2, httpConnection, n3, string3);
|
|
}
|
|
} else {
|
|
bl = this.setAuthOnConnection(httpConnection, string3);
|
|
this.addHeaders(string2, l, n, httpConnection, n2);
|
|
n3 = this.sendNewRequest(httpConnection, n3, string3);
|
|
}
|
|
}
|
|
catch (SocketException socketException) {
|
|
log.trace("socket exception", (Throwable)socketException);
|
|
if (n4 < 1) {
|
|
string4 = this.getHost().toString();
|
|
if (string4.indexOf(":") != -1) {
|
|
string4 = "[" + string4 + ']';
|
|
}
|
|
log.warning("connection failed, retrying " + string2 + ' ' + string + " at " + string4 + ':' + this.getPort() + " (" + n + " ms timeout)");
|
|
++n4;
|
|
continue;
|
|
}
|
|
this.handleRetriesExceeded(httpConnection, l2, socketException);
|
|
}
|
|
catch (Exception exception) {
|
|
this.handleConnectionException(string2, httpConnection, string3, l2, exception);
|
|
}
|
|
this.validateResponse(httpConnection, l2);
|
|
String string5 = httpConnection.getResponseHeader("Niagara-Started");
|
|
if (string5 != null) {
|
|
this.hostProperties.checkTimestamp(string5);
|
|
}
|
|
if (this.isSuccessResponseCode(n3)) {
|
|
string4 = httpConnection.getRequestHeader("Authorization");
|
|
if (string4 != null) {
|
|
this.cachedNonceValue = Authenticator.parseHeader(string4);
|
|
}
|
|
this.handleConnectionFlags(n2, l2);
|
|
return httpConnection;
|
|
}
|
|
bl2 = this.handleErrorResponses(string2, httpConnection, n2, n3, string3, bl, l2);
|
|
if (!bl2) break;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected String redirect(String string, HttpConnection httpConnection, int n, String string2) throws IOException {
|
|
byte[] byArray = new byte[Math.min(httpConnection.getContentLength(), 75)];
|
|
httpConnection.getInputStream().read(byArray, 0, byArray.length);
|
|
httpConnection.close();
|
|
String string3 = httpConnection.getResponseHeader("location");
|
|
throw new DaemonSSLRequiredException(n, this.getHost().getHostname(), string, string2, string3);
|
|
}
|
|
|
|
private final boolean handleErrorResponses(String string, HttpConnection httpConnection, int n, int n2, String string2, boolean bl, long l) throws ConnectException {
|
|
boolean bl2 = false;
|
|
if (n2 == 401) {
|
|
this.readFully(httpConnection);
|
|
bl2 = this.handleUnauthorizedResponse(httpConnection, n, bl, l);
|
|
} else {
|
|
log.trace("getConnection failed " + Http.getReasonPhrase((int)n2));
|
|
if ((n & 1) == 0) {
|
|
this.doConnected();
|
|
}
|
|
if (n2 == 404) {
|
|
this.readFully(httpConnection);
|
|
httpConnection.close();
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
bl2 = false;
|
|
} else if (httpConnection != null && httpConnection.getContentType() != null && httpConnection.getContentType().equals("text/xml")) {
|
|
this.handleXMLResponse(string, httpConnection, n2, string2, l);
|
|
} else {
|
|
this.handleInvalidResponse(string, httpConnection, n2, string2, l);
|
|
}
|
|
}
|
|
return bl2;
|
|
}
|
|
|
|
private final boolean handleUnauthorizedResponse(HttpConnection httpConnection, int n, boolean bl, long l) throws ConnectException {
|
|
if (this.cachedNonceValue == null) {
|
|
if (bl) {
|
|
this.initAuthenticator(httpConnection);
|
|
this.connectionFailed(httpConnection, n, l);
|
|
} else {
|
|
this.initAuthenticator(httpConnection);
|
|
if (this.getAuthenticator() == null || !this.getAuthenticator().hasCredentials()) {
|
|
this.connectionFailed(httpConnection, n, l);
|
|
}
|
|
}
|
|
}
|
|
this.cachedNonceValue = Authenticator.parseHeader(httpConnection, "Authorization");
|
|
return true;
|
|
}
|
|
|
|
private final void connectionFailed(HttpConnection httpConnection, int n, long l) {
|
|
httpConnection.close();
|
|
AuthenticationException authenticationException = new AuthenticationException((AuthenticationRealm)this.getAuthenticator());
|
|
if ((n & 2) == 0) {
|
|
this.notifyConnectionError(authenticationException);
|
|
}
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw authenticationException;
|
|
}
|
|
|
|
private final void handleConnectionException(String string, HttpConnection httpConnection, String string2, long l, Exception exception) {
|
|
httpConnection.close();
|
|
this.hostProperties.reset();
|
|
this.notifyConnectionError(exception);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
if (exception instanceof ICancelHint.CanceledException) {
|
|
throw (ICancelHint.CanceledException)((Object)exception);
|
|
}
|
|
if (exception instanceof DaemonSSLRequiredException) {
|
|
throw (DaemonSSLRequiredException)((Object)exception);
|
|
}
|
|
throw new LocalizableRuntimeException("platform", "DaemonSession.exception.connectError", new Object[]{this.getAddressString(), string, string2}, (Throwable)exception);
|
|
}
|
|
|
|
private final void handleRetriesExceeded(HttpConnection httpConnection, long l, SocketException socketException) throws ConnectException {
|
|
try {
|
|
httpConnection.close();
|
|
}
|
|
catch (Exception exception) {}
|
|
this.hostProperties.reset();
|
|
this.notifyConnectionError(socketException);
|
|
this.disconnect(false);
|
|
if (socketException instanceof ConnectException) {
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw (ConnectException)socketException;
|
|
}
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw new ConnectException(socketException.getMessage());
|
|
}
|
|
|
|
private final void handleConnectionFlags(int n, long l) throws ConnectException {
|
|
if ((n & 0x10) > 0) {
|
|
this.authenticator = null;
|
|
}
|
|
if ((n & 8) > 0) {
|
|
this.close();
|
|
} else if ((n & 4) > 0) {
|
|
this.disconnect(false);
|
|
} else if ((n & 0x10) == 0) {
|
|
this.initHostProperties(false);
|
|
if ((n & 1) == 0) {
|
|
this.doConnected();
|
|
}
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
}
|
|
}
|
|
|
|
private final void handleInvalidResponse(String string, HttpConnection httpConnection, int n, String string2, long l) {
|
|
this.readFully(httpConnection);
|
|
httpConnection.close();
|
|
this.hostProperties.reset();
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
if (n == 403) {
|
|
throw new LocalizableRuntimeException("platform", "DaemonSession.exception.badBrand", new Object[]{Brand.getBrandId()});
|
|
}
|
|
throw new DaemonResponseException(n, this.getAddressString(), string, string2);
|
|
}
|
|
|
|
private final void handleXMLResponse(String string, HttpConnection httpConnection, int n, String string2, long l) {
|
|
try {
|
|
XElem xElem;
|
|
Object object;
|
|
if (debug) {
|
|
int n2;
|
|
object = new ByteArrayOutputStream();
|
|
InputStream inputStream = httpConnection.getInputStream();
|
|
byte[] byArray = new byte[4096];
|
|
while ((n2 = inputStream.read(byArray, 0, byArray.length)) > 0) {
|
|
((ByteArrayOutputStream)object).write(byArray, 0, n2);
|
|
}
|
|
if (debug) {
|
|
((ByteArrayOutputStream)object).writeTo(System.out);
|
|
}
|
|
xElem = XParser.make((InputStream)new ByteArrayInputStream(((ByteArrayOutputStream)object).toByteArray())).parse();
|
|
} else {
|
|
xElem = XParser.make((InputStream)httpConnection.getInputStream()).parse();
|
|
}
|
|
object = new DaemonText(xElem);
|
|
this.hostProperties.reset();
|
|
httpConnection.close();
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw new DaemonResponseException(n, this.getAddressString(), ((DaemonText)object).message);
|
|
}
|
|
catch (LocalizableRuntimeException localizableRuntimeException) {
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
catch (Exception exception) {
|
|
httpConnection.close();
|
|
this.hostProperties.reset();
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw new LocalizableRuntimeException("platform", "DaemonSession.exception.badConnectResponse", new Object[]{new Integer(n), this.getAddressString(), string, string2});
|
|
}
|
|
}
|
|
|
|
private final void validateResponse(HttpConnection httpConnection, long l) {
|
|
int n;
|
|
Version version;
|
|
BDaemonSession.checkServerBrand(httpConnection);
|
|
String string = httpConnection.getResponseHeader("Server");
|
|
if (string == null) {
|
|
httpConnection.close();
|
|
LocalizableRuntimeException localizableRuntimeException = new LocalizableRuntimeException("platform", "daemon.session.versionError", new Object[]{requiredVersion, this.getAddressString(), "?"});
|
|
this.notifyConnectionError(localizableRuntimeException);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
if (this.tunnelAuthorities != null) {
|
|
if (httpConnection.getResponseHeader("Tunneled-Connection-Proxy-Response") != null) {
|
|
LocalizableRuntimeException localizableRuntimeException = new LocalizableRuntimeException("platform", "daemon.session.proxyTunnelError", new Object[]{httpConnection.getStatusMessage()});
|
|
httpConnection.close();
|
|
this.notifyConnectionError(localizableRuntimeException);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
if (httpConnection.getResponseHeader("Tunneled-Connection-Proxy") == null) {
|
|
LocalizableRuntimeException localizableRuntimeException = new LocalizableRuntimeException("platform", "daemon.session.proxyVersionError", new Object[]{this.getAddressString(), requiredVersionForTunnel});
|
|
httpConnection.close();
|
|
this.notifyConnectionError(localizableRuntimeException);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
if (httpConnection.getResponseHeader("Tunneled-Connection-Endpoint") == null) {
|
|
LocalizableRuntimeException localizableRuntimeException = new LocalizableRuntimeException("platform", "daemon.session.endpointVersionError", new Object[]{this.getRemoteAddressString(), requiredVersionForTunnel});
|
|
httpConnection.close();
|
|
this.notifyConnectionError(localizableRuntimeException);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
}
|
|
if ((version = new Version(string.substring((n = string.lastIndexOf(47)) + 1))).compareTo((Object)requiredVersion) < 0) {
|
|
httpConnection.close();
|
|
LocalizableRuntimeException localizableRuntimeException = new LocalizableRuntimeException("platform", "daemon.session.versionError", new Object[]{requiredVersion, this.getAddressString(), version});
|
|
this.notifyConnectionError(localizableRuntimeException);
|
|
this.disconnect(false);
|
|
log.trace("getConnection completed in " + (Clock.ticks() - l) + "ms");
|
|
throw localizableRuntimeException;
|
|
}
|
|
}
|
|
|
|
private final boolean isSuccessResponseCode(int n) {
|
|
boolean bl = false;
|
|
if (n > 99 && n < 300) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
private final int sendNewRequest(HttpConnection httpConnection, int n, String string) throws ConnectException {
|
|
try {
|
|
n = httpConnection.newRequest(string);
|
|
}
|
|
catch (Exception exception) {
|
|
BDaemonSession.processException(exception);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
protected void addHeaders(String string, long l, int n, HttpConnection httpConnection, int n2) throws SocketException {
|
|
if (l >= 0L) {
|
|
httpConnection.setRequestHeader("Content-Length", l);
|
|
}
|
|
BDaemonSession.addBrandHeader(httpConnection);
|
|
httpConnection.setRequestMethod(string);
|
|
httpConnection.setTimeout(n);
|
|
if ((n2 & 0x20) != 0) {
|
|
httpConnection.removeRequestHeader("expect");
|
|
httpConnection.setRequestHeader("expect", "100-continue");
|
|
}
|
|
}
|
|
|
|
protected boolean setAuthOnConnection(HttpConnection httpConnection, String string) throws IOException {
|
|
boolean bl = this.getAuthenticator() == null ? false : (this.cachedNonceValue != null ? this.getAuthenticator().setAuthorization(httpConnection, string, this.cachedNonceValue) : this.getAuthenticator().setAuthorization(httpConnection, string));
|
|
return bl;
|
|
}
|
|
|
|
protected int connect(HttpConnection httpConnection) throws ConnectException {
|
|
int n = -1;
|
|
try {
|
|
if (httpConnection != null) {
|
|
n = httpConnection.connect();
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
BDaemonSession.processException(exception);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
protected HttpConnection createNewConnection(String string, long l, int n, int n2, String string2) throws SocketException {
|
|
HttpConnection httpConnection = new HttpConnection(this.getHost(), this.getPort(), string2);
|
|
return this.initConnection(httpConnection, string, l, n, n2);
|
|
}
|
|
|
|
protected HttpConnection initConnection(HttpConnection httpConnection, String string, long l, int n, int n2) throws SocketException {
|
|
this.addHeaders(string, l, n, httpConnection, n2);
|
|
return httpConnection;
|
|
}
|
|
|
|
private final String parseTunnelAuthorities(String string) {
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
int n = 0;
|
|
while (n < this.tunnelAuthorities.length) {
|
|
int n2;
|
|
stringBuffer.append("/tunnel/").append(HttpUtil.parseHost((String)this.tunnelAuthorities[n]));
|
|
if (n < this.tunnelAuthorities.length - 1) {
|
|
n2 = HttpUtil.parsePort((String)this.tunnelAuthorities[n], (int)80);
|
|
if (n2 != 80) {
|
|
stringBuffer.append(":" + n2);
|
|
}
|
|
} else {
|
|
n2 = HttpUtil.parsePort((String)this.tunnelAuthorities[n], (int)3011);
|
|
stringBuffer.append(":" + n2);
|
|
}
|
|
++n;
|
|
}
|
|
if (!string.startsWith(stringBuffer.toString())) {
|
|
stringBuffer.append(string);
|
|
string = stringBuffer.toString();
|
|
}
|
|
return string;
|
|
}
|
|
|
|
String readFully(HttpConnection httpConnection) {
|
|
try {
|
|
int n;
|
|
byte[] byArray = new byte[1024];
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(httpConnection.getInputStream());
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
while ((n = bufferedInputStream.read(byArray, 0, 1024)) > 0) {
|
|
byteArrayOutputStream.write(byArray, 0, n);
|
|
}
|
|
return byteArrayOutputStream.toString();
|
|
}
|
|
catch (Exception exception) {
|
|
if (debug) {
|
|
exception.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static boolean canceled(ICancelHint iCancelHint) {
|
|
boolean bl = false;
|
|
if (iCancelHint != null && iCancelHint.isCanceled()) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public static void checkCanceled(ICancelHint iCancelHint) {
|
|
if (BDaemonSession.canceled(iCancelHint)) {
|
|
throw new ICancelHint.CanceledException();
|
|
}
|
|
}
|
|
|
|
public boolean isSecure() {
|
|
return this.getHost() instanceof BLocalHost;
|
|
}
|
|
|
|
public void addListener(DaemonSessionListener daemonSessionListener) {
|
|
if (!this.listeners.contains(daemonSessionListener)) {
|
|
this.listeners.add(daemonSessionListener);
|
|
}
|
|
}
|
|
|
|
public void removeListener(DaemonSessionListener daemonSessionListener) {
|
|
this.listeners.remove(daemonSessionListener);
|
|
}
|
|
|
|
protected void notifyConnected() {
|
|
Iterator iterator = this.listeners.iterator();
|
|
while (iterator.hasNext()) {
|
|
DaemonSessionListener daemonSessionListener = (DaemonSessionListener)iterator.next();
|
|
daemonSessionListener.sessionConnected(this);
|
|
}
|
|
}
|
|
|
|
protected void notifyDisconnected() {
|
|
Iterator iterator = this.listeners.iterator();
|
|
while (iterator.hasNext()) {
|
|
DaemonSessionListener daemonSessionListener = (DaemonSessionListener)iterator.next();
|
|
daemonSessionListener.sessionDisconnected(this);
|
|
}
|
|
}
|
|
|
|
protected void notifyConnectionError(Throwable throwable) {
|
|
Iterator iterator = this.listeners.iterator();
|
|
while (iterator.hasNext()) {
|
|
DaemonSessionListener daemonSessionListener = (DaemonSessionListener)iterator.next();
|
|
daemonSessionListener.sessionConnectionError(this, throwable);
|
|
}
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
if (this.isConnected()) {
|
|
return this.tunnelAuthorities == null ? iconConnected : tunnelIconConnected;
|
|
}
|
|
return this.tunnelAuthorities == null ? iconDisconnected : tunnelIconDisconnected;
|
|
}
|
|
|
|
public AgentList getAgents(Context context) {
|
|
if (this.isConnected()) {
|
|
if (this.agentList == null) {
|
|
AgentTypeComparator agentTypeComparator = new AgentTypeComparator(context);
|
|
this.agentList = Sys.getRegistry().getAgents(this.getType().getTypeInfo());
|
|
try {
|
|
AgentList agentList = this.getAgentList().filter(AgentFilter.is((String)"workbench:WbView"));
|
|
agentList.remove("workbench:NavContainerView");
|
|
agentList.remove("platDaemon:PlatformSessionListView");
|
|
AgentInfo[] agentInfoArray = agentList.list();
|
|
this.filterNavNodes(agentInfoArray);
|
|
this.sortAgentList(agentTypeComparator);
|
|
this.setDefaultAgent();
|
|
this.agentList.toTop("workbench:NavContainerView");
|
|
this.agentList.toTop("platDaemon:PlatformSessionListView");
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
typeNotFoundException.printStackTrace();
|
|
}
|
|
}
|
|
} else if (this.agentList == null) {
|
|
this.agentList = super.getAgents(context);
|
|
AgentList agentList = this.getAgentList().filter(AgentFilter.is((String)"workbench:WbView"));
|
|
agentList.remove("workbench:NavContainerView");
|
|
this.agentList.remove(agentList);
|
|
AgentTypeComparator agentTypeComparator = new AgentTypeComparator(context);
|
|
this.sortAgentList(agentTypeComparator);
|
|
this.setDefaultAgent();
|
|
}
|
|
return this.agentList;
|
|
}
|
|
|
|
private final void filterNavNodes(AgentInfo[] agentInfoArray) {
|
|
int n = 0;
|
|
while (n < agentInfoArray.length) {
|
|
if (agentInfoArray[n] instanceof NAgentInfo) {
|
|
TypeInfo typeInfo = ((NAgentInfo)agentInfoArray[n]).getTypeInfo();
|
|
String string = Lexicon.make((String)typeInfo.getModuleName()).get(typeInfo.getTypeName() + ".navName", typeInfo.getTypeName());
|
|
if (this.getNavNode(string) == null) {
|
|
this.agentList.remove(agentInfoArray[n]);
|
|
}
|
|
} else {
|
|
this.agentList.remove(agentInfoArray[n]);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void sortAgentList(Comparator comparator) {
|
|
if (this.agentList.size() > 1) {
|
|
int n = 0;
|
|
while (n < this.agentList.size() - 1) {
|
|
int n2 = n + 1;
|
|
while (n2 < this.agentList.size()) {
|
|
if (comparator.compare(this.agentList.get(n), this.agentList.get(n2)) > 0) {
|
|
this.agentList.swap(n, n2);
|
|
}
|
|
++n2;
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean shouldDowngrade(BPlatformSSLSettings bPlatformSSLSettings) {
|
|
return false;
|
|
}
|
|
|
|
protected void setDefaultAgent() {
|
|
if (this.tunnelAuthorities != null) {
|
|
this.getAgentList().toTop("platform:DaemonTunnelSessionAgent");
|
|
} else {
|
|
this.getAgentList().toTop("platform:DaemonSessionAgent");
|
|
}
|
|
}
|
|
|
|
protected AgentList getAgentList() {
|
|
return this.agentList;
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.agentList = null;
|
|
this.tunnelAuthorities = null;
|
|
this.localEnvironment = false;
|
|
this.navFactories = null;
|
|
this.connected = false;
|
|
this.inInit = false;
|
|
this.listeners = new HashSet();
|
|
}
|
|
|
|
protected BDaemonSession(String string, BHost bHost, int n, String[] stringArray) {
|
|
super(string, stringArray == null ? LexiconText.make((String)"platform", (String)"daemon.session") : LexiconText.make((String)"platform", (String)"daemon.tunnel.session"));
|
|
this.this();
|
|
this.host = bHost;
|
|
this.port = n;
|
|
this.tunnelAuthorities = stringArray;
|
|
if (stringArray != null) {
|
|
int n2 = 0;
|
|
while (n2 < stringArray.length) {
|
|
HttpUtil.parseHost((String)stringArray[n2]);
|
|
HttpUtil.parsePort((String)stringArray[n2], (int)3011);
|
|
++n2;
|
|
}
|
|
this.ordInHost = BOrd.make((OrdQuery)new BDaemonScheme.DaemonQuery(n, stringArray));
|
|
} else {
|
|
this.ordInHost = BOrd.make((OrdQuery)new BDaemonScheme.DaemonQuery(n));
|
|
}
|
|
this.absOrd = BOrd.make((BOrd)bHost.getAbsoluteOrd(), (BOrd)this.ordInHost);
|
|
this.hostProperties = new BHostProperties();
|
|
}
|
|
|
|
protected BDaemonSession(String string, BHost bHost, int n, String[] stringArray, BOrd bOrd, LexiconText lexiconText) {
|
|
super(string, lexiconText);
|
|
this.this();
|
|
this.host = bHost;
|
|
this.port = n;
|
|
this.tunnelAuthorities = stringArray;
|
|
this.ordInHost = bOrd;
|
|
this.absOrd = BOrd.make((BOrd)bHost.getAbsoluteOrd(), (BOrd)this.ordInHost);
|
|
this.hostProperties = new BHostProperties();
|
|
}
|
|
|
|
BDaemonSession(String string, BHost bHost, int n) {
|
|
this(string, bHost, n, null);
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$platform$daemon$BDaemonSession;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$platform$daemon$BDaemonSession = BDaemonSession.class("[Lcom.tridium.platform.daemon.BDaemonSession;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
iconConnected = BIcon.std((String)"platform.png");
|
|
iconDisconnected = BIcon.std((String)"platformDisconnected.png");
|
|
tunnelIconConnected = BIcon.std((String)"platformTunnel.png");
|
|
tunnelIconDisconnected = BIcon.std((String)"platformTunnelDisconnected.png");
|
|
debug = false;
|
|
DEFAULT_TIMEOUT = 60000;
|
|
debug = Boolean.valueOf(System.getProperty("niagara.daemonsession.debug", "false"));
|
|
DEFAULT_TIMEOUT = debug ? 0 : Integer.parseInt(System.getProperty("niagara.daemonsession.timeout", "60000"));
|
|
requiredVersion = new Version("3");
|
|
requiredVersionForTunnel = new Version("3.5");
|
|
rebootMessage = new RebootMessage(false);
|
|
forceRebootMessage = new RebootMessage(true);
|
|
brandIdHolder = null;
|
|
log = Log.getLog((String)"platform.daemonSession");
|
|
}
|
|
|
|
public static class Stream
|
|
extends FilterInputStream {
|
|
private HttpConnection conn;
|
|
|
|
public String getContentType() {
|
|
return this.conn.getResponseHeader("Content-Type");
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void close() throws IOException {
|
|
try {
|
|
super.close();
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var2_2 = null;
|
|
this.conn.close();
|
|
throw throwable;
|
|
}
|
|
{
|
|
Object var2_3 = null;
|
|
}
|
|
this.conn.close();
|
|
}
|
|
|
|
public Stream(HttpConnection httpConnection) throws IOException {
|
|
super(httpConnection.getInputStream());
|
|
this.conn = httpConnection;
|
|
}
|
|
}
|
|
|
|
private static class RebootMessage
|
|
extends DaemonMessage {
|
|
private boolean force;
|
|
|
|
public String getMessageString() {
|
|
return "reboot?force=" + this.force;
|
|
}
|
|
|
|
public int getConnectionFlags() {
|
|
return 4;
|
|
}
|
|
|
|
public RebootMessage(boolean bl) {
|
|
this.force = bl;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
private class AgentTypeComparator
|
|
implements Comparator {
|
|
private Context context;
|
|
|
|
public int compare(Object object, Object object2) {
|
|
AgentInfo agentInfo = (AgentInfo)object;
|
|
AgentInfo agentInfo2 = (AgentInfo)object2;
|
|
return agentInfo.getDisplayName(this.context).compareTo(agentInfo2.getDisplayName(this.context));
|
|
}
|
|
|
|
public AgentTypeComparator(Context context) {
|
|
this.context = context;
|
|
}
|
|
}
|
|
}
|
|
|