public bool Connect(string password)
{
var wifi = new Wifi();
var accessPoint = wifi.GetAccessPoints().FirstOrDefault(x => x.Name.Equals(Name));
if (accessPoint == null)
{
return(false);
}
var authRequest = new AuthRequest(accessPoint)
{
Password = password
};
return(accessPoint.Connect(authRequest));
}
private void UpdateAvailableNetworks()
{
lock (@lock)
{
networks.Clear();
foreach (var accessPoint in wifi.GetAccessPoints())
{
// The user may only connect to an already configured wireless network!
if (accessPoint.HasProfile)
{
networks.Add(ToDefinition(accessPoint));
}
}
}
}
private void RefreshButton_Click(object sender, EventArgs e)
{
myList.Items.Clear();
wifi = new Wifi();
List <AccessPoint> aps = wifi.GetAccessPoints();
var counter = 1;
foreach (AccessPoint ap in aps)
{
ListViewItem lvItem = new ListViewItem(counter.ToString());
lvItem.SubItems.Add(ap.Name);
lvItem.SubItems.Add(ap.SignalStrength + "%");
myList.Items.Add(lvItem);
counter++;
}
}
public List <WiFiNetwork> GetNetworks()
{
List <WiFiNetwork> networks = new List <WiFiNetwork>();
List <AccessPoint> accessPoints = _wifi.GetAccessPoints();
foreach (AccessPoint accessPoint in accessPoints)
{
networks.Add(new WiFiNetwork(accessPoint.Name,
accessPoint.SignalStrength.ToString() + "%",
accessPoint.ToString(),
GetMAC(accessPoint),
accessPoint.IsSecure,
accessPoint.IsConnected)
);
}
return(networks);
}
public List <Network> GetNetworks()
{
var networks = new List <Network>();
var accessPoints = _wifi.GetAccessPoints();
foreach (var accessPoint in accessPoints)
{
networks.Add(new Network(accessPoint.Name,
accessPoint.SignalStrength.ToString() + "%",
accessPoint.ToString(),
GetMac(accessPoint),
accessPoint.IsSecure,
accessPoint.IsConnected)
);
}
return(networks);
}
private static bool List()
{
Console.WriteLine("\r\n-- Access point list --");
IEnumerable <AccessPoint> accessPoints = wifi.GetAccessPoints().OrderByDescending(ap => ap.SignalStrength);
foreach (AccessPoint ap in accessPoints)
{
if (ap.IsConnected)
{
Console.WriteLine("Current connection: {0}.", ap.Name);
}
if (ap.Name == "MAInet_public" && ap.IsConnected)
{
return(true);
}
}
return(false);
}
public List <WiFiNetwork> GetNetworks()
{
var networks = new List <WiFiNetwork>();
foreach (var accessPoint in _wifi.GetAccessPoints())
{
networks.Add(new WiFiNetwork()
{
Name = accessPoint.Name,
SignalStrength = accessPoint.SignalStrength.ToString() + "%",
Description = accessPoint.ToString(),
BssId = GetBssId(accessPoint),
IsSecured = accessPoint.IsSecure,
IsConnected = accessPoint.IsConnected
});
}
return(networks);
}
private void RefreshAvailableWifiConnections()
{
_accessPoints = _wifi.GetAccessPoints();
var items = new List <ListViewItem>();
foreach (var ap in _accessPoints)
{
var item = new ListViewItem(ap.Name);
item.SubItems.Add(ap.MacAddress);
item.SubItems.Add($"{ap.SignalStrength.ToString()} %");
item.SubItems.Add(ap.AuthType);
item.Tag = ap;
items.Add(item);
}
AddListViewItems(items);
}
// On Load, get all avialable WiFi within the vicinity
private void WifiForm_Load(object sender, EventArgs e)
{
wifi = new Wifi();
List <AccessPoint> aps = wifi.GetAccessPoints();
foreach (AccessPoint ap in aps)
{
ListViewItem lvap = new ListViewItem(ap.Name);
// Grab signal strength
lvap.SubItems.Add(ap.SignalStrength + "%");
// Check if secured or open
if (ap.IsSecure)
{
lvap.SubItems.Add("\u221A");
}
else
{
lvap.SubItems.Add("");
}
// Add name
lvap.Tag = ap;
lvAccessPoints.Items.Add(lvap);
}
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
lblConnStatus.Text = "ONLINE";
lblConnStatus.ForeColor = Color.Green;
btnDisconnect.Visible = true;
btnConnect.Visible = false;
}
else
{
lblConnStatus.Text = "OFFLINE";
lblConnStatus.ForeColor = Color.Red;
btnDisconnect.Visible = false;
btnConnect.Visible = true;
}
}
private void WifiSearch(Wifi wifi)
{
listBox.Items.Clear();
if (!wifi.NoWifiAvailable)
{
foreach (var accessPoint in wifi.GetAccessPoints())
{
ListBoxItem network = new ListBoxItem();
network.Content = accessPoint.Name;
if (accessPoint.IsConnected)
{
network.FontWeight = FontWeights.Bold;
lastNetwork = network;
}
listBox.Items.Add(network);
var test = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault();
}
}
}
private void LoadWifiHotSpot()
{
if (wifi == null)
{
wifi = new Wifi();
}
lbxWIFI.Items.Clear();
accessPoints = wifi.GetAccessPoints();
List <string> ssids = new List <string>();
foreach (var item in accessPoints)
{
if (!ssids.Any(w => w == item.Name))// item.Name.Contains("Bangvo") &&
{
ssids.Add(item.Name);
lbxWIFI.Items.Add(item.Name);
}
}
}
/// <summary>
/// Ищем доступные точки доступа wifi
/// </summary>
private void ScanerWiFi_ButtonClick(object sender, RoutedEventArgs e)
{
try
{
Wifi wifi = new Wifi();
// get list of access points
IEnumerable <AccessPoint> accessPoints = wifi.GetAccessPoints();
ArenaPrint(null);
ArenaPrint($"найдено точек {accessPoints.Count()}");
ArenaPrint("-------------------------------------");
List <MyAccessPoint> bufer = new List <MyAccessPoint>();
if (accessPoints.Count() > 0)
{
foreach (var item in accessPoints)
{
if (item.Name == "")// если сеть скрытая
{
ArenaPrint($"Скрытая сеть \t- {item.SignalStrength} %");
bufer.Add(new Models.MyAccessPoint()
{
Ssid = "Скрытая сеть",
SignalStrength = item.SignalStrength
});
}
else
{
ArenaPrint($"{item.Name} \t- {item.SignalStrength} %");
bufer.Add(new Models.MyAccessPoint()
{
Ssid = item.Name,
SignalStrength = item.SignalStrength
});
}
}
}
pointsViewModel.MyAccessPoints = bufer;
}
catch (Exception exc)
{
pointsViewModel.MyAccessPoints = new List <MyAccessPoint>();
ArenaPrint(exc.Message, true);
}
}
private void WifiSearch(Wifi wifi)
{
NetworkList.Clear();
string fontValue = "Normal";
if (!wifi.NoWifiAvailable)
{
foreach (var accessPoint in wifi.GetAccessPoints())
{
fontValue = "Normal";
if (accessPoint.IsConnected)
{
fontValue = "Bold";
}
NetworkList.Add(new WifiNetwork {
Name = accessPoint.Name, Font = fontValue
});
}
}
}
/*
* public void Connect(string name, string password)
* {
* var client = new WlanClient();
* foreach (var wlanIface in client.Interfaces)
* {
* var wlanBssEntries = wlanIface.GetAvailableNetworkList(0);
* foreach (var network in wlanBssEntries)
* {
* var profileName = Encoding.ASCII.GetString(network.dot11Ssid.SSID);
* if (profileName == name)
* {
* var strTemplate = "";
* var authentication = "";
* switch ((int)network.dot11DefaultAuthAlgorithm)
* {
* case 1: // Open
* break;
* case 3: // WEP
* break;
* case 4: // WPA_PSK
* strTemplate = Properties.Resources.WPAPSK;
* authentication = "WPAPSK";
* var encryption = network.dot11DefaultCipherAlgorithm.ToString().Trim((char)0);
* var profileXml = string.Format(strTemplate, profileName, authentication, encryption, password);
* wlanIface.SetProfile(Wlan.WlanProfileFlags.AllUser, profileXml, true);
* wlanIface.Connect(Wlan.WlanConnectionMode.Profile, Wlan.Dot11BssType.Any, profileName);
* break;
*
* default:
* break;
* }
* }
* }
* }
* }
*/
public bool Connect(string name, string password)
{
var wifi = new Wifi();
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
wifi.Disconnect();
}
var selectedAP = wifi.GetAccessPoints().First(p => p.Name == name.Trim((char)0));
if (selectedAP != null)
{
var authRequest = new AuthRequest(selectedAP);
if (authRequest.IsPasswordRequired)
{
authRequest.Password = password;
}
return(selectedAP.Connect(authRequest));
}
return(false);
}
public static void ConnectNetwork(Wifi wifi, string ssid, string password = "")
{
if (!wifi.NoWifiAvailable)
{
var accessPoint = wifi.GetAccessPoints().Find(item => item.Name == ssid);
AuthRequest authRequest = new AuthRequest(accessPoint);
bool overwrite = true;
if (authRequest.IsPasswordRequired)
{
if (accessPoint.HasProfile)
{
overwrite = false;
}
else
{
authRequest.Password = password;
}
}
accessPoint.Connect(authRequest, overwrite);
}
}
private static void Run()
{
var wifi = new Wifi();
if (wifi.NoWifiAvailable)
{
Console.WriteLine("No WiFi available");
return;
}
if (wifi.ConnectionStatus == WifiStatus.Disconnected)
{
Console.WriteLine("WiFi not connected");
return;
}
var connectedNetwork = wifi.GetAccessPoints().FirstOrDefault(n => n.IsConnected);
if (connectedNetwork == null)
{
Console.WriteLine("Not connected to any WiFi network");
return;
}
if (CanReachInternet())
{
Console.WriteLine($"Internet access working");
return;
}
Console.WriteLine($"No internet access detected. Disconnecting from {connectedNetwork.Name}");
wifi.Disconnect();
Console.WriteLine("Waiting 15 seconds");
Thread.Sleep(15000);
Console.WriteLine($"Reconnecting to {connectedNetwork.Name}");
connectedNetwork.Connect(new AuthRequest(connectedNetwork));
}
private IEnumerable <string> RetrieveConnectedSsids()
{
LoggerService.Instance.WriteLog("RetrieveConnectedSsids begin.");
var ssids = new List <string>();
try
{
foreach (var ap in _wifi.GetAccessPoints())
{
if (ap.IsConnected)
{
ssids.Add(ap.Name);
}
}
}
catch (System.ComponentModel.Win32Exception ex)
{
// Throwed when WLAN switched-off.
LoggerService.Instance.WriteLog($"Throwed Win32Exception on RetrieveConnectedSsids: {ex.Message}");
}
LoggerService.Instance.WriteLog($"RetrieveConnectedSsids end. Data:{string.Join(",",ssids)}");
return(ssids);
}
private static void verify_and_connect()
{
while (run)
{
try
{
//get list of access points
IEnumerable <AccessPoint> accessPoints = wifi.GetAccessPoints();
//scan for ardrone
foreach (AccessPoint ap in accessPoints)
{
if (ap.Name.StartsWith("ardrone_"))
{
rssi = (int)ap.SignalStrength;
//verify connection
if (!ap.IsConnected)
{
//connect if not connected
AuthRequest authRequest = new AuthRequest(ap);
ap.Connect(authRequest);
autoEvent = new AutoResetEvent(false);
autoEvent.WaitOne(20000);
}
}
}
Thread.Sleep(250);
}
catch (Exception ex)
{
Console.WriteLine("update_rssi ex=" + ex.Message);
}
}
}
public bool FindAllPoints()
{
FindBssids();
try
{
Wifi wifi = new Wifi();
List <Connection> newConnections = new List <Connection>();
foreach (var accessPoint in wifi.GetAccessPoints())
{
newConnections.Add(new Connection
{
accessPoint = accessPoint,
Mac = FindMac(accessPoint)
});
}
Connections = newConnections;
return(true);
}
catch (System.ComponentModel.Win32Exception) // Wifi is turned off
{
Connections.Clear();
return(false);
}
}
private static bool HandleListenEvent()
{
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
List <AccessPoint> aps = wifi.GetAccessPoints();
foreach (AccessPoint ap in aps)
{
if (ap.IsConnected)
{
Console.WriteLine("i'm connected to " + ap.Name);
if (ap.Name == "WLAN-503v")
{
Console.WriteLine("That's mine enable!!!");
return(true);
}
}
}
}
else
{
Console.WriteLine("not for me, disable");
}
return(false);
}
private static async Task <bool> Request()
{
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
if (wlan.Interfaces.First() != null)
{
if (wlan.Interfaces.First().InterfaceState != WlanInterfaceState.Disconnected)
{
var interfaceFound = wlan.Interfaces.FirstOrDefault(x => x.CurrentConnection.profileName == SSID);
if (interfaceFound != null)
{
if (interfaceFound.CurrentConnection.isState == WlanInterfaceState.Connected)
{
if (!CheckForInternetConnection())
{
return(await Authenticate());
}
else
{
CheckHowManyDevicesAreConnected();
throw new AppException($"Sei connesso alla rete {SSID}.");
}
}
else
{
throw new AppException($"Prova a riconnetterti alla rete {SSID}");
}
}
else
{
var ap = wifi.GetAccessPoints();
var ergo = ap.FirstOrDefault(x => x.Name == SSID);
if (ergo != null)
{
throw new AppException("Sei connesso ad un'altra rete ma la rete ergo è nelle vicinanze!");
}
throw new AppException($"La rete {SSID} non è nelle vicinanze.");
}
}
else
{
var ap = wifi.GetAccessPoints();
var ergo = ap.FirstOrDefault(x => x.Name == SSID);
if (ergo != null)
{
if (!ergo.IsConnected)
{
//connect if not connected
Console.WriteLine("\r\n{0}\r\n", ergo.ToString());
Console.WriteLine("Trying to connect..\r\n");
AuthRequest authRequest = new AuthRequest(ergo);
var connected = ergo.Connect(authRequest);
if (connected)
{
return(await Authenticate());
}
else
{
throw new AppException("Non sono riuscito a connettermi automaticamente alla rete. Prova manualmente :(");
}
}
}
throw new AppException($"La rete {SSID} non è nelle vicinanze.");
}
}
else
{
throw new AppException("Non riesco ad usare il modulo wifi. Hai una scheda di rete nel tuo pc?");
}
}
/// <summary>
///
/// </summary>
private void List()
{
lvAccessPoint.HeaderStyle = ColumnHeaderStyle.Clickable;
lvAccessPoint.View = View.Details;
lvAccessPoint.Scrollable = true;
lvAccessPoint.ContextMenuStrip = contextMenuStripView;
WlanClient client = new WlanClient();
if (client.Interfaces != null && client.Interfaces.Length > 0)
{
foreach (WlanInterface wlanIface in client.Interfaces)
{
if (wlanIface.InterfaceState == WlanInterfaceState.Connected && wlanIface.CurrentConnection.isState == WlanInterfaceState.Connected)
{
wlanIface.Scan();
}
}
tssl.Text = "Wlan is enable";
wlanIsEnable = true;
BtnEnableWlan.Text = "Disnable";
}
else
{
wlanIsEnable = false;
BtnEnableWlan.Text = "Enable";
tssl.Text = "Wlan is disnable";
}
if (wifi.ConnectionStatus != WifiStatus.Connected)
{
//return;
}
accessPoints = wifi.GetAccessPoints().OrderByDescending(ap => ap.HasProfile).ThenByDescending(ap => ap.SignalStrength);
lvAccessPoint?.Items?.Clear();
lvAccessPoint?.Columns?.Clear();
lvAccessPoint.SmallImageList = new ImageList
{
ImageSize = new Size(1, 25)
};
int c1 = int.Parse(Math.Floor(0.5 * lvAccessPoint.Width).ToString()),
c2 = int.Parse(Math.Floor(0.25 * lvAccessPoint.Width).ToString()),
c3 = lvAccessPoint.Width - c1 - c2;
lvAccessPoint.Columns.Add("WifiName", c1, HorizontalAlignment.Left);
lvAccessPoint.Columns.Add("Singnalr", c2, HorizontalAlignment.Center);
lvAccessPoint.Columns.Add("IsConnected", c3, HorizontalAlignment.Center);
lvAccessPoint.BeginUpdate();
foreach (AccessPoint ap in accessPoints)
{
if (ap.Name.Trim() != string.Empty)
{
var lvi = new ListViewItem(ap.Name)
{
Tag = ap
};
lvi.SubItems.AddRange(new string[] { ap.SignalStrength.ToString(), ap.IsConnected.ToString() });
lvi.Selected = ap.IsConnected;
if (lvi.Selected)
{
lvi.UseItemStyleForSubItems = true;
lvi.ForeColor = Color.DarkGreen;
lvi.Font = new Font(lvi.Font, FontStyle.Bold);
}
else if (!ap.HasProfile)
{
lvi.ForeColor = Color.Gray;
}
lvAccessPoint.Items.Add(lvi);
}
}
lvAccessPoint.EndUpdate();
//this.lvAccessPoint.Scrollable = false;
//ShowScrollBar((int)this.lvAccessPoint.Handle, SB_VERT, 1);
}
public static AccessPoint GetCurrentConnectedAccessPoint()
{
return(wifi.GetAccessPoints().FirstOrDefault(ap => ap.IsConnected == true));
}
public static bool ConnectBluegiga(TcpClient tcp, Wifi wifi)
{
bool connection = false;
bool networksAvailable = false;
try
{
networksAvailable = wifi.GetAccessPoints().Any();
}
catch { }
if (!tcp.Connected)
{
if (!wifi.NoWifiAvailable && networksAvailable)
{
IPAddress IP;
string ssid;
if (ReadMemory(out IP, out ssid))
{
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
if (wifi.GetAccessPoints().Find(item => item.IsConnected).Name == ssid)
{
tcp = CreateTCPConnection(IP, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
else if (wifi.GetAccessPoints().Exists(item => item.Name == ssid))
{
ConnectNetwork(wifi, ssid);
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
if (wifi.GetAccessPoints().Find(item => item.IsConnected).Name == ssid)
{
tcp = CreateTCPConnection(IP, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
}
}
else
{
tcp = CreateTCPConnection(IPAddress.Any, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
}
else if (wifi.ConnectionStatus == WifiStatus.Disconnected)
{
if (wifi.GetAccessPoints().Exists(item => item.Name == ssid))
{
ConnectNetwork(wifi, ssid);
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
if (wifi.GetAccessPoints().Find(item => item.IsConnected).Name == ssid)
{
tcp = CreateTCPConnection(IP, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
}
}
}
}
else if (wifi.ConnectionStatus == WifiStatus.Connected)
{
tcp = CreateTCPConnection(IPAddress.Any, port, tcp);
if (tcp.Connected)
{
connection = true;
}
else
{
if (wifi.GetAccessPoints().Exists(item => item.Name == defaultAP))
{
ConnectNetwork(wifi, defaultAP, defaultPW);
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
if (wifi.GetAccessPoints().Find(item => item.IsConnected).Name == defaultAP)
{
tcp = CreateTCPConnection(IPAddress.Any, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
}
}
}
}
else if (wifi.ConnectionStatus == WifiStatus.Disconnected)
{
if (wifi.GetAccessPoints().Exists(item => item.Name == defaultAP))
{
ConnectNetwork(wifi, defaultAP, defaultPW);
if (wifi.ConnectionStatus == WifiStatus.Connected)
{
if (wifi.GetAccessPoints().Find(item => item.IsConnected).Name == defaultAP)
{
tcp = CreateTCPConnection(IPAddress.Any, port, tcp);
if (tcp.Connected)
{
connection = true;
}
}
}
}
}
}
}
else
{
connection = true;
}
if (connection)
{
SaveMemory(((IPEndPoint)tcp.Client.RemoteEndPoint).Address, wifi.GetAccessPoints().Find(item => item.IsConnected).Name);
}
return(connection);
}
/// <summary>
/// Список точек
/// </summary>
/// <returns></returns>
private IEnumerable <AccessPoint> List()
{
IEnumerable <AccessPoint> accessPointsList = wifi.GetAccessPoints().OrderByDescending(ap => ap.SignalStrength);
return(accessPointsList);
}
public void DisconnectNetwork()
{
Wifi.Disconnect();
ScanWiFiList = Wifi.GetAccessPoints();
ScanWiFiList.ForEach(e => e.DeleteProfile());
}
private void PollCurrentState(WifiStatus wifiState)
{
string wifiSsid = "";
try
{
// WiFi
wifiState = wifi.ConnectionStatus;
// if connected find ssid
if (wifiState == WifiStatus.Connected)
{
foreach (AccessPoint ap in wifi.GetAccessPoints())
{
if (ap.IsConnected)
{
Console.WriteLine("i'm connected to " + ap.Name);
wifiSsid = ap.Name;
}
}
}
}
catch (Exception)
{
Console.WriteLine("cant check wifi state");
}
// Network address
// Evaluate
Trigger candidate = null;
foreach (Trigger trigger in triggers.Triggers)
{
bool wifiMatch = false, addressMatch = false;
if (trigger.IsWiFiTrigger && trigger.WiFiSsid == wifiSsid && wifiState == WifiStatus.Connected)
{
Console.WriteLine("found a trigger for this ssid, ");
wifiMatch = true;
}
//if(trigger.IsAddressTrigger && trigger.AddressMask ==?)
//{
//addressMatch = true;
//}
// check if it doesn't match, and continue search if so
if ((trigger.IsWiFiTrigger && trigger.IsAddressTrigger && !(wifiMatch && addressMatch)) ||
(trigger.IsWiFiTrigger && !wifiMatch) ||
(trigger.IsAddressTrigger && !addressMatch) ||
!(trigger.IsWiFiTrigger || trigger.IsAddressTrigger))
{
Console.WriteLine(trigger.Title + " is no good, continue");
continue;
}
candidate = trigger;
break;
}
// Enable if candidate found
if (candidate != null)
{
Console.WriteLine("it seems we have a winner: " + candidate.Title);
var proxy = profiles.FindProxyByTitle(candidate.ProfileToActivate);
if (proxy != null)
{
bool activated = ProxyController.Instance.ActivateProxy(proxy);
OnProxyTriggered?.Invoke(proxy, "trigger: " + candidate.Title + " activated: " + activated);
}
else
{
Console.WriteLine("proxy not found: " + candidate.ProfileToActivate);
}
}
else
{
Console.WriteLine("no trigger found, maybe wanna disable?");
}
}
/// <summary>
/// Get list of access points in range
/// </summary>
public List <AccessPoint> GetAvailableAccessPoints()
{
return(wifi.GetAccessPoints().OrderByDescending(ap => ap.SignalStrength).ToList());
}
//private List<WIFISSID> ssids=new List<WIFISSID>();
//private wifiSo wifiso;
public void Run(IProperties properties, GlobalDic <string, object> globalDic)//virtual
{
config = properties as ConnectSsiProperties;
ILog log = globalDic[typeof(ILog).ToString()] as ILog;
configGv = globalDic[typeof(GlobalVaribles).ToString()] as GlobalVaribles;
bool hasSsid = false;
string mac = configGv.Get(GlobalVaribles.MAC);
string ssid = string.Format(config.SSID, mac);
Wifi g_wifi;
try
{
//WlanClient client = new WlanClient();
//foreach (WlanClient.WlanInterface wlanIface in client.Interfaces)
//{
WlanClient client = new WlanClient();
foreach (WlanClient.WlanInterface wlanIface in client.Interfaces)
{
wlanIface.Scan();
}
Thread.Sleep(1000);
g_wifi = new Wifi();
List <AccessPoint> wifiList = g_wifi.GetAccessPoints();
foreach (AccessPoint item in wifiList)
{
if (item.Name == ssid)
{
hasSsid = true;
if (!item.IsConnected)
{
AuthRequest authRequest = new AuthRequest(item);
bool bConnect = item.Connect(authRequest);
if (bConnect)
{
log.Info(string.Format("连接网络成功"));
configGv.Add("ObjWifi", g_wifi);
}
}
else
{
log.Info(string.Format("网络已处于连接状态，无需连接"));
configGv.Add("ObjWifi", g_wifi);
}
break;
}
}
// wlanIface.Scan();
//}
if (!hasSsid)
{
throw new BaseException(string.Format("未扫描到SSID:{0}", ssid));
}
////WlanClient client = new WlanClient();
//foreach (WlanClient.WlanInterface wlanIface in client.Interfaces)
//{
// wlanIface.Scan();
//}
//#region
//WlanClient client = new WlanClient();
//WIFISSID targetSSID;
//foreach (WlanClient.WlanInterface wlanIface in client.Interfaces)
//{
// // Lists all networks with WEP security
// Wlan.WlanAvailableNetwork[] networks = wlanIface.GetAvailableNetworkList(Wlan.WlanGetAvailableNetworkFlags.IncludeAllAdhocProfiles);
// foreach (Wlan.WlanAvailableNetwork network in networks)
// {
// //ssids.Add(targetSSID);
// //wifiListOKADDitem(GetStringForSSID(network.dot11Ssid), network.dot11DefaultCipherAlgorithm.ToString(),
// // network.dot11DefaultAuthAlgorithm.ToString(), (int)network.wlanSignalQuality);
// if (GetStringForSSID(network.dot11Ssid).Equals(ssid))
// {
// //var obj = new wifiSo(targetSSID, config.Key);
// targetSSID = new WIFISSID();
// targetSSID.wlanInterface = wlanIface;
// targetSSID.wlanSignalQuality = (int)network.wlanSignalQuality;
// targetSSID.SSID = GetStringForSSID(network.dot11Ssid);
// //targetSSID.SSID = Encoding.Default.GetString(network.dot11Ssid.SSID, 0, (int)network.dot11Ssid.SSIDLength);
// targetSSID.dot11DefaultAuthAlgorithm = network.dot11DefaultAuthAlgorithm.ToString();
// targetSSID.dot11DefaultCipherAlgorithm = network.dot11DefaultCipherAlgorithm.ToString();
// ConnectToSSID(targetSSID, config.Key);
// hasSsid = true;
// log.Info(string.Format("连接网络成功"));
// return;
// //Thread wificonnect = new Thread(obj.ConnectToSSID);
// //wificonnect.Start();
// //WifiSocket wifiscoket = new WifiSocket();
// //wifiscoket.fuwu();
// //wifiscoket.kehuduan();
// //wifiso.ConnectToSSID(targetSSID, "ZMZGZS520");//连接wifi
// //connectWifiOK.Text = GetStringForSSID(network.dot11Ssid);
// //Image img = new Bitmap(Environment.CurrentDirectory + "/image/wifi.png");//这里是你要替换的图片。当然你必须事先初始化出来图
// //pictureBoxW.BackgroundImage = img;
// //Console.WriteLine(">>>>>>>>>>>>>>>>>开始连接网络！" + targetSSID.SSID + GetStringForSSID(network.dot11Ssid) + GetStringForSSID(network.dot11Ssid).Equals("DZSJ1"));
// }
// }
// wlanIface.Scan();
//}
//if (!hasSsid)
//{
// throw new BaseException(string.Format("未扫描到SSID:{0}", ssid));
//}
//#endregion
}
catch (Exception ex)
{
throw new Exception("连接热点出错，" + ex.Message);
}
}
public WifiService()
{
wifi = new Wifi();
accessPoints = wifi.GetAccessPoints();
}
