/// <summary>
///
/// </summary>
/// <param name="token"></param>
/// <param name="logger"></param>
public virtual void Apply(ProxyToken token, Logger logger)
{
token.Status = Block ? NetStatusCodes.Blocked : NetStatusCodes.Success;
token.Graph = Graph;
token.Client = Client;
List <INetworkLayer> layers = new List <INetworkLayer>(Layers.CreateLayers(logger));
if (token.Layers != null)
{
switch (MergePolicy)
{
case LayerMergePolicy.Prefix:
layers.AddRange(token.Layers);
break;
case LayerMergePolicy.Suffix:
layers.InsertRange(0, token.Layers);
break;
default:
// Do nothing
break;
}
}
token.Layers = layers.ToArray();
}
private ProxyToken HandleConnectRequest(DataAdapterToStream stm)
{
ProxyToken ret = null;
int version = stm.ReadByte();
if (IsSupported(version))
{
if (version == 4)
{
_logger.LogVerbose(CANAPE.Net.Properties.Resources.SocksProxyServer_NewV4ConnectionLog);
ret = HandleSocksv4Request(stm);
}
else if (version == 5)
{
_logger.LogVerbose(CANAPE.Net.Properties.Resources.SocksProxyServer_NewV5ConnectionLog);
ret = HandleSocksv5Request(stm);
}
}
else
{
_logger.LogError(CANAPE.Net.Properties.Resources.SocksProxyServer_UnsupportedVersionLog, version);
}
return(ret);
}
/// <summary>
/// Encode a ProxyToken to base64 JWT, and sign it with the private key
/// provided by the certificate.
/// </summary>
/// <param name="payload">
/// The ProxyToken to be encoded.
/// </param>
/// <param name="signingCertificate">
/// The X509Certificate which includes the private key to sign the JWT.
/// </param>
/// <returns>
/// The base64 encoded JWT with signature appended.
/// </returns>
public static string Encode(ProxyToken payload, X509Certificate2 signingCertificate)
{
// header, payload and signature are joint by dot
// header.payload.signature
var segments = new List <string>();
// RS256 is the ONLY algorithm that works
var header = new JwtHeader {
typ = Type, alg = SigningAlgorithm
};
// x5t is the base64 encoded SHA1 hash of the certificate
// must use SHA1 hash algorithm here
header.x5t = Base64Helper.Base64Encode(signingCertificate.GetCertHash());
// header and payload should be encoded using UTF8
var base64header = Base64Helper.Base64Encode(Encoding.UTF8.GetBytes(header.ToString()));
var base64payload = Base64Helper.Base64Encode(Encoding.UTF8.GetBytes(payload.ToString()));
segments.Add(base64header);
segments.Add(base64payload);
// what we sign is the base64 encoded result
var stringToSign = string.Join(".", segments.ToArray());
// sign the data: header and payload
var signature = RSASigningHelper.SignData(
// data to be signed should use ASCII encoding
Encoding.ASCII.GetBytes(stringToSign),
signingCertificate, HashAlgorithm);
segments.Add(Base64Helper.Base64Encode(signature));
return(string.Join(".", segments.ToArray()));
}
private ProxyToken HandleOtherRequest(HttpRequestHeader header, DataAdapterToStream stm, ProxyNetworkService service)
{
Uri url;
if (Uri.TryCreate(header.Path, UriKind.Absolute, out url))
{
// Use generic token so filters don't get used
ProxyToken ret = new ProxyToken();
ret.State.Add("url", url);
ret.State.Add("stm", stm);
ret.State.Add("header", header);
ret.Client = new HttpProxyDummyClient(this, service);
ret.Graph = _factory;
return(ret);
}
else
{
_logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidUrl, header.Path);
// TODO: Put in some decent error codes
ReturnResponse(null, 400, "Bad Request", header.Method, header.Version, stm);
return(null);
}
}
/// <summary>
/// Connect socket.
/// </summary>
/// <param name="token">The proxy token (ignored).</param>
/// <param name="logger">The logger object.</param>
/// <param name="meta">Connection meta-data.</param>
/// <param name="globalMeta">Global meta-data.</param>
/// <param name="properties">Properties for the connection.</param>
/// <returns>The connected data adapater.</returns>
public override IDataAdapter Connect(ProxyToken token, Logger logger,
MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties)
{
IDataAdapter adapter = null;
try
{
Socket socket = new Socket(_endPoint.AddressFamily, SocketType.Stream, _protocolType);
socket.Connect(_endPoint);
NetUtils.PopulateBagFromSocket(socket, properties);
adapter = new StreamSocketDataAdapter(socket);
}
catch (SocketException ex)
{
logger.LogException(ex);
token.Status = NetStatusCodes.ConnectFailure;
}
catch (IOException ex)
{
logger.LogException(ex);
token.Status = NetStatusCodes.ConnectFailure;
}
return(adapter);
}
/// <summary>
///
/// </summary>
/// <param name="token"></param>
/// <param name="client"></param>
/// <param name="globalMeta"></param>
/// <param name="meta"></param>
/// <param name="service"></param>
/// <returns></returns>
public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client)
{
SocksProxyToken socksToken = (SocksProxyToken)token;
if (IsSupported(socksToken.Version))
{
if (socksToken.Version == 4)
{
return(HandleSocksV4Response(socksToken));
}
else if (socksToken.Version == 5)
{
return(HandleSocksV5Response(socksToken));
}
else
{
// We shouldn't get here
throw new InvalidOperationException(CANAPE.Net.Properties.Resources.SocksProxyServer_IsSupportedError);
}
}
else
{
_logger.LogError(CANAPE.Net.Properties.Resources.SocksProxyServer_UnsupportedTokenVersion, socksToken.Version);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="adapter"></param>
/// <param name="meta"></param>
/// <param name="globalMeta"></param>
/// <param name="service"></param>
/// <returns></returns>
public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service)
{
ProxyToken token = null;
if (_config.SslConfig.Enabled)
{
IDataAdapter client = null;
INetworkLayer ssl = new TlsNetworkLayer(_config.SslConfig);
ssl.Negotiate(ref adapter, ref client, null, _logger, null, null,
new PropertyBag("Root"), NetworkLayerBinding.Server);
}
if (adapter is HttpProxyDataAdapter)
{
HttpProxyDataAdapter proxyAdapter = (HttpProxyDataAdapter)adapter;
token = new FullHttpProxyToken(proxyAdapter.Url.Host, proxyAdapter.Url.Port);
token.State.Add("adapter", adapter);
}
else
{
DataAdapterToStream stm = new DataAdapterToStream(adapter);
DataReader reader = new DataReader(stm);
try
{
HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger);
if (HandleProxyAuthentication(reader, stm, ref header))
{
// We just have a connect
if (header.IsConnect)
{
token = HandleConnect(header, stm);
}
else
{
token = HandleOtherRequest(header, stm, service);
}
}
}
catch (HttpStreamParserException ex)
{
_logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message);
// TODO: Put in some decent error codes
ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm);
}
catch (EndOfStreamException)
{
token = null;
}
}
return(token);
}
/// <summary>
/// Connect to the required service with the token
/// </summary>
/// <param name="token">The token recevied from proxy</param>
/// <param name="globalMeta">The global meta</param>
/// <param name="logger">The logger</param>
/// <param name="meta">The meta</param>
/// <param name="properties">Property bag to add any information to</param>
/// <returns>The connected data adapter</returns>
public override IDataAdapter Connect(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties)
{
IpProxyToken iptoken = token as IpProxyToken;
if ((iptoken != null) && IsFiltered(iptoken))
{
return(base.Connect(token, logger, meta, globalMeta, properties));
}
else
{
token.Status = NetStatusCodes.Blocked;
return(null);
}
}
protected internal virtual ProxyToken DeserializeToken(string[] elements, int offset)
{
string indexS = elements[offset + 0];
string typeS = elements[offset + 1];
string channelS = elements[offset + 2];
string lineS = elements[offset + 3];
string posS = elements[offset + 4];
string text = elements[offset + 5];
text = UnEscapeNewlines(text);
int index = int.Parse(indexS, CultureInfo.InvariantCulture);
ProxyToken t = new ProxyToken(index, int.Parse(typeS, CultureInfo.InvariantCulture), int.Parse(channelS, CultureInfo.InvariantCulture), int.Parse(lineS, CultureInfo.InvariantCulture), int.Parse(posS, CultureInfo.InvariantCulture), text);
return(t);
}
/// <summary>
/// Complete the client connection, just returns the original adapter
/// </summary>
/// <param name="token">The proxy token</param>
/// <param name="client"></param>
/// <param name="globalMeta"></param>
/// <param name="meta"></param>
/// <param name="service"></param>
/// <returns>The data adapter</returns>
public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client)
{
PassThroughToken passToken = (PassThroughToken)token;
IDataAdapter adapter = passToken.Adapter;
if (token.Status != NetStatusCodes.Success)
{
return(null);
}
else
{
// Set to null to prevent Dispose being called
passToken.Adapter = null;
return(adapter);
}
}
/// <summary>
/// Negotiate the layer
/// </summary>
/// <param name="server">The server data adapter</param>
/// <param name="client">The client data adapter</param>
/// <param name="token">The associated proxy token</param>
/// <param name="logger">The current service's logger</param>
/// <param name="meta">The current service's meta dictionary</param>
/// <param name="globalMeta">The current global meta dictionary</param>
/// <param name="properties">Additional properties</param>
/// <param name="defaultBinding">The default binding</param>
public void Negotiate(ref IDataAdapter server, ref IDataAdapter client, ProxyToken token, Logger logger,
MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, NetworkLayerBinding defaultBinding)
{
if (_config.Enabled)
{
if (defaultBinding == NetworkLayerBinding.Default)
{
defaultBinding = NetworkLayerBinding.ClientAndServer;
}
if (Binding != NetworkLayerBinding.Default)
{
defaultBinding = Binding;
}
if ((defaultBinding & NetworkLayerBinding.Client) == NetworkLayerBinding.Client)
{
if (_config.ClientProtocol != SslProtocols.None)
{
IpProxyToken iptoken = token as IpProxyToken;
string serverName = null;
if (iptoken != null)
{
if (!String.IsNullOrWhiteSpace(iptoken.Hostname))
{
serverName = iptoken.Hostname;
}
else
{
serverName = iptoken.Address.ToString();
}
}
client = ConnectClient(client, logger, properties, serverName);
}
}
if ((defaultBinding & NetworkLayerBinding.Server) == NetworkLayerBinding.Server)
{
if (_config.ServerProtocol != SslProtocols.None)
{
server = ConnectServerBC(server, logger, properties);
}
}
}
}
/// <summary>
/// The the JWT authToken used in url query string.
/// </summary>
public string GetAuthToken()
{
var proxyToken = new ProxyToken();
proxyToken.ver = "1.0";
proxyToken.deviceregid = String.Empty;
proxyToken.authinstant = DateTime.UtcNow.ToString("O") + "Z";
proxyToken.authmethod = Constraints.DefaultAuthMethod;
proxyToken.aud = Constraints.DefaultProxyRelyingPartyTrustIdentifier;
proxyToken.iss = UrlHelper.CombineUrls(EnvironmentConfig.ADFSServerUrl, AdfsServicePathPairs.Trust);
proxyToken.upn = EnvironmentConfig.AppUserUpn;
proxyToken.iat = Convert.ToInt64(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds);
proxyToken.exp = Convert.ToInt64(TimeSpan.FromHours(1).TotalSeconds) + proxyToken.iat;
proxyToken.relyingpartytrustid = TestEndpointGuid1;
return(PreauthJsonWebToken.Encode(proxyToken, _adfsSigningCertificate));
}
/// <summary>
/// Apply the proxy filter to a token
/// </summary>
/// <param name="token">The tokeb</param>
/// <param name="logger">A logger to log data to</param>
public override void Apply(ProxyToken token, Logger logger)
{
base.Apply(token, logger);
IpProxyToken t = token as IpProxyToken;
if (t != null)
{
if (!String.IsNullOrWhiteSpace(RedirectAddress))
{
t.Hostname = RedirectAddress;
}
if (RedirectPort != 0)
{
t.Port = RedirectPort;
}
}
}
private ProxyToken FilterToken(ProxyToken token)
{
if ((_filters != null) && (_filters.Length > 0))
{
foreach (var filter in _filters)
{
if (!filter.Disabled && filter.Match(token))
{
_logger.LogVerbose(CANAPE.Net.Properties.Resources.ProxyNetworkService_MatchedFilter, filter.ToString());
filter.Apply(token, _logger);
break;
}
}
return(token);
}
return(token);
}
/// <summary>
/// Bind to the required service with the token
/// </summary>
/// <param name="token">The token recevied from proxy</param>
/// <param name="globalMeta">The global meta</param>
/// <param name="logger">The logger</param>
/// <param name="meta">The meta</param>
/// <param name="properties">Property bag to add any information to</param>
/// <returns>The connected data adapter</returns>
public override IDataAdapter Bind(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties)
{
IDataAdapter adapter = null;
IpProxyToken iptoken = token as IpProxyToken;
if (iptoken != null)
{
if (iptoken.ClientType == IpProxyToken.IpClientType.Tcp)
{
adapter = BindTcp(iptoken, logger, properties);
}
else
{
throw new ArgumentException(CANAPE.Net.Properties.Resources.IpProxyClient_InvalidTokenType);
}
}
return(adapter);
}
private ProxyClient BuildProxyClient(ProxyToken token, Logger logger)
{
Uri url = null;
if (token is HttpProxyToken)
{
url = ((HttpProxyToken)token).Url;
}
else if (token is IpProxyToken)
{
IpProxyToken iptoken = token as IpProxyToken;
UriBuilder builder = new UriBuilder();
switch (iptoken.Port)
{
case 443:
builder.Scheme = "https";
break;
case 21:
builder.Scheme = "ftp";
break;
default:
builder.Scheme = "http";
break;
}
builder.Port = iptoken.Port;
builder.Host = iptoken.Hostname ?? iptoken.Address.ToString();
builder.Path = "/";
url = builder.Uri;
}
else
{
throw new ArgumentException(CANAPE.Net.Properties.Resources.ScriptProxyClient_InvalidToken, "token");
}
return(CreateClient(url, logger));
}
/// <summary>
/// Connect the client
/// </summary>
/// <param name="token">The proxy token</param>
/// <param name="logger">The proxy logger instance</param>
/// <param name="meta">The proxy meta data</param>
/// <param name="globalMeta">The proxy global meta data</param>
/// <param name="properties">The proxy property bag</param>
/// <returns>The connected adapter</returns>
public override IDataAdapter Connect(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties)
{
IDataAdapter ret = null;
for (int i = 0; i < _clients.Length; ++i)
{
ret = _clients[i].Connect(token, logger, meta, globalMeta, properties);
if (ret != null)
{
break;
}
}
if ((ret == null) && (token.Status == NetStatusCodes.Success))
{
ret = new IpProxyClient().Connect(token, logger, meta, globalMeta, properties);
}
return(ret);
}
/// <summary>
/// Negotiate method
/// </summary>
/// <param name="server">Server adapter</param>
/// <param name="client">Client adapter</param>
/// <param name="token">The associated proxy token</param>
/// <param name="logger">The associated logger</param>
/// <param name="meta">The associated meta dictionary</param>
/// <param name="globalMeta">The assocaited global meta dictionary</param>
/// <param name="properties">Property bag</param>
/// <param name="defaultBinding">Default layer binding mode</param>
public void Negotiate(ref IDataAdapter server, ref IDataAdapter client, ProxyToken token, Logger logger,
MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, NetworkLayerBinding defaultBinding)
{
Token = token;
Logger = logger;
Meta = meta;
GlobalMeta = globalMeta;
Properties = properties;
if (defaultBinding == NetworkLayerBinding.Default)
{
defaultBinding = NetworkLayerBinding.ClientAndServer;
}
if (Binding != NetworkLayerBinding.Default)
{
defaultBinding = Binding;
}
OnConnect(ref client, ref server, defaultBinding);
}
/// <summary>
/// Check if the token matches this filter
/// </summary>
/// <param name="token">The token to match</param>
/// <returns>True if it matches</returns>
public override bool Match(ProxyToken token)
{
bool bMatch = base.Match(token);
if (bMatch)
{
if (token is IpProxyToken)
{
IpProxyToken iptoken = (IpProxyToken)token;
string hostName = iptoken.Hostname;
string ipAddress = iptoken.Address != null?iptoken.Address.ToString() : "0.0.0.0";
bMatch = Address.IsMatch(ipAddress);
if (!bMatch)
{
bMatch = Address.IsMatch(hostName);
}
if (Port != 0)
{
if (iptoken.Port != Port)
{
bMatch = false;
}
}
if (iptoken.ClientType != ClientType)
{
bMatch = false;
}
}
else
{
bMatch = false;
}
}
return(bMatch);
}
/// <summary>
///
/// </summary>
/// <param name="token"></param>
/// <param name="meta"></param>
/// <param name="globalMeta"></param>
/// <param name="service"></param>
/// <param name="client"></param>
/// <returns></returns>
public override IDataAdapter Complete(ProxyToken token, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service, IDataAdapter client)
{
IDataAdapter ret = null;
// An empty initial request indicates we are a full connection
if (token.State.ContainsKey("header"))
{
HttpRequestHeader initialRequest = (HttpRequestHeader)token.State["header"];
DataAdapterToStream stm = (DataAdapterToStream)token.State["stm"];
if (token.Status == NetStatusCodes.Success)
{
if (initialRequest.IsConnect)
{
ReturnResponse(null, 200, "Connection established", initialRequest.Method, initialRequest.Version, stm);
// Connect is transparent
ret = new StreamDataAdapter(stm);
}
else
{
// Use a proxy adapter
ret = new HttpProxyServerAdapter(stm, initialRequest, _logger);
}
}
else
{
ReturnResponse(initialRequest, 404, "Not Found", initialRequest.Method, HttpVersion.Version11, stm);
}
}
else
{
ret = (IDataAdapter)token.State["adapter"];
}
token.State.Clear();
return(ret);
}
/// <summary>
///
/// </summary>
/// <param name="adapter"></param>
/// <param name="meta"></param>
/// <param name="globalMeta"></param>
/// <param name="service"></param>
/// <returns></returns>
public override ProxyToken Accept(IDataAdapter adapter, MetaDictionary meta, MetaDictionary globalMeta, ProxyNetworkService service)
{
ProxyToken token = null;
TcpClientDataAdapter tcpAdapter = adapter as TcpClientDataAdapter;
if (_config.SslConfig.Enabled)
{
IDataAdapter client = null;
INetworkLayer ssl = new SslNetworkLayer(_config.SslConfig);
ssl.Negotiate(ref adapter, ref client, null, _logger, null, null,
new PropertyBag("Root"), NetworkLayerBinding.Server);
}
DataAdapterToStream stm = new DataAdapterToStream(adapter);
DataReader reader = new DataReader(stm);
try
{
HttpRequestHeader header = HttpParser.ReadRequestHeader(reader, false, _logger);
token = HandleOtherRequest(header, stm, tcpAdapter);
}
catch (HttpStreamParserException ex)
{
_logger.LogError(CANAPE.Net.Properties.Resources.HttpProxyServer_InvalidRequest, ex.Message);
// TODO: Put in some decent error codes
ReturnResponse(null, 400, "Bad Request", "GET", HttpVersion.Version11, stm);
}
catch (EndOfStreamException)
{
token = null;
}
return(token);
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="client"></param>
/// <param name="token"></param>
/// <param name="logger"></param>
/// <param name="meta"></param>
/// <param name="globalMeta"></param>
/// <param name="properties"></param>
/// <param name="defaultBinding"></param>
public void Negotiate(ref IDataAdapter server, ref IDataAdapter client, ProxyToken token, Logger logger,
MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, NetworkLayerBinding defaultBinding)
{
if (defaultBinding == NetworkLayerBinding.Default)
{
defaultBinding = NetworkLayerBinding.ClientAndServer;
}
if (Binding != NetworkLayerBinding.Default)
{
defaultBinding = Binding;
}
if ((defaultBinding & NetworkLayerBinding.Server) == NetworkLayerBinding.Server)
{
server = new HttpRequestDataAdapter(server, logger, this);
}
if ((defaultBinding & NetworkLayerBinding.Client) == NetworkLayerBinding.Client)
{
client = new HttpResponseDataAdapter(client, logger, this);
}
}
/// <summary>
/// Connect to the required service with the token
/// </summary>
/// <param name="token">The token recevied from proxy</param>
/// <param name="globalMeta">The global meta</param>
/// <param name="logger">The logger</param>
/// <param name="meta">The meta</param>
/// <param name="properties">Property bag to add any information to</param>
/// <param name="credmgr">Credentials manager</param>
/// <returns>The connected data adapter</returns>
public override IDataAdapter Connect(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, CredentialsManagerService credmgr)
{
IDataAdapter adapter = null;
IpProxyToken iptoken = token as IpProxyToken;
if (iptoken != null)
{
if (iptoken.ClientType == IpProxyToken.IpClientType.Tcp)
{
adapter = ConnectTcp(iptoken, logger, properties);
}
else if (iptoken.ClientType == IpProxyToken.IpClientType.Udp)
{
adapter = ConnectUdp(iptoken, logger, properties);
}
else
{
throw new ArgumentException(CANAPE.Net.Properties.Resources.IpProxyClient_InvalidTokenType);
}
}
return(adapter);
}
public override IDataAdapter Bind(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, CredentialsManagerService credmgr)
{
return(null);
}
protected virtual void Dispatch( string line )
{
//[email protected]( "event: " + line );
string[] elements = GetEventElements( line );
if ( elements == null || elements[0] == null )
{
Console.Error.WriteLine( "unknown debug event: " + line );
return;
}
if ( elements[0].Equals( "enterRule" ) )
{
listener.EnterRule( elements[1], elements[2] );
}
else if ( elements[0].Equals( "exitRule" ) )
{
listener.ExitRule( elements[1], elements[2] );
}
else if ( elements[0].Equals( "enterAlt" ) )
{
listener.EnterAlt( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "enterSubRule" ) )
{
listener.EnterSubRule( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "exitSubRule" ) )
{
listener.ExitSubRule( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "enterDecision" ) )
{
listener.EnterDecision( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "exitDecision" ) )
{
listener.ExitDecision( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "location" ) )
{
listener.Location( int.Parse( elements[1] ),
int.Parse( elements[2] ) );
}
else if ( elements[0].Equals( "consumeToken" ) )
{
ProxyToken t = DeserializeToken( elements, 1 );
if ( t.TokenIndex == previousTokenIndex )
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeToken( t );
}
else if ( elements[0].Equals( "consumeHiddenToken" ) )
{
ProxyToken t = DeserializeToken( elements, 1 );
if ( t.TokenIndex == previousTokenIndex )
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeHiddenToken( t );
}
else if ( elements[0].Equals( "LT" ) )
{
IToken t = DeserializeToken( elements, 2 );
listener.LT( int.Parse( elements[1] ), t );
}
else if ( elements[0].Equals( "mark" ) )
{
listener.Mark( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "rewind" ) )
{
if ( elements[1] != null )
{
listener.Rewind( int.Parse( elements[1] ) );
}
else
{
listener.Rewind();
}
}
else if ( elements[0].Equals( "beginBacktrack" ) )
{
listener.BeginBacktrack( int.Parse( elements[1] ) );
}
else if ( elements[0].Equals( "endBacktrack" ) )
{
int level = int.Parse( elements[1] );
int successI = int.Parse( elements[2] );
listener.EndBacktrack( level, successI == DebugEventListenerConstants.True );
}
else if ( elements[0].Equals( "exception" ) )
{
#if true
throw new System.NotImplementedException();
#else
string excName = elements[1];
string indexS = elements[2];
string lineS = elements[3];
string posS = elements[4];
Class excClass = null;
try
{
excClass = Class.forName( excName );
RecognitionException e =
(RecognitionException)excClass.newInstance();
e.index = int.Parse( indexS );
e.line = int.Parse( lineS );
e.charPositionInLine = int.Parse( posS );
listener.recognitionException( e );
}
catch ( ClassNotFoundException cnfe )
{
Console.Error.println( "can't find class " + cnfe );
cnfe.printStackTrace( Console.Error );
}
catch ( InstantiationException ie )
{
Console.Error.println( "can't instantiate class " + ie );
ie.printStackTrace( Console.Error );
}
catch ( IllegalAccessException iae )
{
Console.Error.println( "can't access class " + iae );
iae.printStackTrace( Console.Error );
}
#endif
}
else if ( elements[0].Equals( "beginResync" ) )
{
listener.BeginResync();
}
else if ( elements[0].Equals( "endResync" ) )
{
listener.EndResync();
}
else if ( elements[0].Equals( "terminate" ) )
{
listener.Terminate();
}
else if ( elements[0].Equals( "semanticPredicate" ) )
{
bool result = bool.Parse( elements[1] );
string predicateText = elements[2];
predicateText = UnEscapeNewlines( predicateText );
listener.SemanticPredicate( result,
predicateText );
}
else if ( elements[0].Equals( "consumeNode" ) )
{
ProxyTree node = DeserializeNode( elements, 1 );
listener.ConsumeNode( node );
}
else if ( elements[0].Equals( "LN" ) )
{
int i = int.Parse( elements[1] );
ProxyTree node = DeserializeNode( elements, 2 );
listener.LT( i, node );
}
else if ( elements[0].Equals( "createNodeFromTokenElements" ) )
{
int ID = int.Parse( elements[1] );
int type = int.Parse( elements[2] );
string text = elements[3];
text = UnEscapeNewlines( text );
ProxyTree node = new ProxyTree( ID, type, -1, -1, -1, text );
listener.CreateNode( node );
}
else if ( elements[0].Equals( "createNode" ) )
{
int ID = int.Parse( elements[1] );
int tokenIndex = int.Parse( elements[2] );
// create dummy node/token filled with ID, tokenIndex
ProxyTree node = new ProxyTree( ID );
ProxyToken token = new ProxyToken( tokenIndex );
listener.CreateNode( node, token );
}
else if ( elements[0].Equals( "nilNode" ) )
{
int ID = int.Parse( elements[1] );
ProxyTree node = new ProxyTree( ID );
listener.NilNode( node );
}
else if ( elements[0].Equals( "errorNode" ) )
{
// TODO: do we need a special tree here?
int ID = int.Parse( elements[1] );
int type = int.Parse( elements[2] );
string text = elements[3];
text = UnEscapeNewlines( text );
ProxyTree node = new ProxyTree( ID, type, -1, -1, -1, text );
listener.ErrorNode( node );
}
else if ( elements[0].Equals( "becomeRoot" ) )
{
int newRootID = int.Parse( elements[1] );
int oldRootID = int.Parse( elements[2] );
ProxyTree newRoot = new ProxyTree( newRootID );
ProxyTree oldRoot = new ProxyTree( oldRootID );
listener.BecomeRoot( newRoot, oldRoot );
}
else if ( elements[0].Equals( "addChild" ) )
{
int rootID = int.Parse( elements[1] );
int childID = int.Parse( elements[2] );
ProxyTree root = new ProxyTree( rootID );
ProxyTree child = new ProxyTree( childID );
listener.AddChild( root, child );
}
else if ( elements[0].Equals( "setTokenBoundaries" ) )
{
int ID = int.Parse( elements[1] );
ProxyTree node = new ProxyTree( ID );
listener.SetTokenBoundaries(
node,
int.Parse( elements[2] ),
int.Parse( elements[3] ) );
}
else
{
Console.Error.WriteLine( "unknown debug event: " + line );
}
}
/// <summary> /// Bind to the required service with the token /// </summary> /// <param name="token">The token recevied from proxy</param> /// <param name="globalMeta">The global meta</param> /// <param name="logger">The logger</param> /// <param name="meta">The meta</param> /// <param name="properties">Property bag to add any information to</param> /// <param name="credmgr">Credentials manager</param> /// <returns>The connected data adapter</returns> public abstract IDataAdapter Bind(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, CredentialsManagerService credmgr);
/// <summary>
/// Connect to the required service with the token
/// </summary>
/// <param name="token">The token recevied from proxy</param>
/// <param name="globalMeta">The global meta</param>
/// <param name="logger">The logger</param>
/// <param name="meta">The meta</param>
/// <param name="properties">Property bag to add any information to</param>
/// <param name="credmgr">Credentials manager</param>
/// <returns>The connected data adapter</returns>
public override IDataAdapter Connect(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, CredentialsManagerService credmgr)
{
IDataAdapter ret = null;
token.Status = NetStatusCodes.ConnectFailure;
if ((token is IpProxyToken) && ((IpProxyToken)token).ClientType == IpProxyToken.IpClientType.Tcp)
{
TcpClient client = new TcpClient();
try
{
client.Connect(_hostname, _port);
if (token is FullHttpProxyToken)
{
bool binary = false;
if ((token.Layers != null) && (token.Layers.Length > 0))
{
foreach (INetworkLayer layer in token.Layers)
{
// Find a binding layer
if (layer.Binding == NetworkLayerBinding.Client ||
layer.Binding == NetworkLayerBinding.ClientAndServer ||
layer.Binding == NetworkLayerBinding.Default)
{
if (!(layer is HttpNetworkLayer))
{
binary = true;
}
break;
}
}
}
if (!binary)
{
ret = new FullHttpProxyDataAdapter(client, (FullHttpProxyToken)token, IpProxyClient.GetDescription((IpProxyToken)token), logger);
NetUtils.PopulateBagFromSocket(client.Client, properties);
token.Status = NetStatusCodes.Success;
}
else
{
ConnectWithIpProxyToken(client.GetStream(), (IpProxyToken)token, logger);
if (token.Status == NetStatusCodes.Success)
{
NetUtils.PopulateBagFromSocket(client.Client, properties);
ret = new TcpClientDataAdapter(client, IpProxyClient.GetDescription((IpProxyToken)token));
}
}
}
else
{
if (token is HttpProxyToken)
{
ConnectWithHttpProxyToken(client.GetStream(), (HttpProxyToken)token, logger);
}
else
{
ConnectWithIpProxyToken(client.GetStream(), (IpProxyToken)token, logger);
}
if (token.Status == NetStatusCodes.Success)
{
NetUtils.PopulateBagFromSocket(client.Client, properties);
ret = new TcpClientDataAdapter(client, IpProxyClient.GetDescription((IpProxyToken)token));
}
}
}
catch (SocketException ex)
{
logger.LogException(ex);
token.Status = NetStatusCodes.ConnectFailure;
}
catch (IOException ex)
{
logger.LogException(ex);
token.Status = NetStatusCodes.ConnectFailure;
}
finally
{
if (ret == null)
{
client.Close();
}
}
}
else
{
throw new ArgumentException(CANAPE.Net.Properties.Resources.HttpProxyClient_InvalidProxyToken);
}
return(ret);
}
// TODO: Should merge with implementation for the general connection so that it is 100% compatible
/// <summary>
///
/// </summary>
/// <param name="graph"></param>
/// <param name="token"></param>
public void ReconnectClient(NetGraph graph, ProxyToken token)
{
IDataAdapter client = null;
bool connected = false;
PropertyBag networkService = graph.ConnectionProperties.GetRelativeBag("NetworkService");
PropertyBag clientProperties = graph.ConnectionProperties.GetRelativeBag("Client");
PropertyBag tokenProperties = graph.ConnectionProperties.GetRelativeBag("Token");
try
{
while (graph.Parent != null)
{
graph = graph.Parent;
}
if (token != null)
{
// If passed in a token we need to apply filters to it
token = FilterToken(token);
}
else
{
// Use original post-filtered
token = (ProxyToken)networkService.GetRelativeValue("Token");
}
if (token.Status == NetStatusCodes.Success)
{
clientProperties.Clear();
if (token.Client == null)
{
client = _proxyClient.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
}
else
{
client = token.Client.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
}
tokenProperties.Clear();
token.PopulateBag(tokenProperties);
// Negotiate SSL or other bespoke encryption mechanisms
if (token.Layers != null)
{
// Bind but disabling server layer
NetworkLayerBinding binding = DefaultBinding & ~NetworkLayerBinding.Server;
foreach (INetworkLayer layer in token.Layers)
{
IDataAdapter server = null;
layer.Negotiate(ref server, ref client, token, _logger, graph.Meta, _globalMeta, graph.ConnectionProperties, binding);
}
}
graph.BindEndpoint((Guid)networkService.GetRelativeValue("ClientId"), client);
IDataAdapter serverAdapter = networkService.GetRelativeValue("ServerAdapter");
if (token.NetworkDescription != null)
{
graph.NetworkDescription = token.NetworkDescription;
}
else
{
graph.NetworkDescription = String.Format("{0} <=> {1}",
serverAdapter.Description, client.Description);
}
IDataAdapter oldClient = networkService.GetRelativeValue("ClientAdapter");
networkService.AddValue("ClientAdapter", client);
networkService.AddValue("Token", token);
oldClient.Dispose();
connected = true;
}
else
{
_logger.LogVerbose(Properties.Resources.ProxyNetworkService_ConnectionFiltered);
}
}
catch (Exception ex)
{
_logger.LogException(ex);
}
finally
{
if (!connected)
{
try
{
if (client != null)
{
client.Dispose();
}
}
catch (Exception ex)
{
Logger.SystemLogger.LogException(ex);
}
}
}
}
/// <summary>
/// Overridable method to determine if this token matches
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public virtual bool Match(ProxyToken token)
{
return(token.Bind == Bound);
}
protected virtual void Dispatch(string line)
{
//[email protected]( "event: " + line );
string[] elements = GetEventElements(line);
if (elements == null || elements[0] == null)
{
Console.Error.WriteLine("unknown debug event: " + line);
return;
}
if (elements[0].Equals("enterRule"))
{
listener.EnterRule(elements[1], elements[2]);
}
else if (elements[0].Equals("exitRule"))
{
listener.ExitRule(elements[1], elements[2]);
}
else if (elements[0].Equals("enterAlt"))
{
listener.EnterAlt(int.Parse(elements[1]));
}
else if (elements[0].Equals("enterSubRule"))
{
listener.EnterSubRule(int.Parse(elements[1]));
}
else if (elements[0].Equals("exitSubRule"))
{
listener.ExitSubRule(int.Parse(elements[1]));
}
else if (elements[0].Equals("enterDecision"))
{
listener.EnterDecision(int.Parse(elements[1]), elements[2].Equals("true"));
}
else if (elements[0].Equals("exitDecision"))
{
listener.ExitDecision(int.Parse(elements[1]));
}
else if (elements[0].Equals("location"))
{
listener.Location(int.Parse(elements[1]),
int.Parse(elements[2]));
}
else if (elements[0].Equals("consumeToken"))
{
ProxyToken t = DeserializeToken(elements, 1);
if (t.TokenIndex == previousTokenIndex)
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeToken(t);
}
else if (elements[0].Equals("consumeHiddenToken"))
{
ProxyToken t = DeserializeToken(elements, 1);
if (t.TokenIndex == previousTokenIndex)
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeHiddenToken(t);
}
else if (elements[0].Equals("LT"))
{
IToken t = DeserializeToken(elements, 2);
listener.LT(int.Parse(elements[1]), t);
}
else if (elements[0].Equals("mark"))
{
listener.Mark(int.Parse(elements[1]));
}
else if (elements[0].Equals("rewind"))
{
if (elements[1] != null)
{
listener.Rewind(int.Parse(elements[1]));
}
else
{
listener.Rewind();
}
}
else if (elements[0].Equals("beginBacktrack"))
{
listener.BeginBacktrack(int.Parse(elements[1]));
}
else if (elements[0].Equals("endBacktrack"))
{
int level = int.Parse(elements[1]);
int successI = int.Parse(elements[2]);
listener.EndBacktrack(level, successI == DebugEventListenerConstants.True);
}
else if (elements[0].Equals("exception"))
{
#if true
throw new System.NotImplementedException();
#else
string excName = elements[1];
string indexS = elements[2];
string lineS = elements[3];
string posS = elements[4];
Class excClass = null;
try
{
excClass = Class.forName(excName);
RecognitionException e =
(RecognitionException)excClass.newInstance();
e.index = int.Parse(indexS);
e.line = int.Parse(lineS);
e.charPositionInLine = int.Parse(posS);
listener.recognitionException(e);
}
catch (ClassNotFoundException cnfe)
{
Console.Error.println("can't find class " + cnfe);
cnfe.printStackTrace(Console.Error);
}
catch (InstantiationException ie)
{
Console.Error.println("can't instantiate class " + ie);
ie.printStackTrace(Console.Error);
}
catch (IllegalAccessException iae)
{
Console.Error.println("can't access class " + iae);
iae.printStackTrace(Console.Error);
}
#endif
}
else if (elements[0].Equals("beginResync"))
{
listener.BeginResync();
}
else if (elements[0].Equals("endResync"))
{
listener.EndResync();
}
else if (elements[0].Equals("terminate"))
{
listener.Terminate();
}
else if (elements[0].Equals("semanticPredicate"))
{
bool result = bool.Parse(elements[1]);
string predicateText = elements[2];
predicateText = UnEscapeNewlines(predicateText);
listener.SemanticPredicate(result,
predicateText);
}
else if (elements[0].Equals("consumeNode"))
{
ProxyTree node = DeserializeNode(elements, 1);
listener.ConsumeNode(node);
}
else if (elements[0].Equals("LN"))
{
int i = int.Parse(elements[1]);
ProxyTree node = DeserializeNode(elements, 2);
listener.LT(i, node);
}
else if (elements[0].Equals("createNodeFromTokenElements"))
{
int ID = int.Parse(elements[1]);
int type = int.Parse(elements[2]);
string text = elements[3];
text = UnEscapeNewlines(text);
ProxyTree node = new ProxyTree(ID, type, -1, -1, -1, text);
listener.CreateNode(node);
}
else if (elements[0].Equals("createNode"))
{
int ID = int.Parse(elements[1]);
int tokenIndex = int.Parse(elements[2]);
// create dummy node/token filled with ID, tokenIndex
ProxyTree node = new ProxyTree(ID);
ProxyToken token = new ProxyToken(tokenIndex);
listener.CreateNode(node, token);
}
else if (elements[0].Equals("nilNode"))
{
int ID = int.Parse(elements[1]);
ProxyTree node = new ProxyTree(ID);
listener.NilNode(node);
}
else if (elements[0].Equals("errorNode"))
{
// TODO: do we need a special tree here?
int ID = int.Parse(elements[1]);
int type = int.Parse(elements[2]);
string text = elements[3];
text = UnEscapeNewlines(text);
ProxyTree node = new ProxyTree(ID, type, -1, -1, -1, text);
listener.ErrorNode(node);
}
else if (elements[0].Equals("becomeRoot"))
{
int newRootID = int.Parse(elements[1]);
int oldRootID = int.Parse(elements[2]);
ProxyTree newRoot = new ProxyTree(newRootID);
ProxyTree oldRoot = new ProxyTree(oldRootID);
listener.BecomeRoot(newRoot, oldRoot);
}
else if (elements[0].Equals("addChild"))
{
int rootID = int.Parse(elements[1]);
int childID = int.Parse(elements[2]);
ProxyTree root = new ProxyTree(rootID);
ProxyTree child = new ProxyTree(childID);
listener.AddChild(root, child);
}
else if (elements[0].Equals("setTokenBoundaries"))
{
int ID = int.Parse(elements[1]);
ProxyTree node = new ProxyTree(ID);
listener.SetTokenBoundaries(
node,
int.Parse(elements[2]),
int.Parse(elements[3]));
}
else
{
Console.Error.WriteLine("unknown debug event: " + line);
}
}
protected internal virtual ProxyToken DeserializeToken(string[] elements, int offset)
{
string indexS = elements[offset + 0];
string typeS = elements[offset + 1];
string channelS = elements[offset + 2];
string lineS = elements[offset + 3];
string posS = elements[offset + 4];
string text = elements[offset + 5];
text = UnEscapeNewlines(text);
int index = int.Parse(indexS, CultureInfo.InvariantCulture);
ProxyToken t = new ProxyToken(index, int.Parse(typeS, CultureInfo.InvariantCulture), int.Parse(channelS, CultureInfo.InvariantCulture), int.Parse(lineS, CultureInfo.InvariantCulture), int.Parse(posS, CultureInfo.InvariantCulture), text);
return t;
}
protected virtual void Dispatch(string line)
{
string[] elements = GetEventElements(line);
if (elements == null || elements[0] == null)
{
Console.Error.WriteLine("unknown debug event: " + line);
return ;
}
if (elements[0].Equals("enterRule"))
{
listener.EnterRule(elements[1], elements[2]);
}
else if (elements[0].Equals("exitRule"))
{
listener.ExitRule(elements[1], elements[2]);
}
else if (elements[0].Equals("enterAlt"))
{
listener.EnterAlt(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("enterSubRule"))
{
listener.EnterSubRule(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("exitSubRule"))
{
listener.ExitSubRule(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("enterDecision"))
{
listener.EnterDecision(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("exitDecision"))
{
listener.ExitDecision(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("location"))
{
listener.Location(int.Parse(elements[1], CultureInfo.InvariantCulture),
int.Parse(elements[2], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("consumeToken"))
{
ProxyToken t = DeserializeToken(elements, 1);
if (t.TokenIndex == previousTokenIndex)
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeToken(t);
}
else if (elements[0].Equals("consumeHiddenToken"))
{
ProxyToken t = DeserializeToken(elements, 1);
if (t.TokenIndex == previousTokenIndex)
{
tokenIndexesInvalid = true;
}
previousTokenIndex = t.TokenIndex;
listener.ConsumeHiddenToken(t);
}
else if (elements[0].Equals("LT"))
{
IToken t = DeserializeToken(elements, 2);
listener.LT(int.Parse(elements[1], CultureInfo.InvariantCulture), t);
}
else if (elements[0].Equals("mark"))
{
listener.Mark(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("rewind"))
{
if (elements[1] != null)
{
listener.Rewind(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else
{
listener.Rewind();
}
}
else if (elements[0].Equals("beginBacktrack"))
{
listener.BeginBacktrack(int.Parse(elements[1], CultureInfo.InvariantCulture));
}
else if (elements[0].Equals("endBacktrack"))
{
int level = int.Parse(elements[1], CultureInfo.InvariantCulture);
int successI = int.Parse(elements[2], CultureInfo.InvariantCulture);
//listener.EndBacktrack(level, successI == (int)true);
listener.EndBacktrack(level, successI == 1 /*1=TRUE*/);
}
else if (elements[0].Equals("exception"))
{
string excName = elements[1];
string indexS = elements[2];
string lineS = elements[3];
string posS = elements[4];
Type excClass = null;
try
{
excClass = System.Type.GetType(excName);
RecognitionException e = (RecognitionException) System.Activator.CreateInstance(excClass);
e.Index = int.Parse(indexS, CultureInfo.InvariantCulture);
e.Line = int.Parse(lineS, CultureInfo.InvariantCulture);
e.CharPositionInLine = int.Parse(posS, CultureInfo.InvariantCulture);
listener.RecognitionException(e);
}
catch (System.UnauthorizedAccessException iae)
{
Console.Error.WriteLine("can't access class " + iae);
Console.Error.WriteLine(iae.StackTrace);
}
}
else if (elements[0].Equals("beginResync"))
{
listener.BeginResync();
}
else if (elements[0].Equals("endResync"))
{
listener.EndResync();
}
else if (elements[0].Equals("terminate"))
{
listener.Terminate();
}
else if (elements[0].Equals("semanticPredicate"))
{
bool result = bool.Parse(elements[1]);
string predicateText = elements[2];
predicateText = UnEscapeNewlines(predicateText);
listener.SemanticPredicate(result, predicateText);
}
else if (elements[0].Equals("consumeNode"))
{
ProxyTree node = DeserializeNode(elements, 1);
listener.ConsumeNode(node);
}
else if (elements[0].Equals("LN"))
{
int i = int.Parse(elements[1], CultureInfo.InvariantCulture);
ProxyTree node = DeserializeNode(elements, 2);
listener.LT(i, node);
}
else if (elements[0].Equals("createNodeFromTokenElements"))
{
int ID = int.Parse(elements[1], CultureInfo.InvariantCulture);
int type = int.Parse(elements[2], CultureInfo.InvariantCulture);
string text = elements[3];
text = UnEscapeNewlines(text);
ProxyTree node = new ProxyTree(ID, type, -1, -1, -1, text);
listener.CreateNode(node);
}
else if (elements[0].Equals("createNode"))
{
int ID = int.Parse(elements[1], CultureInfo.InvariantCulture);
int tokenIndex = int.Parse(elements[2], CultureInfo.InvariantCulture);
// create dummy node/token filled with ID, tokenIndex
ProxyTree node = new ProxyTree(ID);
ProxyToken token = new ProxyToken(tokenIndex);
listener.CreateNode(node, token);
}
else if (elements[0].Equals("nilNode"))
{
int ID = int.Parse(elements[1], CultureInfo.InvariantCulture);
ProxyTree node = new ProxyTree(ID);
listener.GetNilNode(node);
}
else if ( elements[0].Equals("errorNode") ) {
int ID = int.Parse(elements[1], CultureInfo.InvariantCulture);
int type = int.Parse(elements[2], CultureInfo.InvariantCulture);
String text = elements[3];
text = UnEscapeNewlines(text);
ProxyTree node = new ProxyTree(ID, type, -1, -1, -1, text);
listener.ErrorNode(node);
}
else if (elements[0].Equals("becomeRoot"))
{
int newRootID = int.Parse(elements[1], CultureInfo.InvariantCulture);
int oldRootID = int.Parse(elements[2], CultureInfo.InvariantCulture);
ProxyTree newRoot = new ProxyTree(newRootID);
ProxyTree oldRoot = new ProxyTree(oldRootID);
listener.BecomeRoot(newRoot, oldRoot);
}
else if (elements[0].Equals("addChild"))
{
int rootID = int.Parse(elements[1], CultureInfo.InvariantCulture);
int childID = int.Parse(elements[2], CultureInfo.InvariantCulture);
ProxyTree root = new ProxyTree(rootID);
ProxyTree child = new ProxyTree(childID);
listener.AddChild(root, child);
}
else if (elements[0].Equals("setTokenBoundaries"))
{
int ID = int.Parse(elements[1], CultureInfo.InvariantCulture);
ProxyTree node = new ProxyTree(ID);
listener.SetTokenBoundaries(node,
int.Parse(elements[2], CultureInfo.InvariantCulture),
int.Parse(elements[3], CultureInfo.InvariantCulture));
}
else
{
Console.Error.WriteLine("unknown debug event: " + line);
}
}
public override IDataAdapter Connect(ProxyToken token, Logger logger, MetaDictionary meta, MetaDictionary globalMeta, PropertyBag properties, CredentialsManagerService credmgr)
{
return(new DataEndpointAdapter(_factory.Create(logger, meta, globalMeta), logger));
}
