2019 lines
66 KiB
C++
2019 lines
66 KiB
C++
#include "NetworkManager.h"
|
|
#include "ui_NetworkManager.h"
|
|
#include <QDebug>
|
|
#include <QProcess>
|
|
#include <QNetworkInterface>
|
|
#include <QMessageBox>
|
|
#include "myinclude.h"
|
|
#include "dirent.h"
|
|
#include "common/wpa_ctrl.h"
|
|
#define LANINTERFACE_NAME "eth0"
|
|
|
|
#ifdef Q_OS_WIN
|
|
#include <wbemidl.h>
|
|
#include <comdef.h>
|
|
#include <windows.h>
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
#pragma comment(lib, "Wbemuuid.lib")
|
|
#else
|
|
#define BUFSIZE 8192
|
|
#include <arpa/inet.h>
|
|
#include <net/if.h>
|
|
#include <sys/socket.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <unistd.h>
|
|
|
|
struct route_info {
|
|
in_addr dstAddr;
|
|
in_addr srcAddr;
|
|
in_addr gateWay;
|
|
char ifName[IF_NAMESIZE];
|
|
};
|
|
|
|
int readNlSock(int sockFd, char *bufPtr, unsigned int seqNum, int pId) {
|
|
struct nlmsghdr *nlHdr;
|
|
int readLen = 0, msgLen = 0;
|
|
do {
|
|
if ((readLen = recv(sockFd, bufPtr, BUFSIZE - msgLen, 0)) < 0) {
|
|
perror("SOCK READ: ");
|
|
return -1;
|
|
}
|
|
nlHdr = (struct nlmsghdr *)bufPtr;
|
|
if ((NLMSG_OK(nlHdr, readLen) == 0) || (nlHdr->nlmsg_type == NLMSG_ERROR)) {
|
|
perror("Error in received packet");
|
|
return -1;
|
|
}
|
|
if (nlHdr->nlmsg_type == NLMSG_DONE)
|
|
break;
|
|
|
|
bufPtr += readLen;
|
|
msgLen += readLen;
|
|
|
|
if ((nlHdr->nlmsg_flags & NLM_F_MULTI) == 0)
|
|
break;
|
|
|
|
} while ((nlHdr->nlmsg_seq != seqNum) || (nlHdr->nlmsg_pid != (unsigned)pId));
|
|
return msgLen;
|
|
}
|
|
|
|
void parseRoutes(struct nlmsghdr *nlHdr, struct route_info *rtInfo) {
|
|
struct rtmsg *rtMsg = (struct rtmsg *)NLMSG_DATA(nlHdr);
|
|
|
|
if ((rtMsg->rtm_family != AF_INET) || (rtMsg->rtm_table != RT_TABLE_MAIN))
|
|
return;
|
|
|
|
struct rtattr *rtAttr = (struct rtattr *)RTM_RTA(rtMsg);
|
|
int rtLen = RTM_PAYLOAD(nlHdr);
|
|
for (; RTA_OK(rtAttr, rtLen); rtAttr = RTA_NEXT(rtAttr, rtLen)) {
|
|
switch (rtAttr->rta_type) {
|
|
case RTA_OIF:
|
|
if_indextoname(*(int *)RTA_DATA(rtAttr), rtInfo->ifName);
|
|
break;
|
|
case RTA_GATEWAY:
|
|
rtInfo->gateWay = *(in_addr *)RTA_DATA(rtAttr);
|
|
break;
|
|
case RTA_PREFSRC:
|
|
rtInfo->srcAddr = *(in_addr *)RTA_DATA(rtAttr);
|
|
break;
|
|
case RTA_DST:
|
|
rtInfo->dstAddr = *(in_addr *)RTA_DATA(rtAttr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
class NetworkHelper {
|
|
public:
|
|
static QString DefaultGateway() {
|
|
QString ret;
|
|
#ifdef Q_OS_WIN
|
|
CoInitialize(NULL);
|
|
if (CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0) != S_OK)
|
|
return ret;
|
|
|
|
IWbemLocator *pLoc = NULL;
|
|
if (CoCreateInstance(CLSID_WbemAdministrativeLocator, NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, IID_IUnknown, (void **)&pLoc) != S_OK)
|
|
return ret;
|
|
|
|
IWbemServices *pSvc = NULL;
|
|
if (pLoc->ConnectServer(L"root\\cimv2", NULL, NULL, NULL, 0, NULL, NULL, &pSvc) != S_OK)
|
|
return ret;
|
|
|
|
IEnumWbemClassObject *pEnumerator = NULL;
|
|
HRESULT hr = pSvc->ExecQuery(L"WQL", L"SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'", WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator);
|
|
if (FAILED(hr)) {
|
|
pSvc->Release();
|
|
pLoc->Release();
|
|
CoUninitialize();
|
|
return ret;
|
|
}
|
|
|
|
IWbemClassObject *pclsObj = NULL;
|
|
while (pEnumerator && ret.isEmpty()) {
|
|
_variant_t vaDefaultIPGateway;
|
|
ULONG uReturn;
|
|
hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
|
|
if (!uReturn)
|
|
break;
|
|
|
|
hr = pclsObj->Get(L"DefaultIPGateway", 0, &vaDefaultIPGateway, NULL, NULL);
|
|
if (hr == WBEM_S_NO_ERROR && vaDefaultIPGateway.vt != VT_NULL) {
|
|
LONG lLow = 0;
|
|
LONG lUp = 0;
|
|
::SafeArrayGetLBound(vaDefaultIPGateway.parray, 1, &lLow);
|
|
::SafeArrayGetUBound(vaDefaultIPGateway.parray, 1, &lUp);
|
|
for (LONG i = lLow; i <= lUp; i++) {
|
|
BSTR bsDefaultIPGateway;
|
|
if (::SafeArrayGetElement(vaDefaultIPGateway.parray, &i, &bsDefaultIPGateway) == S_OK) {
|
|
ret = QString::fromUtf16(reinterpret_cast<const ushort *>(bsDefaultIPGateway));
|
|
::SysFreeString(bsDefaultIPGateway);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
VariantClear(&vaDefaultIPGateway);
|
|
}
|
|
|
|
if (pclsObj)
|
|
pclsObj->Release();
|
|
if (pEnumerator)
|
|
pEnumerator->Release();
|
|
if (pSvc)
|
|
pSvc->Release();
|
|
if (pLoc)
|
|
pLoc->Release();
|
|
CoUninitialize();
|
|
#else
|
|
int sock, msgSeq = 0;
|
|
if ((sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) {
|
|
perror("Socket Creation: ");
|
|
return ret;
|
|
}
|
|
|
|
char msgBuf[BUFSIZE];
|
|
memset(msgBuf, 0, BUFSIZE);
|
|
struct nlmsghdr *nlMsg = (struct nlmsghdr *)msgBuf;
|
|
|
|
nlMsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
|
|
nlMsg->nlmsg_type = RTM_GETROUTE;
|
|
|
|
nlMsg->nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST;
|
|
nlMsg->nlmsg_seq = msgSeq++;
|
|
nlMsg->nlmsg_pid = getpid();
|
|
|
|
if (send(sock, nlMsg, nlMsg->nlmsg_len, 0) < 0)
|
|
return ret;
|
|
|
|
int len;
|
|
if ((len = readNlSock(sock, msgBuf, msgSeq, getpid())) < 0)
|
|
return ret;
|
|
|
|
struct route_info *rtInfo = (struct route_info *)malloc(sizeof(struct route_info));
|
|
|
|
for (; NLMSG_OK(nlMsg, len); nlMsg = NLMSG_NEXT(nlMsg, len)) {
|
|
memset(rtInfo, 0, sizeof(struct route_info));
|
|
parseRoutes(nlMsg, rtInfo);
|
|
|
|
if (strstr((char *)inet_ntoa(rtInfo->dstAddr), "0.0.0.0") && !strstr((char *)inet_ntoa(rtInfo->gateWay), "0.0.0.0")) {
|
|
char buf[64];
|
|
inet_ntop(AF_INET, &rtInfo->gateWay, buf, sizeof(buf));
|
|
ret = QString(buf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(rtInfo);
|
|
close(sock);
|
|
#endif
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
NetworkManager::NetworkManager(QWidget *parent) :
|
|
QWidget(parent),
|
|
ui(new Ui::NetworkManager)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
Json_ip_init_done =false;
|
|
net_data = new PrintNet();
|
|
|
|
connect(net_data,SIGNAL(json_server_error()),this,SLOT(onjson_server_error()));
|
|
connect(net_data,SIGNAL(receiveJSONDatafinish()),this,SLOT(onfinish_get_json()));
|
|
connect(net_data,SIGNAL(showMessege()),this,SLOT(ShowNet_dataMessege()));
|
|
|
|
QRegExp regExp("((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)");
|
|
QRegExpValidator *pValidator = new QRegExpValidator(regExp, this);
|
|
|
|
// ui->lineEditLanGW->setValidator(new QRegExpValidator(pValidator));
|
|
// ui->lineEditLanGW->setInputMask("000.000.000.000;");
|
|
|
|
ui->spinBoxLanIP3->setDisabled(true);
|
|
ui->spinBoxLanIP2->setDisabled(true);
|
|
ui->spinBoxLanIP1->setDisabled(true);
|
|
ui->spinBoxLanIP0->setDisabled(true);
|
|
ui->spinBoxLanMask3->setDisabled(true);
|
|
ui->spinBoxLanMask2->setDisabled(true);
|
|
ui->spinBoxLanMask1->setDisabled(true);
|
|
ui->spinBoxLanMask0->setDisabled(true);
|
|
// ui->lineEditLanGW->setDisabled(true);
|
|
ui->spinBoxLanGW3->setDisabled(true);
|
|
ui->spinBoxLanGW2->setDisabled(true);
|
|
ui->spinBoxLanGW1->setDisabled(true);
|
|
ui->spinBoxLanGW0->setDisabled(true);
|
|
ui->pushButtonSetCancel->setDisabled(true);
|
|
|
|
connect(ui->networkSelect, SIGNAL(activated(const QString&)), this,
|
|
SLOT(selectNetwork(const QString&)));
|
|
ctrl_iface = NULL;
|
|
ctrl_conn = NULL;
|
|
monitor_conn = NULL;
|
|
msgNotifier = NULL;
|
|
ctrl_iface_dir = strdup("/var/run/wpa_supplicant");
|
|
|
|
timer = new QTimer(this);
|
|
connect(timer, SIGNAL(timeout()), SLOT(ping()));
|
|
timer->setSingleShot(FALSE);
|
|
timer->start(3000);
|
|
|
|
Json_timer = new QTimer(this);
|
|
connect(Json_timer, SIGNAL(timeout()), SLOT(onjson_timer_handler()));
|
|
Json_timer->stop();
|
|
Jsom_timer_stop =true;
|
|
// Json_timer->start(1000);
|
|
|
|
wlanStartUpFailed = false;
|
|
if (openCtrlConnection(ctrl_iface) < 0) {
|
|
qDebug()<<"Failed to open control connection to "
|
|
"wpa_supplicant.";
|
|
wlanStartUpFailed = true;
|
|
}
|
|
|
|
if(wlanStartUpFailed)
|
|
return;
|
|
updateStatus();
|
|
networkMayHaveChanged = true;
|
|
updateNetworks();
|
|
updateSysStatusToUI();
|
|
}
|
|
|
|
NetworkManager::~NetworkManager()
|
|
{
|
|
delete ui;
|
|
//delete processNetwork;
|
|
}
|
|
|
|
void NetworkManager::onfinish_get_json()
|
|
{
|
|
|
|
net_data->getJson_data(&sysPara->Get_JSON_DATA);
|
|
|
|
if(Jsom_timer_stop == true){
|
|
|
|
Json_timer->start(1000);
|
|
Jsom_timer_stop = false;
|
|
}
|
|
|
|
|
|
ui->messege_info_label->setText( net_data->getMessege() );
|
|
|
|
emit updateJSONData();
|
|
}
|
|
|
|
void NetworkManager::ShowNet_dataMessege()
|
|
{
|
|
ui->messege_info_label->setText( net_data->getMessege());
|
|
}
|
|
|
|
void NetworkManager::bindSysPara(SysPara *sysPara){
|
|
this->sysPara = sysPara;
|
|
const QString cip=getCurrentNetworkIP();
|
|
qDebug()<<"当前IP地址是:"<<cip;
|
|
if(cip.startsWith("0"))//0.0.0.0
|
|
{
|
|
qDebug()<<"1秒后设置静态IP";
|
|
QTimer::singleShot(1000,this,SLOT(setEth0StaticIP_Thread()));
|
|
}
|
|
}
|
|
|
|
void NetworkManager::updateSysStatusToUI()
|
|
{
|
|
|
|
if(sysPara){
|
|
|
|
if(!Json_ip_init_done){
|
|
|
|
Json_ip_init_done = true;
|
|
ui->deviceID_lineEdit->setText(QString(sysPara->para.Json_device_code));
|
|
QString ip_str;
|
|
ip_str = QString::number(sysPara->para.Json_IP[0]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[1]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[2]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[3]);
|
|
ui->SeverIP_lineEdit->setText(ip_str);
|
|
ui->server_port_lineEdit->setText(QString::number(sysPara->para.Json_server_port));
|
|
|
|
}
|
|
|
|
ui->checkBoxRemoveCode->setCheckState(sysPara->para.isRemoveCode ? Qt::Checked : Qt::Unchecked);
|
|
ui->checkBoxRemoveDigitCode->setCheckState(sysPara->para.isRemoveDigitCode ? Qt::Checked : Qt::Unchecked);
|
|
ui->radioButtonGetDataEnable->setChecked(sysPara->para.isEnableGetDataButton);
|
|
|
|
QList<QNetworkInterface> list = QNetworkInterface::allInterfaces(); //QNetworkInterface::interfaceFromName(LANINTERFACE_NAME);
|
|
//获取所有网络接口的列表
|
|
foreach(QNetworkInterface interface,list)
|
|
{
|
|
#if 0
|
|
//遍历每一个网络接口
|
|
qDebug() << "Device: "<<interface.name();
|
|
//设备名
|
|
qDebug() << "HardwareAddress: "<<interface.hardwareAddress();
|
|
//硬件地址
|
|
QList<QNetworkAddressEntry> entryList = interface.addressEntries();
|
|
//获取IP地址条目列表，每个条目中包含一个IP地址，一个子网掩码和一个广播地址
|
|
foreach(QNetworkAddressEntry entry,entryList)
|
|
{//遍历每一个IP地址条目
|
|
qDebug()<<"IP Address: "<<entry.ip().toString();
|
|
//IP地址
|
|
qDebug()<<"Netmask: "<<entry.netmask().toString();
|
|
//子网掩码
|
|
qDebug()<<"Broadcast: "<<entry.broadcast().toString();
|
|
//广播地址
|
|
|
|
QStringList ipList = entry.ip().toString().split(".");
|
|
if (ipList.size() == 4) {
|
|
qDebug()<<"IP 3: "<<ipList.at(0).toInt();
|
|
qDebug()<<"IP 2: "<<ipList.at(1).toInt();
|
|
qDebug()<<"IP 1: "<<ipList.at(2).toInt();
|
|
qDebug()<<"IP 0: "<<ipList.at(3).toInt();
|
|
}
|
|
}
|
|
#endif
|
|
if(QString::compare(interface.name(), LANINTERFACE_NAME)==0)
|
|
{
|
|
QList<QNetworkAddressEntry> entryList = interface.addressEntries();
|
|
//获取IP地址条目列表，每个条目中包含一个IP地址，一个子网掩码和一个广播地址
|
|
foreach(QNetworkAddressEntry entry,entryList)
|
|
{
|
|
#if 0
|
|
//遍历每一个IP地址条目
|
|
qDebug()<<"IP Address: "<<entry.ip().toString();
|
|
//IP地址
|
|
qDebug()<<"Netmask: "<<entry.netmask().toString();
|
|
//子网掩码
|
|
qDebug()<<"Broadcast: "<<entry.broadcast().toString();
|
|
//广播地址
|
|
qDebug() << "Prefix Length:" << entry.prefixLength(); // 前缀长度
|
|
//prefix
|
|
#endif
|
|
//ui->lineEditLanIP->setText(entry.ip().toString());
|
|
//ui->lineEditLanMask->setText(entry.netmask().toString());
|
|
QStringList lanIpList = entry.ip().toString().split(".");
|
|
if (lanIpList.size() == 4) {
|
|
ui->spinBoxLanIP3->setValue(lanIpList.at(0).toInt());
|
|
ui->spinBoxLanIP2->setValue(lanIpList.at(1).toInt());
|
|
ui->spinBoxLanIP1->setValue(lanIpList.at(2).toInt());
|
|
ui->spinBoxLanIP0->setValue(lanIpList.at(3).toInt());
|
|
}
|
|
else if (lanIpList.size() == 0) {
|
|
ui->spinBoxLanIP3->setValue(0);
|
|
ui->spinBoxLanIP2->setValue(0);
|
|
ui->spinBoxLanIP1->setValue(0);
|
|
ui->spinBoxLanIP0->setValue(0);
|
|
}
|
|
QStringList lanMaskList = entry.netmask().toString().split(".");
|
|
if (lanMaskList.size() == 4) {
|
|
ui->spinBoxLanMask3->setValue(lanMaskList.at(0).toInt());
|
|
ui->spinBoxLanMask2->setValue(lanMaskList.at(1).toInt());
|
|
ui->spinBoxLanMask1->setValue(lanMaskList.at(2).toInt());
|
|
ui->spinBoxLanMask0->setValue(lanMaskList.at(3).toInt());
|
|
}
|
|
else if (lanMaskList.size() == 0) {
|
|
ui->spinBoxLanMask3->setValue(0);
|
|
ui->spinBoxLanMask2->setValue(0);
|
|
ui->spinBoxLanMask1->setValue(0);
|
|
ui->spinBoxLanMask0->setValue(0);
|
|
}
|
|
//ui->lineEditLanGW->setText(entry.netmask().toString());
|
|
QString GatewayAddr = NetworkHelper::DefaultGateway();
|
|
//ui->lineEditLanGW->setText(GatewayAddr);
|
|
QStringList lanGWList = GatewayAddr.split(".");
|
|
if (lanGWList.size() == 4) {
|
|
ui->spinBoxLanGW3->setValue(lanGWList.at(0).toInt());
|
|
ui->spinBoxLanGW2->setValue(lanGWList.at(1).toInt());
|
|
ui->spinBoxLanGW1->setValue(lanGWList.at(2).toInt());
|
|
ui->spinBoxLanGW0->setValue(lanGWList.at(3).toInt());
|
|
}
|
|
else if (lanGWList.size() == 0) {
|
|
ui->spinBoxLanGW3->setValue(0);
|
|
ui->spinBoxLanGW2->setValue(0);
|
|
ui->spinBoxLanGW1->setValue(0);
|
|
ui->spinBoxLanGW0->setValue(0);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
//ui->radioButtonGetDataEnable->setChecked(ui->radioButtonGetDataEnable ? true: false);
|
|
}
|
|
|
|
}
|
|
#define INTERFACE_OTHERS "# The loopback interface \n\
|
|
auto lo \n\
|
|
iface lo inet loopback \n\
|
|
\n \
|
|
# Wireless interfaces \n\
|
|
auto wlan0 \n\
|
|
iface wlan0 inet dhcp \n\
|
|
wireless_mode managed \n\
|
|
wireless_essid any \n\
|
|
wpa-driver wext \n\
|
|
wpa-conf /etc/wpa_supplicant.conf\n"
|
|
|
|
void NetworkManager::applyLanUIPara(void)
|
|
{
|
|
|
|
if(sysPara){
|
|
QList<QNetworkInterface> list = QNetworkInterface::allInterfaces(); //QNetworkInterface::interfaceFromName(LANINTERFACE_NAME);
|
|
//获取所有网络接口的列表
|
|
foreach(QNetworkInterface interface,list) {
|
|
if(QString::compare(interface.name(), LANINTERFACE_NAME)==0)
|
|
{
|
|
uint8_t ip3 = ui->spinBoxLanIP3->value();
|
|
uint8_t ip2 = ui->spinBoxLanIP2->value();
|
|
uint8_t ip1 = ui->spinBoxLanIP1->value();
|
|
uint8_t ip0 = ui->spinBoxLanIP0->value();
|
|
uint8_t lanMask3 = ui->spinBoxLanMask3->value();
|
|
uint8_t lanMask2 = ui->spinBoxLanMask2->value();
|
|
uint8_t lanMask1 = ui->spinBoxLanMask1->value();
|
|
uint8_t lanMask0 = ui->spinBoxLanMask0->value();
|
|
uint8_t lanGW0 = ui->spinBoxLanGW0->value();
|
|
QString ipAddrStr(QString("%1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(ip0));
|
|
QString netMaskStr(QString("%1.%2.%3.%4").arg(lanMask3).arg(lanMask2).arg(lanMask1).arg(lanMask0));
|
|
// QHostAddress ipAddr(ipAddrStr);
|
|
// QHostAddress netMask(netMaskStr);
|
|
qDebug() << "set ip:"<<ipAddrStr;
|
|
// entry.setIp(ipAddr);
|
|
// entry.setNetmask(netMask);
|
|
|
|
//process->start("ifconfig", QStringList() << LANINTERFACE_NAME << "192.168.1.100");
|
|
//startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory,
|
|
// qint64 *pid = 0)
|
|
QStringList argrList;
|
|
if (!(ip3|ip2|ip1|ip0)) {
|
|
// 动态IP
|
|
//qDebug() << "set dhcp";
|
|
QProcess dhcpProcess;
|
|
dhcpProcess.startDetached("/bin/cp /etc/network/interfaces_dhcp /etc/network/interfaces", argrList);
|
|
argrList<< LANINTERFACE_NAME << ipAddrStr;
|
|
|
|
}
|
|
else {
|
|
// 静态IP
|
|
QFile netInterface("/etc/network/interfaces");
|
|
netInterface.open(QIODevice::WriteOnly|QIODevice::Text|QIODevice::Truncate);
|
|
if (netInterface.isOpen()) {
|
|
QTextStream stream(&netInterface);
|
|
stream.seek(0);
|
|
stream << INTERFACE_OTHERS;
|
|
stream << " " <<"\n";
|
|
stream << "# eth0 interfaces" <<"\n";
|
|
stream << "auto eth0" <<"\n";
|
|
stream << "iface eth0 inet static" <<"\n";
|
|
stream << QString("address %1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(ip0) <<"\n";
|
|
stream << QString("gateway %1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(lanGW0) <<"\n";
|
|
stream << QString("netmask %1.%2.%3.%4").arg(lanMask3).arg(lanMask2).arg(lanMask1).arg(lanMask0) <<"\n";
|
|
stream << " \n";
|
|
netInterface.close();
|
|
}
|
|
//const QFile::FileError eno=netInterface.error();
|
|
//qDebug()<<"打开网络设置文件失败,error="<<eno<<",errstr="<<netInterface.errorString();
|
|
argrList<< LANINTERFACE_NAME << ipAddrStr << "netmask" << netMaskStr;
|
|
}
|
|
qDebug() << "set argu:" << argrList;
|
|
//processNetwork->start("ifconfig", argrList);
|
|
QProcess process;
|
|
process.startDetached("/sbin/ifconfig", argrList);
|
|
//processNetwork->startDetached("/sbin/ifconfig", argrList, "/sbin/");
|
|
//char cmd[100];
|
|
//sprintf(cmd,"ifconfig %s %s netmask %s",LANINTERFACE_NAME, ui->lineEditLanIP->text(), ui->lineEditLanMask->text());
|
|
//system(cmd);
|
|
//system("ifconfig eth0 192.168.0.16");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
qint32 NetworkManager::isIpv4Address(QString ip)
|
|
{
|
|
QRegExp regExp("\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b");
|
|
if( !regExp.exactMatch(ip) )
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonSetIP_clicked(bool checked)
|
|
{
|
|
|
|
if(sysPara){
|
|
if(sysPara->status.bLanConfigManual)
|
|
{
|
|
//qDebug()<<QString("before set %1.%2.%3.%4 ").arg(ui->spinBoxLanIP3->value()).arg(ui->spinBoxLanIP2->value()).arg(ui->spinBoxLanIP1->value()).arg(ui->spinBoxLanIP0->value());
|
|
//if(isIpv4Address(ui->lineEditLanIP->text())&&isIpv4Address(ui->lineEditLanMask->text()))//检查IP地址是否有效
|
|
if(1)
|
|
{
|
|
applyLanUIPara();
|
|
ui->pushButtonSetIP->setText(QObject::tr("手动设定"));
|
|
|
|
ui->spinBoxLanIP3->setDisabled(true);
|
|
ui->spinBoxLanIP2->setDisabled(true);
|
|
ui->spinBoxLanIP1->setDisabled(true);
|
|
ui->spinBoxLanIP0->setDisabled(true);
|
|
ui->spinBoxLanMask3->setDisabled(true);
|
|
ui->spinBoxLanMask2->setDisabled(true);
|
|
ui->spinBoxLanMask1->setDisabled(true);
|
|
ui->spinBoxLanMask0->setDisabled(true);
|
|
ui->spinBoxLanGW0->setDisabled(true);
|
|
|
|
ui->pushButtonSetCancel->setDisabled(true);
|
|
sysPara->status.bLanConfigManual = false;
|
|
}
|
|
else
|
|
{
|
|
//QMessageBox::information(this, tr("错误"), tr("ip地址错误"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sysPara->status.bLanConfigManual = true;
|
|
ui->spinBoxLanIP3->setDisabled(false);
|
|
ui->spinBoxLanIP2->setDisabled(false);
|
|
ui->spinBoxLanIP1->setDisabled(false);
|
|
ui->spinBoxLanIP0->setDisabled(false);
|
|
ui->spinBoxLanMask3->setDisabled(false);
|
|
ui->spinBoxLanMask2->setDisabled(false);
|
|
ui->spinBoxLanMask1->setDisabled(false);
|
|
ui->spinBoxLanMask0->setDisabled(false);
|
|
ui->spinBoxLanGW0->setDisabled(false);
|
|
ui->pushButtonSetIP->setText(QObject::tr("应用"));
|
|
ui->pushButtonSetCancel->setDisabled(false);
|
|
|
|
}
|
|
}
|
|
// qDebug()<<ui->lineEditLanIP->text();
|
|
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonSetCancel_clicked(bool checked)
|
|
{
|
|
|
|
if(sysPara){
|
|
if(sysPara->status.bLanConfigManual)
|
|
{
|
|
sysPara->status.bLanConfigManual = false;
|
|
ui->spinBoxLanIP3->setDisabled(true);
|
|
ui->spinBoxLanIP2->setDisabled(true);
|
|
ui->spinBoxLanIP1->setDisabled(true);
|
|
ui->spinBoxLanIP0->setDisabled(true);
|
|
ui->spinBoxLanMask3->setDisabled(true);
|
|
ui->spinBoxLanMask2->setDisabled(true);
|
|
ui->spinBoxLanMask1->setDisabled(true);
|
|
ui->spinBoxLanMask0->setDisabled(true);
|
|
ui->pushButtonSetCancel->setDisabled(true);
|
|
ui->pushButtonSetIP->setText(QObject::tr("手动设定"));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
int NetworkManager::openCtrlConnection(const char *ifname)
|
|
{
|
|
char *cfile;
|
|
int flen;
|
|
// char buf[2048], *pos, *pos2;
|
|
// size_t len;
|
|
|
|
if (ifname) {
|
|
if (ifname != ctrl_iface) {
|
|
free(ctrl_iface);
|
|
ctrl_iface = strdup(ifname);
|
|
}
|
|
} else {
|
|
#ifdef CONFIG_CTRL_IFACE_UDP
|
|
free(ctrl_iface);
|
|
ctrl_iface = strdup("udp");
|
|
#endif /* CONFIG_CTRL_IFACE_UDP */
|
|
#ifdef CONFIG_CTRL_IFACE_UNIX
|
|
struct dirent *dent;
|
|
DIR *dir = opendir(ctrl_iface_dir);
|
|
free(ctrl_iface);
|
|
ctrl_iface = NULL;
|
|
if (dir) {
|
|
while ((dent = readdir(dir))) {
|
|
#ifdef _DIRENT_HAVE_D_TYPE
|
|
/* Skip the file if it is not a socket.
|
|
* Also accept DT_UNKNOWN (0) in case
|
|
* the C library or underlying file
|
|
* system does not support d_type. */
|
|
if (dent->d_type != DT_SOCK &&
|
|
dent->d_type != DT_UNKNOWN)
|
|
continue;
|
|
#endif /* _DIRENT_HAVE_D_TYPE */
|
|
|
|
if (strcmp(dent->d_name, ".") == 0 ||
|
|
strcmp(dent->d_name, "..") == 0)
|
|
continue;
|
|
printf("Selected interface '%s'\n",
|
|
dent->d_name);
|
|
ctrl_iface = strdup(dent->d_name);
|
|
break;
|
|
}
|
|
closedir(dir);
|
|
}
|
|
#endif /* CONFIG_CTRL_IFACE_UNIX */
|
|
#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
|
|
struct wpa_ctrl *ctrl;
|
|
int ret;
|
|
|
|
free(ctrl_iface);
|
|
ctrl_iface = NULL;
|
|
|
|
ctrl = wpa_ctrl_open(NULL);
|
|
if (ctrl) {
|
|
len = sizeof(buf) - 1;
|
|
ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf,
|
|
&len, NULL);
|
|
if (ret >= 0) {
|
|
connectedToService = true;
|
|
buf[len] = '\0';
|
|
pos = strchr(buf, '\n');
|
|
if (pos)
|
|
*pos = '\0';
|
|
ctrl_iface = strdup(buf);
|
|
}
|
|
wpa_ctrl_close(ctrl);
|
|
}
|
|
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
|
|
}
|
|
|
|
if (ctrl_iface == NULL) {
|
|
#ifdef CONFIG_NATIVE_WINDOWS
|
|
static bool first = true;
|
|
if (first && !serviceRunning()) {
|
|
first = false;
|
|
if (QMessageBox::warning(
|
|
this, qAppName(),
|
|
tr("wpa_supplicant service is not "
|
|
"running.\n"
|
|
"Do you want to start it?"),
|
|
QMessageBox::Yes | QMessageBox::No) ==
|
|
QMessageBox::Yes)
|
|
startService();
|
|
}
|
|
#endif /* CONFIG_NATIVE_WINDOWS */
|
|
return -1;
|
|
}
|
|
|
|
#ifdef CONFIG_CTRL_IFACE_UNIX
|
|
flen = strlen(ctrl_iface_dir) + strlen(ctrl_iface) + 2;
|
|
cfile = (char *) malloc(flen);
|
|
if (cfile == NULL)
|
|
return -1;
|
|
snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ctrl_iface);
|
|
#else /* CONFIG_CTRL_IFACE_UNIX */
|
|
flen = strlen(ctrl_iface) + 1;
|
|
cfile = (char *) malloc(flen);
|
|
if (cfile == NULL)
|
|
return -1;
|
|
snprintf(cfile, flen, "%s", ctrl_iface);
|
|
#endif /* CONFIG_CTRL_IFACE_UNIX */
|
|
|
|
if (ctrl_conn) {
|
|
wpa_ctrl_close(ctrl_conn);
|
|
ctrl_conn = NULL;
|
|
}
|
|
|
|
if (monitor_conn) {
|
|
delete msgNotifier;
|
|
msgNotifier = NULL;
|
|
wpa_ctrl_detach(monitor_conn);
|
|
wpa_ctrl_close(monitor_conn);
|
|
monitor_conn = NULL;
|
|
}
|
|
|
|
printf("Trying to connect to '%s'\n", cfile);
|
|
ctrl_conn = wpa_ctrl_open(cfile);
|
|
if (ctrl_conn == NULL) {
|
|
free(cfile);
|
|
return -1;
|
|
}
|
|
monitor_conn = wpa_ctrl_open(cfile);
|
|
free(cfile);
|
|
if (monitor_conn == NULL) {
|
|
wpa_ctrl_close(ctrl_conn);
|
|
return -1;
|
|
}
|
|
if (wpa_ctrl_attach(monitor_conn)) {
|
|
printf("Failed to attach to wpa_supplicant\n");
|
|
wpa_ctrl_close(monitor_conn);
|
|
monitor_conn = NULL;
|
|
wpa_ctrl_close(ctrl_conn);
|
|
ctrl_conn = NULL;
|
|
return -1;
|
|
}
|
|
|
|
#if defined(CONFIG_CTRL_IFACE_UNIX) || defined(CONFIG_CTRL_IFACE_UDP)
|
|
msgNotifier = new QSocketNotifier(wpa_ctrl_get_fd(monitor_conn),
|
|
QSocketNotifier::Read, this);
|
|
connect(msgNotifier, SIGNAL(activated(int)), SLOT(receiveMsgs()));
|
|
#endif
|
|
|
|
//adapterSelect->clear();
|
|
//adapterSelect->addItem(ctrl_iface);
|
|
//adapterSelect->setCurrentIndex(0);
|
|
#if 0
|
|
printf("Trying to INTERFACES to '%s'\n", cfile);
|
|
len = sizeof(buf) - 1;
|
|
if (wpa_ctrl_request(ctrl_conn, "INTERFACES", 10, buf, &len, NULL) >=
|
|
0) {
|
|
buf[len] = '\0';
|
|
pos = buf;
|
|
while (*pos) {
|
|
pos2 = strchr(pos, '\n');
|
|
if (pos2)
|
|
*pos2 = '\0';
|
|
if (strcmp(pos, ctrl_iface) != 0)
|
|
//adapterSelect->addItem(pos);
|
|
if (pos2)
|
|
pos = pos2 + 1;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
len = sizeof(buf) - 1;
|
|
if (wpa_ctrl_request(ctrl_conn, "GET_CAPABILITY eap", 18, buf, &len,
|
|
NULL) >= 0) {
|
|
buf[len] = '\0';
|
|
|
|
QString res(buf);
|
|
QStringList types = res.split(QChar(' '));
|
|
bool wps = types.contains("WSC");
|
|
actionWPS->setEnabled(wps);
|
|
wpsTab->setEnabled(wps);
|
|
wpaguiTab->setTabEnabled(wpaguiTab->indexOf(wpsTab), wps);
|
|
}
|
|
#endif
|
|
printf("network out to '%s'\n", cfile);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int NetworkManager::ctrlRequest(const char *cmd, char *buf, size_t *buflen)
|
|
{
|
|
int ret;
|
|
|
|
if (ctrl_conn == NULL)
|
|
return -3;
|
|
ret = wpa_ctrl_request(ctrl_conn, cmd, strlen(cmd), buf, buflen, NULL);
|
|
if (ret == -2)
|
|
printf("'%s' command timed out.\n", cmd);
|
|
else if (ret < 0)
|
|
printf("'%s' command failed.\n", cmd);
|
|
|
|
return ret;
|
|
}
|
|
QString NetworkManager::wpaStateTranslate(char *state)
|
|
{
|
|
|
|
if (!strcmp(state, "DISCONNECTED"))
|
|
{
|
|
//QProcess process;
|
|
//process.startDetached("killall udhcpc");
|
|
return tr("Disconnected");
|
|
}
|
|
else if (!strcmp(state, "INACTIVE"))
|
|
return tr("Inactive");
|
|
else if (!strcmp(state, "SCANNING"))
|
|
return tr("Scanning");
|
|
else if (!strcmp(state, "AUTHENTICATING"))
|
|
return tr("Authenticating");
|
|
else if (!strcmp(state, "ASSOCIATING"))
|
|
return tr("Associating");
|
|
else if (!strcmp(state, "ASSOCIATED"))
|
|
return tr("Associated");
|
|
else if (!strcmp(state, "4WAY_HANDSHAKE"))
|
|
return tr("4-Way Handshake");
|
|
else if (!strcmp(state, "GROUP_HANDSHAKE"))
|
|
return tr("Group Handshake");
|
|
else if (!strcmp(state, "COMPLETED"))
|
|
{
|
|
QProcess process;
|
|
process.startDetached("/home/plg/checkUdhcpcRun.sh");
|
|
return tr("Completed");
|
|
}
|
|
else
|
|
|
|
return tr("Unknown");
|
|
}
|
|
void NetworkManager::updateStatus()
|
|
{
|
|
|
|
char buf[2048], *start, *end, *pos;
|
|
size_t len;
|
|
|
|
pingsToStatusUpdate = 10;
|
|
|
|
len = sizeof(buf) - 1;
|
|
if (ctrl_conn == NULL || ctrlRequest("STATUS", buf, &len) < 0) {
|
|
ui->textStatus->setText(tr("Could not get status from "
|
|
"wpa_supplicant"));
|
|
//ui->textAuthentication->clear();
|
|
//ui->textEncryption->clear();
|
|
ui->textSSID->clear();
|
|
//ui->textBssid->clear();
|
|
ui->textIPAdrr->clear();
|
|
|
|
return;
|
|
}
|
|
|
|
buf[len] = '\0';
|
|
|
|
bool auth_updated = false, ssid_updated = false;
|
|
bool bssid_updated = false, ipaddr_updated = false;
|
|
bool status_updated = false;
|
|
char *pairwise_cipher = NULL, *group_cipher = NULL;
|
|
char *mode = NULL;
|
|
|
|
start = buf;
|
|
while (*start) {
|
|
bool last = false;
|
|
end = strchr(start, '\n');
|
|
if (end == NULL) {
|
|
last = true;
|
|
end = start;
|
|
while (end[0] && end[1])
|
|
end++;
|
|
}
|
|
*end = '\0';
|
|
|
|
pos = strchr(start, '=');
|
|
if (pos) {
|
|
*pos++ = '\0';
|
|
if (strcmp(start, "bssid") == 0) {
|
|
bssid_updated = true;
|
|
//textBssid->setText(pos);
|
|
} else if (strcmp(start, "ssid") == 0) {
|
|
ssid_updated = true;
|
|
ui->textSSID->setText(pos);
|
|
} else if (strcmp(start, "ip_address") == 0) {
|
|
ipaddr_updated = true;
|
|
ui->textIPAdrr->setText(pos);
|
|
} else if (strcmp(start, "wpa_state") == 0) {
|
|
status_updated = true;
|
|
ui->textStatus->setText(wpaStateTranslate(pos));
|
|
} else if (strcmp(start, "key_mgmt") == 0) {
|
|
auth_updated = true;
|
|
//textAuthentication->setText(pos);
|
|
/* TODO: could add EAP status to this */
|
|
} else if (strcmp(start, "pairwise_cipher") == 0) {
|
|
pairwise_cipher = pos;
|
|
} else if (strcmp(start, "group_cipher") == 0) {
|
|
group_cipher = pos;
|
|
} else if (strcmp(start, "mode") == 0) {
|
|
mode = pos;
|
|
}
|
|
}
|
|
|
|
if (last)
|
|
break;
|
|
start = end + 1;
|
|
}
|
|
if (status_updated && mode)
|
|
ui->textStatus->setText(ui->textStatus->text() + " (" + mode + ")");
|
|
|
|
if (pairwise_cipher || group_cipher) {
|
|
QString encr;
|
|
if (pairwise_cipher && group_cipher &&
|
|
strcmp(pairwise_cipher, group_cipher) != 0) {
|
|
encr.append(pairwise_cipher);
|
|
encr.append(" + ");
|
|
encr.append(group_cipher);
|
|
} else if (pairwise_cipher) {
|
|
encr.append(pairwise_cipher);
|
|
} else {
|
|
encr.append(group_cipher);
|
|
encr.append(" [group key only]");
|
|
}
|
|
//textEncryption->setText(encr);
|
|
} else
|
|
//textEncryption->clear();
|
|
;
|
|
|
|
if (!status_updated)
|
|
ui->textStatus->clear();
|
|
//if (!auth_updated)
|
|
// textAuthentication->clear();
|
|
if (!ssid_updated)
|
|
ui->textSSID->clear();
|
|
//if (!bssid_updated)
|
|
// textBssid->clear();
|
|
if (!ipaddr_updated)
|
|
ui->textIPAdrr->clear();
|
|
|
|
}
|
|
|
|
void NetworkManager::updateNetworks()
|
|
{
|
|
|
|
char buf[2048], *start, *end, *id, *ssid, *bssid, *flags;
|
|
size_t len;
|
|
int first_active = -1;
|
|
int was_selected = -1;
|
|
bool current = false;
|
|
if(wlanStartUpFailed)
|
|
return;
|
|
if (!networkMayHaveChanged)
|
|
return;
|
|
|
|
//if (networkList->currentRow() >= 0)
|
|
// was_selected = networkList->currentRow();
|
|
|
|
ui->networkSelect->clear();
|
|
//ui->scanSSIDSelect->clear();
|
|
//networkList->clear();
|
|
|
|
if (ctrl_conn == NULL)
|
|
return;
|
|
|
|
len = sizeof(buf) - 1;
|
|
if (ctrlRequest("LIST_NETWORKS", buf, &len) < 0)
|
|
return;
|
|
|
|
buf[len] = '\0';
|
|
start = strchr(buf, '\n');
|
|
if (start == NULL)
|
|
return;
|
|
start++;
|
|
|
|
while (*start) {
|
|
bool last = false;
|
|
end = strchr(start, '\n');
|
|
if (end == NULL) {
|
|
last = true;
|
|
end = start;
|
|
while (end[0] && end[1])
|
|
end++;
|
|
}
|
|
*end = '\0';
|
|
|
|
id = start;
|
|
ssid = strchr(id, '\t');
|
|
if (ssid == NULL)
|
|
break;
|
|
*ssid++ = '\0';
|
|
bssid = strchr(ssid, '\t');
|
|
if (bssid == NULL)
|
|
break;
|
|
*bssid++ = '\0';
|
|
flags = strchr(bssid, '\t');
|
|
if (flags == NULL)
|
|
break;
|
|
*flags++ = '\0';
|
|
|
|
if (strstr(flags, "[DISABLED][P2P-PERSISTENT]")) {
|
|
if (last)
|
|
break;
|
|
start = end + 1;
|
|
continue;
|
|
}
|
|
|
|
QString network(id);
|
|
network.append(": ");
|
|
network.append(ssid);
|
|
ui->networkSelect->addItem(network);
|
|
//networkList->addItem(network);
|
|
//scanSSIDSelect
|
|
if (strstr(flags, "[CURRENT]")) {
|
|
ui->networkSelect->setCurrentIndex(ui->networkSelect->count() -
|
|
1);
|
|
current = true;
|
|
} else if (first_active < 0 &&
|
|
strstr(flags, "[DISABLED]") == NULL)
|
|
first_active = ui->networkSelect->count() - 1;
|
|
|
|
if (last)
|
|
break;
|
|
start = end + 1;
|
|
}
|
|
|
|
if (ui->networkSelect->count() > 1)
|
|
ui->networkSelect->addItem(tr("Select any network"));
|
|
|
|
if (!current && first_active >= 0)
|
|
ui->networkSelect->setCurrentIndex(first_active);
|
|
#if 0
|
|
if (was_selected >= 0 && networkList->count() > 0) {
|
|
if (was_selected < networkList->count())
|
|
networkList->setCurrentRow(was_selected);
|
|
else
|
|
networkList->setCurrentRow(networkList->count() - 1);
|
|
}
|
|
else
|
|
networkList->setCurrentRow(networkSelect->currentIndex());
|
|
#endif
|
|
networkMayHaveChanged = false;
|
|
|
|
}
|
|
static int str_match(const char *a, const char *b)
|
|
{
|
|
return strncmp(a, b, strlen(b)) == 0;
|
|
}
|
|
void NetworkManager::scan()
|
|
{
|
|
#if 0
|
|
if (scanres) {
|
|
scanres->close();
|
|
delete scanres;
|
|
}
|
|
|
|
scanres = new ScanResults();
|
|
if (scanres == NULL)
|
|
return;
|
|
scanres->setWpaGui(this);
|
|
scanres->show();
|
|
scanres->exec();
|
|
#endif
|
|
}
|
|
void NetworkManager::processMsg(char *msg)
|
|
{
|
|
|
|
char *pos = msg, *pos2;
|
|
int priority = 2;
|
|
|
|
if (*pos == '<') {
|
|
/* skip priority */
|
|
pos++;
|
|
priority = atoi(pos);
|
|
pos = strchr(pos, '>');
|
|
if (pos)
|
|
pos++;
|
|
else
|
|
pos = msg;
|
|
}
|
|
|
|
WpaMsg wm(pos, priority);
|
|
//if (eh)
|
|
// eh->addEvent(wm);
|
|
//if (peers)
|
|
// peers->event_notify(wm);
|
|
msgs.append(wm);
|
|
while (msgs.count() > 100)
|
|
msgs.pop_front();
|
|
|
|
/* Update last message with truncated version of the event */
|
|
if (strncmp(pos, "CTRL-", 5) == 0) {
|
|
pos2 = strchr(pos, str_match(pos, WPA_CTRL_REQ) ? ':' : ' ');
|
|
if (pos2)
|
|
pos2++;
|
|
else
|
|
pos2 = pos;
|
|
} else
|
|
pos2 = pos;
|
|
QString lastmsg = pos2;
|
|
lastmsg.truncate(40);
|
|
//textLastMessage->setText(lastmsg);
|
|
|
|
pingsToStatusUpdate = 0;
|
|
networkMayHaveChanged = true;
|
|
|
|
if (str_match(pos, WPA_CTRL_REQ))
|
|
//processCtrlReq(pos + strlen(WPA_CTRL_REQ));
|
|
;
|
|
else if (str_match(pos, WPA_EVENT_SCAN_RESULTS) && beSentScanCmd)
|
|
{
|
|
updateResults();
|
|
beSentScanCmd = false;
|
|
}
|
|
else if (str_match(pos, WPA_EVENT_DISCONNECTED))
|
|
//showTrayMessage(QSystemTrayIcon::Information, 3,
|
|
// tr("Disconnected from network."));
|
|
ui->textStatus->setText("Disconnected");
|
|
else if (str_match(pos, WPA_EVENT_CONNECTED)) {
|
|
//showTrayMessage(QSystemTrayIcon::Information, 3,
|
|
//tr("Connection to network established."));
|
|
//QTimer::singleShot(5 * 1000, this, SLOT(showTrayStatus()));
|
|
//stopWpsRun(true);
|
|
ui->textStatus->setText("Connected");
|
|
}
|
|
#if 0
|
|
|
|
else if (str_match(pos, WPS_EVENT_AP_AVAILABLE_PBC)) {
|
|
wpsStatusText->setText(tr("WPS AP in active PBC mode found"));
|
|
if (textStatus->text() == "INACTIVE" ||
|
|
textStatus->text() == "DISCONNECTED")
|
|
wpaguiTab->setCurrentWidget(wpsTab);
|
|
wpsInstructions->setText(tr("Press the PBC button on the "
|
|
"screen to start registration"));
|
|
} else if (str_match(pos, WPS_EVENT_AP_AVAILABLE_PIN)) {
|
|
wpsStatusText->setText(tr("WPS AP with recently selected "
|
|
"registrar"));
|
|
if (textStatus->text() == "INACTIVE" ||
|
|
textStatus->text() == "DISCONNECTED")
|
|
wpaguiTab->setCurrentWidget(wpsTab);
|
|
} else if (str_match(pos, WPS_EVENT_AP_AVAILABLE_AUTH)) {
|
|
showTrayMessage(QSystemTrayIcon::Information, 3,
|
|
"Wi-Fi Protected Setup (WPS) AP\n"
|
|
"indicating this client is authorized.");
|
|
wpsStatusText->setText("WPS AP indicating this client is "
|
|
"authorized");
|
|
if (textStatus->text() == "INACTIVE" ||
|
|
textStatus->text() == "DISCONNECTED")
|
|
wpaguiTab->setCurrentWidget(wpsTab);
|
|
} else if (str_match(pos, WPS_EVENT_AP_AVAILABLE)) {
|
|
wpsStatusText->setText(tr("WPS AP detected"));
|
|
} else if (str_match(pos, WPS_EVENT_OVERLAP)) {
|
|
wpsStatusText->setText(tr("PBC mode overlap detected"));
|
|
wpsInstructions->setText(tr("More than one AP is currently in "
|
|
"active WPS PBC mode. Wait couple "
|
|
"of minutes and try again"));
|
|
wpaguiTab->setCurrentWidget(wpsTab);
|
|
} else if (str_match(pos, WPS_EVENT_CRED_RECEIVED)) {
|
|
wpsStatusText->setText(tr("Network configuration received"));
|
|
wpaguiTab->setCurrentWidget(wpsTab);
|
|
} else if (str_match(pos, WPA_EVENT_EAP_METHOD)) {
|
|
if (strstr(pos, "(WSC)"))
|
|
wpsStatusText->setText(tr("Registration started"));
|
|
} else if (str_match(pos, WPS_EVENT_M2D)) {
|
|
wpsStatusText->setText(tr("Registrar does not yet know PIN"));
|
|
} else if (str_match(pos, WPS_EVENT_FAIL)) {
|
|
wpsStatusText->setText(tr("Registration failed"));
|
|
} else if (str_match(pos, WPS_EVENT_SUCCESS)) {
|
|
wpsStatusText->setText(tr("Registration succeeded"));
|
|
}
|
|
#endif
|
|
}
|
|
void NetworkManager::receiveMsgs()
|
|
{
|
|
char buf[256];
|
|
size_t len;
|
|
qDebug()<<"receiveMsgs";
|
|
while (monitor_conn && wpa_ctrl_pending(monitor_conn) > 0) {
|
|
len = sizeof(buf) - 1;
|
|
if (wpa_ctrl_recv(monitor_conn, buf, &len) == 0) {
|
|
buf[len] = '\0';
|
|
processMsg(buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void NetworkManager::updateResults()
|
|
{
|
|
char reply[2048];
|
|
size_t reply_len;
|
|
int index;
|
|
char cmd[20];
|
|
//qDebug()<<"updateResults";
|
|
//ui->networkSelect->clear();
|
|
ui->scanSSIDSelect->clear();
|
|
scanResultMap.clear();
|
|
|
|
index = 0;
|
|
while (1)
|
|
{
|
|
snprintf(cmd, sizeof(cmd), "BSS %d", index++);
|
|
if (index > 1000)
|
|
break;
|
|
|
|
reply_len = sizeof(reply) - 1;
|
|
if (ctrlRequest(cmd, reply, &reply_len) < 0)
|
|
break;
|
|
reply[reply_len] = '\0';
|
|
|
|
QString bss(reply);
|
|
if (bss.isEmpty() || bss.startsWith("FAIL"))
|
|
break;
|
|
|
|
QString ssid, bssid, freq, signal, flags;
|
|
|
|
QStringList lines = bss.split(QRegExp("\\n"));
|
|
for (QStringList::Iterator it = lines.begin();
|
|
it != lines.end(); it++) {
|
|
int pos = (*it).indexOf('=') + 1;
|
|
if (pos < 1)
|
|
continue;
|
|
|
|
if ((*it).startsWith("bssid="))
|
|
bssid = (*it).mid(pos);
|
|
else if ((*it).startsWith("freq="))
|
|
freq = (*it).mid(pos);
|
|
else if ((*it).startsWith("qual="))
|
|
signal = (*it).mid(pos);
|
|
else if ((*it).startsWith("flags="))
|
|
flags = (*it).mid(pos);
|
|
else if ((*it).startsWith("ssid="))
|
|
ssid = (*it).mid(pos);
|
|
}
|
|
#if 0
|
|
QTreeWidgetItem *item = new QTreeWidgetItem(scanResultsWidget);
|
|
if (item) {
|
|
item->setText(0, ssid);
|
|
item->setText(1, bssid);
|
|
item->setText(2, freq);
|
|
item->setText(3, signal);
|
|
item->setText(4, flags);
|
|
}
|
|
#endif
|
|
ui->scanSSIDSelect->addItem(ssid);
|
|
QStringList resultList;
|
|
resultList<<ssid <<bssid <<freq <<signal <<flags;
|
|
//ScanResultList.append(resultList);
|
|
//strcpy(scanResult[index].ssid,ssid);
|
|
//strcpy(scanResult[index].bssid,bssid);
|
|
//strcpy(scanResult[index].signal,signal);
|
|
//strcpy(scanResult[index].flags,flags);
|
|
//strcpy(scanResult[index].bssid,bssid);
|
|
scanResultMap[ssid] = resultList;
|
|
//qDebug()<<"ssid:"<<ssid;
|
|
|
|
if (bssid.isEmpty())
|
|
break;
|
|
}
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonScan_pressed()
|
|
{
|
|
char reply[10];
|
|
size_t reply_len = sizeof(reply);
|
|
if(wlanStartUpFailed)
|
|
return;
|
|
// if (wpagui == NULL)
|
|
// return;
|
|
|
|
ctrlRequest("SCAN", reply, &reply_len);
|
|
beSentScanCmd = true;
|
|
}
|
|
|
|
void NetworkManager::selectSSID( const QString & sel )
|
|
{
|
|
//if (openCtrlConnection(sel.toAscii().constData()) < 0)
|
|
// printf("Failed to open control connection to "
|
|
// "wpa_supplicant.\n");
|
|
//updateStatus();
|
|
//updateNetworks();
|
|
|
|
}
|
|
int NetworkManager::setNetworkParam(int id, const char *field,
|
|
const char *value, bool quote)
|
|
{
|
|
char reply[10], cmd[256];
|
|
size_t reply_len;
|
|
snprintf(cmd, sizeof(cmd), "SET_NETWORK %d %s %s%s%s",
|
|
id, field, quote ? "\"" : "", value, quote ? "\"" : "");
|
|
reply_len = sizeof(reply);
|
|
ctrlRequest(cmd, reply, &reply_len);
|
|
|
|
return strncmp(reply, "OK", 2) == 0 ? 0 : -1;
|
|
}
|
|
void NetworkManager::addNetwork()
|
|
{
|
|
|
|
char reply[10], cmd[256];
|
|
size_t reply_len;
|
|
int id;
|
|
int psklen = ui->pskEdit->text().length();
|
|
int auth = ui->authSelect->currentIndex();
|
|
|
|
if (auth == AUTH_WPA_PSK || auth == AUTH_WPA2_PSK) {
|
|
if (psklen < 8 || psklen > 64) {
|
|
QMessageBox::warning(
|
|
this,
|
|
tr("WPA Pre-Shared Key Error"),
|
|
tr("WPA-PSK requires a passphrase of 8 to 63 "
|
|
"characters\n"
|
|
"or 64 hex digit PSK"));
|
|
ui->pskEdit->setFocus();
|
|
return;
|
|
}
|
|
}
|
|
#if 0
|
|
if (idstrEdit->isEnabled() && !idstrEdit->text().isEmpty()) {
|
|
QRegExp rx("^(\\w|-)+$");
|
|
if (rx.indexIn(idstrEdit->text()) < 0) {
|
|
QMessageBox::warning(
|
|
this, tr("Network ID Error"),
|
|
tr("Network ID String contains non-word "
|
|
"characters.\n"
|
|
"It must be a simple string, "
|
|
"without spaces, containing\n"
|
|
"only characters in this range: "
|
|
"[A-Za-z0-9_-]\n"));
|
|
idstrEdit->setFocus();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (wpagui == NULL)
|
|
return;
|
|
#endif
|
|
memset(reply, 0, sizeof(reply));
|
|
reply_len = sizeof(reply) - 1;
|
|
|
|
if (1) {
|
|
ctrlRequest("ADD_NETWORK", reply, &reply_len);
|
|
if (reply[0] == 'F') {
|
|
QMessageBox::warning(this, "wpa_gui",
|
|
tr("Failed to add "
|
|
"network to wpa_supplicant\n"
|
|
"configuration."));
|
|
return;
|
|
}
|
|
id = atoi(reply);
|
|
} else
|
|
id = edit_network_id;
|
|
|
|
//setNetworkParam(id, "ssid", ssidEdit->text().toAscii().constData(),
|
|
// true);
|
|
setNetworkParam(id, "ssid", ui->scanSSIDSelect->currentText().toAscii().constData(),
|
|
true);
|
|
const char *key_mgmt = NULL, *proto = NULL, *pairwise = NULL;
|
|
switch (auth) {
|
|
case AUTH_NONE_OPEN:
|
|
case AUTH_NONE_WEP:
|
|
case AUTH_NONE_WEP_SHARED:
|
|
key_mgmt = "NONE";
|
|
break;
|
|
case AUTH_IEEE8021X:
|
|
key_mgmt = "IEEE8021X";
|
|
break;
|
|
case AUTH_WPA_PSK:
|
|
key_mgmt = "WPA-PSK";
|
|
proto = "WPA";
|
|
break;
|
|
case AUTH_WPA_EAP:
|
|
key_mgmt = "WPA-EAP";
|
|
proto = "WPA";
|
|
break;
|
|
case AUTH_WPA2_PSK:
|
|
key_mgmt = "WPA-PSK";
|
|
proto = "WPA2";
|
|
break;
|
|
case AUTH_WPA2_EAP:
|
|
key_mgmt = "WPA-EAP";
|
|
proto = "WPA2";
|
|
break;
|
|
}
|
|
|
|
if (auth == AUTH_NONE_WEP_SHARED)
|
|
setNetworkParam(id, "auth_alg", "SHARED", false);
|
|
else
|
|
setNetworkParam(id, "auth_alg", "OPEN", false);
|
|
|
|
if (auth == AUTH_WPA_PSK || auth == AUTH_WPA_EAP ||
|
|
auth == AUTH_WPA2_PSK || auth == AUTH_WPA2_EAP) {
|
|
int encr = ui->EncryptionSelect->currentIndex();
|
|
if (encr == 0)
|
|
pairwise = "TKIP";
|
|
else
|
|
pairwise = "CCMP";
|
|
}
|
|
|
|
if (proto)
|
|
setNetworkParam(id, "proto", proto, false);
|
|
if (key_mgmt)
|
|
setNetworkParam(id, "key_mgmt", key_mgmt, false);
|
|
if (pairwise) {
|
|
setNetworkParam(id, "pairwise", pairwise, false);
|
|
setNetworkParam(id, "group", "TKIP CCMP WEP104 WEP40", false);
|
|
}
|
|
if (ui->pskEdit->isEnabled() &&
|
|
strcmp(ui->pskEdit->text().toAscii().constData(),
|
|
WPA_GUI_KEY_DATA) != 0)
|
|
setNetworkParam(id, "psk",
|
|
ui->pskEdit->text().toAscii().constData(),
|
|
psklen != 64);
|
|
#if 0
|
|
if (eapSelect->isEnabled()) {
|
|
const char *eap =
|
|
eapSelect->currentText().toAscii().constData();
|
|
setNetworkParam(id, "eap", eap, false);
|
|
if (strcmp(eap, "SIM") == 0 || strcmp(eap, "AKA") == 0)
|
|
setNetworkParam(id, "pcsc", "", true);
|
|
else
|
|
setNetworkParam(id, "pcsc", "NULL", false);
|
|
}
|
|
|
|
if (phase2Select->isEnabled()) {
|
|
QString eap = eapSelect->currentText();
|
|
QString inner = phase2Select->currentText();
|
|
char phase2[32];
|
|
phase2[0] = '\0';
|
|
if (eap.compare("PEAP") == 0) {
|
|
if (inner.startsWith("EAP-"))
|
|
snprintf(phase2, sizeof(phase2), "auth=%s",
|
|
inner.right(inner.size() - 4).
|
|
toAscii().constData());
|
|
} else if (eap.compare("TTLS") == 0) {
|
|
if (inner.startsWith("EAP-"))
|
|
snprintf(phase2, sizeof(phase2), "autheap=%s",
|
|
inner.right(inner.size() - 4).
|
|
toAscii().constData());
|
|
else
|
|
snprintf(phase2, sizeof(phase2), "auth=%s",
|
|
inner.toAscii().constData());
|
|
} else if (eap.compare("FAST") == 0) {
|
|
const char *provisioning = NULL;
|
|
if (inner.startsWith("EAP-")) {
|
|
snprintf(phase2, sizeof(phase2), "auth=%s",
|
|
inner.right(inner.size() - 4).
|
|
toAscii().constData());
|
|
provisioning = "fast_provisioning=2";
|
|
} else if (inner.compare("GTC(auth) + MSCHAPv2(prov)")
|
|
== 0) {
|
|
snprintf(phase2, sizeof(phase2),
|
|
"auth=GTC auth=MSCHAPV2");
|
|
provisioning = "fast_provisioning=1";
|
|
} else
|
|
provisioning = "fast_provisioning=3";
|
|
if (provisioning) {
|
|
char blob[32];
|
|
setNetworkParam(id, "phase1", provisioning,
|
|
true);
|
|
snprintf(blob, sizeof(blob),
|
|
"blob://fast-pac-%d", id);
|
|
setNetworkParam(id, "pac_file", blob, true);
|
|
}
|
|
}
|
|
if (phase2[0])
|
|
setNetworkParam(id, "phase2", phase2, true);
|
|
else
|
|
setNetworkParam(id, "phase2", "NULL", false);
|
|
} else
|
|
setNetworkParam(id, "phase2", "NULL", false);
|
|
#endif
|
|
setNetworkParam(id, "phase2", "NULL", false);
|
|
#if 0
|
|
if (identityEdit->isEnabled() && identityEdit->text().length() > 0)
|
|
setNetworkParam(id, "identity",
|
|
identityEdit->text().toAscii().constData(),
|
|
true);
|
|
else
|
|
setNetworkParam(id, "identity", "NULL", false);
|
|
#endif
|
|
setNetworkParam(id, "identity", "NULL", false);
|
|
if (ui->passwordEdit->isEnabled() && ui->passwordEdit->text().length() > 0 &&
|
|
strcmp(ui->passwordEdit->text().toAscii().constData(),
|
|
WPA_GUI_KEY_DATA) != 0)
|
|
setNetworkParam(id, "password",
|
|
ui->passwordEdit->text().toAscii().constData(),
|
|
true);
|
|
else if (ui->passwordEdit->text().length() == 0)
|
|
setNetworkParam(id, "password", "NULL", false);
|
|
#if 0
|
|
if (cacertEdit->isEnabled() && cacertEdit->text().length() > 0)
|
|
setNetworkParam(id, "ca_cert",
|
|
cacertEdit->text().toAscii().constData(),
|
|
true);
|
|
else
|
|
setNetworkParam(id, "ca_cert", "NULL", false);
|
|
|
|
writeWepKey(id, wep0Edit, 0);
|
|
writeWepKey(id, wep1Edit, 1);
|
|
writeWepKey(id, wep2Edit, 2);
|
|
writeWepKey(id, wep3Edit, 3);
|
|
#endif
|
|
setNetworkParam(id, "ca_cert", "NULL", false);
|
|
|
|
#if 0
|
|
if (wep0Radio->isEnabled() && wep0Radio->isChecked())
|
|
setNetworkParam(id, "wep_tx_keyidx", "0", false);
|
|
else if (wep1Radio->isEnabled() && wep1Radio->isChecked())
|
|
setNetworkParam(id, "wep_tx_keyidx", "1", false);
|
|
else if (wep2Radio->isEnabled() && wep2Radio->isChecked())
|
|
setNetworkParam(id, "wep_tx_keyidx", "2", false);
|
|
else if (wep3Radio->isEnabled() && wep3Radio->isChecked())
|
|
setNetworkParam(id, "wep_tx_keyidx", "3", false);
|
|
|
|
if (idstrEdit->isEnabled() && idstrEdit->text().length() > 0)
|
|
setNetworkParam(id, "id_str",
|
|
idstrEdit->text().toAscii().constData(),
|
|
true);
|
|
else
|
|
setNetworkParam(id, "id_str", "NULL", false);
|
|
#endif
|
|
setNetworkParam(id, "id_str", "NULL", false);
|
|
#if 0
|
|
if (prioritySpinBox->isEnabled()) {
|
|
QString prio;
|
|
prio = prio.setNum(prioritySpinBox->value());
|
|
setNetworkParam(id, "priority", prio.toAscii().constData(),
|
|
false);
|
|
}
|
|
#endif
|
|
snprintf(cmd, sizeof(cmd), "ENABLE_NETWORK %d", id);
|
|
reply_len = sizeof(reply);
|
|
ctrlRequest(cmd, reply, &reply_len);
|
|
if (strncmp(reply, "OK", 2) != 0) {
|
|
QMessageBox::warning(this, "wpa_gui",
|
|
tr("Failed to enable "
|
|
"network in wpa_supplicant\n"
|
|
"configuration."));
|
|
/* Network was added, so continue anyway */
|
|
}
|
|
triggerUpdate();
|
|
ctrlRequest("SAVE_CONFIG", reply, &reply_len);
|
|
|
|
//close();
|
|
}
|
|
void NetworkManager::authChanged(int sel)
|
|
{
|
|
|
|
ui->EncryptionSelect->setEnabled(sel != AUTH_NONE_OPEN && sel != AUTH_NONE_WEP &&
|
|
sel != AUTH_NONE_WEP_SHARED);
|
|
ui->pskEdit->setEnabled(sel == AUTH_WPA_PSK || sel == AUTH_WPA2_PSK);
|
|
bool eap = sel == AUTH_IEEE8021X || sel == AUTH_WPA_EAP ||
|
|
sel == AUTH_WPA2_EAP;
|
|
//eapSelect->setEnabled(eap);
|
|
//identityEdit->setEnabled(eap);
|
|
ui->passwordEdit->setEnabled(eap);
|
|
//cacertEdit->setEnabled(eap);
|
|
//phase2Select->setEnabled(eap);
|
|
//if (eap)
|
|
// eapChanged(eapSelect->currentIndex());
|
|
|
|
while (ui->EncryptionSelect->count())
|
|
ui->EncryptionSelect->removeItem(0);
|
|
|
|
if (sel == AUTH_NONE_OPEN || sel == AUTH_NONE_WEP ||
|
|
sel == AUTH_NONE_WEP_SHARED || sel == AUTH_IEEE8021X) {
|
|
ui->EncryptionSelect->addItem("None");
|
|
ui->EncryptionSelect->addItem("WEP");
|
|
ui->EncryptionSelect->setCurrentIndex(sel == AUTH_NONE_OPEN ? 0 : 1);
|
|
} else {
|
|
ui->EncryptionSelect->addItem("TKIP");
|
|
ui->EncryptionSelect->addItem("CCMP");
|
|
ui->EncryptionSelect->setCurrentIndex((sel == AUTH_WPA2_PSK ||
|
|
sel == AUTH_WPA2_EAP) ? 1 : 0);
|
|
}
|
|
//wepEnabled(sel == AUTH_NONE_WEP || sel == AUTH_NONE_WEP_SHARED);
|
|
}
|
|
void NetworkManager::selectNetwork( const QString & sel )
|
|
{
|
|
QString cmd(sel);
|
|
char reply[10];
|
|
size_t reply_len = sizeof(reply);
|
|
|
|
if (cmd.contains(QRegExp("^\\d+:")))
|
|
cmd.truncate(cmd.indexOf(':'));
|
|
else
|
|
cmd = "any";
|
|
cmd.prepend("SELECT_NETWORK ");
|
|
ctrlRequest(cmd.toAscii().constData(), reply, &reply_len);
|
|
triggerUpdate();
|
|
}
|
|
void NetworkManager::triggerUpdate()
|
|
{
|
|
updateStatus();
|
|
networkMayHaveChanged = true;
|
|
updateNetworks();
|
|
}
|
|
void NetworkManager::ping()
|
|
{
|
|
char buf[10];
|
|
size_t len;
|
|
|
|
if(wlanStartUpFailed)
|
|
return;
|
|
len = sizeof(buf) - 1;
|
|
if (ctrlRequest("PING", buf, &len) < 0) {
|
|
qDebug()<<"PING failed - trying to reconnect";
|
|
if (openCtrlConnection(ctrl_iface) >= 0) {
|
|
qDebug()<<"Reconnected successfully";
|
|
pingsToStatusUpdate = 0;
|
|
}
|
|
}
|
|
|
|
pingsToStatusUpdate--;
|
|
if (pingsToStatusUpdate <= 0) {
|
|
updateStatus();
|
|
updateNetworks();
|
|
}
|
|
|
|
#ifndef CONFIG_CTRL_IFACE_NAMED_PIPE
|
|
/* Use less frequent pings and status updates when the main window is
|
|
* hidden (running in taskbar). */
|
|
int interval = isHidden() ? 20000 : 3000;
|
|
if (timer->interval() != interval)
|
|
timer->setInterval(interval);
|
|
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonConnect_pressed()
|
|
{
|
|
on_pushButtonDisconnect_pressed();
|
|
|
|
char reply[10];
|
|
size_t reply_len = sizeof(reply);
|
|
ctrlRequest("REASSOCIATE", reply, &reply_len);
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonDisconnect_pressed()
|
|
{
|
|
char reply[10];
|
|
size_t reply_len = sizeof(reply);
|
|
ctrlRequest("DISCONNECT", reply, &reply_len);
|
|
}
|
|
|
|
void NetworkManager::on_scanSSIDSelect_activated(const QString &arg1)
|
|
{
|
|
//if (openCtrlConnection(sel.toAscii().constData()) < 0)
|
|
// printf("Failed to open control connection to "
|
|
// "wpa_supplicant.\n");
|
|
updateStatus();
|
|
updateNetworks();
|
|
QStringList networkString=scanResultMap[arg1];
|
|
if(networkString.isEmpty())
|
|
{
|
|
return;
|
|
}
|
|
// QString flags = sel->text(4);
|
|
QString flags = networkString.at(4);
|
|
int auth, encr = 0;
|
|
if (flags.indexOf("[WPA2-EAP") >= 0)
|
|
auth = AUTH_WPA2_EAP;
|
|
else if (flags.indexOf("[WPA-EAP") >= 0)
|
|
auth = AUTH_WPA_EAP;
|
|
else if (flags.indexOf("[WPA2-PSK") >= 0)
|
|
auth = AUTH_WPA2_PSK;
|
|
else if (flags.indexOf("[WPA-PSK") >= 0)
|
|
auth = AUTH_WPA_PSK;
|
|
else
|
|
auth = AUTH_NONE_OPEN;
|
|
|
|
if (flags.indexOf("-CCMP") >= 0)
|
|
encr = 1;
|
|
else if (flags.indexOf("-TKIP") >= 0)
|
|
encr = 0;
|
|
else if (flags.indexOf("WEP") >= 0) {
|
|
encr = 1;
|
|
if (auth == AUTH_NONE_OPEN)
|
|
auth = AUTH_NONE_WEP;
|
|
} else
|
|
encr = 0;
|
|
|
|
ui->authSelect->setCurrentIndex(auth);
|
|
authChanged(auth);
|
|
ui->EncryptionSelect->setCurrentIndex(encr);
|
|
|
|
//wepEnabled(auth == AUTH_NONE_WEP);
|
|
|
|
//getEapCapa();
|
|
|
|
//if (flags.indexOf("[WPS") >= 0)
|
|
// useWpsButton->setEnabled(true);
|
|
//bssid = sel.text(1);
|
|
}
|
|
|
|
|
|
void NetworkManager::on_pushButtonAddNetworkd_pressed()
|
|
{
|
|
addNetwork();
|
|
}
|
|
|
|
void NetworkManager::removeNetwork()
|
|
{
|
|
char reply[10], cmd[256];
|
|
size_t reply_len;
|
|
int id;
|
|
if (QMessageBox::information(
|
|
this, "wpa_gui",
|
|
tr("This will permanently remove the network\n"
|
|
"from the configuration. Do you really want\n"
|
|
"to remove this network?"),
|
|
tr("Yes"), tr("No")) != 0)
|
|
return;
|
|
id = ui->networkSelect->currentIndex();
|
|
snprintf(cmd, sizeof(cmd), "REMOVE_NETWORK %d", id);
|
|
reply_len = sizeof(reply);
|
|
ctrlRequest(cmd, reply, &reply_len);
|
|
if (strncmp(reply, "OK", 2) != 0) {
|
|
QMessageBox::warning(this, "wpa_gui",
|
|
tr("Failed to remove network from "
|
|
"wpa_supplicant\n"
|
|
"configuration."));
|
|
} else {
|
|
triggerUpdate();
|
|
ctrlRequest("SAVE_CONFIG", reply, &reply_len);
|
|
}
|
|
}
|
|
|
|
void NetworkManager::on_pushButtonRemove_pressed()
|
|
{
|
|
removeNetwork();
|
|
}
|
|
|
|
|
|
void NetworkManager::on_GetJsonpushButton_clicked()
|
|
{
|
|
QMessageBox::StandardButton ret;
|
|
ret = QMessageBox::question(this, tr("提示"),tr("是否去获取数据!"), QMessageBox::Ok | QMessageBox::Cancel);
|
|
if(ret != QMessageBox::Ok)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// qDebug()<<"on_GetJsonpushButton_clicked";
|
|
QString str = "http://";
|
|
//str += ui->SeverIP_lineEdit->text();
|
|
QString ip_str;
|
|
ip_str = QString::number(sysPara->para.Json_IP[0]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[1]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[2]);
|
|
ip_str += ".";
|
|
ip_str += QString::number(sysPara->para.Json_IP[3]);
|
|
str += ip_str;
|
|
|
|
str += ":";
|
|
//str += ui->server_port_lineEdit->text();
|
|
str +=QString::number(sysPara->para.Json_server_port);
|
|
|
|
if(ui->TestradioButton->isChecked()){
|
|
// qDebug()<<"get test value";
|
|
// str += "/KLAPS/APSServer/ECode/GetProductUniqueCodeTest";
|
|
str = "http://www.anhuikinglan.top:63025/KLAPS/APSServer/ECode/GetProductUniqueCodeTest";
|
|
}else{
|
|
str += "/KLAPS/APSServer/ECode/GetProductUniqueCode";
|
|
}
|
|
|
|
|
|
//net_data->PrintNetGetData(str, ui->deviceID_lineEdit->text());
|
|
net_data->PrintNetGetData(str, QString(sysPara->para.Json_device_code));
|
|
ui->messege_info_label->setText(tr("获取数据中..."));
|
|
}
|
|
|
|
void NetworkManager::onjson_timer_handler()
|
|
{
|
|
static int count_time = 0;
|
|
|
|
count_time++;
|
|
|
|
ui->messege_info_label->setText( net_data->getMessege() );
|
|
|
|
// qDebug()<<"on_json_timer_handler";
|
|
if(sysPara->para.totalProductCnt != 0 && sysPara->para.totalProductCnt >= sysPara->Get_JSON_DATA.ProductPlanQty){
|
|
QString str = "http://";
|
|
str += ui->SeverIP_lineEdit->text();
|
|
str += ":";
|
|
str += ui->server_port_lineEdit->text();
|
|
|
|
if(ui->TestradioButton->isChecked()){
|
|
str += "/KLAPS/APSServer/ECode/UsedProductUniqueCodeTest";
|
|
}else{
|
|
str += "/KLAPS/APSServer/ECode/UsedProductUniqueCode";
|
|
}
|
|
|
|
net_data->PrintNetPostFinish(str);
|
|
sysPara->devOp->clearProductCnt(1 | 0x10 );// [3]总产品计数器清零FPGA
|
|
sysPara->para.totalProductCnt = 0;
|
|
emit net_stopPrint();
|
|
ui->messege_info_label->setText(tr("上报数据中..."));
|
|
|
|
if(sysPara->Get_JSON_DATA.TaskSwitchingMode == 1){
|
|
on_GetJsonpushButton_clicked();
|
|
}
|
|
}
|
|
|
|
if(count_time == 20){
|
|
|
|
count_time = 0;
|
|
QString str = "http://";
|
|
str += ui->SeverIP_lineEdit->text();
|
|
str += ":";
|
|
str += ui->server_port_lineEdit->text();
|
|
if(ui->TestradioButton->isChecked()){
|
|
str += "/KLAPS/APSServer/ECode/SubmitEquipmentCurrentStateTest";
|
|
}else{
|
|
str += "/KLAPS/APSServer/ECode/SubmitEquipmentCurrentState";
|
|
}
|
|
net_data->PrintNetPostFinish(str);
|
|
|
|
// qDebug()<<"upload data";
|
|
ui->messege_info_label->setText(tr("上报数据中..."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void NetworkManager::onjson_server_error()
|
|
{
|
|
// ui->net_state_label->setText(tr("通信失败"));
|
|
// qDebug()<<"on_json_server_error";
|
|
}
|
|
|
|
|
|
|
|
|
|
void NetworkManager::on_applicate_pushButton_clicked()
|
|
{
|
|
QString ip_str = ui->SeverIP_lineEdit->text();
|
|
QStringList ip_list = ip_str.split(".");
|
|
QString ip1,ip2,ip3,ip4;
|
|
|
|
if (ip_list.size() < 4){
|
|
QMessageBox::information(this,tr("提示"),tr("IP设置错误!"));
|
|
return;
|
|
}
|
|
ip1 = ip_list.at(0);
|
|
ip2 = ip_list.at(1);
|
|
ip3 = ip_list.at(2);
|
|
ip4 = ip_list.at(3);
|
|
|
|
sysPara->para.Json_IP[0] = ip1.toInt();
|
|
sysPara->para.Json_IP[1] = ip2.toInt();
|
|
sysPara->para.Json_IP[2] = ip3.toInt();
|
|
sysPara->para.Json_IP[3] = ip4.toInt();
|
|
|
|
if(sysPara->para.Json_IP[0] > 255 || sysPara->para.Json_IP[1] > 255
|
|
||sysPara->para.Json_IP[2] > 255 ||sysPara->para.Json_IP[3] > 255){
|
|
QMessageBox::information(this,tr("提示"),tr("IP设置错误!"));
|
|
return;
|
|
}
|
|
|
|
// strcpy(sysPara->para.Json_IP, std_str);
|
|
|
|
//sysPara->para.Json_device_code = ui->deviceID_lineEdit->text().toInt();
|
|
strncpy(sysPara->para.Json_device_code, ui->deviceID_lineEdit->text().toStdString().data(),sizeof(sysPara->para.Json_device_code)-1);
|
|
sysPara->para.Json_server_port = ui->server_port_lineEdit->text().toInt();
|
|
|
|
QMessageBox::information(this,tr("提示"),tr("应用成功"));
|
|
// qDebug()<<"Json_device_code="<<sysPara->para.Json_device_code
|
|
// <<"Json_server_port="<<sysPara->para.Json_server_port
|
|
// <<"sysPara->para.Json_IP="<<sysPara->para.Json_IP[0] << sysPara->para.Json_IP[1]
|
|
// <<sysPara->para.Json_IP[2]<<sysPara->para.Json_IP[3];
|
|
|
|
sysPara->saveParaToFile();
|
|
}
|
|
|
|
//void NetworkManager::on_checkBoxShortNet_clicked(bool checked)
|
|
//{
|
|
// net_data->m_bShortNet = checked;
|
|
//}
|
|
|
|
void NetworkManager::on_checkBoxRemoveDigitCode_clicked(bool checked)
|
|
{
|
|
sysPara->para.isRemoveDigitCode = checked;
|
|
emit OpenNewFile();
|
|
}
|
|
|
|
void NetworkManager::on_checkBoxRemoveCode_clicked(bool checked)
|
|
{
|
|
//emit VariablePositionChange(checked);
|
|
sysPara->para.isRemoveCode = checked;
|
|
//emit OpenNewFile();
|
|
}
|
|
|
|
void NetworkManager::on_radioButtonGetDataEnable_clicked(bool checked)
|
|
{
|
|
sysPara->para.isEnableGetDataButton = checked;
|
|
}
|
|
|
|
void NetworkManager::updateAuthorization(int auth)
|
|
{
|
|
if(auth & AUTH_SUPER_USER2)
|
|
{
|
|
ui->GetJsonpushButton->show();
|
|
ui->GetJsonpushButton->show();
|
|
ui->messege_info_label->show();
|
|
ui->label->show();
|
|
ui->deviceID_lineEdit->show();
|
|
ui->label_2->show();
|
|
ui->SeverIP_lineEdit->show();
|
|
ui->label_4->show();
|
|
ui->server_port_lineEdit->show();
|
|
ui->TestradioButton->show();
|
|
// ui->checkBoxShortNet->show();
|
|
ui->checkBoxRemoveDigitCode->show();
|
|
ui->applicate_pushButton->show();
|
|
ui->checkBoxRemoveCode->show();
|
|
ui->radioButtonGetDataEnable->show();
|
|
}
|
|
else
|
|
{
|
|
ui->GetJsonpushButton->hide();
|
|
ui->GetJsonpushButton->hide();
|
|
ui->messege_info_label->hide();
|
|
ui->label->hide();
|
|
ui->deviceID_lineEdit->hide();
|
|
ui->label_2->hide();
|
|
ui->SeverIP_lineEdit->hide();
|
|
ui->label_4->hide();
|
|
ui->server_port_lineEdit->hide();
|
|
ui->TestradioButton->hide();
|
|
// ui->checkBoxShortNet->hide();
|
|
ui->checkBoxRemoveDigitCode->hide();
|
|
ui->applicate_pushButton->hide();
|
|
ui->checkBoxRemoveCode->hide();
|
|
ui->radioButtonGetDataEnable->hide();
|
|
//sysPara->para.isEnableGetDataButton = false;
|
|
}
|
|
}
|
|
|
|
bool NetworkManager::setEth0StaticIP()
|
|
{
|
|
const uint8_t ip3=192,ip2=168,ip1=0,ip0=66;//100+QDateTime::currentDateTime().time().second();//IP
|
|
const uint8_t /*ip3=192,ip2=168,ip1=1,ip0=66,*/lanGW0=1;//网关
|
|
const uint8_t lanMask3=255,lanMask2=255,lanMask1=255,lanMask0=0;//子网掩码
|
|
|
|
// 静态IP
|
|
QFile netInterface("/etc/network/interfaces");
|
|
netInterface.open(QIODevice::WriteOnly|QIODevice::Text|QIODevice::Truncate);
|
|
if (netInterface.isOpen()) {
|
|
QTextStream stream(&netInterface);
|
|
stream.seek(0);
|
|
stream << INTERFACE_OTHERS;
|
|
stream << " " <<"\n";
|
|
stream << "# eth0 interfaces" <<"\n";
|
|
stream << "auto eth0" <<"\n";
|
|
stream << "iface eth0 inet static" <<"\n";
|
|
stream << QString("address %1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(ip0) <<"\n";
|
|
stream << QString("gateway %1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(lanGW0) <<"\n";
|
|
stream << QString("netmask %1.%2.%3.%4").arg(lanMask3).arg(lanMask2).arg(lanMask1).arg(lanMask0) <<"\n";
|
|
stream << " \n";
|
|
netInterface.close();
|
|
|
|
QStringList argrList;
|
|
QString ipAddrStr(QString("%1.%2.%3.%4").arg(ip3).arg(ip2).arg(ip1).arg(ip0));
|
|
QString netMaskStr(QString("%1.%2.%3.%4").arg(lanMask3).arg(lanMask2).arg(lanMask1).arg(lanMask0));
|
|
argrList<< LANINTERFACE_NAME << ipAddrStr << "netmask" << netMaskStr;
|
|
|
|
qDebug() << "setEth0StaticIP->set argu:" << argrList;
|
|
|
|
QProcess process;
|
|
process.startDetached("/sbin/ifconfig", argrList);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
const QFile::FileError eno=netInterface.error();
|
|
qDebug()<<"打开网络设置文件失败,error="<<eno<<",errstr="<<netInterface.errorString();
|
|
}
|
|
return false;
|
|
}
|
|
void NetworkManager::setEth0StaticIP_Thread()
|
|
{
|
|
if(!sysPara->status.bLanConfigManual && this->setEth0StaticIP())
|
|
{
|
|
qDebug()<<"设置静态IP-完成";
|
|
sysPara->status.bLanConfigManual=true;
|
|
updateSysStatusToUI();
|
|
}
|
|
else
|
|
{
|
|
qDebug()<<"设置静态IP-失败";
|
|
}
|
|
}
|
|
|
|
/**
|
|
只有返回全是0的地址才需要设置成192.168.0.66这个固定地址
|
|
* @brief NetworkManager::getCurrentNetworkIP
|
|
* @return 返回当前机器的IP地址
|
|
*/
|
|
QString NetworkManager::getCurrentNetworkIP()const
|
|
{
|
|
QString cip("0.0.0.0");
|
|
if(sysPara){
|
|
QList<QNetworkInterface> list = QNetworkInterface::allInterfaces(); //QNetworkInterface::interfaceFromName(LANINTERFACE_NAME);
|
|
//获取所有网络接口的列表
|
|
foreach(QNetworkInterface interface,list)
|
|
{
|
|
if(QString::compare(interface.name(), LANINTERFACE_NAME)==0)
|
|
{
|
|
QList<QNetworkAddressEntry> entryList = interface.addressEntries();
|
|
//获取IP地址条目列表，每个条目中包含一个IP地址，一个子网掩码和一个广播地址
|
|
foreach(QNetworkAddressEntry entry,entryList)
|
|
{
|
|
QStringList lanIpList = entry.ip().toString().split(".");
|
|
if (lanIpList.size() == 4) {
|
|
return QString("%1.%2.%3.%4").arg(lanIpList.at(0)).arg(lanIpList.at(1)).arg(lanIpList.at(2)).arg(lanIpList.at(3));
|
|
}
|
|
return cip;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return cip;
|
|
}
|
|
|