int main(int argc, char* argv[]) { try { initialise_program_options(argc,argv); if (get_program_options()->helpMode()) std::cout << get_program_options(); else if (get_program_options()->versionMode()) std::cout << get_program_version() << "\n"; else { run(argc,argv); TMPROF_PRINT_TO_FILE(get_program_name() + "_TMPROF.html",true); } } catch(std::exception const& e) { try { save_crash_report(e.what()); } catch (...) {} return -1; } catch(...) { try { save_crash_report("Unknown exception was thrown."); } catch (...) {} return -2; } return 0; }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ int main(int argc, char **argv) { progname = get_program_name(argv[0]); parse_commandline(argc, argv); ja_load_config(CONFIG_FILE); START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT); exit(SUCCEED); }
/****************************************************************************** * * * Function: main * * * * Purpose: executes proxy processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { ZBX_TASK_EX t = {ZBX_TASK_START}; char ch; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (SUCCEED != parse_rtc_options(zbx_optarg, daemon_type, &t.flags)) exit(EXIT_FAILURE); t.task = ZBX_TASK_RUNTIME_CONTROL; break; case 'h': help(); exit(EXIT_SUCCESS); break; case 'V': version(); exit(EXIT_SUCCESS); break; default: usage(); exit(EXIT_FAILURE); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_RUNTIME_CONTROL == t.task) exit(SUCCEED == zbx_sigusr_send(t.flags) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER); }
/****************************************************************************** * * * Function: main * * * * Purpose: executes proxy processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { zbx_task_t task = ZBX_TASK_START; char ch; progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD)) task = ZBX_TASK_CONFIG_CACHE_RELOAD; else { printf("invalid runtime control option: %s\n", zbx_optarg); exit(EXIT_FAILURE); } break; case 'h': help(); exit(-1); break; case 'V': version(); exit(-1); break; default: usage(); exit(-1); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_CONFIG_CACHE_RELOAD == task) exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif return daemon_start(CONFIG_ALLOW_ROOT); }
/* Generate an HTML table row for process PID. The return * value is a pointer to a buffer that the caller must * deallocate with free, or NULL if an error occurs. */ static char* format_process_info(pid_t pid) { int rval; uid_t uid; gid_t gid; char* user_name; char* group_name; int rss; char* program_name; size_t result_length; char* result; /* Obtain the process's user and group IDs. */ rval = get_uid_gid(pid, &uid, &gid); if (rval != 0) { return NULL; } /* Obtain the process's RSS. */ rss = get_rss(pid); if (rss == -1) { return NULL; } /* Obtain the process's program name. */ program_name = get_program_name(pid); if (program_name == NULL) { return NULL; } /* Convert user and group IDs to corresponding names. */ user_name = get_user_name(uid); group_name = get_group_name(gid); /* Comput the length of the string we'll need to hold the * result, and allocate memory to hold it. */ result_length = strlen(program_name) + strlen(user_name) + strlen(group_name) + 128; result = (char*) xmalloc(result_length); /* Format the result. */ snprintf(result, result_length, " <tr><td align=\"right\">%d</td>" "<td><tt>%s</tt></td><td>%s</td>" "<td>%s</td><td align=\"right\">%d</td></tr>\n", (int)pid, program_name, user_name, group_name, rss); /* Clean up. */ free(program_name); free(user_name); free(group_name); /* All done. */ return result; }
static void print_version(void) { u_fprintf(u_stdout, "%S: Version 1.0, 3-21-2014 - copyright (C) Oly Project\n", get_program_name()); u_fprintf(u_stdout, "\tLicensed according to the terms of the GNU general public\n"); u_fprintf(u_stdout, "\tlicense, version 2 or (at your option) any later version.\n"); u_fprintf(u_stdout, "\tThis program is provided in the hopes that it will be useful, but\n"); u_fprintf(u_stdout, "\tWITHOUT ANY WARRANTY, to the extent permitted by law.\n\n"); u_fprintf(u_stdout, "\tVisit %s for precise details on authorship.\n", PACKAGE_URL); }
int main(int argc, char **argv) { int trigger_fd; struct trigger_connect_params params; int local_fd[3], remote_fd[3]; int i; char *abs_exec_path; if (argc < 4) { fprintf(stderr, "usage: %s target_vmname program_ident local_program [local program arguments]\n", argv[0]); exit(1); } trigger_fd = open(QREXEC_AGENT_TRIGGER_PATH, O_WRONLY); if (trigger_fd < 0) { perror("open QREXEC_AGENT_TRIGGER_PATH"); exit(1); } for (i = 0; i < 3; i++) { local_fd[i] = connect_unix_socket(); read(local_fd[i], &remote_fd[i], sizeof(remote_fd[i])); if (i != 2 || getenv("PASS_LOCAL_STDERR")) { char *env; asprintf(&env, "SAVED_FD_%d=%d", i, dup(i)); putenv(env); dup2(local_fd[i], i); close(local_fd[i]); } } memset(¶ms, 0, sizeof(params)); strncpy(params.exec_index, argv[2], sizeof(params.exec_index)); strncpy(params.target_vmname, argv[1], sizeof(params.target_vmname)); snprintf(params.process_fds.ident, sizeof(params.process_fds.ident), "%d %d %d", remote_fd[0], remote_fd[1], remote_fd[2]); write(trigger_fd, ¶ms, sizeof(params)); close(trigger_fd); abs_exec_path = strdup(argv[3]); argv[3] = get_program_name(argv[3]); execv(abs_exec_path, argv + 3); perror("execv"); return 1; }
bool self_uninstall() { bool ret; char pname[MAX_PATH]; struct installer inst; if (!get_program_name(pname, MAX_PATH)) return false; DEBUG(LOG_DEFAULT, "progname is %s\n", pname); installer_init(&inst, pname); ret = installer_uninstall(&inst); installer_clear(&inst); return ret; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { struct tm *tm; struct timeval tv; int ms; char ch = '\0'; progname = get_program_name(argv[0]); /* parse the command-line */ while ((char) EOF != (ch = (char) zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'h': help_jobarg(); exit(-1); break; case 'V': version_jobarg(); exit(-1); break; default: usage(); exit(-1); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/jobarg_server.conf"); zbx_load_config(); gettimeofday(&tv, NULL); tm = localtime(&tv.tv_sec); ms = (int)(tv.tv_usec / 1000); zbx_snprintf(serverid, sizeof(serverid), "%04d%02d%02d%02d%02d%02d%03d", 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, ms); return daemon_start(CONFIG_ALLOW_ROOT); }
bool self_install() { struct installer inst; char home[MAX_PATH]; char pname[MAX_PATH]; DEBUG(LOG_DEFAULT, "installation init\n"); if (!get_program_name(pname, MAX_PATH)) return false; DEBUG(LOG_DEFAULT, "progname is %s\n", pname); installer_init(&inst, pname); if (installer_get_target_path(&inst, home, sizeof(home))) return false; installer_install(&inst, home); installer_clear(&inst); return true; }
int main(int argc, char **argv) { char ch; int task = ZBX_TASK_START; char *TEST_METRIC = NULL; zbx_sock_t s_in; zbx_sock_t s_out; int ret; char **value, *command; AGENT_RESULT result; progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(FAIL); break; case 'V': version(); #ifdef _AIX tl_version(); #endif exit(FAIL); break; case 'p': if (task == ZBX_TASK_START) task = ZBX_TASK_PRINT_SUPPORTED; break; case 't': if (task == ZBX_TASK_START) { task = ZBX_TASK_TEST_METRIC; TEST_METRIC = strdup(zbx_optarg); } break; default: usage(); exit(FAIL); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = DEFAULT_CONFIG_FILE; /* load configuration */ if (ZBX_TASK_PRINT_SUPPORTED == task || ZBX_TASK_TEST_METRIC == task) zbx_load_config(ZBX_CFG_FILE_OPTIONAL); else zbx_load_config(ZBX_CFG_FILE_REQUIRED); /* metrics should be initialized before loading user parameters */ init_metrics(); /* user parameters */ load_user_parameters(CONFIG_USER_PARAMETERS); /* aliases */ load_aliases(CONFIG_ALIASES); zbx_free_config(); /* do not create debug files */ zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL); switch (task) { case ZBX_TASK_TEST_METRIC: case ZBX_TASK_PRINT_SUPPORTED: if (ZBX_TASK_TEST_METRIC == task) test_parameter(TEST_METRIC); else test_parameters(); zabbix_close_log(); free_metrics(); alias_list_free(); exit(SUCCEED); break; default: /* do nothing */ break; } signal(SIGINT, child_signal_handler); signal(SIGTERM, child_signal_handler); signal(SIGQUIT, child_signal_handler); signal(SIGALRM, child_signal_handler); alarm(CONFIG_TIMEOUT); zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin)); zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout)); if (SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0))) { if (SUCCEED == (ret = zbx_tcp_recv(&s_in, &command))) { zbx_rtrim(command, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command); init_result(&result); process(command, 0, &result); if (NULL == (value = GET_TEXT_RESULT(&result))) value = GET_MSG_RESULT(&result); if (NULL != value) { zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value); ret = zbx_tcp_send(&s_out, *value); } free_result(&result); } if (FAIL == ret) zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror()); } fflush(stdout); alarm(0); zabbix_close_log(); free_metrics(); alias_list_free(); return SUCCEED; }
/*--------------------------------------------------------------------------------------------------------------------*/ int main (int argc, char **argv) { params_t *par = 0; osr_err_code err = OSR_OK; osr_expert *expert = 0; int parse_result = 0; par = params_create(); parse_result = parse_command_line (argc, argv, par); if (parse_result) { params_destroy(par); if (LEARN_USAGE_ERR_CODE == parse_result) { print_usage(get_program_name(argv[0])); return 0; } printf ("Error: can't parse command line.\n"); return 1; } if (par->print_usage) printf ("libosr version %s\n", osr_version_text() ); if (par->print_ver) printf ("libosr version %s\n", osr_version_text() ); if (par->separate_html) { err = osr_separate_html (par->separate_html, par->html_separate_step); params_destroy(par); if (OSR_OK == err) return 0; else return 1; } if ( OSR_OK == err ) { expert = osr_expert_create(); if (0 == expert) { if (!par->no_print_err) printf ("Error: OSR initializing error, %s.\n", osr_get_error_text(err)); err = OSR_INVALID_DATA; } if (par->ignore_filter) { osr_filter unlim; osr_get_default_filter(&unlim); unlim.min_symbols_in_word=1, unlim.max_symbols_in_word=1000, unlim.min_words_in_line=1, unlim.min_lines_in_text=1, unlim.min_text_percentage=1; osr_set_filter(expert, &unlim); } } if ( OSR_OK == err ) { unsigned int last_frame_index = 0; err = osr_process_file(expert, par->file_name, par->frame_index, &last_frame_index); if ( OSR_OK != err ) if (!par->no_print_err) { if ( OSR_WRONG_FRAME_INDEX == err ) printf ("Error: OSR can't get frame %d of animated image." " It must be [0;%d]. File %s.", par->frame_index, last_frame_index, par->file_name); else printf ("Error: OSR can't process image (file %s), %s.\n", par->file_name, osr_get_error_text(err)); } } if ( OSR_OK == err ) { if (par->print_verdict) { char verdict = 0; err = osr_get_verdict(expert, &verdict); if (OSR_OK == err) printf ("VERDICT: %s\n", verdict ? "text" : "not text"); else if (!par->no_print_err) printf ("Error: OSR can't get verdict (file %s), %s.\n", par->file_name, osr_get_error_text(err)); } } if ( OSR_OK == err ) { if (par->print_info) { size_t symbols_count = 0, words_count = 0, lines_count = 0, words_pixels_percentage = 0; if (OSR_OK == err) err = osr_get_symbols_count(expert, &symbols_count); if (OSR_OK == err) err = osr_get_words_count (expert, &words_count); if (OSR_OK == err) err = osr_get_lines_count (expert, &lines_count); if (OSR_OK == err) err = osr_get_words_pixels_percentage (expert, &words_pixels_percentage); if (OSR_OK == err) { printf ("TEXT INFO:\n"); if (par->frame_index > 0) printf ( "frame index = %d\n", par->frame_index); printf ("good symbols count = %d\n" "good words count = %d\n" "good lines count = %d\n" "good pixels percentage = %d%%\n", symbols_count, words_count, lines_count, words_pixels_percentage); } else if (!par->no_print_err) printf ("Error: OSR can't get text properties (file %s), %s.\n", par->file_name, osr_get_error_text(err)); } } if ( OSR_OK == err ) { if (par->print_signature) { char gsg7[33]; err = osr_get_GSG7_signature(expert, gsg7); if (OSR_OK == err) { if ( 0 != gsg7[0] ) printf ("GSG7 %.*s\n", 32, gsg7); } else if (!par->no_print_err) printf ("Error: OSR can't get GSG7 (file %s), %s.\n", par->file_name, osr_get_error_text(err)); } } if ( OSR_OK == err ) { if (par->dump_image || par->dump_lines || par->dump_symbols || par->dump_words) { char dump_name [500]; get_dump_name (dump_name, 500, par->file_name); err = osr_get_dump (expert, dump_name, par->dump_image, par->dump_symbols, par->dump_lines, par->dump_words); if (OSR_OK != err) if (!par->no_print_err) printf ("Error: OSR can't get dump of file %s, %s.\n", par->file_name, osr_get_error_text(err)); } } if (par->html_report) { char dump_name [500]; get_dump_name (dump_name, 500, par->file_name); err = osr_get_html_report(expert, par->file_name, dump_name, par->html_report, err, par->frame_index); if (OSR_OK != err) if (!par->no_print_err) printf ("Error: OSR can't get html-report (image file %s), %s.\n", par->file_name, osr_get_error_text(err)); } if (OSR_OK == err ) if (par->win_group) { char gsg7[33]; err = osr_get_GSG7_signature(expert, gsg7); if (OSR_OK == err) { if (0 == gsg7[0]) strncpy (gsg7, "_not_text", 32); printf ("@ if not exist %s mkdir %s\n" "@ move \"%s\" %s\n", gsg7, gsg7, par->file_name, gsg7); } else if (!par->no_print_err) printf ("Error: OSR can't get GSG7 (file %s), %s.\n", par->file_name, osr_get_error_text(err)); } if (par) params_destroy(par); if (expert) osr_expert_destroy(expert); if (OSR_OK == err) return 0; return 1; }
static void save_crash_report(std::string const& crash_message) { std::cout << "ERROR: " << crash_message << "\n"; boost::filesystem::ofstream ofile( get_program_name() + "_CRASH.txt", std::ios_base::app ); ofile << crash_message << "\n"; }
int main(int argc, char **argv) { ZBX_TASK_EX t; #ifdef _WINDOWS int ret; /* Provide, so our process handles errors instead of the system itself. */ /* Attention!!! */ /* The system does not display the critical-error-handler message box. */ /* Instead, the system sends the error to the calling process.*/ SetErrorMode(SEM_FAILCRITICALERRORS); #endif #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif memset(&t, 0, sizeof(t)); t.task = ZBX_TASK_START; progname = get_program_name(argv[0]); parse_commandline(argc, argv, &t); import_symbols(); /* this is needed to set default hostname in zbx_load_config() */ init_metrics(); switch (t.task) { case ZBX_TASK_SHOW_USAGE: usage(); exit(EXIT_FAILURE); break; #ifdef _WINDOWS case ZBX_TASK_INSTALL_SERVICE: case ZBX_TASK_UNINSTALL_SERVICE: case ZBX_TASK_START_SERVICE: case ZBX_TASK_STOP_SERVICE: zbx_load_config(ZBX_CFG_FILE_REQUIRED); zbx_free_config(); if (t.flags & ZBX_TASK_FLAG_MULTIPLE_AGENTS) { zbx_snprintf(ZABBIX_SERVICE_NAME, sizeof(ZABBIX_SERVICE_NAME), "%s [%s]", APPLICATION_NAME, CONFIG_HOSTNAME); zbx_snprintf(ZABBIX_EVENT_SOURCE, sizeof(ZABBIX_EVENT_SOURCE), "%s [%s]", APPLICATION_NAME, CONFIG_HOSTNAME); } ret = zbx_exec_service_task(argv[0], &t); free_metrics(); exit(ret); break; #endif case ZBX_TASK_TEST_METRIC: case ZBX_TASK_PRINT_SUPPORTED: zbx_load_config(ZBX_CFG_FILE_OPTIONAL); #ifdef _WINDOWS init_perf_collector(0); load_perf_counters(CONFIG_PERF_COUNTERS); #else zbx_set_common_signal_handlers(); #endif #ifndef _WINDOWS if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 0)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } #endif load_user_parameters(CONFIG_USER_PARAMETERS); load_aliases(CONFIG_ALIASES); zbx_free_config(); if (ZBX_TASK_TEST_METRIC == t.task) test_parameter(TEST_METRIC); else test_parameters(); #ifdef _WINDOWS free_perf_collector(); /* cpu_collector must be freed before perf_collector is freed */ #endif #ifndef _WINDOWS unload_modules(); #endif free_metrics(); alias_list_free(); exit(SUCCEED); break; default: zbx_load_config(ZBX_CFG_FILE_REQUIRED); break; } START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT); exit(SUCCEED); }
static void usage(void) { u_fprintf(u_stdout, "%S: [OPTIONS]\n", get_program_name()); }
stack_trace_::stack_trace_() { #if defined(SYSTEM_UNIX) && !defined(SYSTEM_MAC) std::string programName = get_program_name(); std::string pid = get_pid(); _stack_trace.push_back(std::string("\t[trace] back trace for ") + programName + " (" + pid + "):"); // create a pipe to read gdb's output int pipefds[2]; int res = pipe(pipefds); if (res < 0) return; // create a pipe to be used as a barrier int barrierfds[2]; res = pipe(barrierfds); if (res < 0) return; // fork int childPid = fork(); // child: if (!childPid) { LOG_ALL(tracelog) << "[child] waiting for parent process to allow attaching" << std::endl; // close writing end of barrier pipe close(barrierfds[1]); // wait until parent closes barrier pipe char buf[1]; while (read(barrierfds[0], buf, sizeof(buf)) > 0) LOG_ALL(tracelog) << "[child] " << buf[0] << std::endl; LOG_ALL(tracelog) << "[child] parent process closed barrier pipe, preparing gdb invocation" << std::endl; // close barrier pipe close(barrierfds[0]); // close reading end of output pipe close(pipefds[0]); // redirect stdout and stderr to output pipe dup2(pipefds[1], 1); dup2(pipefds[1], 2); // close writing end of pipe (_we_ don't need it any longer) close(pipefds[1]); // start gdb execlp("gdb", "gdb", "--batch", "-n", "-ex", "bt full", programName.c_str(), pid.c_str(), NULL); // parent: } else { LOG_ALL(tracelog) << "[parent] allowing child to attach" << std::endl; // allow our child process to attach prctl(PR_SET_PTRACER, childPid, 0, 0, 0); LOG_ALL(tracelog) << "[parent] closing barrier pipe" << std::endl; // close barrier pipe to let child proceed close(barrierfds[0]); close(barrierfds[1]); LOG_ALL(tracelog) << "[parent] barrier pipe closed" << std::endl; // close the write end of pipe close(pipefds[1]); // capture child's output std::string output; // read the whole output of gdb char buf[1]; size_t n; while ((n = read(pipefds[0], buf, sizeof(buf)))) output += std::string(buf, n); LOG_ALL(tracelog) << "[parent] end of pipe; I read: " << std::endl << output << std::endl; // split it at newline characters std::stringstream oss(output); std::string line; // ignore every line until '#0 ...' while (std::getline(oss, line) && (line.size() < 2 || (line[0] != '#' && line[1] != '0'))); // copy remaining lines to stack trace do { if (line.size() > 0 && line[0] != '\n') _stack_trace.push_back(std::string("\t[trace] ") + line); } while (std::getline(oss, line)); // wait for the child to finish waitpid(childPid, NULL, 0); } #endif // SYSTEM_UNIX && !SYSTEM_MAC return; }
/****************************************************************************** * * * Function: main * * * * Purpose: main function * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ int main(int argc, char **argv) { int i, ret = SUCCEED; char *host = NULL, *key = NULL, *source_ip = NULL, ch; unsigned short opt_count[256] = {0}, port = ZBX_DEFAULT_AGENT_PORT; #if defined(_WINDOWS) char *error = NULL; #endif #if !defined(_WINDOWS) && (defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)) if (SUCCEED != zbx_coredump_disable()) { zbx_error("cannot disable core dump, exiting..."); exit(EXIT_FAILURE); } #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { opt_count[(unsigned char)ch]++; switch (ch) { case 'k': if (NULL == key) key = zbx_strdup(NULL, zbx_optarg); break; case 'p': port = (unsigned short)atoi(zbx_optarg); break; case 's': if (NULL == host) host = zbx_strdup(NULL, zbx_optarg); break; case 'I': if (NULL == source_ip) source_ip = zbx_strdup(NULL, zbx_optarg); break; case 'h': help(); exit(EXIT_SUCCESS); break; case 'V': version(); exit(EXIT_SUCCESS); break; #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) case '1': CONFIG_TLS_CONNECT = zbx_strdup(CONFIG_TLS_CONNECT, zbx_optarg); break; case '2': CONFIG_TLS_CA_FILE = zbx_strdup(CONFIG_TLS_CA_FILE, zbx_optarg); break; case '3': CONFIG_TLS_CRL_FILE = zbx_strdup(CONFIG_TLS_CRL_FILE, zbx_optarg); break; case '4': CONFIG_TLS_SERVER_CERT_ISSUER = zbx_strdup(CONFIG_TLS_SERVER_CERT_ISSUER, zbx_optarg); break; case '5': CONFIG_TLS_SERVER_CERT_SUBJECT = zbx_strdup(CONFIG_TLS_SERVER_CERT_SUBJECT, zbx_optarg); break; case '6': CONFIG_TLS_CERT_FILE = zbx_strdup(CONFIG_TLS_CERT_FILE, zbx_optarg); break; case '7': CONFIG_TLS_KEY_FILE = zbx_strdup(CONFIG_TLS_KEY_FILE, zbx_optarg); break; case '8': CONFIG_TLS_PSK_IDENTITY = zbx_strdup(CONFIG_TLS_PSK_IDENTITY, zbx_optarg); break; case '9': CONFIG_TLS_PSK_FILE = zbx_strdup(CONFIG_TLS_PSK_FILE, zbx_optarg); break; #else case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': zbx_error("TLS parameters cannot be used: 'zabbix_get' was compiled without TLS" " support"); exit(EXIT_FAILURE); break; #endif default: usage(); exit(EXIT_FAILURE); break; } } #if defined(_WINDOWS) if (SUCCEED != zbx_socket_start(&error)) { zbx_error(error); zbx_free(error); exit(EXIT_FAILURE); } #endif if (NULL == host || NULL == key) { usage(); ret = FAIL; } /* every option may be specified only once */ for (i = 0; NULL != longopts[i].name; i++) { ch = longopts[i].val; if (1 < opt_count[(unsigned char)ch]) { if (NULL == strchr(shortopts, ch)) zbx_error("option \"--%s\" specified multiple times", longopts[i].name); else zbx_error("option \"-%c\" or \"--%s\" specified multiple times", ch, longopts[i].name); ret = FAIL; } } if (FAIL == ret) goto out; /* Parameters which are not option values are invalid. The check relies on zbx_getopt_internal() which */ /* always permutes command line arguments regardless of POSIXLY_CORRECT environment variable. */ if (argc > zbx_optind) { for (i = zbx_optind; i < argc; i++) zbx_error("invalid parameter \"%s\"", argv[i]); ret = FAIL; } if (FAIL == ret) { printf("Try '%s --help' for more information.\n", progname); goto out; } if (NULL != CONFIG_TLS_CONNECT || NULL != CONFIG_TLS_CA_FILE || NULL != CONFIG_TLS_CRL_FILE || NULL != CONFIG_TLS_SERVER_CERT_ISSUER || NULL != CONFIG_TLS_SERVER_CERT_SUBJECT || NULL != CONFIG_TLS_CERT_FILE || NULL != CONFIG_TLS_KEY_FILE || NULL != CONFIG_TLS_PSK_IDENTITY || NULL != CONFIG_TLS_PSK_FILE) { #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) zbx_tls_validate_config(); if (ZBX_TCP_SEC_UNENCRYPTED != configured_tls_connect_mode) { #if defined(_WINDOWS) zbx_tls_init_parent(); #endif zbx_tls_init_child(); } #endif } #if !defined(_WINDOWS) signal(SIGINT, get_signal_handler); signal(SIGTERM, get_signal_handler); signal(SIGQUIT, get_signal_handler); signal(SIGALRM, get_signal_handler); signal(SIGPIPE, get_signal_handler); #endif ret = get_value(source_ip, host, port, key); out: zbx_free(host); zbx_free(key); zbx_free(source_ip); #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) if (ZBX_TCP_SEC_UNENCRYPTED != configured_tls_connect_mode) { zbx_tls_free(); #if defined(_WINDOWS) zbx_tls_library_deinit(); #endif } #endif #if defined(_WINDOWS) while (0 == WSACleanup()) ; #endif return SUCCEED == ret ? EXIT_SUCCESS : EXIT_FAILURE; }
int main(int argc, char **argv) { char ch; int task = ZBX_TASK_START; char *TEST_METRIC = NULL; zbx_sock_t s_in; zbx_sock_t s_out; int ret; char **value, *command; AGENT_RESULT result; memset(&result, 0, sizeof(AGENT_RESULT)); progname = get_program_name(argv[0]); /* Parse the command-line. */ while ((ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)) != (char)EOF) switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(-1); break; case 'V': version(); #ifdef _AIX tl_version(); #endif /* _AIX */ exit(-1); break; case 'p': if (task == ZBX_TASK_START) task = ZBX_TASK_PRINT_SUPPORTED; break; case 't': if (task == ZBX_TASK_START) { task = ZBX_TASK_TEST_METRIC; TEST_METRIC = strdup(zbx_optarg); } break; default: task = ZBX_TASK_SHOW_USAGE; break; } if (CONFIG_FILE == NULL) CONFIG_FILE = DEFAULT_CONFIG_FILE; init_metrics(); if (ZBX_TASK_START == task) { load_config(); load_user_parameters(0); } /* Do not create debug files */ zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL); switch (task) { case ZBX_TASK_PRINT_SUPPORTED: load_user_parameters(1); test_parameters(); exit(-1); break; case ZBX_TASK_TEST_METRIC: load_user_parameters(1); test_parameter(TEST_METRIC, PROCESS_TEST); exit(-1); break; case ZBX_TASK_SHOW_USAGE: usage(); exit(-1); break; } signal(SIGINT, child_signal_handler); signal(SIGTERM, child_signal_handler); signal(SIGQUIT, child_signal_handler); signal(SIGALRM, child_signal_handler); alarm(CONFIG_TIMEOUT); zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin)); zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout)); if( SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)) ) { if( SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)) ) { zbx_rtrim(command, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command); init_result(&result); process(command, 0, &result); if( NULL == (value = GET_TEXT_RESULT(&result)) ) value = GET_MSG_RESULT(&result); if(value) { zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value); ret = zbx_tcp_send(&s_out, *value); } free_result(&result); } if( FAIL == ret ) { zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror()); } } fflush(stdout); free_metrics(); alias_list_free(); alarm(0); zabbix_close_log(); return SUCCEED; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { zbx_task_t task = ZBX_TASK_START; char ch = '\0'; int nodeid = 0; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD)) task = ZBX_TASK_CONFIG_CACHE_RELOAD; else { printf("invalid runtime control option: %s\n", zbx_optarg); exit(EXIT_FAILURE); } break; case 'h': help(); exit(-1); break; case 'n': nodeid = (NULL == zbx_optarg ? 0 : atoi(zbx_optarg)); task = ZBX_TASK_CHANGE_NODEID; break; case 'V': version(); exit(-1); break; default: usage(); exit(-1); break; } } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_server.conf"); /* required for simple checks */ init_metrics(); zbx_load_config(); if (ZBX_TASK_CONFIG_CACHE_RELOAD == task) exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE); #ifdef HAVE_OPENIPMI init_ipmi_handler(); #endif switch (task) { case ZBX_TASK_CHANGE_NODEID: exit(SUCCEED == change_nodeid(nodeid) ? EXIT_SUCCESS : EXIT_FAILURE); break; default: break; } return daemon_start(CONFIG_ALLOW_ROOT); }
#include <netviewer/program_info.hpp> #include <netviewer/program_options.hpp> #include <utility/timeprof.hpp> #include <utility/log.hpp> #include <boost/filesystem.hpp> #include <boost/filesystem/fstream.hpp> #include <stdexcept> #include <iostream> LOG_INITIALISE(get_program_name() + "_LOG",true,true,warning) extern void run(int argc, char* argv[]); static void save_crash_report(std::string const& crash_message) { std::cout << "ERROR: " << crash_message << "\n"; boost::filesystem::ofstream ofile( get_program_name() + "_CRASH.txt", std::ios_base::app ); ofile << crash_message << "\n"; } int main(int argc, char* argv[]) { try { initialise_program_options(argc,argv); if (get_program_options()->helpMode()) std::cout << get_program_options(); else if (get_program_options()->versionMode()) std::cout << get_program_version() << "\n"; else
int main(int argc, char **argv) { FILE *in; char in_line[MAX_BUFFER_LEN], hostname[MAX_STRING_LEN], key[MAX_STRING_LEN], key_value[MAX_BUFFER_LEN], clock[32]; int total_count = 0, succeed_count = 0, buffer_count = 0, read_more = 0, ret = SUCCEED; double last_send = 0; const char *p; zbx_thread_args_t thread_args; ZBX_THREAD_SENDVAL_ARGS sentdval_args; progname = get_program_name(argv[0]); parse_commandline(argc, argv); zbx_load_config(CONFIG_FILE); zabbix_open_log(LOG_TYPE_UNDEFINED, CONFIG_LOG_LEVEL, NULL); if (NULL == ZABBIX_SERVER) { zabbix_log(LOG_LEVEL_WARNING, "'Server' parameter required"); goto exit; } if (0 == ZABBIX_SERVER_PORT) ZABBIX_SERVER_PORT = ZBX_DEFAULT_SERVER_PORT; if (MIN_ZABBIX_PORT > ZABBIX_SERVER_PORT) { zabbix_log(LOG_LEVEL_WARNING, "Incorrect port number [%d]. Allowed [%d:%d]", (int)ZABBIX_SERVER_PORT, (int)MIN_ZABBIX_PORT, (int)MAX_ZABBIX_PORT); goto exit; } thread_args.thread_num = 0; thread_args.args = &sentdval_args; sentdval_args.server = ZABBIX_SERVER; sentdval_args.port = ZABBIX_SERVER_PORT; zbx_json_init(&sentdval_args.json, ZBX_JSON_STAT_BUF_LEN); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA, ZBX_JSON_TYPE_STRING); zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA); if (INPUT_FILE) { if (0 == strcmp(INPUT_FILE, "-")) { in = stdin; if (1 == REAL_TIME) { /* set line buffering on stdin */ setvbuf(stdin, (char *)NULL, _IOLBF, 0); } } else if (NULL == (in = fopen(INPUT_FILE, "r")) ) { zabbix_log(LOG_LEVEL_WARNING, "cannot open [%s]: %s", INPUT_FILE, zbx_strerror(errno)); ret = FAIL; goto exit; } while (NULL != fgets(in_line, sizeof(in_line), in) && SUCCEED == ret) /* <hostname> <key> [<timestamp>] <value> */ { total_count++; /* also used as inputline */ zbx_rtrim(in_line, "\r\n"); p = in_line; if ('\0' == *p || NULL == (p = get_string(p, hostname, sizeof(hostname))) || '\0' == *hostname) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Hostname' required", total_count); continue; } if (0 == strcmp(hostname, "-")) { if (NULL == ZABBIX_HOSTNAME) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] '-' encountered as 'Hostname', " "but no default hostname was specified", total_count); continue; } else zbx_strlcpy(hostname, ZABBIX_HOSTNAME, sizeof(hostname)); } if ('\0' == *p || NULL == (p = get_string(p, key, sizeof(key))) || '\0' == *key) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key' required", total_count); continue; } if (1 == WITH_TIMESTAMPS) { if ('\0' == *p || NULL == (p = get_string(p, clock, sizeof(clock))) || '\0' == *clock) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Timestamp' required", total_count); continue; } } if ('\0' != *p && '"' != *p) zbx_strlcpy(key_value, p, sizeof(key_value)); else if ('\0' == *p || NULL == (p = get_string(p, key_value, sizeof(key_value))) || '\0' == *key_value) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key value' required", total_count); continue; } zbx_rtrim(key_value, "\r\n"); zbx_json_addobject(&sentdval_args.json, NULL); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, hostname, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, key, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, key_value, ZBX_JSON_TYPE_STRING); if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, atoi(clock)); zbx_json_close(&sentdval_args.json); succeed_count++; buffer_count++; if (stdin == in && 1 == REAL_TIME) { /* if there is nothing on standard input after 1/5 seconds, we send what we have */ /* otherwise, we keep reading, but we should send data at least once per second */ struct timeval tv; fd_set read_set; tv.tv_sec = 0; tv.tv_usec = 200000; FD_ZERO(&read_set); FD_SET(0, &read_set); /* stdin is file descriptor 0 */ if (-1 == (read_more = select(1, &read_set, NULL, NULL, &tv))) { zabbix_log(LOG_LEVEL_WARNING, "select() failed: %s", zbx_strerror(errno)); } else if (1 <= read_more) { if (0 == last_send) last_send = zbx_time(); else if (zbx_time() - last_send >= 1) read_more = 0; } } if (VALUES_MAX == buffer_count || (stdin == in && 1 == REAL_TIME && 0 >= read_more)) { zbx_json_close(&sentdval_args.json); if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL)); last_send = zbx_time(); ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); buffer_count = 0; zbx_json_clean(&sentdval_args.json); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA, ZBX_JSON_TYPE_STRING); zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA); } } zbx_json_close(&sentdval_args.json); if (0 != buffer_count) { if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL)); ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); } if (in != stdin) fclose(in); } else { total_count++; do /* try block simulation */ { if (NULL == ZABBIX_HOSTNAME) { zabbix_log(LOG_LEVEL_WARNING, "'Hostname' parameter required"); break; } if (NULL == ZABBIX_KEY) { zabbix_log(LOG_LEVEL_WARNING, "Key required"); break; } if (NULL == ZABBIX_KEY_VALUE) { zabbix_log(LOG_LEVEL_WARNING, "Key value required"); break; } zbx_json_addobject(&sentdval_args.json, NULL); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, ZABBIX_HOSTNAME, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, ZABBIX_KEY, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, ZABBIX_KEY_VALUE, ZBX_JSON_TYPE_STRING); zbx_json_close(&sentdval_args.json); succeed_count++; ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); } while(0); /* try block simulation */ } zbx_json_free(&sentdval_args.json); if (SUCCEED == ret) printf("sent: %d; skipped: %d; total: %d\n", succeed_count, (total_count - succeed_count), total_count); else printf("Sending failed. Use option -vv for more detailed output.\n"); exit: zabbix_close_log(); return ret; }
/****************************************************************************** * * * Function: main * * * * Purpose: executes server processes * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ int main(int argc, char **argv) { ZBX_TASK_EX t = {ZBX_TASK_START}; char ch, *error = NULL; int opt_c = 0, opt_r = 0; #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV) argv = setproctitle_save_env(argc, argv); #endif progname = get_program_name(argv[0]); /* parse the command-line */ while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) { switch (ch) { case 'c': opt_c++; if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg); break; case 'R': opt_r++; if (SUCCEED != parse_rtc_options(zbx_optarg, program_type, &t.data)) exit(EXIT_FAILURE); t.task = ZBX_TASK_RUNTIME_CONTROL; break; case 'h': help(); exit(EXIT_SUCCESS); break; case 'V': version(); exit(EXIT_SUCCESS); break; case 'f': t.flags |= ZBX_TASK_FLAG_FOREGROUND; break; default: usage(); exit(EXIT_FAILURE); break; } } /* every option may be specified only once */ if (1 < opt_c || 1 < opt_r) { if (1 < opt_c) zbx_error("option \"-c\" or \"--config\" specified multiple times"); if (1 < opt_r) zbx_error("option \"-R\" or \"--runtime-control\" specified multiple times"); exit(EXIT_FAILURE); } /* Parameters which are not option values are invalid. The check relies on zbx_getopt_internal() which */ /* always permutes command line arguments regardless of POSIXLY_CORRECT environment variable. */ if (argc > zbx_optind) { int i; for (i = zbx_optind; i < argc; i++) zbx_error("invalid parameter \"%s\"", argv[i]); exit(EXIT_FAILURE); } if (NULL == CONFIG_FILE) CONFIG_FILE = zbx_strdup(NULL, DEFAULT_CONFIG_FILE); /* required for simple checks */ init_metrics(); zbx_load_config(&t); if (ZBX_TASK_RUNTIME_CONTROL == t.task) exit(SUCCEED == zbx_sigusr_send(t.data) ? EXIT_SUCCESS : EXIT_FAILURE); zbx_initialize_events(); if (FAIL == zbx_ipc_service_init_env(CONFIG_SOCKET_PATH, &error)) { zbx_error("Cannot initialize IPC services: %s", error); zbx_free(error); exit(EXIT_FAILURE); } return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER, t.flags); }