void MainWindow::initApp()
{
x11 = 0;
ui->tabWidget->setDisabled(true);
ui->statusBar->addPermanentWidget(ui->progressBar);
ui->progressBar->hide();
ui->pushButton->setEnabled(false);
ui->queue->setHeaderHidden(false);
tray = new QSystemTrayIcon(this);
timer.start(); // get a time reference
connect(&pkgsrc,SIGNAL(packageOptionsResult(QStringList)),this,SLOT(packageOptions(QStringList)));
connect(&pkgsrc,SIGNAL(downloadFinished(int)),this,SLOT(pkgsrcDownloadFinished(int)));
connect(&pkgsrc,SIGNAL(downloadStatus(qint64,qint64)),this,SLOT(pkgsrcDownloadStatus(qint64,qint64)));
connect(&pkgsrc,SIGNAL(extractFinished(int)),this,SLOT(bootstrapExtractFinished(int)));
connect(&pkgsrc,SIGNAL(extractStatus(QString)),this,SLOT(bootstrapExtractRead()));
connect(&pkgsrc,SIGNAL(bootstrapFinished(int)),this,SLOT(bootstrapMakeFinished(int)));
connect(&pkgsrc,SIGNAL(bootstrapStatus(QString)),this,SLOT(bootstrapMakeRead(QString)));
connect(&pkgsrc,SIGNAL(bmakeFinished(int)),this,SLOT(queueFinished(int)));
connect(&pkgsrc,SIGNAL(bmakeStatus(QString)),this,SLOT(queueRead(QString)));
connect(&pkgsrc,SIGNAL(packageDependsResult(QStringList)),this,SLOT(packageDepends(QStringList)));
connect(&pkgsrc,SIGNAL(packagesInstalledResult(QStringList)),this,SLOT(pkgsrcInstalledFinished(QStringList)));
connect(&pkgsrc,SIGNAL(packageVersionResult(QString)),this,SLOT(pkgsrcPkgVersionFinished(QString)));
connect(&pkgsrc,SIGNAL(packageNameResult(QString)),this,SLOT(pkgsrcPkgNameFinished(QString)));
connect(&pkgsrc,SIGNAL(packagesVulnsResult(QStringList)),this,SLOT(pkgsrcPkgVulnCheckFinished(QStringList)));
connect(&pkgsrc,SIGNAL(packageRemoveStatus(QString)),this,SLOT(delPackageLog(QString)));
connect(&pkgsrc,SIGNAL(packageRemoveResult(int)),this,SLOT(delPackageDone(int)));
connect(&pkgsrc,SIGNAL(pkgsrcReady()),this,SLOT(bootstrapCheck()));
connect(&work,SIGNAL(updateListResult(QStringList)),this,SLOT(catchUpdates(QStringList)));
connect(wiz.ui->save,SIGNAL(clicked()),this,SLOT(startWiz()));
QSettings settings;
settings.beginGroup("global");
if (settings.value("firstrun").toInt()==1)
pkgsrc.initPkgsrc(0,"",0,"");
else {
this->hide();
wiz.show();
}
settings.endGroup();
ui->actionSync->setDisabled(true); // sync can only be used after pkgsrcready and bmake must be blocked
connect(tray,SIGNAL(activated(QSystemTrayIcon::ActivationReason)),this,SLOT(trayActivated()));
tray->setIcon(QIcon(":/files/tray.png"));
tray->setToolTip("UserPKG");
if (tray->isSystemTrayAvailable()) {
tray->show();
}
if (tray->isVisible()) {
for (int i = 0; i < QApplication::arguments().size(); ++i) {
if (QApplication::arguments().at(i).contains("--tray"))
this->hide();
}
}
}
/**
* Queues all the initial read requests.
* @return the error code if queuing a read caused an error.
*/
static DWORD queueReads(HSP *sp)
{
uint32_t i;
DWORD error;
for (i = 0; i < numConcurrentReads; i++) {
error = queueRead(sp->filter.dev,
sp->filter.buffers[i],
sizeof(sp->filter.buffers[i]),
&sp->filter.overlaps[i]);
if (error != 0) {
return error;
}
}
return 0;
}
void ADCDevice::queueReadData() {
if (connMask & _BV(0))
queueRead(ADC_REG_CH0, 2);
if (connMask & _BV(1))
queueRead(ADC_REG_CH1, 2);
if (connMask & _BV(2))
queueRead(ADC_REG_CH2, 2);
if (connMask & _BV(3))
queueRead(ADC_REG_CH3, 2);
if (connMask & _BV(4))
queueRead(ADC_REG_CH4, 2);
if (connMask & _BV(5))
queueRead(ADC_REG_CH5, 2);
if (connMask & _BV(6))
queueRead(ADC_REG_CH6, 2);
if (connMask & _BV(7))
queueRead(ADC_REG_CH7, 2);
}
void ServiceMain(int argc, char** argv)
{
ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
if (isService) {
hStatus = RegisterServiceCtrlHandler(HSP_SERVICE_NAME,
(LPHANDLER_FUNCTION)ControlHandler);
if (hStatus == 0)
{
return;
}
}
// Test for only one instance is running
HANDLE mutex = CreateMutex(NULL, TRUE, instanceMutexName);
DWORD err = GetLastError();
if (mutex != NULL && err == ERROR_ALREADY_EXISTS ||
mutex == NULL && err == ERROR_ACCESS_DENIED) {
// Mutex found, so another instance is running
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_SINGLE_INSTANCE_APP;
SetServiceStatus(hStatus, &ServiceStatus);
} else {
myLog(LOG_ERR, "%s.ServiceMain: only one instance can run, existing instance found", HSP_SERVICE_NAME);
}
return;
} else {
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
if (hStatus != 0) {
// We are the first instance, report the running status to SCM.
SetServiceStatus (hStatus, &ServiceStatus);
}
}
wchar_t programDataDir[MAX_PATH];
if (!initialiseProgramDataDir(programDataDir, MAX_PATH)) {
*programDataDir = NULL;
}
char mbcLogFilename[MAX_PATH];
if (isService && *programDataDir != NULL) {
//set the log file name to the default.
size_t dirLen = 0;
if (0 == wcstombs_s(&dirLen, mbcLogFilename, MAX_PATH, programDataDir, wcslen(programDataDir))) {
PathAppend(mbcLogFilename, HSP_DEFAULT_LOGFILE);
logFilename = mbcLogFilename;
} else {
logFilename = NULL;
}
}
if (logFilename != NULL) {
// Logging on
errno_t error = fopen_s(&logFile, logFilename, "wt");
if (error != 0) {
logFile = stderr;
myLog(LOG_ERR, "%s.ServiceMain: could not open log file %s: error %d\n", HSP_SERVICE_NAME, logFilename, error);
}
logFilename = NULL;
}
myLog(debug, "-------------Starting %s %s--------------", HSP_SERVICE_NAME, HSP_VERSION);
fflush(logFile);
HSP sp = { 0 };
// look up host-id fields at startup only (hostname
// may change dynamically so will have to revisit this $$$)
sp.host_hid.hostname.str = (char *)my_calloc(SFL_MAX_HOSTNAME_CHARS+1);
sp.host_hid.os_release.str = (char *)my_calloc(SFL_MAX_OSRELEASE_CHARS+1);
readHidCounters(&sp, &sp.host_hid);
sp.nio_polling_secs = HSP_NIO_POLLING_SECS_32BIT;
readInterfaces(&sp, TRUE);
if (!readConfig(&sp)) {
myLog(LOG_ERR, "%s.ServiceMain: invalid configuration", HSP_SERVICE_NAME);
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_INVALID_PARAMETER;
SetServiceStatus(hStatus, &ServiceStatus);
}
return;
}
sp.hyperV = testForHyperv();
if (sp.hyperV) {
myLog(debug, "%s.ServiceMain Hyper-V services are running", HSP_SERVICE_NAME);
if (programDataDir == NULL || !initialiseProgramDataFiles(&sp, programDataDir)) {
myLog(LOG_ERR, "%s.ServiceMain: cannot initialise switch port and VM state files", HSP_SERVICE_NAME);
if (hStatus != 0) {
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = ERROR_FILE_NOT_FOUND;
SetServiceStatus(hStatus, &ServiceStatus);
}
return;
}
readGuidStore(sp.f_vmStore, sp.vmStoreFile, &sp.vmStore, &sp.maxDsIndex);
readGuidStore(sp.f_portStore, sp.portStoreFile, &sp.portStore, &sp.maxIfIndex);
}
openFilter(&sp); //try to initialise the sFlow filter for sampling
initAgent(&sp);
// initialize the clock so we can detect second boundaries
sp.clk = time(NULL);
// main loop
BOOL dataAvailable = true;
uint32_t currReadNum = 0;
while (ServiceStatus.dwCurrentState == SERVICE_RUNNING && dataAvailable)
{
// check for second boundaries and generate ticks for the sFlow library
time_t now = time(NULL);
if ((now < sp.clk) || (now - sp.clk) > HSP_MAX_TICKS) {
// avoid a busy-loop of ticks if time jumps
myLog(LOG_INFO, "%s.ServiceMain: time jump detected", HSP_SERVICE_NAME);
sp.clk = now - 1;
}
while (sp.clk < now) { //only happens on second boundary
//start critical
if (sp.sFlow->sFlowSettings) {
// update polling interval here if config has changed.
tick(&sp);
}
//end critical
sp.clk++;
}
DWORD result;
//process a queued counter poller
processQueuedPoller(&sp);
//timeout is set so that we loop around checking for ticks and samples
//several times/s.
//calculate timeout 200 if the counter poller queue is empty, 0 otherwise
DWORD timeout = sp.pollerQHead == NULL ? HSP_TIMEOUT : 0;
if (HSP_FILTER_ACTIVE(sp.filter)) {
result = WaitForSingleObject(sp.filter.overlaps[currReadNum].hEvent,
timeout);
if (result == WAIT_OBJECT_0) {
dataAvailable = sp.filter.overlaps[currReadNum].Internal == ERROR_SUCCESS;
if (dataAvailable && sp.filter.overlaps[currReadNum].InternalHigh > 0) {
//process the sample info in sp.filter.buffers[currReadNum]
readPackets(&sp, sp.filter.buffers[currReadNum]);
}
// Re-queue this read
queueRead(sp.filter.dev,
sp.filter.buffers[currReadNum],
sizeof(sp.filter.buffers[currReadNum]),
&sp.filter.overlaps[currReadNum]);
//set the next buffer to read
currReadNum = (currReadNum+1)%numConcurrentReads;
}
} else {
Sleep(timeout);
}
}
return;
}
