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 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 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(); }
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())); }