private static bool TryConvertBssNetwork(InterfaceInfo interfaceInfo, WLAN_BSS_ENTRY bssEntry, out BssNetworkPack bssNetwork)
{
bssNetwork = null;
if (!BssTypeConverter.TryConvert(bssEntry.dot11BssType, out BssType bssType))
{
return(false);
}
if (!TryDetectBandChannel(bssEntry.ulChCenterFrequency, out float band, out int channel))
{
return(false);
}
bssNetwork = new BssNetworkPack(
interfaceInfo: interfaceInfo,
ssid: new NetworkIdentifier(bssEntry.dot11Ssid),
bssType: bssType,
bssid: new NetworkIdentifier(bssEntry.dot11Bssid),
signalStrength: bssEntry.lRssi,
linkQuality: (int)bssEntry.uLinkQuality,
frequency: (int)bssEntry.ulChCenterFrequency,
band: band,
channel: channel);
return(true);
}
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 <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));
}
}
}
private ProfileDocument(XDocument root)
{
if (root is null)
{
return;
}
this.Root = root;
Name = Root.Elements().First().Elements(XName.Get("name", Namespace)).FirstOrDefault()?.Value;
var ssidElement = Root.Descendants(XName.Get("SSID", Namespace)).FirstOrDefault();
var ssidHexString = ssidElement?.Descendants(XName.Get("hex", Namespace)).FirstOrDefault()?.Value;
var ssidHexBytes = HexadecimalStringConverter.ToBytes(ssidHexString);
var ssidNameString = ssidElement?.Descendants(XName.Get("name", Namespace)).FirstOrDefault()?.Value;
Ssid = new NetworkIdentifier(ssidHexBytes, ssidNameString);
var connectionTypeString = Root.Descendants(XName.Get("connectionType", Namespace)).FirstOrDefault()?.Value;
if (!BssTypeConverter.TryParse(connectionTypeString, out BssType bssType))
{
return;
}
this.BssType = bssType;
AuthenticationString = Root.Descendants(XName.Get("authentication", Namespace)).FirstOrDefault()?.Value;
if (!AuthenticationMethodConverter.TryParse(AuthenticationString, out AuthenticationMethod authentication))
{
return;
}
this.Authentication = authentication;
EncryptionString = Root.Descendants(XName.Get("encryption", Namespace)).FirstOrDefault()?.Value;
if (!EncryptionTypeConverter.TryParse(EncryptionString, out EncryptionType encryption))
{
return;
}
this.Encryption = encryption;
//Debug.WriteLine("SSID: {0}, BssType: {1}, Authentication: {2}, Encryption: {3}",
// Ssid,
// BssType,
// Authentication,
// Encryption);
_connectionModeElement = Root.Descendants(XName.Get("connectionMode", Namespace)).FirstOrDefault();
if (_connectionModeElement is null)
{
return;
}
_autoSwitchElement = Root.Descendants(XName.Get("autoSwitch", Namespace)).FirstOrDefault();
IsValid = true;
}
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 bool ConnectNetwork(Base.WlanClient client, Guid interfaceId, string profileName, BssType bssType)
{
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.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType)));
}
internal static IEnumerable <BssNetworkPack> EnumerateBssNetworks(Base.WlanClient client, AvailableNetworkPack network)
{
using (var container = new DisposableContainer <Base.WlanClient>(client))
{
DOT11_SSID ssid;
ssid.ucSSID = network.Ssid.ToBytes();
ssid.uSSIDLength = network.Ssid.GetLength();
DOT11_BSS_TYPE bssTypes = BssTypeConverter.ConvertBack(network.BssType);
var networkBssEntryList = Base.GetNetworkBssEntryList(container.Content.Handle, network.Interface.Id, ssid, bssTypes);
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);
yield return(new BssNetworkPack(
interfaceInfo: network.Interface,
network: network,
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 <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(x)))
{
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);
yield return(new BssNetworkPack(
interfaceInfo: interfaceInfo,
ssid: new NetworkIdentifier(networkBssEntry.dot11Ssid.ToBytes(), networkBssEntry.dot11Ssid.ToString()),
bssType: bssType,
bssid: new NetworkIdentifier(networkBssEntry.dot11Bssid.ToBytes(), networkBssEntry.dot11Bssid.ToString()),
signalStrength: networkBssEntry.lRssi,
linkQuality: (int)networkBssEntry.uLinkQuality,
frequency: (int)networkBssEntry.ulChCenterFrequency,
channel: DetectChannel(networkBssEntry.ulChCenterFrequency)));
}
}
}
}
private static IEnumerable <AvailableNetworkGroupPack> EnumerateAvailableNetworkGroups(Base.WlanClient client, InterfaceInfo interfaceInfo)
{
foreach (var availableNetwork in Base.GetAvailableNetworkList(client.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;
}
var bssNetworks = Base.GetNetworkBssEntryList(client.Handle, interfaceInfo.Id,
availableNetwork.dot11Ssid, availableNetwork.dot11BssType, availableNetwork.bSecurityEnabled)
.Select(x => TryConvertBssNetwork(interfaceInfo, x, out BssNetworkPack bssNetwork) ? bssNetwork : null)
.Where(x => x is not null);
yield return(new AvailableNetworkGroupPack(
interfaceInfo: interfaceInfo,
ssid: new NetworkIdentifier(availableNetwork.dot11Ssid),
bssType: bssType,
signalQuality: (int)availableNetwork.wlanSignalQuality,
isSecurityEnabled: availableNetwork.bSecurityEnabled,
profileName: availableNetwork.strProfileName,
authenticationAlgorithm: authenticationAlgorithm,
cipherAlgorithm: cipherAlgorithm,
bssNetworks: bssNetworks));
}
}
internal static async Task <bool> ConnectNetworkAsync(Base.WlanNotificationClient client, Guid interfaceId, string profileName, BssType bssType, PhysicalAddress bssid, TimeSpan timeout, CancellationToken cancellationToken)
{
if (interfaceId == Guid.Empty)
{
throw new ArgumentException("The specified interface ID is invalid.", nameof(interfaceId));
}
if (string.IsNullOrWhiteSpace(profileName))
{
throw new ArgumentNullException(nameof(profileName));
}
if (timeout <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(timeout), "The timeout duration must be positive.");
}
using var container = new DisposableContainer <Base.WlanNotificationClient>(client);
var tcs = new TaskCompletionSource <bool>();
container.Content.NotificationReceived += (sender, data) =>
{
if (data.InterfaceGuid != interfaceId)
{
return;
}
switch ((WLAN_NOTIFICATION_ACM)data.NotificationCode)
{
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_connection_complete:
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_connection_attempt_fail:
break;
default:
return;
}
var connectionNotificationData = Marshal.PtrToStructure <WLAN_CONNECTION_NOTIFICATION_DATA>(data.pData);
if (connectionNotificationData.strProfileName != profileName)
{
return;
}
switch ((WLAN_NOTIFICATION_ACM)data.NotificationCode)
{
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_connection_complete:
Task.Run(() => tcs.TrySetResult(true));
break;
case WLAN_NOTIFICATION_ACM.wlan_notification_acm_connection_attempt_fail:
// This notification will not always mean that a connection has failed.
// A connection consists of one or more connection attempts and this notification
// may be received zero or more times before the connection completes.
Task.Run(() => tcs.TrySetResult(false));
break;
}
};
bool result;
if (bssid is not null)
{
var dot11MacAddress = new DOT11_MAC_ADDRESS {
ucDot11MacAddress = bssid.GetAddressBytes()
};
result = Base.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType), dot11MacAddress);
}
else
{
result = Base.Connect(container.Content.Handle, interfaceId, profileName, BssTypeConverter.ConvertBack(bssType));
}
if (!result)
{
tcs.SetResult(false);
}
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
var connectTask = tcs.Task;
var completedTask = await Task.WhenAny(connectTask, Task.Delay(timeout, cancellationToken));
return((completedTask == connectTask) && connectTask.IsCompleted && connectTask.Result);
}
}
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)));
}
}
