Exemple #1
0
        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;
        }
Exemple #2
0
 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);
     }
 }
Exemple #3
0
 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);
     }
 }
Exemple #4
0
 /// <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;
 }
Exemple #5
0
 public static string GetStringForSSID(Wlan.Dot11Ssid ssid)
 {
     return Encoding.ASCII.GetString(ssid.SSID, 0, (int)ssid.SSIDLength);
 }
Exemple #6
0
 /// <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);
     }
 }
Exemple #7
0
 /// <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);
     }
 }
Exemple #8
0
 /// <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));
 }
Exemple #9
0
 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);
     }
 }
Exemple #10
0
 internal void OnWlanNotification(Wlan.WlanNotificationData notifyData)
 {
     if (WlanNotification != null)
         WlanNotification(notifyData);
 }
Exemple #11
0
        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);
        }
Exemple #12
0
 /// <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);
     }
 }
Exemple #13
0
 /// <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);
     }
 }
Exemple #14
0
 /// <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"
 }
Exemple #15
0
 /// <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);
 }
Exemple #16
0
 /// <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);
 }
Exemple #17
0
 internal WlanInterface(WlanClient client, Wlan.WlanInterfaceInfo info)
 {
     this.client = client;
     this.info = info;
 }
Exemple #18
0
        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;
        }
Exemple #19
0
            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);
                }
            }
Exemple #20
0
 /// <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();
 }