internal static InterfaceRadio GetInterfaceRadio(Base.WlanClient client, Guid interfaceId)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException(nameof(interfaceId));
}
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var capability = Base.GetInterfaceCapability(container.Content.Handle, interfaceId);
var states = Base.GetPhyRadioStates(container.Content.Handle, interfaceId); // The underlying collection is array.
if ((capability.interfaceType == WLAN_INTERFACE_TYPE.wlan_interface_type_invalid) ||
(capability.dwNumberOfSupportedPhys != states.Count()))
{
return(null);
}
var radioSets = Enumerable.Zip(
capability.dot11PhyTypes,
states.OrderBy(x => x.dwPhyIndex),
(x, y) => new RadioSet(
type: PhyTypeConverter.Convert(x),
softwareOn: ConvertToNullableBoolean(y.dot11SoftwareRadioState),
hardwareOn: ConvertToNullableBoolean(y.dot11HardwareRadioState)));
return(new InterfaceRadio(
id: interfaceId,
radioSets: radioSets));
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Returns true if the command executed successfully such that the transition to the next state should occurr, false
/// if the current state is to be maintained.</returns>
internal override async Task <bool> ExecuteAsync(SmtpSessionContext context, CancellationToken cancellationToken)
{
using (var container = new DisposableContainer <IMailboxFilter>(Options.MailboxFilterFactory.CreateInstance(context)))
{
switch (await container.Instance.CanDeliverToAsync(context, Address, context.Transaction.From, cancellationToken).ConfigureAwait(false))
{
case MailboxFilterResult.Yes:
context.Transaction.To.Add(Address);
await context.NetworkClient.ReplyAsync(SmtpResponse.Ok, cancellationToken).ConfigureAwait(false);
return(true);
case MailboxFilterResult.NoTemporarily:
await context.NetworkClient.ReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken).ConfigureAwait(false);
return(false);
case MailboxFilterResult.NoPermanently:
await context.NetworkClient.ReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken).ConfigureAwait(false);
return(false);
}
}
throw new NotSupportedException("The Acceptance state is not supported.");
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which asynchronously performs the execution.</returns>
internal override async Task ExecuteAsync(SmtpSessionContext context, CancellationToken cancellationToken)
{
if (context.Transaction.To.Count == 0)
{
await context.Client.ReplyAsync(SmtpResponse.NoValidRecipientsGiven, cancellationToken).ConfigureAwait(false);
return;
}
await context.Client.ReplyAsync(new SmtpResponse(SmtpReplyCode.StartMailInput, "end with <CRLF>.<CRLF>"), cancellationToken).ConfigureAwait(false);
context.Transaction.Message = await ReadMessageAsync(context, cancellationToken).ConfigureAwait(false);
try
{
// store the transaction
using (var container = new DisposableContainer <IMessageStore>(Options.MessageStoreFactory.CreateInstance(context)))
{
var response = await container.Instance.SaveAsync(context, context.Transaction, cancellationToken).ConfigureAwait(false);
await context.Client.ReplyAsync(response, cancellationToken).ConfigureAwait(false);
}
}
catch (Exception)
{
await context.Client.ReplyAsync(new SmtpResponse(SmtpReplyCode.TransactionFailed), cancellationToken).ConfigureAwait(false);
}
}
internal static bool ConnectNetwork(Base.WlanClient client, Guid interfaceId, string profileName, BssType bssType, PhysicalAddress bssid = null)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException("The specified interface ID is invalid.", nameof(interfaceId));
}
if (string.IsNullOrWhiteSpace(profileName))
{
throw new ArgumentNullException(nameof(profileName));
}
using var container = new DisposableContainer <Base.WlanClient>(client);
if (bssid is not null)
{
var dot11MacAddress = new DOT11_MAC_ADDRESS {
ucDot11MacAddress = bssid.GetAddressBytes()
};
return(Base.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType), dot11MacAddress));
}
else
{
return(Base.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType)));
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which asynchronously performs the execution.</returns>
public override async Task ExecuteAsync(ISmtpSessionContext context, CancellationToken cancellationToken)
{
using (var container = new DisposableContainer <IMailboxFilter>(_mailboxFilterFactory.CreateInstance(context)))
{
switch (await container.Instance.CanDeliverToAsync(context, _address, context.Transaction.From))
{
case MailboxFilterResult.Yes:
context.Transaction.To.Add(_address);
await context.Text.ReplyAsync(SmtpResponse.Ok, cancellationToken);
return;
case MailboxFilterResult.NoTemporarily:
await context.Text.ReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken);
return;
case MailboxFilterResult.NoPermanently:
await context.Text.ReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken);
return;
}
}
throw new NotSupportedException("The Acceptance state is not supported.");
}
internal static IEnumerable <ProfilePack> EnumerateProfiles(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in EnumerateInterfaces(container.Content))
{
int position = 0;
foreach (var profileInfo in Base.GetProfileInfoList(container.Content.Handle, interfaceInfo.Id))
{
var profileXml = Base.GetProfile(container.Content.Handle, interfaceInfo.Id, profileInfo.strProfileName, out uint profileTypeFlag);
if (string.IsNullOrWhiteSpace(profileXml))
{
continue;
}
if (!ProfileTypeConverter.TryConvert(profileTypeFlag, out ProfileType profileType))
{
continue;
}
yield return(new ProfilePack(
name: profileInfo.strProfileName,
interfaceInfo: interfaceInfo,
profileType: profileType,
profileXml: profileXml,
position: position++));
}
}
}
internal static IEnumerable <ProfilePack> EnumerateProfiles(Base.WlanClient client)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var interfaceInfoList = Base.GetInterfaceInfoList(container.Content.Handle);
foreach (var interfaceInfo in interfaceInfoList.Select(x => new InterfaceInfo(x)))
{
var interfaceIsConnected = (interfaceInfo.State == InterfaceState.Connected);
var interfaceIsRadioOn = interfaceIsConnected || IsInterfaceRadioOn(container.Content, interfaceInfo.Id);
var availableNetworkList = Base.GetAvailableNetworkList(container.Content.Handle, interfaceInfo.Id)
.Where(x => !string.IsNullOrWhiteSpace(x.strProfileName))
.ToArray();
var connection = Base.GetConnectionAttributes(container.Content.Handle, interfaceInfo.Id);
var profileInfoList = Base.GetProfileInfoList(container.Content.Handle, interfaceInfo.Id);
int position = 0;
foreach (var profileInfo in profileInfoList)
{
var availableNetwork = availableNetworkList.FirstOrDefault(x => string.Equals(x.strProfileName, profileInfo.strProfileName, StringComparison.Ordinal));
var signalQuality = (int)availableNetwork.wlanSignalQuality;
var profileIsConnected = interfaceIsConnected && string.Equals(connection.strProfileName, profileInfo.strProfileName, StringComparison.Ordinal);
var profileXml = Base.GetProfile(container.Content.Handle, interfaceInfo.Id, profileInfo.strProfileName, out uint profileTypeFlag);
if (string.IsNullOrWhiteSpace(profileXml))
{
continue;
}
if (!ProfileTypeConverter.TryConvert(profileTypeFlag, out ProfileType profileType))
{
continue;
}
//Debug.WriteLine("Interface: {0}, Profile: {1}, Position: {2}, RadioOn: {3}, Signal: {4}, Connected: {5}",
// interfaceInfo.Description,
// profileInfo.strProfileName,
// position,
// interfaceIsRadioOn,
// signalQuality,
// profileIsConnected);
yield return(new ProfilePack(
name: profileInfo.strProfileName,
interfaceInfo: interfaceInfo,
profileType: profileType,
profileXml: profileXml,
position: position++,
isRadioOn: interfaceIsRadioOn,
signalQuality: signalQuality,
isConnected: profileIsConnected));
}
}
}
}
internal static IEnumerable <AvailableNetworkPack> EnumerateAvailableNetworks(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in EnumerateInterfaces(container.Content))
{
foreach (var availableNetwork in Base.GetAvailableNetworkList(container.Content.Handle, interfaceInfo.Id))
{
if (!BssTypeConverter.TryConvert(availableNetwork.dot11BssType, out BssType bssType))
{
continue;
}
if (!AuthenticationAlgorithmConverter.TryConvert(availableNetwork.dot11DefaultAuthAlgorithm, out AuthenticationAlgorithm authenticationAlgorithm))
{
continue;
}
if (!CipherAlgorithmConverter.TryConvert(availableNetwork.dot11DefaultCipherAlgorithm, out CipherAlgorithm cipherAlgorithm))
{
continue;
}
yield return(new AvailableNetworkPack(
interfaceInfo: interfaceInfo,
ssid: new NetworkIdentifier(availableNetwork.dot11Ssid),
bssType: bssType,
signalQuality: (int)availableNetwork.wlanSignalQuality,
isSecurityEnabled: availableNetwork.bSecurityEnabled,
profileName: availableNetwork.strProfileName,
authenticationAlgorithm: authenticationAlgorithm,
cipherAlgorithm: cipherAlgorithm));
}
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Returns true if the command executed successfully such that the transition to the next state should occurr, false
/// if the current state is to be maintained.</returns>
internal override async Task <bool> ExecuteAsync(SmtpSessionContext context, CancellationToken cancellationToken)
{
var mailboxFilter = context.ServiceProvider.GetService <IMailboxFilterFactory, IMailboxFilter>(context, MailboxFilter.Default);
using var container = new DisposableContainer <IMailboxFilter>(mailboxFilter);
switch (await container.Instance.CanDeliverToAsync(context, Address, context.Transaction.From, cancellationToken).ConfigureAwait(false))
{
case MailboxFilterResult.Yes:
context.Transaction.To.Add(Address);
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.Ok, cancellationToken).ConfigureAwait(false);
return(true);
case MailboxFilterResult.NoTemporarily:
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken).ConfigureAwait(false);
return(false);
case MailboxFilterResult.NoPermanently:
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken).ConfigureAwait(false);
return(false);
}
throw new NotSupportedException("The Acceptance state is not supported.");
}
internal static IEnumerable <InterfaceInfo> EnumerateInterfaces(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
return(Base.GetInterfaceInfoList(container.Content.Handle)
.Select(x => new InterfaceInfo(x)));
}
internal static IEnumerable <AvailableNetworkPack> EnumerateAvailableNetworks(Base.WlanClient client)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var interfaceInfoList = Base.GetInterfaceInfoList(container.Content.Handle);
foreach (var interfaceInfo in interfaceInfoList.Select(x => new InterfaceInfo(x)))
{
var availableNetworkList = Base.GetAvailableNetworkList(container.Content.Handle, interfaceInfo.Id);
foreach (var availableNetwork in availableNetworkList)
{
if (!BssTypeConverter.TryConvert(availableNetwork.dot11BssType, out BssType bssType))
{
continue;
}
//Debug.WriteLine("Interface: {0}, SSID: {1}, Signal: {2}, Security: {3}",
// interfaceInfo.Description,
// availableNetwork.dot11Ssid,
// availableNetwork.wlanSignalQuality,
// availableNetwork.bSecurityEnabled);
yield return(new AvailableNetworkPack(
interfaceInfo: interfaceInfo,
ssid: new NetworkIdentifier(availableNetwork.dot11Ssid.ToBytes(), availableNetwork.dot11Ssid.ToString()),
bssType: bssType,
signalQuality: (int)availableNetwork.wlanSignalQuality,
isSecurityEnabled: availableNetwork.bSecurityEnabled,
profileName: availableNetwork.strProfileName));
}
}
}
}
internal static IEnumerable <NetworkIdentifier> EnumerateConnectedNetworkSsids(Base.WlanClient client)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var interfaceInfoList = Base.GetInterfaceInfoList(container.Content.Handle);
foreach (var interfaceInfo in interfaceInfoList)
{
var connection = Base.GetConnectionAttributes(container.Content.Handle, interfaceInfo.InterfaceGuid);
if (connection.isState != WLAN_INTERFACE_STATE.wlan_interface_state_connected)
{
continue;
}
var association = connection.wlanAssociationAttributes;
//Debug.WriteLine("Interface: {0}, SSID: {1}, BSSID: {2}, Signal: {3}",
// interfaceInfo.strInterfaceDescription,
// association.dot11Ssid,
// association.dot11Bssid,
// association.wlanSignalQuality);
yield return(new NetworkIdentifier(association.dot11Ssid.ToBytes(), association.dot11Ssid.ToString()));
}
}
}
internal static bool DisconnectNetwork(Base.WlanClient client, Guid interfaceId)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException("The specified interface ID is invalid.", nameof(interfaceId));
}
using var container = new DisposableContainer <Base.WlanClient>(client);
return(Base.Disconnect(container.Content.Handle, interfaceId));
}
internal static IEnumerable <string> EnumerateProfileNames(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in Base.GetInterfaceInfoList(container.Content.Handle))
{
foreach (var profileInfo in Base.GetProfileInfoList(container.Content.Handle, interfaceInfo.InterfaceGuid))
{
yield return(profileInfo.strProfileName);
}
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Returns true if the command executed successfully such that the transition to the next state should occurr, false
/// if the current state is to be maintained.</returns>
internal override async Task <bool> ExecuteAsync(SmtpSessionContext context, CancellationToken cancellationToken)
{
if (context.EndpointDefinition.AuthenticationRequired && context.Authentication.IsAuthenticated == false)
{
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.AuthenticationRequired, cancellationToken).ConfigureAwait(false);
return(false);
}
context.Transaction.Reset();
context.Transaction.Parameters = Parameters;
// check if a size has been defined
var size = GetMessageSize();
// check against the server supplied maximum
if (context.ServerOptions.MaxMessageSize > 0 && size > context.ServerOptions.MaxMessageSize)
{
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.SizeLimitExceeded, cancellationToken).ConfigureAwait(false);
return(false);
}
var mailboxFilter = context.ServiceProvider.GetService <IMailboxFilterFactory, IMailboxFilter>(context, MailboxFilter.Default);
using var container = new DisposableContainer <IMailboxFilter>(mailboxFilter);
switch (await container.Instance.CanAcceptFromAsync(context, Address, size, cancellationToken).ConfigureAwait(false))
{
case MailboxFilterResult.Yes:
context.Transaction.From = Address;
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.Ok, cancellationToken).ConfigureAwait(false);
return(true);
case MailboxFilterResult.NoTemporarily:
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken).ConfigureAwait(false);
return(false);
case MailboxFilterResult.NoPermanently:
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken).ConfigureAwait(false);
return(false);
case MailboxFilterResult.SizeLimitExceeded:
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.SizeLimitExceeded, cancellationToken).ConfigureAwait(false);
return(false);
}
throw new SmtpResponseException(SmtpResponse.TransactionFailed);
}
internal static IEnumerable <AvailableNetworkGroupPack> EnumerateAvailableNetworkGroups(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in EnumerateInterfaces(container.Content))
{
foreach (var availableNetworkGroup in EnumerateAvailableNetworkGroups(container.Content, interfaceInfo))
{
yield return(availableNetworkGroup);
}
}
}
internal static IEnumerable <NetworkIdentifier> EnumerateAvailableNetworkSsids(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in Base.GetInterfaceInfoList(container.Content.Handle))
{
foreach (var availableNetwork in Base.GetAvailableNetworkList(container.Content.Handle, interfaceInfo.InterfaceGuid))
{
yield return(new NetworkIdentifier(availableNetwork.dot11Ssid));
}
}
}
internal static bool GetInterfaceAutoConfig(Base.WlanClient client, Guid interfaceId)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException(nameof(interfaceId));
}
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
return(Base.GetAutoConfig(container.Content.Handle, interfaceId).GetValueOrDefault());
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Returns true if the command executed successfully such that the transition to the next state should occur, false
/// if the current state is to be maintained.</returns>
internal override async Task <bool> ExecuteAsync(SmtpSessionContext context, CancellationToken cancellationToken)
{
context.Authentication = AuthenticationContext.Unauthenticated;
switch (Method)
{
case AuthenticationMethod.Plain:
if (await TryPlainAsync(context, cancellationToken).ConfigureAwait(false) == false)
{
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.AuthenticationFailed, cancellationToken).ConfigureAwait(false);
return(false);
}
break;
case AuthenticationMethod.Login:
if (await TryLoginAsync(context, cancellationToken).ConfigureAwait(false) == false)
{
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.AuthenticationFailed, cancellationToken).ConfigureAwait(false);
return(false);
}
break;
}
var userAuthenticator = context.ServiceProvider.GetService <IUserAuthenticatorFactory, IUserAuthenticator>(context, UserAuthenticator.Default);
using (var container = new DisposableContainer <IUserAuthenticator>(userAuthenticator))
{
if (await container.Instance.AuthenticateAsync(context, _user, _password, cancellationToken).ConfigureAwait(false) == false)
{
var remaining = context.ServerOptions.MaxAuthenticationAttempts - ++context.AuthenticationAttempts;
var response = new SmtpResponse(SmtpReplyCode.AuthenticationFailed, $"authentication failed, {remaining} attempt(s) remaining.");
await context.Pipe.Output.WriteReplyAsync(response, cancellationToken).ConfigureAwait(false);
if (remaining <= 0)
{
throw new SmtpResponseException(SmtpResponse.ServiceClosingTransmissionChannel, true);
}
return(false);
}
}
await context.Pipe.Output.WriteReplyAsync(SmtpResponse.AuthenticationSuccessful, cancellationToken).ConfigureAwait(false);
context.Authentication = new AuthenticationContext(_user);
context.RaiseSessionAuthenticated();
return(true);
}
public Foo()
{
_disposable = new DisposableContainer();
// Adding a disposabe object.
_baz = _disposable.AddManagedResource(new Baz());
// Adding an event. This prevent a memory leak. object is the event argument type.
_disposable.AddEventSubscription <object>(typeof(Baz), nameof(Baz.StaticEventHandler), EventHandler);
// Adding an arbitary cleanup action.
_disposable.AddCleanupAction(SomeCleanup);
}
internal static IEnumerable <BssNetworkPack> EnumerateBssNetworks(Base.WlanClient client)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var interfaceInfoList = Base.GetInterfaceInfoList(container.Content.Handle);
foreach (var interfaceInfo in interfaceInfoList.Select(x => new InterfaceInfo(container.Content.Handle, x)))
{
var networkList = EnumerateAvailableNetworks(client);
var networkBssEntryList = Base.GetNetworkBssEntryList(container.Content.Handle, interfaceInfo.Id);
foreach (var networkBssEntry in networkBssEntryList)
{
if (!BssTypeConverter.TryConvert(networkBssEntry.dot11BssType, out BssType bssType))
{
continue;
}
//Debug.WriteLine("Interface: {0}, SSID: {1}, BSSID: {2}, Signal: {3} Link: {4}, Frequency: {5}",
// interfaceInfo.Description,
// networkBssEntry.dot11Ssid,
// networkBssEntry.dot11Bssid,
// networkBssEntry.lRssi,
// networkBssEntry.uLinkQuality,
// networkBssEntry.ulChCenterFrequency);
var network = networkList.Where(o => o.Ssid.ToString() == new NetworkIdentifier(networkBssEntry.dot11Ssid.ToBytes(), networkBssEntry.dot11Ssid.ToString(), networkBssEntry.dot11Ssid.uSSIDLength).ToString());
//this program work get available network first and get bssnetwork list.
//so if can not found network. just skip the bss network.
//it just happen if you don't have a luck.
if (!network.Any())
{
continue;
}
yield return(new BssNetworkPack(
interfaceInfo: interfaceInfo,
network: network.First(),
ssid: new NetworkIdentifier(networkBssEntry.dot11Ssid.ToBytes(), networkBssEntry.dot11Ssid.ToString(), networkBssEntry.dot11Ssid.uSSIDLength),
bssType: bssType,
bssid: new NetworkIdentifier(networkBssEntry.dot11Bssid.ToBytes(), networkBssEntry.dot11Bssid.ToString(), networkBssEntry.dot11Ssid.uSSIDLength),
signalStrength: networkBssEntry.lRssi,
linkQuality: (int)networkBssEntry.uLinkQuality,
frequency: (int)networkBssEntry.ulChCenterFrequency,
channel: DetectChannel(networkBssEntry.ulChCenterFrequency)));
}
}
}
}
internal static IEnumerable <InterfaceInfoEx> EnumerateInterfacesEx(Base.WlanClient client)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var interfaceInfoList = Base.GetInterfaceInfoList(container.Content.Handle);
foreach (var interfaceInfo in interfaceInfoList)
{
var connection = Base.GetConnectionAttributes(container.Content.Handle, interfaceInfo.InterfaceGuid);
yield return(new InterfaceInfoEx(interfaceInfo, connection));
}
}
}
internal static IEnumerable <BssNetworkPack> EnumerateBssNetworks(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in EnumerateInterfaces(container.Content))
{
foreach (var networkBssEntry in Base.GetNetworkBssEntryList(container.Content.Handle, interfaceInfo.Id))
{
if (TryConvertBssNetwork(interfaceInfo, networkBssEntry, out BssNetworkPack bssNetwork))
{
yield return(bssNetwork);
}
}
}
}
internal static bool DeleteProfile(Base.WlanClient client, Guid interfaceId, string profileName)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException("The specified interface ID is invalid.", nameof(interfaceId));
}
if (string.IsNullOrWhiteSpace(profileName))
{
throw new ArgumentNullException(nameof(profileName));
}
using var container = new DisposableContainer <Base.WlanClient>(client);
return(Base.DeleteProfile(container.Content.Handle, interfaceId, profileName));
}
public void Dispose(bool disposing)
{
if (m_Disposed)
{
return;
}
if (disposing)
{
m_Transaction.Dispose();
m_Connection.Dispose();
DisposableContainer?.OnDispose();
m_Disposed = true;
}
}
internal static async Task <IEnumerable <Guid> > ScanNetworksAsync(Base.WlanNotificationClient client, TimeSpan timeout, CancellationToken cancellationToken)
{
if (timeout <= TimeSpan.Zero)
{
throw new ArgumentException(nameof(timeout));
}
using (var container = new DisposableContainer <Base.WlanNotificationClient>(client))
{
var interfaceIds = Base.GetInterfaceInfoList(container.Content.Handle)
.Select(x => x.InterfaceGuid)
.ToArray();
var tcs = new TaskCompletionSource <bool>();
var counter = new ScanCounter(() => Task.Run(() => tcs.TrySetResult(true)), interfaceIds);
container.Content.NotificationReceived += (sender, data) =>
{
switch ((WLAN_NOTIFICATION_ACM)data.NotificationCode)
{
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_scan_complete:
counter.SetSuccess(data.InterfaceGuid);
break;
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_scan_fail:
counter.SetFailure(data.InterfaceGuid);
break;
}
};
foreach (var interfaceId in interfaceIds)
{
var result = Base.Scan(container.Content.Handle, interfaceId);
if (!result)
{
counter.SetFailure(interfaceId);
}
}
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
var scanTask = tcs.Task;
await Task.WhenAny(scanTask, Task.Delay(timeout, cancellationToken));
return(counter.Results);
}
}
}
internal static bool TurnInterfaceRadio(Base.WlanClient client, Guid interfaceId, DOT11_RADIO_STATE radioState)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException(nameof(interfaceId));
}
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
var phyRadioState = new WLAN_PHY_RADIO_STATE {
dot11SoftwareRadioState = radioState,
};
return(Base.SetPhyRadioState(container.Content.Handle, interfaceId, phyRadioState));
}
}
internal static bool ConnectNetwork(Base.WlanClient client, Guid interfaceId, string profileName, BssType bssType)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException(nameof(interfaceId));
}
if (string.IsNullOrWhiteSpace(profileName))
{
throw new ArgumentNullException(nameof(profileName));
}
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
return(Base.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType)));
}
}
internal static bool SetProfile(Base.WlanClient client, Guid interfaceId, ProfileType profileType, string profileXml, string profileSecurity, bool overwrite)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException("The specified interface ID is invalid.", nameof(interfaceId));
}
if (string.IsNullOrWhiteSpace(profileXml))
{
throw new ArgumentNullException(nameof(profileXml));
}
using var container = new DisposableContainer <Base.WlanClient>(client);
var profileTypeFlag = ProfileTypeConverter.ConvertBack(profileType);
return(Base.SetProfile(container.Content.Handle, interfaceId, profileTypeFlag, profileXml, profileSecurity, overwrite));
}
internal static IEnumerable <NetworkIdentifier> EnumerateConnectedNetworkSsids(Base.WlanClient client)
{
using var container = new DisposableContainer <Base.WlanClient>(client);
foreach (var interfaceInfo in Base.GetInterfaceInfoList(container.Content.Handle))
{
var connection = Base.GetConnectionAttributes(container.Content.Handle, interfaceInfo.InterfaceGuid);
if (connection.isState != WLAN_INTERFACE_STATE.wlan_interface_state_connected)
{
continue;
}
var association = connection.wlanAssociationAttributes;
yield return(new NetworkIdentifier(association.dot11Ssid));
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which asynchronously performs the execution.</returns>
public override async Task ExecuteAsync(ISmtpSessionContext context, CancellationToken cancellationToken)
{
if (context.Transaction.To.Count == 0)
{
await context.Text.ReplyAsync(SmtpResponse.NoValidRecipientsGiven, cancellationToken).ConfigureAwait(false);
return;
}
await context.Text.ReplyAsync(new SmtpResponse(SmtpReplyCode.StartMailInput, "end with <CRLF>.<CRLF>"), cancellationToken).ConfigureAwait(false);
try
{
string text;
while ((text = await context.Text.ReadLineAsync(TimeSpan.FromSeconds(60), cancellationToken).ConfigureAwait(false)) != ".")
{
// need to trim the '.' at the start of the line if it
// exists as this would have been added for transparency
// http://tools.ietf.org/html/rfc5321#section-4.5.2
context.Transaction.Mime.AppendLine(text.TrimStart('.'));
}
}
catch (TimeoutException)
{
// TODO: not sure what the best thing to do here is
throw;
}
try
{
// store the transaction
using (var container = new DisposableContainer<IMessageStore>(_messageStoreFactory.CreateInstance(context)))
{
var response = await container.Instance.SaveAsync(context, context.Transaction, cancellationToken).ConfigureAwait(false);
await context.Text.ReplyAsync(response, cancellationToken).ConfigureAwait(false);
}
}
catch (Exception)
{
await context.Text.ReplyAsync(new SmtpResponse(SmtpReplyCode.TransactionFailed), cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which asynchronously performs the execution.</returns>
public override async Task ExecuteAsync(ISmtpSessionContext context, CancellationToken cancellationToken)
{
context.Transaction.Reset();
// check if a size has been defined
var size = GetMessageSize();
// check against the server supplied maximum
if (_maxMessageSize > 0 && size > _maxMessageSize)
{
await context.Text.ReplyAsync(SmtpResponse.SizeLimitExceeded, cancellationToken);
return;
}
using (var container = new DisposableContainer<IMailboxFilter>(_mailboxFilterFactory.CreateInstance(context)))
{
switch (await container.Instance.CanAcceptFromAsync(context, Address, size))
{
case MailboxFilterResult.Yes:
context.Transaction.From = _address;
await context.Text.ReplyAsync(SmtpResponse.Ok, cancellationToken);
return;
case MailboxFilterResult.NoTemporarily:
await context.Text.ReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken);
return;
case MailboxFilterResult.NoPermanently:
await context.Text.ReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken);
return;
case MailboxFilterResult.SizeLimitExceeded:
await context.Text.ReplyAsync(SmtpResponse.SizeLimitExceeded, cancellationToken);
return;
}
}
throw new NotSupportedException("The Acceptance state is not supported.");
}
/// <summary>
/// Execute the command.
/// </summary>
/// <param name="context">The execution context to operate on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which asynchronously performs the execution.</returns>
public override async Task ExecuteAsync(ISmtpSessionContext context, CancellationToken cancellationToken)
{
using (var container = new DisposableContainer<IMailboxFilter>(_mailboxFilterFactory.CreateInstance(context)))
{
switch (await container.Instance.CanDeliverToAsync(context, _address, context.Transaction.From))
{
case MailboxFilterResult.Yes:
context.Transaction.To.Add(_address);
await context.Text.ReplyAsync(SmtpResponse.Ok, cancellationToken);
return;
case MailboxFilterResult.NoTemporarily:
await context.Text.ReplyAsync(SmtpResponse.MailboxUnavailable, cancellationToken);
return;
case MailboxFilterResult.NoPermanently:
await context.Text.ReplyAsync(SmtpResponse.MailboxNameNotAllowed, cancellationToken);
return;
}
}
throw new NotSupportedException("The Acceptance state is not supported.");
}
