/// <summary> /// Produces a command socket to the FTP server /// </summary> /// <returns></returns> private async Task ConnectCommandSocketAsync() { try { Logger?.LogDebug($"Connecting command socket, {Configuration.Host}:{Configuration.Port}"); var ipEndpoint = await dnsResolver.ResolveAsync(Configuration.Host, Configuration.Port, Configuration.IpVersion); commandSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { ReceiveTimeout = Configuration.TimeoutSeconds * 1000 }; commandSocket.Connect(ipEndpoint); var response = await GetResponseAsync(); await BailIfResponseNotAsync(response, FtpStatusCode.SendUserCommand); } catch (Exception ex) { Logger?.LogDebug("Connecting to command socket failed"); await LogOutAsync(); throw new FtpException("Unable to login to FTP server", ex); } }
/// <summary> /// Queries a dns resolver for IP addresses of a host as an asynchronous operation. /// </summary> /// <param name="resolver"> The resolver instance, that should be used for queries </param> /// <param name="name"> Host name, that should be queried </param> /// <param name="token"> The token to monitor cancellation requests </param> /// <returns> A list of matching host addresses </returns> public static async Task <List <IPAddress> > ResolveHostAsync(this IDnsResolver resolver, DomainName name, CancellationToken token = default(CancellationToken)) { List <IPAddress> result = new List <IPAddress>(); List <AaaaRecord> aaaaRecords = await resolver.ResolveAsync <AaaaRecord>(name, RecordType.Aaaa, token : token); if (aaaaRecords != null) { result.AddRange(aaaaRecords.Select(x => x.Address)); } List <ARecord> aRecords = await resolver.ResolveAsync <ARecord>(name, token : token); if (aRecords != null) { result.AddRange(aRecords.Select(x => x.Address)); } return(result); }
/// <summary> /// Forces to update all hints using the given resolver /// </summary> /// <param name="resolver">The resolver to use for resolving the new hints</param> #if NETSTANDARD public async System.Threading.Tasks.Task UpdateAsync(IDnsResolver resolver) { Zone zone = new Zone(DomainName.Root); var nameServer = await resolver.ResolveAsync <NsRecord>(DomainName.Root, RecordType.Ns); zone.AddRange(nameServer); var aRecordTasks = new List <System.Threading.Tasks.Task <List <ARecord> > >(nameServer.Count); var aaaaRecordTasks = new List <System.Threading.Tasks.Task <List <AaaaRecord> > >(nameServer.Count); var dnsKeyRecordTask = resolver.ResolveAsync <DnsKeyRecord>(DomainName.Root, RecordType.DnsKey); foreach (var nsRecord in nameServer) { aRecordTasks.Add(resolver.ResolveAsync <ARecord>(nsRecord.NameServer, RecordType.A)); aaaaRecordTasks.Add(resolver.ResolveAsync <AaaaRecord>(nsRecord.NameServer, RecordType.Aaaa)); } var aRecords = await System.Threading.Tasks.Task.WhenAll(aRecordTasks); foreach (var aRecordList in aRecords) { zone.AddRange(aRecordList); } var aaaaRecords = await System.Threading.Tasks.Task.WhenAll(aaaaRecordTasks); foreach (var aaaaRecordList in aaaaRecords) { zone.AddRange(aaaaRecordList); } zone.AddRange((await dnsKeyRecordTask).Where(x => x.IsSecureEntryPoint)); LoadZoneInternal(zone); Save(zone); }
protected async Task <Socket> ConnectSocketAsync(string host, int port, CancellationToken token) { try { Logger?.LogDebug("Connecting"); var ipEndpoint = await dnsResolver.ResolveAsync(host, port, Configuration.IpVersion, token); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { ReceiveTimeout = Configuration.TimeoutSeconds * 1000 }; socket.Connect(ipEndpoint); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true); return(socket); } catch (Exception exception) { Logger?.LogError($"Could not to connect socket {host}:{port} - {exception.Message}", exception); throw; } }
/// <summary> /// Queries a dns resolver for specified records as an asynchronous operation. /// </summary> /// <typeparam name="T"> Type of records, that should be returned </typeparam> /// <param name="resolver"> The resolver instance, that should be used for queries </param> /// <param name="name"> Domain, that should be queried </param> /// <param name="recordType"> Type the should be queried </param> /// <param name="recordClass"> Class the should be queried </param> /// <param name="token"> The token to monitor cancellation requests </param> /// <returns> A list of matching <see cref="DnsRecordBase">records</see> </returns> public static Task <List <T> > ResolveAsync <T>(this IDnsResolver resolver, string name, RecordType recordType = RecordType.A, RecordClass recordClass = RecordClass.INet, CancellationToken token = default(CancellationToken)) where T : DnsRecordBase { return(resolver.ResolveAsync <T>(DomainName.Parse(name), recordType, recordClass, token)); }
/// <summary> /// Queries a dns resolver for reverse name of an IP address as an asynchronous operation. /// </summary> /// <param name="resolver"> The resolver instance, that should be used for queries </param> /// <param name="address"> The address, that should be queried </param> /// <param name="token"> The token to monitor cancellation requests </param> /// <returns> The reverse name of the IP address </returns> public static async Task <DomainName> ResolvePtrAsync(this IDnsResolver resolver, IPAddress address, CancellationToken token = default(CancellationToken)) { List <PtrRecord> ptrRecords = await resolver.ResolveAsync <PtrRecord>(address.GetReverseLookupDomain(), RecordType.Ptr, token : token); return(ptrRecords.Select(x => x.PointerDomainName).FirstOrDefault()); }