C# NativeWifi.Wlan类代码示例

        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);
 }

        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);
        }

        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;
            }
        }

 /// <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 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);
                }
            }

        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;
 }