int do_exec(int nargs, char** args) { service* svc = make_exec_oneshot_service(nargs, args); if (svc == NULL) { return -1; } service_start(svc, NULL); return 0; }
static void service_start_if_not_disabled(struct service *svc) { if (!(svc->flags & SVC_DISABLED)) { service_start(svc, NULL); } else { svc->flags |= SVC_DISABLED_START; } }
static void console_service (int argc, char ** argv) { log_printf ("%s %s: starting in console mode", application_name, application_version); SetConsoleCtrlHandler (control_handler, TRUE); service_start (argc, argv); control_break = FALSE; }
int do_start(int nargs, char **args) { struct service *svc; svc = service_find_by_name(args[1]); if (svc) { service_start(svc, NULL); } return 0; }
static void test_jsonrpc_main(int argc, char *argv[]) { proctitle_init(argc, argv); set_program_name(argv[0]); service_start(&argc, &argv); parse_options(argc, argv); run_command(argc - optind, argv + optind, get_all_commands()); }
void service_restart(struct service *svc) { if (svc->flags & SVC_RUNNING) { /* Stop, wait, then start the service. */ service_stop_or_reset(svc, SVC_RESTART); } else if (!(svc->flags & SVC_RESTARTING)) { /* Just start the service since it's not running. */ service_start(svc, NULL); } /* else: Service is restarting anyways. */ }
int main(int argc, char **argv) { errval_t err; debug_printf("Xeon Phi Manager started.\n"); err = service_start(); if (err_is_fail(err)) { USER_PANIC_ERR(err, "could not start the service\n"); } }
static void scmdatabase_autostart_services(struct scmdatabase *db) { struct service_entry **services_list; unsigned int i = 0; unsigned int size = 32; struct service_entry *service; services_list = HeapAlloc(GetProcessHeap(), 0, size * sizeof(services_list[0])); if (!services_list) return; scmdatabase_lock_shared(db); LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry) { if (service->config.dwStartType == SERVICE_BOOT_START || service->config.dwStartType == SERVICE_SYSTEM_START || service->config.dwStartType == SERVICE_AUTO_START) { if (i+1 >= size) { struct service_entry **slist_new; size *= 2; slist_new = HeapReAlloc(GetProcessHeap(), 0, services_list, size * sizeof(services_list[0])); if (!slist_new) break; services_list = slist_new; } services_list[i] = service; service->ref_count++; i++; } } scmdatabase_unlock(db); size = i; for (i = 0; i < size; i++) { DWORD err; const WCHAR *argv[2]; service = services_list[i]; argv[0] = service->name; argv[1] = NULL; err = service_start(service, 1, argv); if (err != ERROR_SUCCESS) WINE_FIXME("Auto-start service %s failed to start: %d\n", wine_dbgstr_w(service->name), err); release_service(service); } HeapFree(GetProcessHeap(), 0, services_list); }
void CL_Service_Unix::service_thread_main(std::vector<CL_String> args) { service_start(args); while (true) { int wakeup_reason = CL_Event::wait(stop_event, reload_event); if (wakeup_reason == 1) service_reload(); else break; } service_stop(); }
/* stop + start * * XXX: This should be refactored into a background job AND marked such * so that the service monitor doesn't attempt to restart it! */ int service_restart(svc_t *svc) { int result = 0; if (!svc) return 1; result += service_stop(svc); sleep(1); result += service_start(svc); return result; }
/* Singing and dancing ... */ static void svc_dance(svc_t *svc) { svc_cmd_t cmd = service_enabled(svc, 0, NULL); if (svc->pid) { if (SVC_STOP == cmd) service_stop(svc); else if (SVC_RELOAD == cmd) service_reload(svc); } else { if (SVC_START == cmd || SVC_RELOAD == cmd) service_start(svc); } }
int do_enable(int nargs, char **args) { struct service *svc; svc = service_find_by_name(args[1]); if (svc) { svc->flags &= ~(SVC_DISABLED | SVC_RC_DISABLED); if (svc->flags & SVC_DISABLED_START) { service_start(svc, NULL); } } else { return -1; } return 0; }
static void restart_service_if_needed(struct service *svc) { time_t next_start_time = svc->time_started + 5; if (next_start_time <= gettime()) { svc->flags &= (~SVC_RESTARTING); service_start(svc, NULL); return; } if ((next_start_time < process_needs_restart) || (process_needs_restart == 0)) { process_needs_restart = next_start_time; } }
void Service_Unix::service_thread_main(std::vector<std::string> args) { service_start(args); while (true) { std::unique_lock<std::mutex> lock(mutex); event_condition.wait(lock, [&]() { return stop_flag || reload_flag; }); if (stop_flag) break; reload_flag = false; service_reload(); } service_stop(); }
void wsvc_command_option(const char* wopt, const char* cfgfile, int v, int c) { if(strcmp(wopt, "install") == 0) wsvc_install(stdout, NULL); else if(strcmp(wopt, "remove") == 0) wsvc_remove(stdout); else if(strcmp(wopt, "service") == 0) service_start(cfgfile, v, c); else if(strcmp(wopt, "start") == 0) wsvc_rc_start(stdout); else if(strcmp(wopt, "stop") == 0) wsvc_rc_stop(stdout); else fatal_exit("unknown option: %s", wopt); exit(0); }
/** * service_bootstrap - Start bootstrap services and tasks * * System startup, runlevel S, where only services, tasks and * run commands absolutely essential to bootstrap are located. */ void service_bootstrap(void) { svc_t *svc; _d("Bootstrapping all services in runlevel S from %s", FINIT_CONF); for (svc = svc_iterator(1); svc; svc = svc_iterator(0)) { svc_cmd_t cmd; /* Inetd services cannot be part of bootstrap currently. */ if (svc_is_inetd(svc)) continue; cmd = service_enabled(svc, 0, NULL); if (SVC_START == cmd || (SVC_RELOAD == cmd)) service_start(svc); } }
static void restart_lost_procs(void) { svc_t *svc; for (svc = svc_iterator(1); svc; svc = svc_iterator(0)) { if (svc->pid > 0 && pid_alive(svc->pid)) continue; /* Only restart lost daemons, not task/run/inetd services */ if (SVC_TYPE_SERVICE != svc->type) { svc->pid = 0; continue; } service_start(svc); } }
int Service_Win32::run_debug(std::vector<std::string> args) { debug_mode = true; SetConsoleCtrlHandler(&Service_Win32::control_handler, TRUE); service_start(args); while (true) { std::unique_lock<std::mutex> lock(mutex); event_condition.wait(lock, [&]() { return stop_flag || reload_flag; }); if (stop_flag) break; reload_flag = false; service_reload(); } service_stop(); return 0; }
void WINAPI service_main (int argc, char **argv) { /* Register our service control handler: */ service_status_handle = RegisterServiceCtrlHandler (service_name, service_control); if (!service_status_handle) return; service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS; service_status.dwServiceSpecificExitCode = 0; /* report the status to the service control manager. */ if (report_status ( SERVICE_START_PENDING, /* Service state */ NO_ERROR, /* Exit code */ 3000)) /* Wait Hint */ service_start (argc, argv); /* Try to report the stopped status to the service control manager. */ if (service_status_handle) report_status (SERVICE_STOPPED, error_code, 0); }
int main(int argc, char *argv[]) { const struct ovsdb_client_command *command; char *database; struct jsonrpc *rpc; ovs_cmdl_proctitle_init(argc, argv); set_program_name(argv[0]); service_start(&argc, &argv); parse_options(argc, argv); fatal_ignore_sigpipe(); daemon_become_new_user(false); if (optind >= argc) { ovs_fatal(0, "missing command name; use --help for help"); } for (command = get_all_commands(); ; command++) { if (!command->name) { VLOG_FATAL("unknown command '%s'; use --help for help", argv[optind]); } else if (!strcmp(command->name, argv[optind])) { break; } } optind++; if (command->need != NEED_NONE) { if (argc - optind > command->min_args && (isalpha((unsigned char) argv[optind][0]) && strchr(argv[optind], ':'))) { rpc = open_jsonrpc(argv[optind++]); } else { char *sock = xasprintf("unix:%s/db.sock", ovs_rundir()); rpc = open_jsonrpc(sock); free(sock); } } else { rpc = NULL; } if (command->need == NEED_DATABASE) { struct svec dbs; svec_init(&dbs); fetch_dbs(rpc, &dbs); if (argc - optind > command->min_args && svec_contains(&dbs, argv[optind])) { database = xstrdup(argv[optind++]); } else if (dbs.n == 1) { database = xstrdup(dbs.names[0]); } else if (svec_contains(&dbs, "Open_vSwitch")) { database = xstrdup("Open_vSwitch"); } else { jsonrpc_close(rpc); ovs_fatal(0, "no default database for `%s' command, please " "specify a database name", command->name); } svec_destroy(&dbs); } else { database = NULL; } if (argc - optind < command->min_args || argc - optind > command->max_args) { free(database); VLOG_FATAL("invalid syntax for '%s' (use --help for help)", command->name); } command->handler(rpc, database, argc - optind, argv + optind); free(database); jsonrpc_close(rpc); if (ferror(stdout)) { VLOG_FATAL("write to stdout failed"); } if (ferror(stderr)) { VLOG_FATAL("write to stderr failed"); } return 0; }
int main(int argc, char *argv[]) { char *unixctl_path = NULL; struct unixctl_server *unixctl; char *remote; bool exiting; int retval; set_program_name(argv[0]); retval = dpdk_init(argc,argv); argc -= retval; argv += retval; ovs_cmdl_proctitle_init(argc, argv); service_start(&argc, &argv); remote = parse_options(argc, argv, &unixctl_path); fatal_ignore_sigpipe(); ovsrec_init(); daemonize_start(); if (want_mlockall) { #ifdef HAVE_MLOCKALL if (mlockall(MCL_CURRENT | MCL_FUTURE)) { VLOG_ERR("mlockall failed: %s", ovs_strerror(errno)); } #else VLOG_ERR("mlockall not supported on this system"); #endif } retval = unixctl_server_create(unixctl_path, &unixctl); if (retval) { exit(EXIT_FAILURE); } unixctl_command_register("exit", "", 0, 0, ovs_vswitchd_exit, &exiting); bridge_init(remote); free(remote); exiting = false; while (!exiting) { memory_run(); if (memory_should_report()) { struct simap usage; simap_init(&usage); bridge_get_memory_usage(&usage); memory_report(&usage); simap_destroy(&usage); } bridge_run(); unixctl_server_run(unixctl); netdev_run(); memory_wait(); bridge_wait(); unixctl_server_wait(unixctl); netdev_wait(); if (exiting) { poll_immediate_wake(); } poll_block(); if (should_service_stop()) { exiting = true; } } bridge_exit(); unixctl_server_destroy(unixctl); service_stop(); return 0; }
int ssh_server_start() { return service_start("sshd"); }
static void test_jsonrpc_main(int argc, char *argv[]) { struct ovs_cmdl_context ctx = { .argc = 0, }; ovs_cmdl_proctitle_init(argc, argv); set_program_name(argv[0]); service_start(&argc, &argv); parse_options(argc, argv); ctx.argc = argc - optind; ctx.argv = argv + optind; ovs_cmdl_run_command(&ctx, get_all_commands()); } static void parse_options(int argc, char *argv[]) { enum { OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1, DAEMON_OPTION_ENUMS }; static const struct option long_options[] = { {"verbose", optional_argument, NULL, 'v'}, {"help", no_argument, NULL, 'h'}, DAEMON_LONG_OPTIONS, {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT}, STREAM_SSL_LONG_OPTIONS, {NULL, 0, NULL, 0}, }; char *short_options = ovs_cmdl_long_options_to_short_options(long_options); for (;;) { int c = getopt_long(argc, argv, short_options, long_options, NULL); if (c == -1) { break; } switch (c) { case 'h': usage(); case 'v': vlog_set_verbosity(optarg); break; DAEMON_OPTION_HANDLERS STREAM_SSL_OPTION_HANDLERS case OPT_BOOTSTRAP_CA_CERT: stream_ssl_set_ca_cert_file(optarg, true); break; case '?': exit(EXIT_FAILURE); default: abort(); } } free(short_options); } static void usage(void) { printf("%s: JSON-RPC test utility\n" "usage: %s [OPTIONS] COMMAND [ARG...]\n" " listen LOCAL listen for connections on LOCAL\n" " request REMOTE METHOD PARAMS send request, print reply\n" " notify REMOTE METHOD PARAMS send notification and exit\n", program_name, program_name); stream_usage("JSON-RPC", true, true, true); daemon_usage(); vlog_usage(); printf("\nOther options:\n" " -h, --help display this help message\n"); exit(EXIT_SUCCESS); }
void service_monitor(pid_t lost) { svc_t *svc; static int was_stopped = 0; if (was_stopped && !is_norespawn()) { was_stopped = 0; restart_lost_procs(); return; } if (fexist(SYNC_SHUTDOWN) || lost <= 1) return; /* Power user at the console, don't respawn tasks. */ if (is_norespawn()) { was_stopped = 1; return; } if (tty_respawn(lost)) return; #ifndef INETD_DISABLED if (inetd_respawn(lost)) return; #endif for (svc = svc_iterator(1); svc; svc = svc_iterator(0)) { if (lost != svc->pid) continue; if (SVC_TYPE_SERVICE != svc->type) { svc->pid = 0; continue; } _d("Ouch, lost pid %d - %s(%d)", lost, basename(svc->cmd), svc->pid); /* No longer running, update books. */ svc->pid = 0; if (sig_stopped()) { _e("Stopped, not respawning killed processes."); break; } /* Restarting lost service. */ if (service_enabled(svc, 0, NULL)) { if (svc->restart_counter > RESPAWN_MAX) { _e("Not restarting %s id %d, respawn MAX (%d) reached!", svc->cmd, svc->id, RESPAWN_MAX); break; } svc->restart_counter++; service_start(svc); } break; } }
static void service_start_if_not_disabled(struct service *svc) { if (!(svc->flags & SVC_DISABLED)) { service_start(svc); } }
/* * Elevate from local admin to local system via Named Pipe Impersonation. We spawn a cmd.exe under local * system which then connects to our named pipe and we impersonate this client. This can be done by an * Administrator without the need for SeDebugPrivilege. Works on 2000, XP, 2003 and 2008 for all local * administrators. On Vista and 7 it will only work if the host process has been elevated through UAC * first. Does not work on NT4. */ DWORD elevate_via_service_namedpipe(Remote * remote, Packet * packet) { DWORD dwResult = ERROR_SUCCESS; char * cpServiceName = NULL; THREAD * pThread = NULL; HANDLE hSem = NULL; char cServiceArgs[MAX_PATH] = {0}; char cServicePipe[MAX_PATH] = {0}; OSVERSIONINFO os = {0}; do { os.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx(&os)) { BREAK_ON_ERROR("[ELEVATE] elevate_via_service_namedpipe: GetVersionEx failed") } // filter out Windows NT4 if (os.dwMajorVersion == 4 && os.dwMinorVersion == 0) { SetLastError(ERROR_ACCESS_DENIED); BREAK_ON_ERROR("[ELEVATE] elevate_via_service_namedpipe: Windows NT4 not supported.") } cpServiceName = packet_get_tlv_value_string(packet, TLV_TYPE_ELEVATE_SERVICE_NAME); if (!cpServiceName) { BREAK_WITH_ERROR("[ELEVATE] elevate_via_service_namedpipe. invalid arguments", ERROR_BAD_ARGUMENTS); } _snprintf_s(cServicePipe, sizeof(cServicePipe), MAX_PATH, "\\\\.\\pipe\\%s", cpServiceName); _snprintf_s(cServiceArgs, sizeof(cServiceArgs), MAX_PATH, "cmd.exe /c echo %s > %s", cpServiceName, cServicePipe); hSem = CreateSemaphore(NULL, 0, 1, NULL); pThread = thread_create(elevate_namedpipe_thread, &cServicePipe, remote, hSem); if (!pThread) { BREAK_WITH_ERROR("[ELEVATE] elevate_via_service_namedpipe. thread_create failed", ERROR_INVALID_HANDLE); } if (!thread_run(pThread)) { BREAK_WITH_ERROR("[ELEVATE] elevate_via_service_namedpipe. thread_run failed", ERROR_ACCESS_DENIED); } //wait for the thread to create the pipe(if it times out terminate) if (hSem) { if (WaitForSingleObject(hSem, 500) != WAIT_OBJECT_0) { BREAK_WITH_ERROR("[ELEVATE] elevate_via_service_namedpipe. WaitForSingleObject failed", ERROR_ACCESS_DENIED); } } else { Sleep(500); } // start the elevator service (if it doesnt start first time we need to create it and then start it). if (service_start(cpServiceName) != ERROR_SUCCESS) { dprintf("[ELEVATE] service starting failed, attempting to create"); if (service_create(cpServiceName, cServiceArgs) != ERROR_SUCCESS) { BREAK_ON_ERROR("[ELEVATE] elevate_via_service_namedpipe. service_create failed"); } dprintf("[ELEVATE] creation of service succeeded, attempting to start"); // we dont check a return value for service_start as we expect it to fail as cmd.exe is not // a valid service and it will never signal to the service manager that is is a running service. service_start(cpServiceName); } // signal our thread to terminate if it is still running thread_sigterm(pThread); // and wait for it to terminate... thread_join(pThread); // get the exit code for our pthread dprintf("[ELEVATE] dwResult before exit code: %u", dwResult); if (!GetExitCodeThread(pThread->handle, &dwResult)) { BREAK_WITH_ERROR("[ELEVATE] elevate_via_service_namedpipe. GetExitCodeThread failed", ERROR_INVALID_HANDLE); } dprintf("[ELEVATE] dwResult after exit code: %u", dwResult); } while (0);
static void run(void) { service_start(__service); }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, #ifdef _WIN32_WCE LPWSTR lpCmdLine, #else LPSTR lpCmdLine, #endif int nCmdShow) { LPSTR command_line; #ifdef _WIN32_WCE command_line=tstr2str(lpCmdLine); #else command_line=lpCmdLine; #endif ghInst=hInstance; parse_cmdline(command_line); /* setup global cmdline structure */ #ifndef _WIN32_WCE if(set_cwd()) /* set current working directory */ return 1; #endif /* setup the windo caption before reading the configuration file * options.win32_service is not available here and may not be used */ #ifdef _WIN32_WCE _tcscpy(win32_name, TEXT("stunnel ") TEXT(VERSION) TEXT(" on Windows CE (not configured)")); #else _tcscpy(win32_name, TEXT("stunnel ") TEXT(VERSION) TEXT(" on Win32 (not configured)")); #endif if(initialize_winsock()) return 1; if(!setjmp(jump_buf)) { /* TRY */ main_initialize( cmdline.config_file[0] ? cmdline.config_file : NULL, NULL); #ifdef _WIN32_WCE _tcscpy(win32_name, TEXT("stunnel ") TEXT(VERSION) TEXT(" on Windows CE")); #else _snprintf(win32_name, STRLEN, "stunnel %s on Win32 (%s)", VERSION, options.win32_service); /* update the information */ if(!cmdline.service) { if(cmdline.install) return service_install(command_line); if(cmdline.uninstall) return service_uninstall(); if(cmdline.start) return service_start(); if(cmdline.stop) return service_stop(); } #endif } /* CATCH */ #ifndef _WIN32_WCE if(cmdline.service) return service_initialize(); else #endif return win_main(hInstance, hPrevInstance, command_line, nCmdShow); }
void httpserver::start(int port) { service_start(); if(run(port, 1000000) == false) VERBOSE(m_errrostring << " "); }
static void test_netflow_main(int argc, char *argv[]) { struct unixctl_server *server; enum { MAX_RECV = 1500 }; const char *target; struct ofpbuf buf; bool exiting = false; int error; int sock; int n; proctitle_init(argc, argv); set_program_name(argv[0]); service_start(&argc, &argv); parse_options(argc, argv); if (argc - optind != 1) { ovs_fatal(0, "exactly one non-option argument required " "(use --help for help)"); } target = argv[optind]; sock = inet_open_passive(SOCK_DGRAM, target, 0, NULL, 0, true); if (sock < 0) { ovs_fatal(0, "%s: failed to open (%s)", argv[1], ovs_strerror(-sock)); } daemon_save_fd(STDOUT_FILENO); daemonize_start(); error = unixctl_server_create(NULL, &server); if (error) { ovs_fatal(error, "failed to create unixctl server"); } unixctl_command_register("exit", "", 0, 0, test_netflow_exit, &exiting); daemonize_complete(); ofpbuf_init(&buf, MAX_RECV); n = 0; for (;;) { int retval; unixctl_server_run(server); ofpbuf_clear(&buf); do { retval = recv(sock, ofpbuf_data(&buf), buf.allocated, 0); } while (retval < 0 && errno == EINTR); if (retval > 0) { ofpbuf_put_uninit(&buf, retval); if (n++ > 0) { putchar('\n'); } print_netflow(&buf); fflush(stdout); } if (exiting) { break; } poll_fd_wait(sock, POLLIN); unixctl_server_wait(server); poll_block(); } }