ConstructorInfo exec <T>()
{
Type @class = typeof(T);
ServiceFlagsGenerator flagsGenerator =
new ServiceFlagsGenerator(new ServiceFlagsProvider(new AttributesFinder(), new MemberGenerator(new MemberFlagsGenerator())), new ServiceFlagsIssuesResolver());
ServiceFlags flags = flagsGenerator.GenerateFlags(@class);
ConstructorProvider provider = new ConstructorProvider(new ConstructorChecker(), new DefaultConstructorProvider(), new ConstructorGenerator(new ParametersGenerator(new ParameterGenerator())));
return(provider.ProvideConstructor(@class).Instance);
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = fullname;
this.port = port;
TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv4)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv6)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.AAAA, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (hostentry.AddressList != null)
{
ServiceResolvedEventHandler handler = Resolved;
if (handler != null)
{
handler(this, new ServiceResolvedEventArgs(this));
}
}
}
bool exec(string flagName)
{
ServiceFlags flags = new ServiceFlags();
flags.AddFlag(flagName, null);
Service service = new Service()
{
Flags = flags
};
return(new ServiceHasFactoryChecker().Check(service));
}
/// <summary>
/// Initializes static members of the <see cref="DownloadsDatabase"/> class.
/// </summary>
static DownloadsDatabase()
{
downloadStatus = DownloadStatus.Unknown;
flags = 0;
versionCode = -1;
if (File.Exists(XmlDatastore.GetDataPath <MetadataTable>()))
{
downloadStatus = XmlDatastore.GetData <MetadataTable>().DownloadStatus;
flags = XmlDatastore.GetData <MetadataTable>().Flags;
versionCode = XmlDatastore.GetData <MetadataTable>().ApkVersion;
}
}
internal NodeLauncher(Networks network, ServiceFlags serviceFlag, IRpcNodeFactory rpcNodeFactory, IBlockChainStore blockChainStore, IMessageCoordinator messageCoordinator, ISmartContractStore smartContractStore)
{
_network = network;
_serviceFlag = serviceFlag;
_p2pNetworkConnector = new P2PNetworkConnector(messageCoordinator);
_p2pNetworkConnector.ConnectEvent += P2PConnectEvent;
_p2pNetworkConnector.DisconnectEvent += P2PDisconnectEvent;
_p2pNode = new P2PNode(_network, _serviceFlag, _p2pNetworkConnector, messageCoordinator);
_rpcNode = rpcNodeFactory.Build(_network);
blockChainStore.Switch(network);
smartContractStore.Switch(network);
_blockChain = blockChainStore.GetBlockChain();
}
public RegisterMessagePayload(string instanceName, string serviceType, string domain, string hostName, ushort port, byte[] txtRecord, ServiceFlags flags, uint interfaceIndex)
{
Guard.Against.NullOrEmpty(serviceType, nameof(serviceType));
InstanceName = instanceName ?? string.Empty;
ServiceType = serviceType;
Domain = domain ?? string.Empty;
HostName = hostName ?? string.Empty;
Port = port;
TxtRecord = txtRecord;
Flags = flags;
InterfaceIndex = interfaceIndex;
}
private void OnBrowseReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex, ServiceError errorCode,
IntPtr serviceName, string regtype, string replyDomain, IntPtr context)
{
string name = Native.Utf8toString(serviceName);
BrowseService service = new BrowseService();
service.Flags = flags;
service.Name = name;
service.RegType = regtype;
service.ReplyDomain = replyDomain;
service.InterfaceIndex = interfaceIndex;
service.AddressProtocol = address_protocol;
ServiceBrowseEventArgs args = new ServiceBrowseEventArgs(
service, (flags & ServiceFlags.MoreComing) != 0);
if ((flags & ServiceFlags.Add) != 0)
{
lock (service_table) {
if (service_table.ContainsKey(name))
{
service_table[name] = service;
}
else
{
service_table.Add(name, service);
}
}
ServiceBrowseEventHandler handler = ServiceAdded;
if (handler != null)
{
handler(this, args);
}
}
else
{
lock (service_table) {
if (service_table.ContainsKey(name))
{
service_table.Remove(name);
}
}
ServiceBrowseEventHandler handler = ServiceRemoved;
if (handler != null)
{
handler(this, args);
}
}
}
public void ResolveIssues(ServiceFlags flags)
{
// add resolving probles with multiple creation methods like ctors and factors later TODO
if (flags.HasFlag(ServiceFlagConstants.MultiInstance) && flags.HasFlag(ServiceFlagConstants.SingleInstance))
{
flags.RemoveFlag(ServiceFlagConstants.MultiInstance);
}
if (!flags.HasFlag(ServiceFlagConstants.MultiInstance) && !flags.HasFlag(ServiceFlagConstants.SingleInstance))
{
flags.AddFlag(ServiceFlagConstants.SingleInstance, null);
}
}
/// <summary>
/// The update network state.
/// </summary>
/// <param name="info">
/// The info.
/// </param>
private void UpdateNetworkState(NetworkInfo info)
{
NetworkState tempState = this.networkState;
this.networkState = NetworkState.Disconnected;
if (info != null && info.IsConnected)
{
this.networkState = NetworkState.Connected;
if (info.IsRoaming)
{
this.networkState |= NetworkState.Roaming;
}
if (info.IsFailover)
{
this.networkState |= NetworkState.IsFailOver;
}
this.networkState |= this.GetNetworkState(info);
}
this.stateChanged = this.stateChanged || this.networkState != tempState;
if (this.stateChanged)
{
Log.Debug(Tag, "LVLDL Network state changed: ");
Log.Debug(Tag, "LVLDL Starting State: {0}", tempState);
Log.Debug(Tag, "LVLDL Ending State: {0}", this.networkState);
if (this.IsServiceRunning)
{
if (this.networkState.HasFlag(NetworkState.Roaming))
{
this.Status = ExpansionDownloadStatus.WaitingForNetwork;
this.Control = ControlAction.Paused;
}
else if (this.networkState.HasFlag(NetworkState.IsCellular))
{
ServiceFlags flags = DownloadsDatabase.Flags;
if (!flags.HasFlag(ServiceFlags.FlagsDownloadOverCellular))
{
this.Status = ExpansionDownloadStatus.QueuedForWifi;
this.Control = ControlAction.Paused;
}
}
}
}
}
public ServiceMessageHeader(uint version, uint dataLength, ServiceFlags flags, OperationCode opCode, ulong subordinateID = 0, uint regIndex = 0)
{
if (opCode == OperationCode.None)
{
throw new ArgumentException($"Parameter {nameof(opCode)} cannont be {nameof(OperationCode.None)}");
}
Version = version;
DataLength = dataLength;
Flags = flags;
OperationCode = opCode;
SubordinateID = subordinateID;
RegIndex = regIndex;
}
public void Connect(string host, ServiceFlags serviceFlag)
{
if (string.IsNullOrWhiteSpace(host))
{
throw new ArgumentNullException(nameof(host));
}
var iid = Interop.Constants.InterfaceId;
var port = PortsHelper.GetPort(_network);
IPAddress ipAdr = null;
if (!IPAddress.TryParse(host, out ipAdr))
{
// TODO : Throw an exception.
}
var adrBytes = ipAdr.MapToIPv6().GetAddressBytes();
_serviceFlag = serviceFlag;
_currentIpAddress = new IpAddress(serviceFlag, adrBytes, ushort.Parse(port));
// _client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, host, port);
_client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, host);
// Connection to peers : https://bitcoin.org/en/developer-guide#connecting-to-peers
var instance = PeersStore.Instance();
var transmittingNode = instance.GetMyIpAddress();
var nonce = NonceHelper.GetNonceUInt64();
var versionMessage = new VersionMessage(transmittingNode, _currentIpAddress, nonce, string.Empty, 0, false, _network);
try
{
_peerConnection = new PeerConnection(adrBytes);
var result = _messageCoordinator.Launch(this, versionMessage);
if (result != null && result is VerackMessage)
{
_peerConnection.Connect();
if (ConnectEvent != null)
{
ConnectEvent(this, new IpAddressEventArgs(_currentIpAddress));
}
_timer = new Timer(TimerElapsed, _autoEvent, CHECK_INTERVAL, CHECK_INTERVAL); // CHECK PEERS AVAILABILITY EVERY 60 SECONDS.
}
}
catch (Interop.RpcException)
{
throw new PeerConnectorException(ErrorCodes.PeerRpcError);
}
}
private static void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var browseService = handle.Target as BrowseService;
browseService.is_resolved = true;
browseService.resolve_pending = false;
browseService.InterfaceIndex = interfaceIndex;
browseService.FullName = fullname;
browseService.port = port;
browseService.TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv4)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, browseService.query_record_reply_handler, context);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv6)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.AAAA, ServiceClass.IN, browseService.query_record_reply_handler, context);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
}
OnRegisterReply
(
ServiceRef sdRef,
ServiceFlags flags,
ErrorCode errorCode,
String name,
String regtype,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
Invoke(registerServiceCallback, new Object[] { name });
}
else
{
MessageBox.Show("OnRegisterReply returned an error code " + errorCode, "Error");
}
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, IntPtr fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = Native.Utf8toString(fullname);
this.port = (ushort)IPAddress.NetworkToHostOrder((short)port);
TxtRecord = new TxtRecord(txtLen, txtRecord);
this.hosttarget = hosttarget;
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv4)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv6)
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.AAAA, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
}
private Task ConnectToPeer(string host, ServiceFlags serviceFlag)
{
if (string.IsNullOrWhiteSpace(host))
{
throw new ArgumentNullException(nameof(host));
}
return(Task.Factory.StartNew(() =>
{
var peerConnector = new PeerConnector(_network, this, _messageCoordinator);
try
{
var manualResetEvent = new ManualResetEvent(false);
peerConnector.ConnectEvent += (s, i) =>
{
AddPeer(s, i);
manualResetEvent.Set();
};
if (_isSeedNode)
{
peerConnector.TimeOutEvent += RemovePeer;
}
else
{
peerConnector.TimeOutEvent += Disconnect;
}
peerConnector.Connect(host, serviceFlag);
manualResetEvent.WaitOne();
}
catch (PeerConnectorException)
{
if (_isSeedNode)
{
RemovePeer(peerConnector, peerConnector.GetCurrentIpAddress());
}
else
{
Disconnect();
}
throw;
}
}));
}
public static ServiceError DNSServiceBrowse(out ServiceRef sdRef,
ServiceFlags flags,
uint interfaceIndex,
string regtype,
string domain,
DNSServiceBrowseReply callBack,
IntPtr context)
{
switch (Native.GetCurrentOperatingSystem())
{
case OperatingSystem.Windows:
return(NativeWindows.DNSServiceBrowse(out sdRef, flags, interfaceIndex, regtype, domain, callBack, context));
case OperatingSystem.OSX:
return(NativeOSX.DNSServiceBrowse(out sdRef, flags, interfaceIndex, regtype, domain, callBack, context));
default:
throw new InvalidOperationException("The current OS is unsupported");
}
}
public static ServiceError DNSServiceQueryRecord(out ServiceRef sdRef,
ServiceFlags flags,
uint interfaceIndex,
string fullname,
ServiceType rrtype,
ServiceClass rrclass,
DNSServiceQueryRecordReply callBack,
IntPtr context)
{
switch (Native.GetCurrentOperatingSystem())
{
case OperatingSystem.Windows:
return(NativeWindows.DNSServiceQueryRecord(out sdRef, flags, interfaceIndex, fullname, rrtype, rrclass, callBack, context));
case OperatingSystem.OSX:
return(NativeOSX.DNSServiceQueryRecord(out sdRef, flags, interfaceIndex, fullname, rrtype, rrclass, callBack, context));
default:
throw new InvalidOperationException("The current OS is unsupported");
}
}
private void OnRegisterReply(ServiceRef sdRef, ServiceFlags flags, ServiceError errorCode,
string name, string regtype, string domain, IntPtr context)
{
RegisterServiceEventArgs args = new RegisterServiceEventArgs();
args.Service = this;
args.IsRegistered = false;
args.ServiceError = (ServiceErrorCode)errorCode;
if(errorCode == ServiceError.NoError) {
Name = name;
RegType = regtype;
ReplyDomain = domain;
args.IsRegistered = true;
}
RegisterServiceEventHandler handler = Response;
if(handler != null) {
handler(this, args);
}
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = fullname;
HostTarget = hosttarget;
this.port = (short)port;
TxtRecord = new TxtRecord(txtLen, txtRecord);
EventHandler handler = Resolved;
if (handler != null)
{
handler(this, new EventArgs());
}
sdRef.Deallocate();
}
private void OnBrowseReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex, ServiceError errorCode,
string serviceName, string regtype, string replyDomain, IntPtr context)
{
BrowseService service = new BrowseService();
service.Flags = flags;
service.Name = serviceName;
service.RegType = regtype;
service.ReplyDomain = replyDomain;
service.InterfaceIndex = interfaceIndex;
ServiceBrowseEventArgs args = new ServiceBrowseEventArgs();
args.Service = service;
args.MoreComing = (flags & ServiceFlags.MoreComing) != 0;
if ((flags & ServiceFlags.Add) != 0)
{
lock (service_table.SyncRoot) {
service_table[serviceName] = service;
}
ServiceBrowseEventHandler handler = ServiceAdded;
if (handler != null)
{
handler(this, args);
}
}
else
{
lock (service_table.SyncRoot) {
service_table.Remove(serviceName);
}
ServiceBrowseEventHandler handler = ServiceRemoved;
if (handler != null)
{
handler(this, args);
}
}
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = fullname;
this.port = port;
TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv4) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
// RichardF: fix
//http://bryanprice.info/2011/01/29/mono-zeroconf-on-windows/
if (/*AddressProtocol == AddressProtocol.Any || */ AddressProtocol == AddressProtocol.IPv6) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A6, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
}
/// <summary>
/// The set download flags.
/// </summary>
/// <param name="flags">
/// The flags.
/// </param>
public void SetDownloadFlags(ServiceFlags flags)
{
using (var p = new Bundle())
{
p.PutInt(ServiceParameters.Flags, (int)flags);
this.Send(ServiceMessages.SetDownloadFlags, p);
}
}
private void OnQueryRecordReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, ServiceType rrtype, ServiceClass rrclass, ushort rdlen,
IntPtr rdata, uint ttl, IntPtr context)
{
switch(rrtype) {
case ServiceType.A:
IPAddress address;
if(rdlen == 4) {
// ~4.5 times faster than Marshal.Copy into byte[4]
uint address_raw = (uint)(Marshal.ReadByte (rdata, 3) << 24);
address_raw |= (uint)(Marshal.ReadByte (rdata, 2) << 16);
address_raw |= (uint)(Marshal.ReadByte (rdata, 1) << 8);
address_raw |= (uint)Marshal.ReadByte (rdata, 0);
address = new IPAddress(address_raw);
} else if(rdlen == 16) {
byte [] address_raw = new byte[rdlen];
Marshal.Copy(rdata, address_raw, 0, rdlen);
address = new IPAddress(address_raw, interfaceIndex);
} else {
break;
}
if(hostentry == null) {
hostentry = new IPHostEntry();
hostentry.HostName = hosttarget;
}
if(hostentry.AddressList != null) {
ArrayList list = new ArrayList(hostentry.AddressList);
list.Add(address);
hostentry.AddressList = list.ToArray(typeof(IPAddress)) as IPAddress [];
} else {
hostentry.AddressList = new IPAddress [] { address };
}
ServiceResolvedEventHandler handler = Resolved;
if(handler != null) {
handler(this, new ServiceResolvedEventArgs(this));
}
break;
case ServiceType.TXT:
if(TxtRecord != null) {
TxtRecord.Dispose();
}
TxtRecord = new TxtRecord(rdlen, rdata);
break;
default:
break;
}
sdRef.Deallocate();
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = fullname;
this.port = (ushort)IPAddress.NetworkToHostOrder((short)port);
TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv4) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (AddressProtocol == AddressProtocol.Any || AddressProtocol == AddressProtocol.IPv6) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A6, ServiceClass.IN, query_record_reply_handler, IntPtr.Zero);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
}
public static extern ServiceError DNSServiceRegister(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, string name, string regtype, string domain, string host, ushort port,
ushort txtLen, byte [] txtRecord, DNSServiceRegisterReply callBack, IntPtr context);
public static extern ServiceError DNSServiceRegister(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, byte[] name, string regtype, string domain, string host, ushort port,
ushort txtLen, byte [] txtRecord, DNSServiceRegisterReply callBack, IntPtr context);
public IpAddress(ServiceFlags serviceFlag, byte[] ipv6, UInt16 port)
{
ServiceFlag = serviceFlag;
Ipv6 = ipv6;
Port = port;
}
private static void OnRegisterReply(ServiceRef sdRef, ServiceFlags flags, ServiceError errorCode,
string name, string regtype, string domain, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var registerService = handle.Target as RegisterService;
RegisterServiceEventArgs args = new RegisterServiceEventArgs();
args.Service = registerService;
args.IsRegistered = false;
args.ServiceError = (ServiceErrorCode)errorCode;
if(errorCode == ServiceError.NoError) {
registerService.Name = name;
registerService.RegType = regtype;
registerService.ReplyDomain = domain;
args.IsRegistered = true;
}
RegisterServiceEventHandler handler = registerService.Response;
if(handler != null) {
handler(registerService, args);
}
}
private void OnQueryRecordReply(ServiceRef sdRef,
ServiceFlags flags,
uint interfaceIndex,
ServiceError errorCode,
string fullname,
ServiceType rrtype,
ServiceClass rrclass,
ushort rdlen,
IntPtr rdata,
uint ttl,
IntPtr context)
{
switch (rrtype)
{
case ServiceType.A:
case ServiceType.AAAA:
IPAddress address;
if (rdlen == 4)
{
// ~4.5 times faster than Marshal.Copy into byte[4]
var addressRaw = (uint)(Marshal.ReadByte(rdata, 3) << 24);
addressRaw |= (uint)(Marshal.ReadByte(rdata, 2) << 16);
addressRaw |= (uint)(Marshal.ReadByte(rdata, 1) << 8);
addressRaw |= Marshal.ReadByte(rdata, 0);
address = new IPAddress(addressRaw);
}
else if (rdlen == 16)
{
var addressRaw = new byte[rdlen];
Marshal.Copy(rdata, addressRaw, 0, rdlen);
address = new IPAddress(addressRaw, interfaceIndex);
}
else
{
break;
}
if (this.hostentry == null)
{
this.hostentry = new IPHostEntry {
HostName = this.hosttarget
};
}
if (this.hostentry.AddressList != null)
{
var list = new ArrayList(this.hostentry.AddressList)
{
address
};
this.hostentry.AddressList = list.ToArray(typeof(IPAddress)) as IPAddress[];
}
else
{
this.hostentry.AddressList = new[] { address };
}
//ServiceResolvedEventHandler handler = this.Resolved ;
//if (handler != null)
// handler (this, new ServiceResolvedEventArgs (this)) ;
break;
case ServiceType.TXT:
this.TxtRecord?.Dispose();
this.TxtRecord = new TxtRecord(rdlen, rdata);
break;
}
if ((flags & ServiceFlags.MoreComing) != ServiceFlags.MoreComing)
{
sdRef.Deallocate();
}
}
public ServiceBinding(Service service, ServiceFlags flags)
{
Service = service;
Flags = flags;
}
//
// OnBrowseReply
//
// This call is invoked by the DNSService core. It is
// executed in the context of a worker thread, not the
// main (GUI) thread. We create a BrowseData object
// and invoked the appropriate method in the GUI thread
// so we can update the UI
//
private void OnBrowseReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain
)
{
if (errorCode == ErrorCode.NoError)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = interfaceIndex;
data.Name = name;
data.Type = type;
data.Domain = domain;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addServiceCallback, new Object[]{data});
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removeServiceCallback, new Object[]{data});
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code: " + errorCode, "Error");
}
}
public static extern ServiceError DNSServiceQueryRecord(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, string fullname, ServiceType rrtype, ServiceClass rrclass,
DNSServiceQueryRecordReply callBack, IntPtr context);
public static extern ServiceError DNSServiceResolve(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, byte[] name, string regtype, string domain, DNSServiceResolveReply callBack,
IntPtr context);
/// <summary>
/// The set download flags.
/// </summary>
/// <param name="flags">
/// The flags.
/// </param>
public void SetDownloadFlags(ServiceFlags flags)
{
DownloadsDatabase.Flags = flags;
}
public static extern ServiceError DNSServiceQueryRecord(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, string fullname, ServiceType rrtype, ServiceClass rrclass,
DNSServiceQueryRecordReply callBack, IntPtr context);
public static extern ServiceError DNSServiceResolve(out ServiceRef sdRef, ServiceFlags flags,
uint interfaceIndex, string name, string regtype, string domain, DNSServiceResolveReply callBack,
IntPtr context);
private static void OnBrowseReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex, ServiceError errorCode,
string serviceName, string regtype, string replyDomain, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var serviceBrowser = handle.Target as ServiceBrowser;
BrowseService service = new BrowseService();
service.Flags = flags;
service.Name = serviceName;
service.RegType = regtype;
service.ReplyDomain = replyDomain;
service.InterfaceIndex = interfaceIndex;
service.AddressProtocol = serviceBrowser.address_protocol;
Log.To.Discovery.V(TAG, "{0} (0x{1}) entered OnBrowseReply (found={2} flags={3})",
serviceBrowser, sdRef.Raw.ToString("X"), service, flags);
ServiceBrowseEventArgs args = new ServiceBrowseEventArgs(
service, (flags & ServiceFlags.MoreComing) != 0);
if((flags & ServiceFlags.Add) != 0) {
lock (serviceBrowser.service_table) {
if (serviceBrowser.service_table.ContainsKey (serviceName)) {
serviceBrowser.service_table[serviceName] = service;
} else {
serviceBrowser.service_table.Add (serviceName, service);
}
}
ServiceBrowseEventHandler handler = serviceBrowser._serviceAdded;
if(handler != null) {
handler(serviceBrowser, args);
}
} else {
lock (serviceBrowser.service_table) {
if (serviceBrowser.service_table.ContainsKey (serviceName)) {
serviceBrowser.service_table.Remove (serviceName);
}
}
ServiceBrowseEventHandler handler = serviceBrowser._serviceRemoved;
if(handler != null) {
handler(serviceBrowser, args);
}
service.Dispose();
}
}
private void OnRegisterReply(ServiceRef sdRef, ServiceFlags flags, ServiceError errorCode,
string name, string regtype, string domain, IntPtr context)
{
RegisterServiceEventArgs args = new RegisterServiceEventArgs();
args.Service = this;
args.IsRegistered = false;
args.ServiceError = (ServiceErrorCode)errorCode;
if(errorCode == ServiceError.NoError) {
Name = name;
RegType = regtype;
ReplyDomain = domain;
args.IsRegistered = true;
}
RegisterServiceEventHandler handler = Response;
if(handler != null) {
handler(this, args);
}
}
private void OnResolveReply(ServiceRef sdRef,
ServiceFlags flags,
uint interfaceIndex,
ServiceError errorCode,
IntPtr fullname,
string hosttarget,
ushort port,
ushort txtLen,
IntPtr txtRecord,
IntPtr contex)
{
this.IsResolved = true;
this.resolvePending = false;
this.InterfaceIndex = interfaceIndex;
this.FullName = Native.Utf8toString(fullname);
this.port = (ushort)IPAddress.NetworkToHostOrder((short)port);
this.TxtRecord = new TxtRecord(txtLen, txtRecord);
this.hosttarget = hosttarget;
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if ((this.AddressProtocol == AddressProtocol.Any) || (this.AddressProtocol == AddressProtocol.IPv4))
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref,
ServiceFlags.None,
interfaceIndex,
hosttarget,
ServiceType.A,
ServiceClass.IN,
this.queryRecordReplyHandler,
IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if ((this.AddressProtocol == AddressProtocol.Any) || (this.AddressProtocol == AddressProtocol.IPv6))
{
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref,
ServiceFlags.None,
interfaceIndex,
hosttarget,
ServiceType.AAAA,
ServiceClass.IN,
this.queryRecordReplyHandler,
IntPtr.Zero);
if (error != ServiceError.NoError)
{
throw new ServiceErrorException(error);
}
sd_ref.Process();
}
if (this.hostentry.AddressList != null)
{
ServiceResolvedEventHandler handler = this.Resolved;
handler?.Invoke(this, new ServiceResolvedEventArgs(this));
}
}
private void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr contex)
{
is_resolved = true;
resolve_pending = false;
InterfaceIndex = interfaceIndex;
FullName = fullname;
HostTarget = hosttarget;
this.port = (short)port;
TxtRecord = new TxtRecord(txtLen, txtRecord);
EventHandler handler = Resolved;
if(handler != null) {
handler(this, new EventArgs());
}
sdRef.Deallocate();
}
private void OnQueryRecordReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, ServiceType rrtype, ServiceClass rrclass, ushort rdlen,
IntPtr rdata, uint ttl, IntPtr context)
{
switch (rrtype)
{
case ServiceType.A:
IPAddress address;
if (rdlen == 4)
{
// ~4.5 times faster than Marshal.Copy into byte[4]
uint address_raw = (uint)(Marshal.ReadByte(rdata, 3) << 24);
address_raw |= (uint)(Marshal.ReadByte(rdata, 2) << 16);
address_raw |= (uint)(Marshal.ReadByte(rdata, 1) << 8);
address_raw |= (uint)Marshal.ReadByte(rdata, 0);
address = new IPAddress(address_raw);
}
else if (rdlen == 16)
{
byte [] address_raw = new byte[rdlen];
Marshal.Copy(rdata, address_raw, 0, rdlen);
address = new IPAddress(address_raw, interfaceIndex);
}
else
{
break;
}
if (hostentry == null)
{
hostentry = new IPHostEntry();
hostentry.HostName = hosttarget;
}
if (hostentry.AddressList != null)
{
ArrayList list = new ArrayList(hostentry.AddressList);
list.Add(address);
hostentry.AddressList = list.ToArray(typeof(IPAddress)) as IPAddress [];
}
else
{
hostentry.AddressList = new IPAddress [] { address };
}
ServiceResolvedEventHandler handler = Resolved;
if (handler != null)
{
handler(this, new ServiceResolvedEventArgs(this));
}
break;
case ServiceType.TXT:
if (TxtRecord != null)
{
TxtRecord.Dispose();
}
TxtRecord = new TxtRecord(rdlen, rdata);
break;
default:
break;
}
sdRef.Deallocate();
}
/// <summary>
/// The set download flags.
/// </summary>
/// <param name="flags">
/// The flags.
/// </param>
public void SetDownloadFlags(ServiceFlags flags)
{
DownloadsDatabase.Flags = flags;
}
private void OnBrowseReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex, ServiceError errorCode,
string serviceName, string regtype, string replyDomain, IntPtr context)
{
BrowseService service = new BrowseService();
service.Flags = flags;
service.Name = serviceName;
service.RegType = regtype;
service.ReplyDomain = replyDomain;
service.InterfaceIndex = interfaceIndex;
service.AddressProtocol = address_protocol;
ServiceBrowseEventArgs args = new ServiceBrowseEventArgs(
service, (flags & ServiceFlags.MoreComing) != 0);
if((flags & ServiceFlags.Add) != 0) {
lock (service_table) {
if (service_table.ContainsKey (serviceName)) {
service_table[serviceName] = service;
} else {
service_table.Add (serviceName, service);
}
}
ServiceBrowseEventHandler handler = ServiceAdded;
if(handler != null) {
handler(this, args);
}
} else {
lock (service_table) {
if (service_table.ContainsKey (serviceName)) {
service_table.Remove (serviceName);
}
}
ServiceBrowseEventHandler handler = ServiceRemoved;
if(handler != null) {
handler(this, args);
}
}
}
private static void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var browseService = handle.Target as BrowseService;
Log.To.Discovery.V(Tag, "Resolve reply received for {0} (0x{1}), entering DNSServiceQueryRecord next",
browseService, sdRef.Raw.ToString("X"));
browseService.is_resolved = true;
browseService.resolve_pending = false;
browseService.InterfaceIndex = interfaceIndex;
browseService.FullName = fullname;
browseService.Port = (ushort)IPAddress.NetworkToHostOrder((short)port);
browseService.TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv4) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, browseService.query_record_reply_handler, context);
if(error != ServiceError.NoError) {
Log.To.Discovery.W(Tag, "Error in DNSServiceQueryRecord {0}", error);
browseService.Error(browseService, new ServiceErrorEventArgs("ResolveReply (IPv4)", error));
sd_ref.Deallocate();
return;
}
sd_ref.ProcessSingle(ServiceParams.Timeout);
}
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv6) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.AAAA, ServiceClass.IN, browseService.query_record_reply_handler, context);
if(error != ServiceError.NoError) {
if(error != ServiceError.NoError) {
Log.To.Discovery.W(Tag, "Error in DNSServiceQueryRecord {0}", error);
browseService.Error(browseService, new ServiceErrorEventArgs("ResolveReply (IPv6)", error));
sd_ref.Deallocate();
return;
}
}
sd_ref.ProcessSingle(ServiceParams.Timeout);
}
}
//
// OnBrowseReply
//
// Called by DNSServices core as a result of DNSService.Browse()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnBrowseReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = interfaceIndex;
peer.Name = name;
peer.Type = type;
peer.Domain = domain;
peer.Address = null;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addPeerCallback, new Object[]{peer});
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removePeerCallback, new Object[]{peer});
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code " + errorCode, "Error");
}
}
//
// OnRegisterReply
//
// Called by DNSServices core as a result of DNSService.Register()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnRegisterReply(
ServiceRef sdRef,
ServiceFlags flags,
ErrorCode errorCode,
String name,
String regtype,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
Invoke(registerServiceCallback, new Object[]{name});
}
else
{
MessageBox.Show("OnRegisterReply returned an error code " + errorCode, "Error");
}
}
private static void OnQueryRecordReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, ServiceType rrtype, ServiceClass rrclass, ushort rdlen,
IntPtr rdata, uint ttl, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var browseService = handle.Target as BrowseService;
switch(rrtype) {
case ServiceType.A:
IPAddress address;
if(rdlen == 4) {
// ~4.5 times faster than Marshal.Copy into byte[4]
uint address_raw = (uint)(Marshal.ReadByte (rdata, 3) << 24);
address_raw |= (uint)(Marshal.ReadByte (rdata, 2) << 16);
address_raw |= (uint)(Marshal.ReadByte (rdata, 1) << 8);
address_raw |= (uint)Marshal.ReadByte (rdata, 0);
address = new IPAddress(address_raw);
} else if(rdlen == 16) {
byte [] address_raw = new byte[rdlen];
Marshal.Copy(rdata, address_raw, 0, rdlen);
address = new IPAddress(address_raw, interfaceIndex);
} else {
break;
}
if(browseService.hostentry == null) {
browseService.hostentry = new IPHostEntry();
browseService.hostentry.HostName = browseService.hosttarget;
}
if(browseService.hostentry.AddressList != null) {
ArrayList list = new ArrayList(browseService.hostentry.AddressList);
list.Add(address);
browseService.hostentry.AddressList = list.ToArray(typeof(IPAddress)) as IPAddress [];
} else {
browseService.hostentry.AddressList = new IPAddress [] { address };
}
Log.To.Discovery.V(Tag, "Query record reply received for {0} (0x{1})", browseService, sdRef.Raw.ToString("X"));
ServiceResolvedEventHandler handler = browseService._resolved;
if(handler != null) {
handler(browseService, new ServiceResolvedEventArgs(browseService));
}
break;
case ServiceType.TXT:
if(browseService.TxtRecord != null) {
browseService.TxtRecord.Dispose();
}
browseService.TxtRecord = new TxtRecord(rdlen, rdata);
break;
default:
break;
}
sdRef.Deallocate();
}
private static void OnResolveReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex,
ServiceError errorCode, string fullname, string hosttarget, ushort port, ushort txtLen,
IntPtr txtRecord, IntPtr context)
{
var handle = GCHandle.FromIntPtr(context);
var browseService = handle.Target as BrowseService;
browseService.is_resolved = true;
browseService.resolve_pending = false;
browseService.InterfaceIndex = interfaceIndex;
browseService.FullName = fullname;
browseService.Port = (ushort)IPAddress.NetworkToHostOrder((short)port);
browseService.TxtRecord = new TxtRecord(txtLen, txtRecord);
sdRef.Deallocate();
// Run an A query to resolve the IP address
ServiceRef sd_ref;
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv4) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.A, ServiceClass.IN, browseService.query_record_reply_handler, context);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process(ServiceParams.Timeout);
}
if (browseService.AddressProtocol == AddressProtocol.Any || browseService.AddressProtocol == AddressProtocol.IPv6) {
ServiceError error = Native.DNSServiceQueryRecord(out sd_ref, ServiceFlags.None, interfaceIndex,
hosttarget, ServiceType.AAAA, ServiceClass.IN, browseService.query_record_reply_handler, context);
if(error != ServiceError.NoError) {
throw new ServiceErrorException(error);
}
sd_ref.Process(ServiceParams.Timeout);
}
}
//
// OnQueryRecordReply
//
// Called by DNSServices core as a result of DNSService.QueryRecord()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnQueryRecordReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
int rrtype,
int rrclass,
Byte[] rdata,
int ttl
)
{
if (errorCode == ErrorCode.NoError)
{
uint bits = BitConverter.ToUInt32(rdata, 0);
System.Net.IPAddress data = new System.Net.IPAddress(bits);
Invoke(resolveAddressCallback, new Object[]{data});
}
else
{
MessageBox.Show("OnQueryRecordReply returned an error code: " + errorCode, "Error");
}
}
private void OnBrowseReply(ServiceRef sdRef, ServiceFlags flags, uint interfaceIndex, ServiceError errorCode,
string serviceName, string regtype, string replyDomain, IntPtr context)
{
BrowseService service = new BrowseService();
service.Flags = flags;
service.Name = serviceName;
service.RegType = regtype;
service.ReplyDomain = replyDomain;
service.InterfaceIndex = interfaceIndex;
ServiceBrowseEventArgs args = new ServiceBrowseEventArgs();
args.Service = service;
args.MoreComing = (flags & ServiceFlags.MoreComing) != 0;
if((flags & ServiceFlags.Add) != 0) {
lock(service_table.SyncRoot) {
service_table[serviceName] = service;
}
ServiceBrowseEventHandler handler = ServiceAdded;
if(handler != null) {
handler(this, args);
}
} else {
lock(service_table.SyncRoot) {
service_table.Remove(serviceName);
}
ServiceBrowseEventHandler handler = ServiceRemoved;
if(handler != null) {
handler(this, args);
}
}
}
//
// OnResolveReply
//
// Called by DNSServices core as a result of DNSService.Resolve()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnResolveReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
String hostName,
int port,
Byte[] txtRecord
)
{
if (errorCode == ErrorCode.NoError)
{
ResolveData data = new ResolveData();
data.InterfaceIndex = interfaceIndex;
data.FullName = fullName;
data.HostName = hostName;
data.Port = port;
data.TxtRecord = txtRecord;
Invoke(resolveServiceCallback, new Object[]{data});
}
else
{
MessageBox.Show("OnResolveReply returned an error code: " + errorCode, "Error");
}
}
public void dont_throws_exceptions()
{
Assert.DoesNotThrow(() => exec(ServiceFlags.CreateNew()));
}
