Esempio n. 1
0
int
tempDirToucherMain(int argc, char *argv[]) {
	initialize(argc, argv, 2);
	installSignalHandlers();
	maybeDaemonize();
	maybeWritePidfile();

	while (1) {
		if (dirExists(dir)) {
			DEBUG("Touching directory");
			touchDir(dir);
			if (!doSleep(sleepInterval)) {
				break;
			}
		} else {
			DEBUG("Directory no longer exists, exiting");
			break;
		}
	}

	maybeDeletePidFile();
	if (shouldCleanup) {
		DEBUG("Cleaning up directory");
		performCleanup(dir);
	}

	return 0;
}
Esempio n. 2
0
int
main(void)
{
    const char str[] = "string 1";
    int   size = (4096*10);
    char *anon;
 
    installSignalHandlers();

    anon = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
    if (anon == MAP_FAILED) {
        fprintf(stderr, "mmap fails\n");
        exit(errno);
    }
 
    strcpy(anon, str);
 
    printf("anonymous page(%x): %s\n", anon, anon);

    if (mprotect(anon, 4096, PROT_NONE)) {
        perror("Couldn¡¯t mprotect");
        exit(errno);
    }

    printf("anonymous page(%x): %s\n", anon, anon);
    strcpy(anon, str);

    munmap(anon, size);
    exit(0);
}
Esempio n. 3
0
KSshProcess::KSshProcess() : mVersion(UNKNOWN_VER), mConnected(false), mRunning(false), mConnectState(0)
{
    mSshPath = KStandardDirs::findExe(QString::fromLatin1("ssh"));
    kdDebug(KSSHPROC) << "KSshProcess::KSshProcess(): ssh path [" << mSshPath << "]" << endl;

    installSignalHandlers();
}
Esempio n. 4
0
int
main(int argc, char *argv[]) {
	initialize(argc, argv);
	installSignalHandlers();
	maybeDaemonize();
	maybeWritePidfile();

	while (1) {
		if (dirExists(dir)) {
			touchDir(dir);
			if (!doSleep(1800)) {
				break;
			}
		} else {
			break;
		}
	}

	maybeDeletePidFile();
	if (shouldCleanup) {
		performCleanup(dir);
	}

	return 0;
}
Esempio n. 5
0
int main(int argc, char* argv[])
{
  installSignalHandlers();
  printLibraryVersions();

  /** Setup D-BUS information */
  QCoreApplication::setOrganizationName("QlixIsOSS");
  QCoreApplication::setOrganizationDomain("Qlix.berlios.de");
  QCoreApplication::setApplicationName("Qlix");
  /** Setup QSettings */
  QSettings settings;
  QString ret = settings.value("DefaultDevice").toString();
  
  /** Setup QApplication */
  QApplication app(argc, argv);
  app.setStyle("Plastique");

  /** Grab AutoFix options */
  CommandLineOptions opts = ParseCommandLineOptions(argc, argv);

  _subSystem.SetAutoFixOptions(opts); 
  if (opts.AutoFixPlaylists)
    cout << "Working" << endl;
  //app.setStyleSheet("QTreeView::branch:!adjoins-item{ border-color: none;}"); works
  //app.setStyleSheet("QTreeView::branch:!adjoins-item{ background: none}"); 
  //app.setStyleSheet("QTreeView::branch:!adjoins-item:!has-children{ foreground: red}"); 
  //app.setStyleSheet("QTreeView::branch:adjoins-item:has-children{ background: cyan}"); 

  QlixMainWindow qmw(&_subSystem);
  qmw.show();
  Q_INIT_RESOURCE(Qlix);
  app.exec();
  return 0;
} 
Esempio n. 6
0
void spawnManagedChild() {
  installSignalHandlers();

  // Loops forever to make sure the parent process never leaves.
  while (true) {
    switch (childPid = fork()) {
    case -1:
      // error
      logFailure(failure::Category::kSystemError,
          "Can't spawn child process, sleeping");
      std::this_thread::sleep_for(std::chrono::seconds(SpawnWait));
      break;

    case 0:
      // child process. cleanup and continue with the startup logic.
      uninstallSignalHandlers();
      return;

    default:
      // parent process.
      LOG(INFO) << "Spawned child process " << childPid;

      int rv;
      do {
        rv = wait(nullptr);
      } while (rv == -1 && errno != ECHILD && running);

      if (running) {
        // Child died accidentally. Cleanup and restart.
        LOG(INFO) << "Child process " << childPid << " exited";
        waitpid(childPid, nullptr, 0);
      } else {
        // Child was killed. Shutdown parent.
        if (!waitpidTimeout(childPid, TermSignalTimeout)) {
          logFailure(failure::Category::kSystemError,
              "Child process did not exit in {} microseconds. Sending SIGKILL.",
              TermSignalTimeout);
          kill(childPid, SIGKILL);
        }
        exit(0);
      }
      break;
    }
  }
}
Esempio n. 7
0
KSshProcess::KSshProcess(QString pathToSsh) : mSshPath(pathToSsh), mVersion(UNKNOWN_VER), mConnected(false), mRunning(false), mConnectState(0)
{
    installSignalHandlers();
}
Esempio n. 8
0
jboolean rvmSetupSignals(Env* env) {
    if (!installSignalHandlers(env)) {
        return FALSE;
    }
    return TRUE;
}
Esempio n. 9
0
int main(int argc, char *argv[]) {
#ifdef Q_OS_WIN
	_oldWndExceptionFilter = SetUnhandledExceptionFilter(_exceptionFilter);
//	CAPIHook apiHook("kernel32.dll", "SetUnhandledExceptionFilter", (PROC)RedirectedSetUnhandledExceptionFilter);
#endif

	settingsParseArgs(argc, argv);
	for (int32 i = 0; i < argc; ++i) {
		if (string("-fixprevious") == argv[i]) {
			return psFixPrevious();
		} else if (string("-cleanup") == argv[i]) {
			return psCleanup();
		}
	}
	if (!logsInit()) {
		return 0;
	}

	installSignalHandlers();

	Global::Initializer _init;

	Local::readSettings();
	if (Local::oldSettingsVersion() < AppVersion) {
		psNewVersion();
	}
	if (cFromAutoStart() && !cAutoStart()) {
		psAutoStart(false, true);
		Local::stop();
		return 0;
	}

	DEBUG_LOG(("Application Info: Telegram started, test mode: %1, exe dir: %2").arg(logBool(cTestMode())).arg(cExeDir()));
	if (cDebug()) {
		LOG(("Application Info: Telegram started in debug mode"));
		for (int32 i = 0; i < argc; ++i) {
			LOG(("Argument: %1").arg(fromUtf8Safe(argv[i])));
		}
        QStringList logs = psInitLogs();
        for (int32 i = 0, l = logs.size(); i < l; ++i) {
            LOG(("Init Log: %1").arg(logs.at(i)));
        }
    }
    psClearInitLogs();

	DEBUG_LOG(("Application Info: ideal thread count: %1, using %2 connections per session").arg(QThread::idealThreadCount()).arg(cConnectionsInSession()));

	psStart();
	int result = 0;
	{
		QByteArray args[] = { "-style=0" }; // prepare fake args
		static const int a_cnt = sizeof(args) / sizeof(args[0]);
		int a_argc = a_cnt + 1;
		char *a_argv[a_cnt + 1] = { argv[0], args[0].data() };

		Application app(a_argc, a_argv);
		if (!App::quiting()) {
			result = app.exec();
		}
	}
    psFinish();
	Local::stop();

	DEBUG_LOG(("Application Info: Telegram done, result: %1").arg(result));

	#ifndef TDESKTOP_DISABLE_AUTOUPDATE
	if (cRestartingUpdate()) {
		if (!cBetaVersion() && DevVersion) {
			LOG(("Writing 'devversion' file before launching the Updater!"));
			QFile f(cWorkingDir() + qsl("tdata/devversion"));
			if (!f.exists() && f.open(QIODevice::WriteOnly)) {
				f.write("1");
				f.close();
			}
		}

		DEBUG_LOG(("Application Info: executing updater to install update.."));
		psExecUpdater();
	} else
	#endif
	if (cRestarting()) {
		DEBUG_LOG(("Application Info: executing Telegram, because of restart.."));
		psExecTelegram();
	}

	logsClose();
	return result;
}
Esempio n. 10
0
int main(int argc, const char** argv)
{
    int retval = 0;
    boost::program_options::options_description general_options_description("Options", 140, 60);
    boost::program_options::variables_map vm;
    std::string colorArg, deviceArg;

    try {
        std::set<Nebula::HAL::Device*> devices;
        std::mutex devicesMutex;

        installSignalHandlers();

        general_options_description.add_options()
                                               (Options::kDevice,
                                                boost::program_options::value<std::string>(),
                                                "specify device")
                                               (Options::kChannel,
                                                boost::program_options::value<RT::s4>()->default_value(0),
                                                "specify LED strip channel")
                                               (Options::kNumberOfLeds,
                                                boost::program_options::value<RT::s4>()->default_value(0),
                                                "set number of leds")
                                               ("nn",
                                                boost::program_options::value<RT::s4>()->default_value(100),
                                                "set running light increment")
                                               ("size,s",
                                                boost::program_options::value<RT::s4>()->default_value(100),
                                                "Ambilight sensing zones size")
                                               (Options::kFrequency,
                                                boost::program_options::value<float>()->default_value(24.0f),
                                                "set number of LEDs color updates per second")
                                               (Options::kColor,
                                                boost::program_options::value<std::string>()->default_value(std::string("255,255,255")),
                                                "set LEDs color")
                                               (Options::kBrightness,
                                                boost::program_options::value<float>()->default_value(0.5f),
                                                "set LEDs brightness")
                                               (Options::kRate,
                                                boost::program_options::value<float>()->default_value(1.0f),
                                                "set dynamic lighting effect rate")
                                               //(Options::kStrobe, "run in stroboscope mode")
                                               (Options::kDebug,
                                                boost::program_options::value<RT::u4>()->default_value(0),
                                                "stroboscope mode");

        if (argc < 2) optionsError("mode was not specified\n");

        auto mode = determineMode(argv[1]);
        if (mode == Mode::none)
            optionsError("invalid mode was specified\n");

        boost::program_options::store(boost::program_options::command_line_parser(argc - 1, argv + 1).options(general_options_description).run(), vm, true);
        boost::program_options::notify(vm);

        switch (mode) {
            case Mode::help:
                print_usage(general_options_description);
                exit(0);

            case Mode::version:
                std::cout << VERSION_STRING(VERSION, __DATE__, __TIME__) << std::endl;
                exit(0);

            default: break;
        }

        auto onDeviceAddition = [&](Nebula::HAL::Device* device) -> void {
            std::lock_guard<std::mutex> lock(devicesMutex);
            devices.insert(device);
        };

        auto onDeviceRemoval = [&](Nebula::HAL::Device* device) -> void {
            std::lock_guard<std::mutex> lock(devicesMutex);
            devices.erase(device);
        };

        std::unique_ptr<Nebula::HAL::Context> nebula(Nebula::HAL::createContext(onDeviceAddition, onDeviceRemoval));

        if (mode == Mode::list) {
            std::lock_guard<std::mutex> lock(devicesMutex);
            for (auto device : devices) printDeviceInfo(device);
        }
        else {
            auto firstDeviceIterator = devices.begin();
            if (firstDeviceIterator != devices.end())
            {
                auto device = *firstDeviceIterator;
                auto channel = vm["channel"].as<RT::s4>();
                auto numberOfLeds = vm["nleds"].as<RT::s4>();
                auto frequency = vm["freq"].as<float>();
                auto brightness = vm["brightness"].as<float>();
                bool animate = false;

                if (channel < 0) optionsError("channel should be >= 0\n");
                if (numberOfLeds <= 0) optionsError("number of LEDs should be > 0\n");
                if (frequency <= 0.0f) optionsError("frequency should be > 0\n");
                if (brightness < 0.0f) optionsError("brightness should be >= 0\n");

                std::unique_ptr<Nebula::Color::RGB<RT::u1>> colors(new Nebula::Color::RGB<RT::u1>[numberOfLeds]);
                std::mutex colorsMutex;

                Nebula::HAL::Device::IoctlParameters::SetNumberOfLeds setNumberOfLedsIoctlParameters(channel, numberOfLeds);
                Nebula::HAL::Device::IoctlParameters::Colors colorsIoctlParameters(channel, colors.get(), numberOfLeds);

                device->controlIn(Nebula::HAL::Device::Request::setNumberOfLeds,
                                  &setNumberOfLedsIoctlParameters,
                                  sizeof(setNumberOfLedsIoctlParameters));

                switch (mode) {
                    case Mode::continuous: {
                        RT::u4 r, g, b;
                        sscanf(vm["color"].as<std::string>().c_str(), "%u,%u,%u", &r, &g, &b);

                        r *= brightness;
                        g *= brightness;
                        b *= brightness;
                        for (auto i = 0; i < numberOfLeds; i++) colors.get()[convertLedNumber(i)].set(r, g, b);

                        device->controlIn(Nebula::HAL::Device::Request::setColors,
                                          &colorsIoctlParameters,
                                          sizeof(colorsIoctlParameters));
                    }
                    break;

                    case Mode::rainbow:
                    case Mode::ambilight:
                    case Mode::run:
                        animate = true;
                    break;

                    default: break;
                }

                if (animate) {
                    std::unique_ptr<Nebula::Generator> generator(createGenerator(mode, vm));
                    std::unique_ptr<Nebula::Transformation> transformation(new Reorder(numberOfLeds, 3));
                    TimerCallbackParameters timerCallbackParameters(device, &colorsIoctlParameters, &colorsMutex);

                    std::thread pluginThread([&]() -> void {
                        std::unique_ptr<Nebula::Color::RGB<RT::u1>> localColors(new Nebula::Color::RGB<RT::u1>[numberOfLeds]);
                        time_t t1, t2;
                        RT::u8 count = 0;

                        time(&t1);
                        while (!doTerminate) {
                            generator->generate(localColors.get());
                            transformation->transformInPlace(localColors.get());

                            guardedMemcpy(localColors.get(), colors.get(),
                                          numberOfLeds * sizeof(Nebula::Color::RGB<RT::u1>),
                                          &colorsMutex);
                            count++;
                        }
                        time(&t2);

                        if (count > 0)
                            printf("updates per second = %f\n", float(count) / float(t2 - t1));
                    });

                    try {
                        runLoop(&timerCallbackParameters, frequency);
                    }
                    catch(...) {
                        pluginThread.join();
                        throw;
                    }

                    pluginThread.join();
                }
            }
            else
                printf("No device found\n");
        }
    }
    catch (RT::u4 ID) {
        printf("Error 0x%x\n", ID);
    }
    catch (OptionsError e) {
        printf("Invalid program invocation: %s", e.getMessage());
        print_usage(general_options_description);
        retval = -1;
    }
    catch (...) {
        printf("Exception occured\n");
    }

    return retval;
}