int command_restart() { int retval = 0; retval = command_stop(); if (retval != 0) return retval; return command_start(); }
int main(int argc, char* argv[]) { int retval = 0; /* We need root rights to initialize everything. */ if (getuid() != 0) { fprintf(stderr, "This program has to be run as root. Exiting.\n"); return 1; } piphoned_commandline_info_from_argv(argc, argv); /* sets up g_cli_options */ setlogmask(LOG_UPTO(g_cli_options.loglevel)); openlog("piphoned", LOG_CONS | LOG_ODELAY | LOG_PID, LOG_DAEMON); syslog(LOG_DEBUG, "Early startup phase entered."); piphoned_config_init(g_cli_options.config_file); /* sets g_piphoned_config_info */ /* Library initialisation */ wiringPiSetup(); /* Requires root */ switch(g_cli_options.command) { case PIPHONED_COMMAND_START: retval = command_start(); break; case PIPHONED_COMMAND_STOP: retval = command_stop(); break; case PIPHONED_COMMAND_RESTART: retval = command_restart(); break; default: fprintf(stderr, "Invalid command %d. This is a bug.\n", g_cli_options.command); return 1; } /* Library cleanup */ piphoned_config_free(); syslog(LOG_DEBUG, "Late termination phase ended."); closelog(); return retval; }
static int worker_cron (aeEventLoop * el, long long id, void *data) { workerState *ws = (workerState *) data; long long ts = currtime_millis (); int ret; if (ws->reconn_after != 0LL && ts > ws->reconn_after) { if (ws->fd >= 0) { free_connection (ws, 1); } else { char ebuf[512]; (void) command_start (ws, ebuf, sizeof (ebuf)); } } if (ws->tps > 0) { long long token_val; token_val = (ws->tps * SINGLE_TOKEN_VAL) / 1000 * WORKER_CRON_INTERVAL; ws->token_val += token_val; if (ws->token_val > ws->tps * SINGLE_TOKEN_VAL) { ws->token_val = ws->tps * SINGLE_TOKEN_VAL; } if (ws->wprepare_at_token && ws->token_val >= SINGLE_TOKEN_VAL) { ret = emit_command (ws); assert (ret == 0); ws->wprepare_at_token = 0; } } return WORKER_CRON_INTERVAL; }
/* Main function. */ int main(int argc, char *argv[]) { cli_t cli; char *hostname = DEFAULT_HOST; char history_file[4096]; ybool_t interactive_mode = YTRUE; bzero(&cli, sizeof(cli_t)); cli.autocheck = YTRUE; if (argc == 2 && argv[1][0] != '-') hostname = argv[1]; if (argc == 3 && !strcmp(argv[2], "-")) interactive_mode = YFALSE; // init database connection if ((cli.finedb = finedb_create(hostname, 11138)) == NULL) { printf_color("red", "Memory error."); printf("\n"); exit(1); } if (finedb_connect(cli.finedb) != FINEDB_OK) { printf_color("red", "Unable to connect to server '%s' on port '%d'.", argv[1], 11138); printf("\n"); exit(2); } // interactive mode init if (interactive_mode) { char *home = NULL; if ((home = getenv("HOME")) != NULL) { FILE *hist; snprintf(history_file, sizeof(history_file), "%s/%s", home, HISTORY_FILE); if ((hist = fopen(history_file, "w+")) != NULL) { fclose(hist); linenoiseHistoryLoad(HISTORY_FILE); } linenoiseSetCompletionCallback(cli_completion); } } // main loop for (; ; ) { char buff[4096], *line = NULL, *pt, *cmd; if (!interactive_mode) { ssize_t bufsz, linesz = 0; while ((bufsz = read(0, buff, sizeof(buff))) > 0) { pt = (char*)malloc(linesz + bufsz + 1); memcpy(pt, line, linesz); memcpy((void*)((size_t)pt + linesz), buff, bufsz); linesz += bufsz; pt[linesz] = '\0'; if (line) free(line); line = pt; } } else { snprintf(buff, sizeof(buff), "%s > ", (cli.dbname ? cli.dbname : "default")); if ((line = linenoise(buff)) == NULL) break; } pt = line; LTRIM(pt); cmd = pt; // add command line to history linenoiseHistoryAdd(cmd); linenoiseHistorySave(history_file); // extract the command while (*pt && !IS_SPACE(*pt)) ++pt; *pt++ = '\0'; LTRIM(pt); /* command management */ if (cmd[0] == '\0') goto reloop; //continue; // local commands, no need for a running connection if (!strcasecmp(cmd, "exit") || !strcasecmp(cmd, "quit")) exit(0); if (!strcasecmp(cmd, "help") || cmd[0] == '?') { command_help(); goto reloop; //continue; } else if (!strcasecmp(cmd, "sync")) { command_sync(&cli); goto reloop; //continue; } else if (!strcasecmp(cmd, "async")) { command_async(&cli); goto reloop; //continue; } // commands that need a running connection if (!strcasecmp(cmd, "use")) command_use(&cli, pt); else if (!strcasecmp(cmd, "get")) command_get(&cli, pt); else if (!strcasecmp(cmd, "del")) command_del(&cli, pt); else if (!strcasecmp(cmd, "put")) command_send_data(&cli, pt, YFALSE, YFALSE); else if (!strcasecmp(cmd, "add")) command_send_data(&cli, pt, YTRUE, YFALSE); else if (!strcasecmp(cmd, "update")) command_send_data(&cli, pt, YFALSE, YTRUE); else if (!strcasecmp(cmd, "inc")) command_inc(&cli, pt); else if (!strcasecmp(cmd, "dec")) command_dec(&cli, pt); else if (!strcasecmp(cmd, "start")) command_start(&cli); else if (!strcasecmp(cmd, "stop")) command_stop(&cli); #if 0 else if (!strcasecmp(cmd, "list")) command_list(&cli, pt); #endif else if (!strcasecmp(cmd, "ping")) command_ping(&cli); else if (!strcasecmp(cmd, "autocheck")) command_autocheck(&cli, pt); else { printf_color("red", "Bad command."); printf("\n"); } reloop: free(line); } return (0); }
static int filter_apply( git_filter *self, void **payload, /* may be read and/or set */ git_buf *to, const git_buf *from, const git_filter_source *src) { struct filter_filter *ffs = (struct filter_filter *)self; git_config *config; git_buf configKey = GIT_BUF_INIT; int isRequired = FALSE; int error; const char *cmd = NULL; git_buf cmdBuf = GIT_BUF_INIT; wchar_t *wide_cmd; COMMAND_HANDLE commandHandle = COMMAND_HANDLE_INIT; git_buf errBuf = GIT_BUF_INIT; DWORD exitCode; if (!*payload) return GIT_PASSTHROUGH; if (git_repository_config__weakptr(&config, git_filter_source_repo(src))) return -1; git_buf_join3(&configKey, '.', "filter", *payload, "required"); if (git_buf_oom(&configKey)) { giterr_set_oom(); return -1; } error = git_config_get_bool(&isRequired, config, configKey.ptr); git_buf_free(&configKey); if (error && error != GIT_ENOTFOUND) return -1; git_buf_join(&configKey, '.', "filter", *payload); if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE) { git_buf_puts(&configKey, ".smudge"); } else { git_buf_puts(&configKey, ".clean"); } if (git_buf_oom(&configKey)) { giterr_set_oom(); return -1; } error = git_config_get_string(&cmd, config, configKey.ptr); git_buf_free(&configKey); if (error && error != GIT_ENOTFOUND) return -1; if (error == GIT_ENOTFOUND) { if (isRequired) return -1; return GIT_PASSTHROUGH; } git_buf_puts(&cmdBuf, cmd); if (git_buf_oom(&cmdBuf)) { giterr_set_oom(); return -1; } if (expandPerCentF(&cmdBuf, git_filter_source_path(src))) return -1; if (ffs->shexepath) { // build params for sh.exe git_buf shParams = GIT_BUF_INIT; git_buf_puts(&shParams, " -c \""); git_buf_text_puts_escaped(&shParams, cmdBuf.ptr, "\"\\", "\\"); git_buf_puts(&shParams, "\""); if (git_buf_oom(&shParams)) { git_buf_free(&cmdBuf); giterr_set_oom(); return -1; } git_buf_swap(&shParams, &cmdBuf); git_buf_free(&shParams); } if (git__utf8_to_16_alloc(&wide_cmd, cmdBuf.ptr) < 0) { git_buf_free(&cmdBuf); giterr_set_oom(); return -1; } git_buf_free(&cmdBuf); if (ffs->shexepath) { // build cmd, i.e. shexepath + params size_t len = wcslen(ffs->shexepath) + wcslen(wide_cmd) + 1; wchar_t *tmp = git__calloc(len, sizeof(wchar_t)); if (!tmp) { git__free(wide_cmd); giterr_set_oom(); return -1; } wcscat_s(tmp, len, ffs->shexepath); wcscat_s(tmp, len, wide_cmd); git__free(wide_cmd); wide_cmd = tmp; } commandHandle.errBuf = &errBuf; if (command_start(wide_cmd, &commandHandle, ffs->pEnv)) { git__free(wide_cmd); if (isRequired) return -1; return GIT_PASSTHROUGH; } git__free(wide_cmd); if (commmand_start_stdout_reading_thread(&commandHandle, to)) { command_close(&commandHandle); return -1; } if (command_write_gitbuf(&commandHandle, from)) { DWORD exitCode = command_close(&commandHandle); if (exitCode) setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); if (isRequired) return -1; return GIT_PASSTHROUGH; } command_close_stdin(&commandHandle); if (command_wait_stdout_reading_thread(&commandHandle)) { DWORD exitCode = command_close(&commandHandle); if (exitCode) setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); if (isRequired) return -1; return GIT_PASSTHROUGH; } exitCode = command_close(&commandHandle); if (exitCode) { if (isRequired) { setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); return -1; } git_buf_free(&errBuf); return GIT_PASSTHROUGH; } git_buf_free(&errBuf); return 0; }
static void command_handler (aeEventLoop * el, int fd, void *data, int mask) { int ret; workerState *ws = (workerState *) data; simpleBuf *sb = &ws->cin; char *cp; int is_quit = 0; int i; ret = sb_read (sb, fd); // master quits this fd instead assert (ret != -1); cp = sb->buf; while (!is_quit && sb->cp - cp >= sizeof (workerCmd *)) { workerCmd *cmd = NULL; memcpy ((char *) &cmd, cp, sizeof (workerCmd *)); switch (cmd->command) { case CMD_SIZE: ws->size = cmd->ival; cmd->ret = 0; break; case CMD_TPS: ws->tps = cmd->ival; cmd->ret = 0; break; case CMD_START: cmd->ret = command_start (ws, cmd->ebuf, sizeof (cmd->ebuf)); break; case CMD_STOP: free_connection (ws, 0); cmd->ret = 0; break; case CMD_STAT: cmd->num_rqst = ws->num_rqst; cmd->num_resp = ws->num_resp; cmd->num_reconn = ws->num_reconn; for (i = 0; i < MAX_HISTO; i++) { cmd->histo[i].count = ws->histo[i].count; cmd->histo[i].sum = ws->histo[i].sum; } cmd->ret = 0; break; case CMD_QUIT: free_connection (ws, 0); aeStop (ws->el); cmd->ret = 0; is_quit = 1; break; default: fprintf (stdout, "-ERR invalid command:%d\n", cmd->command); abort (); } write (ws->arg->wfd, "k", 1); cp += sizeof (workerCmd *); } memmove (sb->buf, cp, sb->cp - cp); sb->cp = sb->buf + (sb->cp - cp); }
static int _git_ssh_setup_tunnel( ssh_subtransport *t, const char *url, const char *gitCmd, git_smart_subtransport_stream **stream) { char *host = NULL, *port = NULL, *path = NULL, *user = NULL, *pass = NULL; size_t i; ssh_stream *s; wchar_t *ssh = t->sshtoolpath; wchar_t *wideParams = NULL; wchar_t *cmd = NULL; git_buf params = GIT_BUF_INIT; int isPutty; size_t length; *stream = NULL; if (ssh_stream_alloc(t, url, gitCmd, stream) < 0) { giterr_set_oom(); return -1; } s = (ssh_stream *)*stream; for (i = 0; i < ARRAY_SIZE(ssh_prefixes); ++i) { const char *p = ssh_prefixes[i]; if (!git__prefixcmp(url, p)) { if (extract_url_parts(&host, &port, &path, &user, &pass, url, NULL) < 0) goto on_error; goto post_extract; } } if (git_ssh_extract_url_parts(&host, &user, url) < 0) goto on_error; post_extract: if (!ssh) { giterr_set(GITERR_SSH, "No GIT_SSH tool configured"); goto on_error; } isPutty = wcstristr(ssh, L"plink"); if (port) { if (isPutty) git_buf_printf(¶ms, " -P %s", port); else git_buf_printf(¶ms, " -p %s", port); } if (isPutty && !wcstristr(ssh, L"tortoiseplink")) { git_buf_puts(¶ms, " -batch"); } if (user) git_buf_printf(¶ms, " %s@%s ", user, host); else git_buf_printf(¶ms, " %s ", host); if (gen_proto(¶ms, s->cmd, s->url)) goto on_error; if (git_buf_oom(¶ms)) { giterr_set_oom(); goto on_error; } if (git__utf8_to_16_alloc(&wideParams, params.ptr) < 0) { giterr_set_oom(); goto on_error; } git_buf_free(¶ms); length = wcslen(ssh) + wcslen(wideParams) + 3; cmd = git__calloc(length, sizeof(wchar_t)); if (!cmd) { giterr_set_oom(); goto on_error; } wcscat_s(cmd, length, L"\""); wcscat_s(cmd, length, ssh); wcscat_s(cmd, length, L"\""); wcscat_s(cmd, length, wideParams); if (command_start(cmd, &s->commandHandle, t->pEnv, isPutty ? CREATE_NEW_CONSOLE : DETACHED_PROCESS)) goto on_error; git__free(wideParams); git__free(cmd); t->current_stream = s; git__free(host); git__free(port); git__free(path); git__free(user); git__free(pass); return 0; on_error: t->current_stream = NULL; if (*stream) ssh_stream_free(*stream); git_buf_free(¶ms); if (wideParams) git__free(wideParams); if (cmd) git__free(cmd); git__free(host); git__free(port); git__free(user); git__free(pass); return -1; }