private bool IsSentByCorrectNetworkInterface(Wlan.WlanNotificationData notificationData)
{
WlanClient.WlanInterface wifiInterface = GetInterfaceByInterfaceId(notificationData.interfaceGuid);
if (wifiInterface == currentWifiInterface)
return true;
return false;
}
static string GetStringForSSID(Wlan.Dot11Ssid ssid)
{
return Encoding.ASCII.GetString(ssid.SSID, 0, (int)ssid.SSIDLength);
}
/// <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));
}
public void WlanEventHandler(Wlan.WlanNotificationData eventData)
{
switch (eventData.notificationSource)
{
case Wlan.WlanNotificationSource.ACM:
switch ((Wlan.WlanNotificationCodeAcm)eventData.notificationCode)
{
case Wlan.WlanNotificationCodeAcm.ConnectionAttemptFail:
log.Debug("ConnectionAttemptFail");
break;
case Wlan.WlanNotificationCodeAcm.ConnectionComplete:
log.Debug("ConnectionComplete");
break;
case Wlan.WlanNotificationCodeAcm.ConnectionStart:
state = WiFiState.Connecting;
updaterNetStatus.Update();
log.Debug("ConnectionStart");
break;
case Wlan.WlanNotificationCodeAcm.Disconnected:
state = WiFiState.Disconnected;
updaterNetStatus.Update();
log.Debug("ACM.Disconnected");
break;
case Wlan.WlanNotificationCodeAcm.Disconnecting:
state = WiFiState.Disconnecting;
updaterNetStatus.Update();
log.Debug("Disconnecting");
break;
case Wlan.WlanNotificationCodeAcm.InterfaceRemoval:
state = WiFiState.NoWirelessInterface;
updaterNetStatus.Update();
log.Debug("InterfaceRemoval");
break;
}
break;
case Wlan.WlanNotificationSource.MSM:
switch ((Wlan.WlanNotificationCodeMsm)eventData.notificationCode)
{
case Wlan.WlanNotificationCodeMsm.AdapterOperationModeChange:
log.Debug("AdapterOperationModeChange");
break;
case Wlan.WlanNotificationCodeMsm.AdapterRemoval:
state = WiFiState.NoWirelessInterface;
updaterNetStatus.Update();
log.Debug("AdapterRemoval");
break;
case Wlan.WlanNotificationCodeMsm.SignalQualityChange:
log.Debug("SignalQualityChange");
break;
case Wlan.WlanNotificationCodeMsm.Associated:
log.Debug("Associated");
break;
case Wlan.WlanNotificationCodeMsm.Associating:
log.Debug("Associating");
break;
case Wlan.WlanNotificationCodeMsm.Authenticating:
log.Debug("Authenticating");
break;
case Wlan.WlanNotificationCodeMsm.Connected:
state = WiFiState.Connected;
updaterNetStatus.Update();
log.Debug("MSM.Connected");
break;
case Wlan.WlanNotificationCodeMsm.Disassociating:
log.Debug("Disassociating");
break;
case Wlan.WlanNotificationCodeMsm.Disconnected:
state = WiFiState.Disconnected;
updaterNetStatus.Update();
log.Debug("MSM.Disconnected");
break;
}
break;
}
}
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:
{
//HACK: Prevents exception on WLAN connection: System.ArgumentException: Type 'NativeWifi.Wlan+WlanReasonCode' cannot be marshaled as an unmanaged structure; no meaningful size or offset can be computed.
int expectedSize = 0;//Marshal.SizeOf(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>
/// 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);
}
/// <summary>
/// Create a valid Profile xml according to: http://msdn.microsoft.com/en-us/library/ms707381(v=VS.85).aspx
/// </summary>
/// <param name="ssid"></param>
/// <param name="key"></param>
/// <param name="authAlg"></param>
/// <param name="encAlg"></param>
/// <returns></returns>
internal static string GetProfileXml(string ssid, string key, Wlan.Dot11AuthAlgorithm authAlg, Wlan.Dot11CipherAlgorithm encAlg)
{
WinProfileAuthenticationEnumeration? auth = null;
WinProfileEncryptionEnumeration? enc = null;
switch (authAlg)
{
case Wlan.Dot11AuthAlgorithm.IEEE80211_SharedKey:
auth = WinProfileAuthenticationEnumeration.open;
enc = WinProfileEncryptionEnumeration.WEP;
break;
case Wlan.Dot11AuthAlgorithm.WPA_PSK:
auth = WinProfileAuthenticationEnumeration.WPAPSK;
break;
case Wlan.Dot11AuthAlgorithm.RSNA_PSK:
auth = WinProfileAuthenticationEnumeration.WPA2PSK;
break;
}
switch (encAlg)
{
case Wlan.Dot11CipherAlgorithm.TKIP:
enc = WinProfileEncryptionEnumeration.TKIP;
break;
case Wlan.Dot11CipherAlgorithm.CCMP:
enc = WinProfileEncryptionEnumeration.AES;
break;
}
if (enc != null && auth != null)
{
return string.Format(@"<?xml version=""1.0""?>
<WLANProfile xmlns=""http://www.microsoft.com/networking/WLAN/profile/v1"">
<name>{0}</name>
<SSIDConfig>
<SSID>
<name>{0}</name>
</SSID>
</SSIDConfig>
<connectionType>ESS</connectionType>
<connectionMode>auto</connectionMode>
<MSM>
<security>
<authEncryption>
<authentication>{2}</authentication>
<encryption>{3}</encryption>
<useOneX>false</useOneX>
</authEncryption>
<sharedKey>
<keyType>passPhrase</keyType>
<protected>false</protected>
<keyMaterial>{1}</keyMaterial>
</sharedKey>
</security>
</MSM>
</WLANProfile>", ssid, key, auth.ToString(), enc.ToString());
}
else
{
return null;
}
}
public static void HandleLinkDown(Wlan.WlanNotificationData notifyData)
{
NativeWifi.WlanClient.WlanInterface wlanIface = null;// = GenericInfo.WlanInterface;
foreach (NativeWifi.WlanClient.WlanInterface wli in Information.GenericInfo.ClientInstance.Interfaces)
if (wli.InterfaceGuid == notifyData.interfaceGuid)
if (wli.NetworkInterface.GetPhysicalAddress().Equals(PhysicalAddress.Parse(Program.MAC.Replace(":", "-").ToUpper()))) //Event filtering
wlanIface = wli;
if (wlanIface != null)
{
ConnectionHelper ch = Program.toMihf;
ID myLinkID = new ID(new OctetString(GenericInfo.myID));
ID mihfID = new ID(new OctetString(GenericInfo.mihfID));
if (Subscriptions.List.Link_Down)
ch.Send(MessageBuilders.Link_Down_Indication_802_11_MsgBuilder(myLinkID, mihfID,
new String(Encoding.ASCII.GetChars(wlanIface.LatestConnection.wlanAssociationAttributes.dot11Ssid.SSID)),
wlanIface.LatestConnection.wlanAssociationAttributes.Dot11Bssid,
Link_Dn_Reason.ExplicitDisconnect).ByteValue);//TODO get reasons
}
}
/// <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();
}
private void OnWlanNotification(ref Wlan.WlanNotificationData notifyData, IntPtr context)
{
WlanInterface wlanIface;
ifaces.TryGetValue(notifyData.interfaceGuid, out wlanIface);
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(int));
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);
}
internal void OnWlanNotification(Wlan.WlanNotificationData notifyData)
{
if (WlanNotification != null)
WlanNotification(notifyData);
}
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>
/// 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);
}
private void ProcessWifiNotificatioEvent(Wlan.WlanNotificationData notificationData)
{
if (currentState != DroneNetworkConnectionState.ScanningForNewNetworks)
return;
if (!IsSentByCorrectNetworkInterface(notificationData))
return;
if (notificationData.notificationCode == notificationCodeScanSuccessful)
{
DiscoverNetwork();
}
else if (notificationData.notificationCode == notificationCodeScanErroneous)
{
ScanCurrentNetworkInterface();
}
}
/// <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"
}
void frmConnectWifiAdaptor_WlanNotification(Wlan.WlanNotificationData notifyData)
{
System.Diagnostics.Debug.WriteLine(notifyData.NotificationCode);
int x = Convert.ToInt32(notifyData.NotificationCode);
if (x == 7)
{
}
}
public Network(Wlan.WlanAvailableNetwork network)
{
profileName = network.profileName;
dot11Ssid = Encoding.ASCII.GetString(network.dot11Ssid.SSID, 0, (int)network.dot11Ssid.SSIDLength);
dot11BssType = network.dot11BssType.ToString();
wlanNotConnectableReason = network.wlanNotConnectableReason.ToString();
defaultAuthAlgorithm= network.dot11DefaultAuthAlgorithm.ToString();
defaultCipherAlgo= network.dot11DefaultCipherAlgorithm.ToString();
numberOfBssids = network.numberOfBssids;
//numberOfPhyTypes = network.Dot11PhyTypes.GetLength(network);
wlanSignalQuality = network.wlanSignalQuality;
securityEnabled = network.securityEnabled;
isConnectable = network.networkConnectable;
}
/// <summary>
/// converts the <c>WlanBssEntry</c> type into a readable MAC address
/// </summary>
/// <param name="bss">Wlan.WlanBssEntry</param>
/// <returns>string</returns>
public static string getBssid(Wlan.WlanBssEntry bss)
{
string bssid = "";
for (int i = 0; i < bss.dot11Bssid.Length; i++)
{
if(i == bss.dot11Bssid.Length-1)
bssid += "" + hex[bss.dot11Bssid[i] / 16] + hex[bss.dot11Bssid[i] % 16] + "|";
else
bssid += "" + hex[bss.dot11Bssid[i] / 16] + hex[bss.dot11Bssid[i] % 16] + ":";
}
return bssid;
}
private void ProcessWifiConnectionEvent(Wlan.WlanNotificationData notificationData, Wlan.WlanConnectionNotificationData connectionData)
{
if (!IsSentByCorrectNetworkInterface(notificationData))
return;
String ssid = CurrentDroneNetworkSsid;
if (ssid == null)
return;
if (ssid.StartsWith(droneNetworkIdentifierStart) && IsDroneNetworkConnected)
ProcessNetworkConnected();
}
/// <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;
}
private void wlanInterface_WlanNotification(Wlan.WlanNotificationData notificationData)
{
ProcessWifiNotificatioEvent(notificationData);
}
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);
}
}
private void wlanInterface_WlanConnectionNotification(Wlan.WlanNotificationData notificationData, Wlan.WlanConnectionNotificationData connectionData)
{
ProcessWifiConnectionEvent(notificationData, connectionData);
}
private static 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;
}
void OnWlanNotification(Wlan.WlanNotificationData notifyData)
{
if (notifyData.notificationSource == Wlan.WlanNotificationSource.ACM)
{
if (_scanningNICs.Count > 0 && (notifyData.notificationCode == (int)Wlan.WlanNotificationCodeAcm.ScanComplete || notifyData.notificationCode == (int)Wlan.WlanNotificationCodeAcm.ScanFail))
{
_scanningNICs[notifyData.interfaceGuid].WlanNotification -= OnWlanNotification;
_scanningNICs.Remove(notifyData.interfaceGuid);
if (_scanningNICs.Count <= 0)
{
if (StateChanged != null)
StateChanged();
WifiConnectionMessaging.SendWifiConnectionMessage(WifiConnectionMessaging.MessageType.ScanCompleted);
}
}
}
}
internal WlanInterface(WlanClient client, Wlan.WlanInterfaceInfo info)
{
this.client = client;
this.info = info;
}
/// <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>
/// 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>
/// 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);
}
}
