static string MakeOpenProfile(string profileName, Wlan.WlanAvailableNetwork network)
{
string ssid = GetStringForSSID(network.dot11Ssid);
string encryption = CipherToStringInProfile(network.dot11DefaultCipherAlgorithm);
string profile = string.Format(
@"<?xml version=""1.0"" encoding=""US-ASCII""?>
<WLANProfile xmlns=""http://www.microsoft.com/networking/WLAN/profile/v1"">
<name>{0}</name>
<SSIDConfig>
<SSID>
<name>{1}</name>
</SSID>
</SSIDConfig>
<connectionType>ESS</connectionType>
<connectionMode>auto</connectionMode>
<autoSwitch>false</autoSwitch>
<MSM>
<security>
<authEncryption>
<authentication>open</authentication>
<encryption>{2}</encryption>
<useOneX>false</useOneX>
</authEncryption>
</security>
</MSM>
</WLANProfile>
", profileName, ssid, encryption);
return profile;
}
public static string MakeProfile(string profileName, Wlan.WlanAvailableNetwork network, string key)
{
switch (network.dot11DefaultAuthAlgorithm)
{
case Wlan.Dot11AuthAlgorithm.WPA_PSK:
return MakeWpaPskProfile(profileName, network, key);
case Wlan.Dot11AuthAlgorithm.RSNA_PSK:
return MakeWpa2PskProfile(profileName, network, key);
case Wlan.Dot11AuthAlgorithm.IEEE80211_Open:
return MakeOpenProfile(profileName, network);
default:
throw new Exception("unsupported auth algorithm: " + network.dot11DefaultAuthAlgorithm);
}
}
static string CipherToStringInProfile(Wlan.Dot11CipherAlgorithm algorithm)
{
switch (algorithm)
{
case Wlan.Dot11CipherAlgorithm.None:
return "none";
case Wlan.Dot11CipherAlgorithm.WEP:
case Wlan.Dot11CipherAlgorithm.WEP104:
case Wlan.Dot11CipherAlgorithm.WEP40:
return "WEP";
case Wlan.Dot11CipherAlgorithm.TKIP:
return "TKIP";
case Wlan.Dot11CipherAlgorithm.CCMP:
return "AES";
default:
throw new Exception("Unsupported cipher algorithm: " + algorithm);
}
}
/// <summary>
/// Sets the profile.
/// </summary>
/// <param name="flags">The flags to set on the profile.</param>
/// <param name="profileXml">The XML representation of the profile. On Windows XP SP 2, special care should be taken to adhere to its limitations.</param>
/// <param name="overwrite">If a profile by the given name already exists, then specifies whether to overwrite it (if <c>true</c>) or return an error (if <c>false</c>).</param>
/// <returns>The resulting code indicating a success or the reason why the profile wasn't valid.</returns>
public Wlan.WlanReasonCode SetProfile(Wlan.WlanProfileFlags flags, string profileXml, bool overwrite)
{
Wlan.WlanReasonCode reasonCode;
Wlan.ThrowIfError(
Wlan.WlanSetProfile(client.clientHandle, info.interfaceGuid, flags, profileXml, null, overwrite, IntPtr.Zero, out reasonCode));
return reasonCode;
}
public static string GetStringForSSID(Wlan.Dot11Ssid ssid)
{
return Encoding.ASCII.GetString(ssid.SSID, 0, (int)ssid.SSIDLength);
}
/// <summary>
/// Sets a parameter of the interface whose data type is <see cref="int"/>.
/// </summary>
/// <param name="opCode">The opcode of the parameter.</param>
/// <param name="value">The value to set.</param>
private void SetInterfaceInt(Wlan.WlanIntfOpcode opCode, int value)
{
IntPtr valuePtr = Marshal.AllocHGlobal(sizeof(int));
Marshal.WriteInt32(valuePtr, value);
try
{
Wlan.ThrowIfError(
Wlan.WlanSetInterface(client.clientHandle, info.interfaceGuid, opCode, sizeof(int), valuePtr, IntPtr.Zero));
}
finally
{
Marshal.FreeHGlobal(valuePtr);
}
}
/// <summary>
/// Gets a parameter of the interface whose data type is <see cref="int"/>.
/// </summary>
/// <param name="opCode">The opcode of the parameter.</param>
/// <returns>The integer value.</returns>
private int GetInterfaceInt(Wlan.WlanIntfOpcode opCode)
{
IntPtr valuePtr;
int valueSize;
Wlan.WlanOpcodeValueType opcodeValueType;
Wlan.ThrowIfError(
Wlan.WlanQueryInterface(client.clientHandle, info.interfaceGuid, opCode, IntPtr.Zero, out valueSize, out valuePtr, out opcodeValueType));
try
{
return Marshal.ReadInt32(valuePtr);
}
finally
{
Wlan.WlanFreeMemory(valuePtr);
}
}
/// <summary>
/// Connects to a network defined by a connection parameters structure.
/// </summary>
/// <param name="connectionParams">The connection paramters.</param>
protected void Connect(Wlan.WlanConnectionParameters connectionParams)
{
Wlan.ThrowIfError(
Wlan.WlanConnect(client.clientHandle, info.interfaceGuid, ref connectionParams, IntPtr.Zero));
}
internal void OnWlanReason(Wlan.WlanNotificationData notifyData, Wlan.WlanReasonCode reasonCode)
{
if (WlanReasonNotification != null)
WlanReasonNotification(notifyData, reasonCode);
if (queueEvents)
{
WlanReasonNotificationData queuedEvent = new WlanReasonNotificationData();
queuedEvent.notifyData = notifyData;
queuedEvent.reasonCode = reasonCode;
EnqueueEvent(queuedEvent);
}
}
internal void OnWlanNotification(Wlan.WlanNotificationData notifyData)
{
if (WlanNotification != null)
WlanNotification(notifyData);
}
private void OnWlanNotification(ref Wlan.WlanNotificationData notifyData, IntPtr context)
{
WlanInterface wlanIface = ifaces.ContainsKey(notifyData.interfaceGuid) ? ifaces[notifyData.interfaceGuid] : null;
switch(notifyData.notificationSource)
{
case Wlan.WlanNotificationSource.ACM:
switch((Wlan.WlanNotificationCodeAcm)notifyData.notificationCode)
{
case Wlan.WlanNotificationCodeAcm.ConnectionStart:
case Wlan.WlanNotificationCodeAcm.ConnectionComplete:
case Wlan.WlanNotificationCodeAcm.ConnectionAttemptFail:
case Wlan.WlanNotificationCodeAcm.Disconnecting:
case Wlan.WlanNotificationCodeAcm.Disconnected:
Wlan.WlanConnectionNotificationData? connNotifyData = ParseWlanConnectionNotification(ref notifyData);
if (connNotifyData.HasValue)
if (wlanIface != null)
wlanIface.OnWlanConnection(notifyData, connNotifyData.Value);
break;
case Wlan.WlanNotificationCodeAcm.ScanFail:
{
//int expectedSize = Marshal.SizeOf(typeof (Wlan.WlanReasonCode));
int expectedSize = Marshal.SizeOf(Enum.GetUnderlyingType(typeof(Wlan.WlanReasonCode)));
if (notifyData.dataSize >= expectedSize)
{
Wlan.WlanReasonCode reasonCode = (Wlan.WlanReasonCode) Marshal.ReadInt32(notifyData.dataPtr);
if (wlanIface != null)
wlanIface.OnWlanReason(notifyData, reasonCode);
}
}
break;
}
break;
case Wlan.WlanNotificationSource.MSM:
switch((Wlan.WlanNotificationCodeMsm)notifyData.notificationCode)
{
case Wlan.WlanNotificationCodeMsm.Associating:
case Wlan.WlanNotificationCodeMsm.Associated:
case Wlan.WlanNotificationCodeMsm.Authenticating:
case Wlan.WlanNotificationCodeMsm.Connected:
case Wlan.WlanNotificationCodeMsm.RoamingStart:
case Wlan.WlanNotificationCodeMsm.RoamingEnd:
case Wlan.WlanNotificationCodeMsm.Disassociating:
case Wlan.WlanNotificationCodeMsm.Disconnected:
case Wlan.WlanNotificationCodeMsm.PeerJoin:
case Wlan.WlanNotificationCodeMsm.PeerLeave:
case Wlan.WlanNotificationCodeMsm.AdapterRemoval:
Wlan.WlanConnectionNotificationData? connNotifyData = ParseWlanConnectionNotification(ref notifyData);
if (connNotifyData.HasValue)
if (wlanIface != null)
wlanIface.OnWlanConnection(notifyData, connNotifyData.Value);
break;
}
break;
}
if (wlanIface != null)
wlanIface.OnWlanNotification(notifyData);
}
/// <summary>
/// Retrieves the list of available networks.
/// </summary>
/// <param name="flags">Controls the type of networks returned.</param>
/// <returns>A list of the available networks.</returns>
public Wlan.WlanAvailableNetwork[] GetAvailableNetworkList(Wlan.WlanGetAvailableNetworkFlags flags)
{
IntPtr availNetListPtr;
Wlan.ThrowIfError(
Wlan.WlanGetAvailableNetworkList(client.clientHandle, info.interfaceGuid, flags, IntPtr.Zero, out availNetListPtr));
try
{
return ConvertAvailableNetworkListPtr(availNetListPtr);
}
finally
{
Wlan.WlanFreeMemory(availNetListPtr);
}
}
/// <summary>
/// Retrieves the basic service sets (BSS) list of the specified network.
/// </summary>
/// <param name="ssid">Specifies the SSID of the network from which the BSS list is requested.</param>
/// <param name="bssType">Indicates the BSS type of the network.</param>
/// <param name="securityEnabled">Indicates whether security is enabled on the network.</param>
public Wlan.WlanBssEntry[] GetNetworkBssList(Wlan.Dot11Ssid ssid, Wlan.Dot11BssType bssType, bool securityEnabled)
{
IntPtr ssidPtr = Marshal.AllocHGlobal(Marshal.SizeOf(ssid));
Marshal.StructureToPtr(ssid, ssidPtr, false);
try
{
IntPtr bssListPtr;
Wlan.ThrowIfError(
Wlan.WlanGetNetworkBssList(client.clientHandle, info.interfaceGuid, ssidPtr, bssType, securityEnabled, IntPtr.Zero, out bssListPtr));
try
{
return ConvertBssListPtr(bssListPtr);
}
finally
{
Wlan.WlanFreeMemory(bssListPtr);
}
}
finally
{
Marshal.FreeHGlobal(ssidPtr);
}
}
/// <summary>
/// Connects (associates) to the specified wireless network, returning either on a success to connect
/// or a failure.
/// </summary>
/// <param name="connectionMode"></param>
/// <param name="bssType"></param>
/// <param name="profile"></param>
/// <param name="connectTimeout"></param>
/// <returns></returns>
public bool ConnectSynchronously(Wlan.WlanConnectionMode connectionMode, Wlan.Dot11BssType bssType, string profile, int connectTimeout)
{
queueEvents = true;
try
{
Connect(connectionMode, bssType, profile);
while (queueEvents && eventQueueFilled.WaitOne(connectTimeout, true))
{
lock (eventQueue)
{
while (eventQueue.Count != 0)
{
object e = eventQueue.Dequeue();
if (e is WlanConnectionNotificationEventData)
{
WlanConnectionNotificationEventData wlanConnectionData = (WlanConnectionNotificationEventData)e;
// Check if the conditions are good to indicate either success or failure.
if (wlanConnectionData.notifyData.notificationSource == Wlan.WlanNotificationSource.ACM)
{
switch ((Wlan.WlanNotificationCodeAcm)wlanConnectionData.notifyData.notificationCode)
{
case Wlan.WlanNotificationCodeAcm.ConnectionComplete:
if (wlanConnectionData.connNotifyData.profileName == profile)
return true;
break;
}
}
break;
}
}
}
}
}
finally
{
queueEvents = false;
eventQueue.Clear();
}
return false; // timeout expired and no "connection complete"
}
/// <summary>
/// Connects to the specified wireless network.
/// </summary>
/// <remarks>
/// The method returns immediately. Progress is reported through the <see cref="WlanNotification"/> event.
/// </remarks>
public void Connect(Wlan.WlanConnectionMode connectionMode, Wlan.Dot11BssType bssType, Wlan.Dot11Ssid ssid, Wlan.WlanConnectionFlags flags)
{
Wlan.WlanConnectionParameters connectionParams = new Wlan.WlanConnectionParameters();
connectionParams.wlanConnectionMode = connectionMode;
connectionParams.dot11SsidPtr = Marshal.AllocHGlobal(Marshal.SizeOf(ssid));
Marshal.StructureToPtr(ssid, connectionParams.dot11SsidPtr, false);
connectionParams.dot11BssType = bssType;
connectionParams.flags = flags;
Connect(connectionParams);
Marshal.DestroyStructure(connectionParams.dot11SsidPtr, ssid.GetType());
Marshal.FreeHGlobal(connectionParams.dot11SsidPtr);
}
/// <summary>
/// Requests a connection (association) to the specified wireless network.
/// </summary>
/// <remarks>
/// The method returns immediately. Progress is reported through the <see cref="WlanNotification"/> event.
/// </remarks>
public void Connect(Wlan.WlanConnectionMode connectionMode, Wlan.Dot11BssType bssType, string profile)
{
Wlan.WlanConnectionParameters connectionParams = new Wlan.WlanConnectionParameters();
connectionParams.wlanConnectionMode = connectionMode;
connectionParams.profile = profile;
connectionParams.dot11BssType = bssType;
connectionParams.flags = 0;
Connect(connectionParams);
}
internal WlanInterface(WlanClient client, Wlan.WlanInterfaceInfo info)
{
this.client = client;
this.info = info;
}
private Wlan.WlanConnectionNotificationData? ParseWlanConnectionNotification(ref Wlan.WlanNotificationData notifyData)
{
int expectedSize = Marshal.SizeOf(typeof(Wlan.WlanConnectionNotificationData));
if (notifyData.dataSize < expectedSize)
return null;
Wlan.WlanConnectionNotificationData connNotifyData =
(Wlan.WlanConnectionNotificationData)
Marshal.PtrToStructure(notifyData.dataPtr, typeof(Wlan.WlanConnectionNotificationData));
if (connNotifyData.wlanReasonCode == Wlan.WlanReasonCode.Success)
{
IntPtr profileXmlPtr = new IntPtr(
notifyData.dataPtr.ToInt64() +
Marshal.OffsetOf(typeof(Wlan.WlanConnectionNotificationData), "profileXml").ToInt64());
connNotifyData.profileXml = Marshal.PtrToStringUni(profileXmlPtr);
}
return connNotifyData;
}
internal void OnWlanConnection(Wlan.WlanNotificationData notifyData, Wlan.WlanConnectionNotificationData connNotifyData)
{
if (WlanConnectionNotification != null)
WlanConnectionNotification(notifyData, connNotifyData);
if (queueEvents)
{
WlanConnectionNotificationEventData queuedEvent = new WlanConnectionNotificationEventData();
queuedEvent.notifyData = notifyData;
queuedEvent.connNotifyData = connNotifyData;
EnqueueEvent(queuedEvent);
}
}
/// <summary>
/// Gets a string that describes a specified reason code.
/// </summary>
/// <param name="reasonCode">The reason code.</param>
/// <returns>The string.</returns>
public string GetStringForReasonCode(Wlan.WlanReasonCode reasonCode)
{
StringBuilder sb = new StringBuilder(1024); // the 1024 size here is arbitrary; the WlanReasonCodeToString docs fail to specify a recommended size
Wlan.ThrowIfError(
Wlan.WlanReasonCodeToString(reasonCode, sb.Capacity, sb, IntPtr.Zero));
return sb.ToString();
}