816 lines
31 KiB
Java
816 lines
31 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.sys.Nre
|
|
* com.tridium.sys.NreLib
|
|
* com.tridium.sys.license.Brand
|
|
* javax.baja.data.BIDataValue
|
|
* javax.baja.io.net.IServerSocketFactory
|
|
* javax.baja.log.Log
|
|
* javax.baja.security.AuthenticationException
|
|
* javax.baja.security.DigestFactory
|
|
* javax.baja.security.crypto.BSslTlsEnum
|
|
* javax.baja.security.crypto.BTlsEnum
|
|
* javax.baja.security.crypto.CertManagerFactory
|
|
* javax.baja.security.crypto.ICryptoManagerEx
|
|
* javax.baja.space.BComponentSpace
|
|
* javax.baja.sys.Action
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BComplex
|
|
* javax.baja.sys.BComponent
|
|
* javax.baja.sys.BFacets
|
|
* javax.baja.sys.BIService
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BInteger
|
|
* javax.baja.sys.BRelTime
|
|
* javax.baja.sys.BString
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.BajaRuntimeException
|
|
* javax.baja.sys.Clock
|
|
* javax.baja.sys.Clock$Ticket
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.Property
|
|
* javax.baja.sys.Slot
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Type
|
|
* javax.baja.util.Lexicon
|
|
* javax.baja.util.Version
|
|
*/
|
|
package com.tridium.fox.sys;
|
|
|
|
import com.tridium.fox.message.FoxMessage;
|
|
import com.tridium.fox.session.Fox;
|
|
import com.tridium.fox.session.FoxConnection;
|
|
import com.tridium.fox.session.FoxServer;
|
|
import com.tridium.fox.session.FoxSession;
|
|
import com.tridium.fox.session.Tuner;
|
|
import com.tridium.fox.sys.Acceptor;
|
|
import com.tridium.fox.sys.BFoxAuthenticationPolicy;
|
|
import com.tridium.fox.sys.BFoxServerConnection;
|
|
import com.tridium.fox.sys.BFoxTunnelServerConnection;
|
|
import com.tridium.fox.sys.BServerConnections;
|
|
import com.tridium.fox.sys.NiagaraNetwork;
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.NreLib;
|
|
import com.tridium.sys.license.Brand;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Method;
|
|
import java.net.BindException;
|
|
import java.net.InetAddress;
|
|
import java.net.ServerSocket;
|
|
import java.util.ArrayList;
|
|
import javax.baja.data.BIDataValue;
|
|
import javax.baja.io.net.IServerSocketFactory;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.security.AuthenticationException;
|
|
import javax.baja.security.DigestFactory;
|
|
import javax.baja.security.crypto.BSslTlsEnum;
|
|
import javax.baja.security.crypto.BTlsEnum;
|
|
import javax.baja.security.crypto.CertManagerFactory;
|
|
import javax.baja.security.crypto.ICryptoManagerEx;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BIService;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BInteger;
|
|
import javax.baja.sys.BRelTime;
|
|
import javax.baja.sys.BString;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.Clock;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.util.Lexicon;
|
|
import javax.baja.util.Version;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BFoxService
|
|
extends BComponent
|
|
implements BIService {
|
|
public static final Property port = BFoxService.newProperty((int)0, (int)1911, null);
|
|
public static final Property foxEnabled = BFoxService.newProperty((int)0, (boolean)true, null);
|
|
public static final Property foxsPort = BFoxService.newProperty((int)0, (int)4911, null);
|
|
public static final Property foxsEnabled = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property foxsOnly = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property foxsMinProtocol = BFoxService.newProperty((int)5, (BValue)BSslTlsEnum.tlsv1, null);
|
|
public static final Property tlsMinProtocol = BFoxService.newProperty((int)4, (BValue)BTlsEnum.tlsv1, null);
|
|
public static final Property foxsCert = BFoxService.newProperty((int)0, (String)"tridium", (BFacets)BFacets.make((String)"fieldEditor", (BIDataValue)BString.make((String)"workbench:CertificateAliasFE")));
|
|
public static final Property authenticationPolicy = BFoxService.newProperty((int)0, (BValue)BFoxAuthenticationPolicy.digest, null);
|
|
public static final Property legacyAuthentication = BFoxService.newProperty((int)0, (BValue)BAbsTime.NULL, (BFacets)BFacets.make((String)"fieldEditor", (String)"workbench:RelaxedFE"));
|
|
public static final Property requestTimeout = BFoxService.newProperty((int)0, (BValue)BRelTime.make((long)Fox.requestTimeout), (BFacets)BFacets.make((String)"min", (BIDataValue)BRelTime.make((long)1L)));
|
|
public static final Property socketOptionTimeout = BFoxService.newProperty((int)0, (BValue)BRelTime.make((long)Fox.soTimeout), (BFacets)BFacets.make((String)"min", (BIDataValue)BRelTime.make((long)1L)));
|
|
public static final Property socketTcpNoDelay = BFoxService.newProperty((int)0, (boolean)true, null);
|
|
public static final Property keepAliveInterval = BFoxService.newProperty((int)0, (BValue)BRelTime.make((long)Fox.keepAliveInterval), null);
|
|
public static final Property maxServerSessions = BFoxService.newProperty((int)0, (int)Fox.maxServerSessions, null);
|
|
public static final Property multicastEnabled = BFoxService.newProperty((int)0, (boolean)true, null);
|
|
public static final Property enableAnnouncement = BFoxService.newProperty((int)0, (boolean)true, null);
|
|
public static final Property multicastTimeToLive = BFoxService.newProperty((int)0, (int)Fox.multicastTimeToLive, null);
|
|
public static final Property serverConnections = BFoxService.newProperty((int)0, (BValue)new BServerConnections(), null);
|
|
public static final Property traceSessionStates = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property traceReadFrame = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property traceWriteFrame = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property traceMulticast = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property tunnelingEnabled = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Property onlyTunnelKnownStations = BFoxService.newProperty((int)0, (boolean)false, null);
|
|
public static final Action delayStationStarted = BFoxService.newAction((int)4, null);
|
|
public static final Action checkLegacyAuth = BFoxService.newAction((int)4, null);
|
|
public static final Type TYPE;
|
|
private static final Type[] serviceTypes;
|
|
private static final BIcon icon;
|
|
public static final Log log;
|
|
private static final Version FOXS_MIN_PROTOCOL_VERSION;
|
|
private Daemon daemon;
|
|
private Clock.Ticket restartTicket;
|
|
private Clock.Ticket legacyAuthCheckTicket;
|
|
private boolean tlsMinProtocolChecked;
|
|
static /* synthetic */ Class class$com$tridium$fox$sys$BFoxService;
|
|
static /* synthetic */ Class class$java$lang$String;
|
|
|
|
public int getPort() {
|
|
return this.getInt(port);
|
|
}
|
|
|
|
public void setPort(int n) {
|
|
this.setInt(port, n, null);
|
|
}
|
|
|
|
public boolean getFoxEnabled() {
|
|
return this.getBoolean(foxEnabled);
|
|
}
|
|
|
|
public void setFoxEnabled(boolean bl) {
|
|
this.setBoolean(foxEnabled, bl, null);
|
|
}
|
|
|
|
public int getFoxsPort() {
|
|
return this.getInt(foxsPort);
|
|
}
|
|
|
|
public void setFoxsPort(int n) {
|
|
this.setInt(foxsPort, n, null);
|
|
}
|
|
|
|
public boolean getFoxsEnabled() {
|
|
return this.getBoolean(foxsEnabled);
|
|
}
|
|
|
|
public void setFoxsEnabled(boolean bl) {
|
|
this.setBoolean(foxsEnabled, bl, null);
|
|
}
|
|
|
|
public boolean getFoxsOnly() {
|
|
return this.getBoolean(foxsOnly);
|
|
}
|
|
|
|
public void setFoxsOnly(boolean bl) {
|
|
this.setBoolean(foxsOnly, bl, null);
|
|
}
|
|
|
|
public BSslTlsEnum getFoxsMinProtocol() {
|
|
return (BSslTlsEnum)this.get(foxsMinProtocol);
|
|
}
|
|
|
|
public void setFoxsMinProtocol(BSslTlsEnum bSslTlsEnum) {
|
|
this.set(foxsMinProtocol, (BValue)bSslTlsEnum, null);
|
|
}
|
|
|
|
public BTlsEnum getTlsMinProtocol() {
|
|
return (BTlsEnum)this.get(tlsMinProtocol);
|
|
}
|
|
|
|
public void setTlsMinProtocol(BTlsEnum bTlsEnum) {
|
|
this.set(tlsMinProtocol, (BValue)bTlsEnum, null);
|
|
}
|
|
|
|
public String getFoxsCert() {
|
|
return this.getString(foxsCert);
|
|
}
|
|
|
|
public void setFoxsCert(String string) {
|
|
this.setString(foxsCert, string, null);
|
|
}
|
|
|
|
public BFoxAuthenticationPolicy getAuthenticationPolicy() {
|
|
return (BFoxAuthenticationPolicy)this.get(authenticationPolicy);
|
|
}
|
|
|
|
public void setAuthenticationPolicy(BFoxAuthenticationPolicy bFoxAuthenticationPolicy) {
|
|
this.set(authenticationPolicy, (BValue)bFoxAuthenticationPolicy, null);
|
|
}
|
|
|
|
public BAbsTime getLegacyAuthentication() {
|
|
return (BAbsTime)this.get(legacyAuthentication);
|
|
}
|
|
|
|
public void setLegacyAuthentication(BAbsTime bAbsTime) {
|
|
this.set(legacyAuthentication, (BValue)bAbsTime, null);
|
|
}
|
|
|
|
public BRelTime getRequestTimeout() {
|
|
return (BRelTime)this.get(requestTimeout);
|
|
}
|
|
|
|
public void setRequestTimeout(BRelTime bRelTime) {
|
|
this.set(requestTimeout, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public BRelTime getSocketOptionTimeout() {
|
|
return (BRelTime)this.get(socketOptionTimeout);
|
|
}
|
|
|
|
public void setSocketOptionTimeout(BRelTime bRelTime) {
|
|
this.set(socketOptionTimeout, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public boolean getSocketTcpNoDelay() {
|
|
return this.getBoolean(socketTcpNoDelay);
|
|
}
|
|
|
|
public void setSocketTcpNoDelay(boolean bl) {
|
|
this.setBoolean(socketTcpNoDelay, bl, null);
|
|
}
|
|
|
|
public BRelTime getKeepAliveInterval() {
|
|
return (BRelTime)this.get(keepAliveInterval);
|
|
}
|
|
|
|
public void setKeepAliveInterval(BRelTime bRelTime) {
|
|
this.set(keepAliveInterval, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public int getMaxServerSessions() {
|
|
return this.getInt(maxServerSessions);
|
|
}
|
|
|
|
public void setMaxServerSessions(int n) {
|
|
this.setInt(maxServerSessions, n, null);
|
|
}
|
|
|
|
public boolean getMulticastEnabled() {
|
|
return this.getBoolean(multicastEnabled);
|
|
}
|
|
|
|
public void setMulticastEnabled(boolean bl) {
|
|
this.setBoolean(multicastEnabled, bl, null);
|
|
}
|
|
|
|
public boolean getEnableAnnouncement() {
|
|
return this.getBoolean(enableAnnouncement);
|
|
}
|
|
|
|
public void setEnableAnnouncement(boolean bl) {
|
|
this.setBoolean(enableAnnouncement, bl, null);
|
|
}
|
|
|
|
public int getMulticastTimeToLive() {
|
|
return this.getInt(multicastTimeToLive);
|
|
}
|
|
|
|
public void setMulticastTimeToLive(int n) {
|
|
this.setInt(multicastTimeToLive, n, null);
|
|
}
|
|
|
|
public BServerConnections getServerConnections() {
|
|
return (BServerConnections)this.get(serverConnections);
|
|
}
|
|
|
|
public void setServerConnections(BServerConnections bServerConnections) {
|
|
this.set(serverConnections, (BValue)bServerConnections, null);
|
|
}
|
|
|
|
public boolean getTraceSessionStates() {
|
|
return this.getBoolean(traceSessionStates);
|
|
}
|
|
|
|
public void setTraceSessionStates(boolean bl) {
|
|
this.setBoolean(traceSessionStates, bl, null);
|
|
}
|
|
|
|
public boolean getTraceReadFrame() {
|
|
return this.getBoolean(traceReadFrame);
|
|
}
|
|
|
|
public void setTraceReadFrame(boolean bl) {
|
|
this.setBoolean(traceReadFrame, bl, null);
|
|
}
|
|
|
|
public boolean getTraceWriteFrame() {
|
|
return this.getBoolean(traceWriteFrame);
|
|
}
|
|
|
|
public void setTraceWriteFrame(boolean bl) {
|
|
this.setBoolean(traceWriteFrame, bl, null);
|
|
}
|
|
|
|
public boolean getTraceMulticast() {
|
|
return this.getBoolean(traceMulticast);
|
|
}
|
|
|
|
public void setTraceMulticast(boolean bl) {
|
|
this.setBoolean(traceMulticast, bl, null);
|
|
}
|
|
|
|
public boolean getTunnelingEnabled() {
|
|
return this.getBoolean(tunnelingEnabled);
|
|
}
|
|
|
|
public void setTunnelingEnabled(boolean bl) {
|
|
this.setBoolean(tunnelingEnabled, bl, null);
|
|
}
|
|
|
|
public boolean getOnlyTunnelKnownStations() {
|
|
return this.getBoolean(onlyTunnelKnownStations);
|
|
}
|
|
|
|
public void setOnlyTunnelKnownStations(boolean bl) {
|
|
this.setBoolean(onlyTunnelKnownStations, bl, null);
|
|
}
|
|
|
|
public void delayStationStarted() {
|
|
this.invoke(delayStationStarted, null, null);
|
|
}
|
|
|
|
public void checkLegacyAuth() {
|
|
this.invoke(checkLegacyAuth, null, null);
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public Type[] getServiceTypes() {
|
|
return serviceTypes;
|
|
}
|
|
|
|
public boolean isServing() {
|
|
Daemon daemon = this.daemon;
|
|
boolean bl = false;
|
|
if (daemon != null && daemon.isServing()) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public void stationStarted() {
|
|
int n = -1;
|
|
int n2 = -1;
|
|
try {
|
|
ArrayList<String> arrayList = new ArrayList<String>();
|
|
ArrayList<String> arrayList2 = new ArrayList<String>();
|
|
this.serviceStopped();
|
|
this.initOptions();
|
|
if (this.getFoxEnabled()) {
|
|
n = this.getFoxPort();
|
|
}
|
|
if (this.getFoxsEnabled()) {
|
|
n2 = this.getFoxsPort();
|
|
}
|
|
this.daemon = new Daemon(this, n, n2);
|
|
this.daemon.run();
|
|
arrayList.add("foxport");
|
|
arrayList2.add(String.valueOf(n));
|
|
arrayList.add("foxsport");
|
|
arrayList2.add(String.valueOf(n2));
|
|
Nre.getPlatform().reportSummaryFields(arrayList.toArray(new String[0]), arrayList2.toArray(new String[0]));
|
|
this.doCheckLegacyAuth();
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Cannot start", (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public void serviceStarted() {
|
|
try {
|
|
Nre.serviceManager.getService("platCrypto:CertManagerService");
|
|
this.setFacets((Slot)tlsMinProtocol, BFacets.make((String)"supportsTlsMinProtocol", (boolean)true));
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) & 0xFFFFFFFB);
|
|
this.setFlags((Slot)foxsPort, this.getFlags((Slot)foxsPort) & 0xFFFFFFFA);
|
|
this.setFlags((Slot)foxsEnabled, this.getFlags((Slot)foxsEnabled) & 0xFFFFFFFA);
|
|
this.setFlags((Slot)foxsOnly, this.getFlags((Slot)foxsOnly) & 0xFFFFFFFA);
|
|
this.setFlags((Slot)foxsCert, this.getFlags((Slot)foxsCert) & 0xFFFFFFFA);
|
|
try {
|
|
Class<?> clazz = Class.forName("javax.net.ssl.SSLContext");
|
|
Class[] classArray = new Class[1];
|
|
Class clazz2 = class$java$lang$String;
|
|
if (clazz2 == null) {
|
|
clazz2 = class$java$lang$String = BFoxService.class("[Ljava.lang.String;", false);
|
|
}
|
|
classArray[0] = clazz2;
|
|
Method method = clazz.getMethod("getInstance", classArray);
|
|
method.invoke(null, "TLSv1.1");
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) & 0xFFFFFFFA);
|
|
this.setFacets((Slot)tlsMinProtocol, BFacets.make((String)"supportsTls11AndAbove", (boolean)true));
|
|
}
|
|
catch (Exception exception) {
|
|
this.setTlsMinProtocol(BTlsEnum.tlsv1);
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) | 1);
|
|
this.setFacets((Slot)tlsMinProtocol, BFacets.make((String)"supportsTls11AndAbove", (boolean)false));
|
|
log.message("Only TLSv1 is supported on this platform, forcing to TLSv1");
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
if (this.getFoxsEnabled()) {
|
|
log.warning("Foxs is unsupported on this device. Using fox instead.");
|
|
}
|
|
this.setFoxEnabled(true);
|
|
this.setFlags((Slot)foxsPort, this.getFlags((Slot)foxsPort) | 1 | 4);
|
|
this.setFoxsEnabled(false);
|
|
this.setFlags((Slot)foxsEnabled, this.getFlags((Slot)foxsEnabled) | 1 | 4);
|
|
this.setFoxsOnly(false);
|
|
this.setFlags((Slot)foxsOnly, this.getFlags((Slot)foxsOnly) | 1 | 4);
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) | 1 | 4);
|
|
this.setFlags((Slot)foxsCert, this.getFlags((Slot)foxsCert) | 1 | 4);
|
|
}
|
|
}
|
|
|
|
public void serviceStopped() {
|
|
if (this.daemon != null) {
|
|
log.message("Service stopped");
|
|
this.daemon.stop();
|
|
}
|
|
this.daemon = null;
|
|
}
|
|
|
|
private final void initOptions() {
|
|
Fox.appName = "Station";
|
|
Fox.appVersion = "" + Sys.getBajaModule().getVendorVersion();
|
|
Fox.hostName = Sys.getLocalHost().getHostName();
|
|
Fox.hostAddress = Sys.getLocalHost().getHostAddress();
|
|
Fox.ipv4Enabled = NreLib.getLocalHost((boolean)false).isLoopbackAddress() ^ true;
|
|
boolean bl = false;
|
|
if (Fox.ipv6Enabled && !NreLib.getLocalHost((boolean)true).isLoopbackAddress()) {
|
|
bl = true;
|
|
}
|
|
Fox.ipv6Enabled = bl;
|
|
Fox.requestTimeout = (int)this.getRequestTimeout().getMillis();
|
|
Fox.keepAliveInterval = (int)this.getKeepAliveInterval().getMillis();
|
|
Fox.soTimeout = (int)this.getSocketOptionTimeout().getMillis();
|
|
Fox.tcpNoDelay = this.getSocketTcpNoDelay();
|
|
Fox.multicastEnabled = this.getMulticastEnabled();
|
|
Fox.multicastTimeToLive = this.getMulticastTimeToLive();
|
|
Fox.maxServerSessions = this.getMaxServerSessions();
|
|
Fox.traceSessionStates = this.getTraceSessionStates();
|
|
Fox.traceReadFrame = this.getTraceReadFrame();
|
|
Fox.traceWriteFrame = this.getTraceWriteFrame();
|
|
Fox.traceMulticast = this.getTraceMulticast();
|
|
Fox.tunnelingEnabled = this.getTunnelingEnabled();
|
|
Fox.onlyTunnelKnownStations = this.getOnlyTunnelKnownStations();
|
|
Acceptor.foxTunnelingLicensed();
|
|
}
|
|
|
|
public static BFoxService waitUntilPortOpen(long l) {
|
|
try {
|
|
BFoxService bFoxService = (BFoxService)Sys.getService((Type)TYPE);
|
|
long l2 = Clock.ticks();
|
|
while (!bFoxService.isServing()) {
|
|
if (Clock.ticks() - l2 > l) {
|
|
throw new BajaRuntimeException("BFoxService.waitUntilPortOpen timed out");
|
|
}
|
|
Thread.sleep(100L);
|
|
}
|
|
return bFoxService;
|
|
}
|
|
catch (BajaRuntimeException bajaRuntimeException) {
|
|
throw bajaRuntimeException;
|
|
}
|
|
catch (Exception exception) {
|
|
System.out.println("ERROR: BFoxService.waitUntilPortOpen failed");
|
|
exception.printStackTrace();
|
|
throw new BajaRuntimeException("FoxService.waitUntilPortOpen", (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public boolean isNavChild() {
|
|
BComponentSpace bComponentSpace;
|
|
if (!this.tlsMinProtocolChecked && (bComponentSpace = this.getComponentSpace()) != null && bComponentSpace.isProxyComponentSpace()) {
|
|
this.tlsMinProtocolChecked = true;
|
|
Version version = (Version)this.fw(404, "baja", null, null, null);
|
|
if (version != null && !version.isNull() && version.compareTo((Object)FOXS_MIN_PROTOCOL_VERSION) >= 0) {
|
|
this.loadSlots();
|
|
this.setFoxsMinProtocol(BSslTlsEnum.tlsv1);
|
|
this.setFlags((Slot)foxsMinProtocol, 5);
|
|
BFacets bFacets = this.getSlotFacets((Slot)tlsMinProtocol);
|
|
if (bFacets != null) {
|
|
boolean bl = bFacets.getb("supportsTlsMinProtocol", false);
|
|
if (!bl) {
|
|
this.setFlags((Slot)tlsMinProtocol, 5, Context.commit);
|
|
} else {
|
|
boolean bl2 = bFacets.getb("supportsTls11AndAbove", false);
|
|
if (bl2) {
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) & 0xFFFFFFFA);
|
|
} else {
|
|
this.setFlags((Slot)tlsMinProtocol, this.getFlags((Slot)tlsMinProtocol) & 0xFFFFFFFB | 1);
|
|
}
|
|
}
|
|
} else {
|
|
this.setFlags((Slot)tlsMinProtocol, 4, Context.commit);
|
|
}
|
|
}
|
|
}
|
|
return super.isNavChild();
|
|
}
|
|
|
|
public void changed(Property property, Context context) {
|
|
super.changed(property, context);
|
|
if (!this.isRunning()) {
|
|
return;
|
|
}
|
|
if (property == port || property == foxsPort) {
|
|
this.triggerDelayedStationStarted();
|
|
} else if (property == foxsCert || property == tlsMinProtocol || property == foxsOnly) {
|
|
if (this.getFoxsEnabled()) {
|
|
this.triggerDelayedStationStarted();
|
|
}
|
|
} else if (property == foxEnabled || property == foxsEnabled || property == multicastEnabled) {
|
|
this.triggerDelayedStationStarted();
|
|
} else {
|
|
this.initOptions();
|
|
}
|
|
}
|
|
|
|
private final synchronized void triggerDelayedStationStarted() {
|
|
this.triggerDelayedStationStarted(500L);
|
|
}
|
|
|
|
private final synchronized void triggerDelayedStationStarted(long l) {
|
|
if (this.restartTicket == null) {
|
|
this.restartTicket = Clock.schedule((BComponent)this, (BRelTime)BRelTime.make((long)l), (Action)delayStationStarted, null);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void doDelayStationStarted() {
|
|
BFoxService bFoxService = this;
|
|
synchronized (bFoxService) {
|
|
this.restartTicket = null;
|
|
// MONITOREXIT @DISABLED, blocks:[0, 1] lbl5 : MonitorExitStatement: MONITOREXIT : var1_1
|
|
this.stationStarted();
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void doCheckLegacyAuth() {
|
|
BAbsTime bAbsTime;
|
|
Class clazz = class$com$tridium$fox$sys$BFoxService;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$fox$sys$BFoxService = BFoxService.class("[Lcom.tridium.fox.sys.BFoxService;", false);
|
|
}
|
|
Lexicon lexicon = Lexicon.make((Class)clazz);
|
|
if (this.legacyAuthCheckTicket != null) {
|
|
this.legacyAuthCheckTicket.cancel();
|
|
}
|
|
if (!(bAbsTime = this.getLegacyAuthentication()).isNull()) {
|
|
if (bAbsTime.isBefore(BAbsTime.now())) {
|
|
log.warning(lexicon.getText("fox.legacy.relaxed.expired"));
|
|
} else {
|
|
log.warning(lexicon.getText("fox.legacy.relaxed"));
|
|
if (BAbsTime.now().delta(bAbsTime).getDays() < 7) {
|
|
log.warning(lexicon.getText("fox.legacy.relaxed.expiring", new Object[]{bAbsTime}));
|
|
}
|
|
}
|
|
}
|
|
BAbsTime bAbsTime2 = Clock.time().timeOfDay(1, 0, 0, 0).nextDay();
|
|
this.legacyAuthCheckTicket = Clock.schedule((BComponent)this, (BAbsTime)bAbsTime2, (Action)checkLegacyAuth, null);
|
|
}
|
|
|
|
public BFoxServerConnection makeServerConnection(FoxSession foxSession, FoxMessage foxMessage) throws Exception {
|
|
BFoxServerConnection bFoxServerConnection = new BFoxServerConnection();
|
|
this.getServerConnections().add("Session" + foxSession.getId(), (BValue)bFoxServerConnection, 3);
|
|
return bFoxServerConnection;
|
|
}
|
|
|
|
public FoxServer getFoxServer() {
|
|
return this.daemon;
|
|
}
|
|
|
|
public int getFoxPort() {
|
|
return this.getPort();
|
|
}
|
|
|
|
public static NiagaraNetwork getNiagaraNetwork() {
|
|
BFoxService bFoxService = (BFoxService)Sys.getService((Type)TYPE);
|
|
BComplex bComplex = bFoxService.getParent();
|
|
while (bComplex != null) {
|
|
if (bComplex instanceof NiagaraNetwork) {
|
|
return (NiagaraNetwork)bComplex;
|
|
}
|
|
bComplex = bComplex.getParent();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void httpSessionClosed(String string) {
|
|
if (string == null) {
|
|
return;
|
|
}
|
|
BFoxService bFoxService = (BFoxService)Sys.getService((Type)TYPE);
|
|
BComponent[] bComponentArray = bFoxService.getServerConnections().getChildComponents();
|
|
if (bComponentArray == null) {
|
|
return;
|
|
}
|
|
int n = 0;
|
|
while (n < bComponentArray.length) {
|
|
String string2;
|
|
BFoxServerConnection bFoxServerConnection = (BFoxServerConnection)bComponentArray[n];
|
|
if (bFoxServerConnection != null && string.equals(string2 = bFoxServerConnection.session().getRemoteHello().getString("httpSession", null))) {
|
|
bFoxServerConnection.close();
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
public static int getHttpPort() {
|
|
try {
|
|
Type type = Sys.getType((String)"web:WebService");
|
|
BComponent bComponent = Sys.getService((Type)type);
|
|
BInteger bInteger = (BInteger)bComponent.get("httpPort");
|
|
return bInteger.getInt();
|
|
}
|
|
catch (Exception exception) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public static boolean auditConnection(FoxSession foxSession) {
|
|
String string = foxSession.getRemoteHello().getString("app.name", "Station");
|
|
return string.equals("Station") ^ true;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
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.restartTicket = null;
|
|
this.legacyAuthCheckTicket = null;
|
|
this.tlsMinProtocolChecked = false;
|
|
}
|
|
|
|
public BFoxService() {
|
|
this.this();
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$fox$sys$BFoxService;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$fox$sys$BFoxService = BFoxService.class("[Lcom.tridium.fox.sys.BFoxService;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
serviceTypes = new Type[]{TYPE};
|
|
icon = BIcon.std((String)"fox.png");
|
|
log = Log.getLog((String)"fox");
|
|
FOXS_MIN_PROTOCOL_VERSION = new Version("3.7.0");
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class Daemon
|
|
extends FoxServer {
|
|
private BFoxService service;
|
|
|
|
public void run() {
|
|
try {
|
|
super.run();
|
|
}
|
|
catch (Exception exception) {}
|
|
}
|
|
|
|
public ServerSocket getFoxsServerSocket() throws IOException {
|
|
ICryptoManagerEx iCryptoManagerEx;
|
|
try {
|
|
iCryptoManagerEx = CertManagerFactory.getInstanceEx();
|
|
}
|
|
catch (Exception exception) {
|
|
throw new IOException("Unable to get crypto service instance");
|
|
}
|
|
try {
|
|
IServerSocketFactory iServerSocketFactory = iCryptoManagerEx.getServerSocketFactory(this.service.getTlsMinProtocol().getTag(), false, this.service.getFoxsCert());
|
|
return iServerSocketFactory.createServerSocket(BFoxService.this.getFoxsPort(), 10);
|
|
}
|
|
catch (BindException bindException) {
|
|
throw bindException;
|
|
}
|
|
catch (Exception exception) {
|
|
if (log.isTraceOn()) {
|
|
exception.printStackTrace();
|
|
}
|
|
if (!BFoxService.this.getFoxEnabled() || BFoxService.this.getFoxsOnly()) {
|
|
log.warning("Unable to start foxs, enabling fox connectivity!");
|
|
BFoxService.this.setFoxEnabled(true);
|
|
BFoxService.this.setFoxsOnly(false);
|
|
}
|
|
throw new IOException("Unable to create socket: " + exception.getLocalizedMessage());
|
|
}
|
|
}
|
|
|
|
public FoxConnection makeConnection(FoxSession foxSession, FoxMessage foxMessage) throws Exception {
|
|
if (foxSession == null) {
|
|
return new BFoxTunnelServerConnection();
|
|
}
|
|
return BFoxService.this.makeServerConnection(foxSession, foxMessage);
|
|
}
|
|
|
|
public FoxMessage getAnnouncement() {
|
|
InetAddress inetAddress;
|
|
if (!BFoxService.this.getEnableAnnouncement()) {
|
|
return null;
|
|
}
|
|
FoxMessage foxMessage = new FoxMessage();
|
|
foxMessage.add("station", Sys.getStation().getStationName());
|
|
if (Fox.ipv4Enabled && !(inetAddress = NreLib.getLocalHost((boolean)false)).isLoopbackAddress()) {
|
|
foxMessage.add("hostName", inetAddress.getHostName());
|
|
foxMessage.add("hostAddress", inetAddress.getHostAddress());
|
|
}
|
|
if (Fox.ipv6Enabled && !(inetAddress = NreLib.getLocalHost((boolean)true)).isLoopbackAddress()) {
|
|
foxMessage.add("hostNameIPv6", inetAddress.getHostName());
|
|
foxMessage.add("hostAddressIPv6", inetAddress.getHostAddress());
|
|
}
|
|
if (BFoxService.this.getFoxEnabled()) {
|
|
foxMessage.add("foxPort", BFoxService.this.getFoxPort());
|
|
}
|
|
if (BFoxService.this.getFoxsEnabled()) {
|
|
foxMessage.add("foxsPort", BFoxService.this.getFoxsPort());
|
|
}
|
|
foxMessage.add("httpPort", BFoxService.getHttpPort());
|
|
foxMessage.add("version", Sys.getBajaModule().getVendorVersion().toString());
|
|
foxMessage.add("hostId", Nre.getHostId());
|
|
foxMessage.add("hostModel", Nre.getHostModel());
|
|
foxMessage.add("brandId", Brand.getBrandId());
|
|
foxMessage.add("vmName", Fox.vmName);
|
|
foxMessage.add("vmVersion", Fox.vmVersion);
|
|
foxMessage.add("osName", Fox.osName);
|
|
foxMessage.add("osVersion", Fox.osVersion);
|
|
return foxMessage;
|
|
}
|
|
|
|
public int getAuthenticationPolicy() {
|
|
return BFoxService.this.getAuthenticationPolicy().getOrdinal();
|
|
}
|
|
|
|
public boolean authenticateBasic(FoxSession foxSession, String string, String string2) throws Exception {
|
|
throw new AuthenticationException("Unsupported method call authenticateBasic in BFoxService. This call should be handled by an Authentication Agent.");
|
|
}
|
|
|
|
public boolean authenticateDigest(FoxSession foxSession, String string, byte[] byArray, byte[] byArray2) throws Exception {
|
|
throw new AuthenticationException("Unsupported method call authenticateDigest in BFoxService. This call should be handled by an Authentication Agent.");
|
|
}
|
|
|
|
public Daemon(BFoxService bFoxService2, int n, int n2) {
|
|
super(n, n2);
|
|
this.service = bFoxService2;
|
|
}
|
|
}
|
|
|
|
static class FoxDigestFactory
|
|
implements DigestFactory {
|
|
byte[] nonce;
|
|
|
|
public byte[] makeDigest(String string, String string2) {
|
|
try {
|
|
return Tuner.generateDigest(string, string2, this.nonce);
|
|
}
|
|
catch (Exception exception) {
|
|
throw new BajaRuntimeException((Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public byte[] getNonce() {
|
|
return this.nonce;
|
|
}
|
|
|
|
FoxDigestFactory(byte[] byArray) {
|
|
this.nonce = byArray;
|
|
}
|
|
}
|
|
}
|
|
|