Beispiel #1
0
 public static extern uint WlanGetNetworkBssList(
     SafeClientHandle hClientHandle,
     [MarshalAs(UnmanagedType.LPStruct)] Guid pInterfaceGuid,
     IntPtr pDot11Ssid,
     DOT11_BSS_TYPE dot11BssType,
     [MarshalAs(UnmanagedType.Bool)] bool bSecurityEnabled,
     IntPtr pReserved,
     out IntPtr ppWlanBssList);             // Pointer to WLAN_BSS_LIST
Beispiel #2
0
 public static extern int WlanGetNetworkBssList(
     [In] IntPtr clientHandle,
     [In, MarshalAs(UnmanagedType.LPStruct)] Guid interfaceGuid,
     [In] IntPtr dot11SsidInt,
     [In] DOT11_BSS_TYPE dot11BssType,
     [In] bool securityEnabled,
     IntPtr reservedPtr,
     [Out] out IntPtr wlanBssList
     );
        private static BssType ConvertToBssType(DOT11_BSS_TYPE source)
        {
            switch (source)
            {
            case DOT11_BSS_TYPE.dot11_BSS_type_infrastructure:
                return(BssType.Infrastructure);

            case DOT11_BSS_TYPE.dot11_BSS_type_independent:
                return(BssType.Independent);

            default:
                return(BssType.Any);
            }
        }
Beispiel #4
0
        public static bool TryConvert(DOT11_BSS_TYPE source, out BssType bssType)
        {
            switch (source)
            {
            case DOT11_BSS_TYPE.dot11_BSS_type_infrastructure:
                bssType = BssType.Infrastructure;
                return(true);

            case DOT11_BSS_TYPE.dot11_BSS_type_independent:
                bssType = BssType.Independent;
                return(true);
            }
            bssType = default(BssType);
            return(false);
        }
        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)));
                }
            }
        }
Beispiel #6
0
        public static bool Connect(SafeClientHandle clientHandle, Guid interfaceId, string profileName, DOT11_BSS_TYPE bssType)
        {
            var connectionParameters = new WLAN_CONNECTION_PARAMETERS
            {
                wlanConnectionMode = WLAN_CONNECTION_MODE.wlan_connection_mode_profile,
                strProfile         = profileName,
                dot11BssType       = bssType,
                dwFlags            = 0U
            };

            var result = WlanConnect(
                clientHandle,
                interfaceId,
                ref connectionParameters,
                IntPtr.Zero);

            // ERROR_NOT_FOUND will be returned if the interface is removed.
            return(CheckResult(nameof(WlanConnect), result, false));
        }
Beispiel #7
0
        public static WLAN_BSS_ENTRY[] GetNetworkBssEntryList(SafeClientHandle clientHandle, Guid interfaceId, DOT11_SSID ssid, DOT11_BSS_TYPE bssType, bool isSecurityEnabled)
        {
            var queryData   = IntPtr.Zero;
            var wlanBssList = IntPtr.Zero;

            try
            {
                queryData = Marshal.AllocHGlobal(Marshal.SizeOf(ssid));
                Marshal.StructureToPtr(ssid, queryData, false);

                var result = WlanGetNetworkBssList(
                    clientHandle,
                    interfaceId,
                    queryData,
                    bssType,
                    isSecurityEnabled,
                    IntPtr.Zero,
                    out wlanBssList);

                // ERROR_NDIS_DOT11_POWER_STATE_INVALID will be returned if the interface is turned off.
                return(CheckResult(nameof(WlanGetNetworkBssList), result, false)
                                        ? new WLAN_BSS_LIST(wlanBssList).wlanBssEntries
                                        : new WLAN_BSS_ENTRY[0]);
            }
            finally
            {
                Marshal.FreeHGlobal(queryData);

                if (wlanBssList != IntPtr.Zero)
                {
                    WlanFreeMemory(wlanBssList);
                }
            }
        }
		private static BssType ConvertToBssType(DOT11_BSS_TYPE source)
		{
			switch (source)
			{
				case DOT11_BSS_TYPE.dot11_BSS_type_infrastructure:
					return BssType.Infrastructure;
				case DOT11_BSS_TYPE.dot11_BSS_type_independent:
					return BssType.Independent;
				default:
					return BssType.Any;
			}
		}
		private static bool Connect(IntPtr clientHandle, Guid interfaceGuid, string profileName, DOT11_BSS_TYPE bssType)
		{
			var connectionParameters = new WLAN_CONNECTION_PARAMETERS
			{
				wlanConnectionMode = WLAN_CONNECTION_MODE.wlan_connection_mode_profile,
				strProfile = profileName,
				dot11BssType = bssType,
				dwFlags = 0U
			};

			var result = WlanConnect(
				clientHandle,
				interfaceGuid,
				ref connectionParameters,
				IntPtr.Zero);

			// ERROR_NOT_FOUND will be returned if the interface is removed.
			return CheckResult(result, "WlanConnect", false);
		}
Beispiel #10
0
        /// <summary>
        /// Retrieves a list of the basic service set (BSS) entries of the wireless network or networks from specified the SSID on a given wireless LAN interface.
        /// </summary>
        /// <param name="clientHandle"></param>
        /// <param name="interfaceId"></param>
        /// <param name="ssid"></param>
        /// <param name="bssType">dot11_BSS_type_infrastructure or dot11_BSS_type_independent</param>
        /// <returns></returns>
        public static IEnumerable <WLAN_BSS_ENTRY> GetNetworkBssEntryList(SafeClientHandle clientHandle, Guid interfaceId, DOT11_SSID ssid, DOT11_BSS_TYPE bssType)
        {
            IntPtr ssidPtr = Marshal.AllocHGlobal(Marshal.SizeOf(ssid));

            Marshal.StructureToPtr(ssid, ssidPtr, false);
            var wlanBssList = IntPtr.Zero;

            try
            {
                var result = WlanGetNetworkBssList(
                    clientHandle,
                    interfaceId,
                    ssidPtr,
                    bssType,
                    true,                 //must true
                    IntPtr.Zero,
                    out wlanBssList);

                // ERROR_NDIS_DOT11_POWER_STATE_INVALID will be returned if the interface is turned off.
                return(CheckResult(nameof(WlanGetNetworkBssList), result, false)
                                    ? new WLAN_BSS_LIST(wlanBssList).wlanBssEntries
                                    : new WLAN_BSS_ENTRY[0]);
            }
            finally
            {
                if (wlanBssList != IntPtr.Zero)
                {
                    WlanFreeMemory(wlanBssList);
                }
            }
        }