int main(int argc, char* argv[]) { printf("[i] Start...\n"); register_signal_handlers(); // init Teleoperation teleop; if( teleop.init() ) { fprintf(stderr, "[!] Error: teleop init!\n"); return -1; } #if defined(USE_KEYBOARD_INPUT) && defined(LINUX) // Use termios to turn off line buffering termios term, cooked; tcgetattr(STDIN_FILENO, &term); memcpy(&cooked, &term, sizeof(term)); term.c_lflag &= ~(ICANON | ECHO); term.c_cc[VEOL] = 1; term.c_cc[VEOF] = 2; tcsetattr(STDIN_FILENO, TCSANOW, &term); setbuf(stdin, NULL); #endif while( !terminated ) { #if defined(USE_KEYBOARD_INPUT) int key = console::waitKey(30); if(key != 0 ) printf( "[i] Key: %c (%d)\n", key ,key ); if(key == 27) { //ESC break; } #endif //#if defined(USE_KEYBOARD_INPUT) // process teleop.make(); } //while( !terminated ) { printf("[i] End.\n"); return 0; }
void prepare_and_run_sampler(const unsigned long max_iterations, int append) { unsigned int n_beta = N_BETA; unsigned int i = 0; int n_swap = N_SWAP; mcmc ** chains = setup_chains(); debug("reading calibrations file") read_calibration_file(chains, n_beta); debug("opening dump files") mcmc_open_dump_files(chains[i], "-chain", i, (append == 1 ? "a" : "w")); #ifdef DUMP_ALL_CHAINS for (i = 1; i < n_beta; i++) { mcmc_open_dump_files(chains[i], "-chain", i, (append == 1 ? "a" : "w")); } #endif if (n_swap < 0) { n_swap = 2000 / n_beta; printf("automatic n_swap: %d\n", n_swap); } debug("running sampler") register_signal_handlers(); run_sampler(chains, n_beta, n_swap, max_iterations, (append == 1 ? "a" : "w")); debug("reporting") report((const mcmc **) chains, n_beta); for (i = 0; i < n_beta; i++) { mem_free(chains[i]->additional_data); if (i != 0) { /* this was reused, thus avoid double free */ set_data(chains[i], NULL); } chains[i] = mcmc_free(chains[i]); mem_free(chains[i]); } mem_free(chains); }
void basic_server_buffer<Document, Selector>::open(unsigned int port) { if(basic_buffer<Document, Selector>::is_open() ) { throw std::logic_error( "obby::basic_server_buffer::open:\n" "Server is already open" ); } basic_buffer<Document, Selector>::m_net.reset(new_net()); register_signal_handlers(); reopen_impl(port); // Clear previous documents and users basic_buffer<Document, Selector>::document_clear(); basic_buffer<Document, Selector>::m_user_table.clear(); basic_buffer<Document, Selector>::m_signal_sync_init.emit(0); basic_buffer<Document, Selector>::m_signal_sync_final.emit(); }
void basic_server_buffer<Document, Selector>::open(const std::string& session, unsigned int port) { // TODO: Close server when session deserialisation failed if(basic_buffer<Document, Selector>::is_open() ) { throw std::logic_error( "obby::basic_server_buffer::open:\n" "Server is already open" ); } // Open server basic_buffer<Document, Selector>::m_net.reset(new_net()); register_signal_handlers(); reopen_impl(port); // Deserialise file serialise::parser parser; parser.deserialise(session); // Clear previous documents and users basic_buffer<Document, Selector>::document_clear(); basic_buffer<Document, Selector>::m_user_table.clear(); basic_buffer<Document, Selector>::m_signal_sync_init.emit(0); if(parser.get_type() != "obby") throw serialise::error(_("File is not an obby document"), 1); // Get root object, verify that it is an obby session serialise::object& root = parser.get_root(); if(root.get_name() != "session") { throw serialise::error( _("File is not a stored obby session"), root.get_line() ); } serialise::attribute& version_attr = root.get_required_attribute("version"); // TODO: Check version for incompatibilites // TODO: Block higher version files // Check children for(serialise::object::child_iterator iter = root.children_begin(); iter != root.children_end(); ++ iter) { if(iter->get_name() == "user_table") { // Stored user table basic_buffer<Document, Selector>:: m_user_table.deserialise( *iter ); } else if(iter->get_name() == "chat") { // Stored chat history basic_buffer<Document, Selector>::m_chat.deserialise( *iter, basic_buffer<Document, Selector>::m_user_table ); } else if(iter->get_name() == "document") { // Stored document, load it base_document_info_type* info = new_document_info(*iter); // Add to list basic_buffer<Document, Selector>::document_add(*info); } else { // Unexpected child // TODO: unexpected_child_error format_string str(_("Unexpected child node: '%0%'") ); str << iter->get_name(); throw serialise::error(str.str(), iter->get_line() ); } } basic_buffer<Document, Selector>::m_signal_sync_final.emit(); }
static int cmd_save(const char *tuner_str, const char *filename) { if (hdhomerun_device_set_tuner_from_str(hd, tuner_str) <= 0) { fprintf(stderr, "invalid tuner number\n"); return -1; } FILE *fp; if (strcmp(filename, "null") == 0) { fp = NULL; } else if (strcmp(filename, "-") == 0) { fp = stdout; } else { fp = fopen(filename, "wb"); if (!fp) { fprintf(stderr, "unable to create file %s\n", filename); return -1; } } int ret = hdhomerun_device_stream_start(hd); if (ret <= 0) { fprintf(stderr, "unable to start stream\n"); if (fp && fp != stdout) { fclose(fp); } return ret; } register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler); struct hdhomerun_video_stats_t stats_old, stats_cur; hdhomerun_device_get_video_stats(hd, &stats_old); uint64_t next_progress = getcurrenttime() + 1000; while (!sigabort_flag) { uint64_t loop_start_time = getcurrenttime(); if (siginfo_flag) { fprintf(stderr, "\n"); cmd_save_print_stats(); siginfo_flag = FALSE; } size_t actual_size; uint8_t *ptr = hdhomerun_device_stream_recv(hd, VIDEO_DATA_BUFFER_SIZE_1S, &actual_size); if (!ptr) { msleep_approx(64); continue; } if (fp) { if (fwrite(ptr, 1, actual_size, fp) != actual_size) { fprintf(stderr, "error writing output\n"); return -1; } } if (loop_start_time >= next_progress) { next_progress += 1000; if (loop_start_time >= next_progress) { next_progress = loop_start_time + 1000; } /* Windows - indicate activity to suppress auto sleep mode. */ #if defined(__WINDOWS__) SetThreadExecutionState(ES_SYSTEM_REQUIRED); #endif /* Video stats. */ hdhomerun_device_get_video_stats(hd, &stats_cur); if (stats_cur.overflow_error_count > stats_old.overflow_error_count) { fprintf(stderr, "o"); } else if (stats_cur.network_error_count > stats_old.network_error_count) { fprintf(stderr, "n"); } else if (stats_cur.transport_error_count > stats_old.transport_error_count) { fprintf(stderr, "t"); } else if (stats_cur.sequence_error_count > stats_old.sequence_error_count) { fprintf(stderr, "s"); } else { fprintf(stderr, "."); } stats_old = stats_cur; fflush(stderr); } int32_t delay = 64 - (int32_t)(getcurrenttime() - loop_start_time); if (delay <= 0) { continue; } msleep_approx(delay); } if (fp) { fclose(fp); } hdhomerun_device_stream_stop(hd); fprintf(stderr, "\n"); fprintf(stderr, "-- Video statistics --\n"); cmd_save_print_stats(); return 0; }
static int cmd_scan(const char *tuner_str, const char *filename) { if (hdhomerun_device_set_tuner_from_str(hd, tuner_str) <= 0) { fprintf(stderr, "invalid tuner number\n"); return -1; } char *ret_error; if (hdhomerun_device_tuner_lockkey_request(hd, &ret_error) <= 0) { fprintf(stderr, "failed to lock tuner\n"); if (ret_error) { fprintf(stderr, "%s\n", ret_error); } return -1; } hdhomerun_device_set_tuner_target(hd, "none"); char *channelmap; if (hdhomerun_device_get_tuner_channelmap(hd, &channelmap) <= 0) { fprintf(stderr, "failed to query channelmap from device\n"); return -1; } const char *channelmap_scan_group = hdhomerun_channelmap_get_channelmap_scan_group(channelmap); if (!channelmap_scan_group) { fprintf(stderr, "unknown channelmap '%s'\n", channelmap); return -1; } if (hdhomerun_device_channelscan_init(hd, channelmap_scan_group) <= 0) { fprintf(stderr, "failed to initialize channel scan\n"); return -1; } FILE *fp = NULL; if (filename) { fp = fopen(filename, "w"); if (!fp) { fprintf(stderr, "unable to create file: %s\n", filename); return -1; } } register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler); int ret = 0; while (!sigabort_flag) { struct hdhomerun_channelscan_result_t result; ret = hdhomerun_device_channelscan_advance(hd, &result); if (ret <= 0) { break; } cmd_scan_printf(fp, "SCANNING: %lu (%s)\n", (unsigned long)result.frequency, result.channel_str ); ret = hdhomerun_device_channelscan_detect(hd, &result); if (ret <= 0) { break; } cmd_scan_printf(fp, "LOCK: %s (ss=%u snq=%u seq=%u)\n", result.status.lock_str, result.status.signal_strength, result.status.signal_to_noise_quality, result.status.symbol_error_quality ); if (result.transport_stream_id_detected) { cmd_scan_printf(fp, "TSID: 0x%04X\n", result.transport_stream_id); } int i; for (i = 0; i < result.program_count; i++) { struct hdhomerun_channelscan_program_t *program = &result.programs[i]; cmd_scan_printf(fp, "PROGRAM %s\n", program->program_str); } } hdhomerun_device_tuner_lockkey_release(hd); if (fp) { fclose(fp); } if (ret < 0) { fprintf(stderr, "communication error sending request to hdhomerun device\n"); } return ret; }
int main(int argc, char* argv[]) { printf("[i] Start...\n"); register_signal_handlers(); roboipc::CommunicatorServer communicator; roboipc::CommunicatorClient client; if( communicator.init(SPEECHER_SOCKET_NAME) ) { fprintf(stderr, "[!] Error: cant create communication: %s!\n", SPEECHER_SOCKET_NAME); return -1; } communicator.is_auto_close = false; client.is_auto_close = false; int res = 0; #if defined(USE_KEYBOARD_INPUT) && defined(LINUX) // Use termios to turn off line buffering termios term; tcgetattr(STDIN_FILENO, &term); term.c_lflag &= ~ICANON; tcsetattr(STDIN_FILENO, TCSANOW, &term); setbuf(stdin, NULL); #endif CmdSpeech cmd_speech; CmdAcknowledgment cmd_ack; memset(&cmd_speech, 0, sizeof(cmd_speech)); memset(&cmd_ack, 0, sizeof(cmd_ack)); char cmd_buf[128]={0}; int cmd_buf_size = 0; int return_value; int child_status = -1; pid_t child_pid; while( !terminated ) { #if defined(USE_KEYBOARD_INPUT) int key = console::waitKey(30); if(key != 0 ) printf( "[i] Key: %c (%d)\n", key ,key ); if(key == 27) { //ESC break; } #endif //#if defined(USE_KEYBOARD_INPUT) #if 1 SOCKET sockfd = SOCKET_ERROR; if( (sockfd = communicator.connected(200)) != SOCKET_ERROR ) { printf("[i] Client connected...\n"); client.close(); client.sockfd = sockfd; } if(client.available(50) > 0) { printf("[i] Client action...\n"); if( (cmd_buf_size = client.read(cmd_buf, sizeof(cmd_buf)))>0 ) { printf("[i] Data size: %d\n", cmd_buf_size); if(cmd_buf_size > CMD_SIG_SIZE) { if( !strncmp(cmd_buf, "speech", CMD_SIG_SIZE) && cmd_buf_size >= sizeof(cmd_speech) ) { memcpy(&cmd_speech, cmd_buf, sizeof(cmd_speech)); printf("[i] Clinet command speech: %d %s\n", cmd_speech.code, cmd_speech.name); child_pid = fork(); if(child_pid == 0) { // child char filename[sizeof(cmd_speech.name)] = {0}; if(get_filename_for_speak(cmd_speech)) { strncpy(filename, get_filename_for_speak(cmd_speech), sizeof(filename)); } printf("[i] play file: %s\n", filename); //return_value = execl("/usr/bin/aplay", "aplay", "./snd/dog_woof.wav"); return_value = execl("/usr/bin/aplay", "aplay", filename, "-D", "default:CARD=ALSA", 0); //return_value = execl("/usr/bin/aplay", "aplay", filename, 0); return return_value; } else { // parent printf("[i] parent process, with id %d\n", (int) getpid()); printf("[i] childs process ID is %d\n", (int) child_pid); } #if 1 wait( &child_status ); printf("[i] status: %d\n", child_status); if (WIFEXITED (child_status)) { printf ("[i] the child process exited normally, with exit code %d\n", WEXITSTATUS (child_status)); } else { printf ("[i] the child process exited abnormally\n"); } printf( "[i] Send ACK...\n"); if(client.sockfd != SOCKET_ERROR) { strncpy(cmd_ack.sig, "ackmnt", CMD_SIG_SIZE); cmd_ack.code = 0; res = client.write(&cmd_ack, sizeof(cmd_ack)); printf( "[i] Send ACK (%d)...\n", res); } #endif } } } else { printf("[i] Connection closed...\n"); client.close(); } } #endif } // while( !terminated ) { communicator.close(); printf("[i] End.\n"); return 0; }
int main(int argc, char **argv) { struct sockaddr_un addr; pid_t pid, sid; int pipefd[2]; int clfd; char deamonize; if(argc==2 && !strncmp(argv[1], "-f", 3)) { deamonize=0; } else { deamonize=1; } if(deamonize) { if(pipe2(pipefd, O_CLOEXEC)) { print( FATAL, "pipe2: %s", strerror(errno) ); return EXIT_FAILURE; } pid = fork(); if(pid<0) { print( FATAL, "fork: %s", strerror(errno) ); return EXIT_FAILURE; } else if(pid) { close(pipefd[1]); if(!read(pipefd[0], &clfd, 1)) return EXIT_FAILURE; return EXIT_SUCCESS; } close(pipefd[0]); umask(0); if(open_logfile(LOG_PATH)) { print( FATAL, "cannot open logfile"); return EXIT_FAILURE; } close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); set_logger(file_logger); sid = setsid(); if(sid<0) { print( FATAL, "setsid: %s", strerror(errno) ); return EXIT_FAILURE; } } if(init_structs()) return EXIT_FAILURE; if(load_handlers()) return EXIT_FAILURE; if(load_users()) return EXIT_FAILURE; if(remove_old_socket()) return EXIT_FAILURE; sockfd = socket(AF_UNIX, SOCK_STREAM, 0); if(sockfd < 0) { print( FATAL, "socket: %s", strerror(errno) ); return EXIT_FAILURE; } if(register_signal_handlers()) { close(sockfd); return EXIT_FAILURE; } memset(&addr, 0, sizeof(struct sockaddr_un)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path)-1); if(bind(sockfd, (struct sockaddr*)&addr, sizeof(addr))) { print( FATAL, "bind: %s", strerror(errno) ); close(sockfd); unlink(SOCKET_PATH); return EXIT_FAILURE; } if(listen(sockfd, 5)) { print( FATAL, "listen: %s", strerror(errno) ); close(sockfd); unlink(SOCKET_PATH); return EXIT_FAILURE; } if(start_reaper()) { close(sockfd); unlink(SOCKET_PATH); return EXIT_FAILURE; } #ifndef NDEBUG chmod(SOCKET_PATH, 0666); #endif if(deamonize) { if(write(pipefd[1], "!", 1) != 1) { print( FATAL, "cannot notify that daemon started" ); return EXIT_FAILURE; } close(pipefd[1]); } while(1) { if((clfd=accept(sockfd, NULL, NULL)) < 0) { if(errno == EINVAL) { #ifndef NDEBUG print( DEBUG, "socket closed" ); #endif } print( ERROR, "accept: %s", strerror(errno) ); break; } if(serve_new_client(clfd)) { print( WARNING, "cannot serve new connection" ); close(clfd); } } unlink(SOCKET_PATH); close_connections(); stop_reaper(); destroy_structs(); unload_users(); unload_handlers(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { const char *sopt = "hVvdm:p:l:f:b:s:t:"; const char *method = NULL, *path = NULL; const char *log_filepath = NULL; const char *pid_filepath = QGA_PIDFILE_DEFAULT; const char *state_dir = QGA_STATEDIR_DEFAULT; #ifdef _WIN32 const char *service = NULL; #endif const struct option lopt[] = { { "help", 0, NULL, 'h' }, { "version", 0, NULL, 'V' }, { "logfile", 1, NULL, 'l' }, { "pidfile", 1, NULL, 'f' }, { "verbose", 0, NULL, 'v' }, { "method", 1, NULL, 'm' }, { "path", 1, NULL, 'p' }, { "daemonize", 0, NULL, 'd' }, { "blacklist", 1, NULL, 'b' }, #ifdef _WIN32 { "service", 1, NULL, 's' }, #endif { "statedir", 1, NULL, 't' }, { NULL, 0, NULL, 0 } }; int opt_ind = 0, ch, daemonize = 0, i, j, len; GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL; GList *blacklist = NULL; GAState *s; module_call_init(MODULE_INIT_QAPI); while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { switch (ch) { case 'm': method = optarg; break; case 'p': path = optarg; break; case 'l': log_filepath = optarg; break; case 'f': pid_filepath = optarg; break; case 't': state_dir = optarg; break; case 'v': /* enable all log levels */ log_level = G_LOG_LEVEL_MASK; break; case 'V': printf("QEMU Guest Agent %s\n", QEMU_VERSION); return 0; case 'd': daemonize = 1; break; case 'b': { char **list_head, **list; if (is_help_option(optarg)) { list_head = list = qmp_get_command_list(); while (*list != NULL) { printf("%s\n", *list); g_free(*list); list++; } g_free(list_head); return 0; } for (j = 0, i = 0, len = strlen(optarg); i < len; i++) { if (optarg[i] == ',') { optarg[i] = 0; blacklist = g_list_append(blacklist, &optarg[j]); j = i + 1; } } if (j < i) { blacklist = g_list_append(blacklist, &optarg[j]); } break; } #ifdef _WIN32 case 's': service = optarg; if (strcmp(service, "install") == 0) { return ga_install_service(path, log_filepath); } else if (strcmp(service, "uninstall") == 0) { return ga_uninstall_service(); } else { printf("Unknown service command.\n"); return EXIT_FAILURE; } break; #endif case 'h': usage(argv[0]); return 0; case '?': g_print("Unknown option, try '%s --help' for more information.\n", argv[0]); return EXIT_FAILURE; } } s = g_malloc0(sizeof(GAState)); s->log_level = log_level; s->log_file = stderr; g_log_set_default_handler(ga_log, s); g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR); ga_enable_logging(s); s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen", state_dir); s->frozen = false; #ifndef _WIN32 /* check if a previous instance of qemu-ga exited with filesystems' state * marked as frozen. this could be a stale value (a non-qemu-ga process * or reboot may have since unfrozen them), but better to require an * uneeded unfreeze than to risk hanging on start-up */ struct stat st; if (stat(s->state_filepath_isfrozen, &st) == -1) { /* it's okay if the file doesn't exist, but if we can't access for * some other reason, such as permissions, there's a configuration * that needs to be addressed. so just bail now before we get into * more trouble later */ if (errno != ENOENT) { g_critical("unable to access state file at path %s: %s", s->state_filepath_isfrozen, strerror(errno)); return EXIT_FAILURE; } } else { g_warning("previous instance appears to have exited with frozen" " filesystems. deferring logging/pidfile creation and" " disabling non-fsfreeze-safe commands until" " guest-fsfreeze-thaw is issued, or filesystems are" " manually unfrozen and the file %s is removed", s->state_filepath_isfrozen); s->frozen = true; } #endif if (ga_is_frozen(s)) { if (daemonize) { /* delay opening/locking of pidfile till filesystem are unfrozen */ s->deferred_options.pid_filepath = pid_filepath; become_daemon(NULL); } if (log_filepath) { /* delay opening the log file till filesystems are unfrozen */ s->deferred_options.log_filepath = log_filepath; } ga_disable_logging(s); ga_disable_non_whitelisted(); } else { if (daemonize) { become_daemon(pid_filepath); } if (log_filepath) { FILE *log_file = fopen(log_filepath, "a"); if (!log_file) { g_critical("unable to open specified log file: %s", strerror(errno)); goto out_bad; } s->log_file = log_file; } } if (blacklist) { s->blacklist = blacklist; do { g_debug("disabling command: %s", (char *)blacklist->data); qmp_disable_command(blacklist->data); blacklist = g_list_next(blacklist); } while (blacklist); } s->command_state = ga_command_state_new(); ga_command_state_init(s, s->command_state); ga_command_state_init_all(s->command_state); json_message_parser_init(&s->parser, process_event); ga_state = s; #ifndef _WIN32 if (!register_signal_handlers()) { g_critical("failed to register signal handlers"); goto out_bad; } #endif s->main_loop = g_main_loop_new(NULL, false); if (!channel_init(ga_state, method, path)) { g_critical("failed to initialize guest agent channel"); goto out_bad; } #ifndef _WIN32 g_main_loop_run(ga_state->main_loop); #else if (daemonize) { SERVICE_TABLE_ENTRY service_table[] = { { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } }; StartServiceCtrlDispatcher(service_table); } else { g_main_loop_run(ga_state->main_loop); } #endif ga_command_state_cleanup_all(ga_state->command_state); ga_channel_free(ga_state->channel); if (daemonize) { unlink(pid_filepath); } return 0; out_bad: if (daemonize) { unlink(pid_filepath); } return EXIT_FAILURE; }
int main(int argc, char *argv[]) { int r; pthread_t uloop_tid; parse_args(argc, argv); register_signal_handlers(); sprintf(ubus_path, "serial.%s", basename(opts.port)); r = pipe2(ubus_pipefd, O_CLOEXEC); if (r < 0) fatal("cannot create pipe to ubus: %s", strerror(errno)); /* Seems like you cannot have multiple ubus connections in single process. */ /* So we fork. */ switch(fork()) { case 0: efd_signal = eventfd(0, EFD_CLOEXEC); if (efd_signal < 0) { fatal("cannot create efd_signal: %s", strerror(errno)); } close(ubus_pipefd[1]); seriald_ubus_run(opts.socket); return EXIT_SUCCESS; case -1: fatal("cannot fork ubus_event_loop"); } close(ubus_pipefd[0]); efd_notify_tty = eventfd(0, EFD_CLOEXEC); if (efd_notify_tty < 0) { fatal("cannot create efd_notify_tty: %s", strerror(errno)); } r = term_lib_init(); if (r < 0) fatal("term_init failed: %s", term_strerror(term_errno, errno)); fd_tty = open(opts.port, O_RDWR | O_NONBLOCK | O_NOCTTY); if (fd_tty < 0) fatal("cannot open %s: %s", opts.port, strerror(errno)); r = term_set(fd_tty, 1, /* raw mode. */ opts.baud, /* baud rate. */ opts.parity, /* parity. */ opts.databits, /* data bits. */ opts.stopbits, /* stop bits. */ opts.flow, /* flow control. */ 1, /* local or modem */ !opts.noreset); /* hup-on-close. */ if (r < 0) { fatal("failed to add device %s: %s", opts.port, term_strerror(term_errno, errno)); } r = term_apply(fd_tty, 0); if (r < 0) { fatal("failed to config device %s: %s", opts.port, term_strerror(term_errno, errno)); } set_tty_write_sz(term_get_baudrate(fd_tty, NULL)); r = seriald_ubus_loop_init(opts.socket); if (r) fatal("failed to connect to ubus"); r = pthread_create(&uloop_tid, NULL, &seriald_ubus_loop, NULL); if (r) fatal("can't create thread for uloop: %s", strerror(r)); loop(); seriald_ubus_loop_done(); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { printf("[i] Start...\n"); register_signal_handlers(); roboipc::CommunicatorServer communicator; roboipc::CommunicatorClient client; if( communicator.init(EYE_SOCKET_NAME) ) { fprintf(stderr, "[!] Error: cant create communication: %s!\n", EYE_SOCKET_NAME); return -1; } int res = 0; #if defined(USE_KEYBOARD_INPUT) && defined(LINUX) // Use termios to turn off line buffering termios term; tcgetattr(STDIN_FILENO, &term); term.c_lflag &= ~ICANON; tcsetattr(STDIN_FILENO, TCSANOW, &term); setbuf(stdin, NULL); #endif CmdEyeData cmd_eye; memset(&cmd_eye, 0, sizeof(cmd_eye)); CvCapture* capture = cvCreateCameraCapture( 200 ); if(!capture) { fprintf(stderr, "[!] Error: cant create camera capture!\n"); } cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, EYE_FRAME_WIDTH); cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, EYE_FRAME_HEIGHT); double width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH); double height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT); printf("[i] Capture: %.0f x %.0f\n", width, height ); IplImage* frame = 0; printf("[i] Capture images...\n"); // frame counter int counter = 0; double fps = 0; double begin = 0; double end = 0; while( !terminated ) { #if defined(USE_KEYBOARD_INPUT) int key = console::waitKey(30); if(key != 0 ) printf( "[i] Key: %c (%d)\n", key ,key ); if(key == 27) { //ESC break; } #endif //#if defined(USE_KEYBOARD_INPUT) begin = (double)cvGetTickCount(); frame = cvQueryFrame( capture ); calc_hsv_colors(frame); end = (double)cvGetTickCount(); // calculate current FPS counter++; fps = (end-begin) / (cvGetTickFrequency()*1000.0); // will print out Inf until sec is greater than 0 printf("[i] FPS = %.2f\n", fps); #if 1 SOCKET sockfd = SOCKET_ERROR; if( (sockfd = communicator.connected(30)) != SOCKET_ERROR ) { printf("[i] Client connected...\n"); client.close(); client.sockfd = sockfd; } if(client.sockfd != SOCKET_ERROR) { strncpy(cmd_eye.sig, "eyedat", CMD_SIG_SIZE); res = client.write(&cmd_eye, sizeof(cmd_eye)); printf( "[i] Send Eye data (%d)...\n", res); } #endif } // while( !terminated ) { cvReleaseCapture( &capture ); printf("[i] End.\n"); return 0; }
void initialize() { time_t now = time(NULL); srand(now); startup_ts = now; if (init_log() == -1) { fprintf(stderr, "Failed to initialzie log module.\n"); exit(EXIT_FAILURE); } int ver = read_version(); if (ver < VERSION) { log_info("Previous version %d, current version %d", ver, VERSION); // this is a version update! if (need_to_delete_redis_db) { log_info("Deleting redis DB due to version update."); delete_redis_db(); } } else log_info("Current version: %d", VERSION); write_version(VERSION); start_redis_server(); if (init_socket() == -1) { log_error("Failed to initialize socket module."); exit(EXIT_FAILURE); } log_debug("Adding iptables rules."); if (add_iptables_rules() == -1) { log_error("Failed to add iptables rules."); exit(EXIT_FAILURE); } register_signal_handlers(); if (setup_nfq() == -1) { log_error("unable to setup netfilter_queue"); exit(EXIT_FAILURE); } log_debug("Init DNS client."); if (init_dns_cli() == -1) { log_error("Failed to initialize DNS module"); exit(EXIT_FAILURE); } log_debug("Init ev watchers."); init_ev_watchers(); // Begin to intercept packets //if (setup_strategy() == -1) { // log_error("Failed to setup strategy"); // exit(EXIT_FAILURE); //} log_debug("Loading TTL from file."); load_ttl_from_file("ttl"); // start a debug thread //pthread_t thread_dbg; //if (pthread_create(&thread_dbg, NULL, debug_main, NULL) != 0) { // log_error("Fail to create debug thread."); // exit(EXIT_FAILURE); //} // start a thread to handle communications with redis pthread_t thread_cache; if (pthread_create(&thread_cache, NULL, cache_main, NULL) != 0){ log_error("Fail to create caching thread."); exit(EXIT_FAILURE); } // start the DNS proxy thread pthread_t thread_dns; if (pthread_create(&thread_dns, NULL, dns_main, NULL) != 0){ log_error("Fail to create DNS thread."); exit(EXIT_FAILURE); } // Uploading diagnostic log is disabled. (2017.4.26) // start a thread to send feedback log //pthread_t thread_fb; //if (pthread_create(&thread_fb, NULL, feedback_main, NULL) != 0){ // log_error("Fail to create feedback thread."); // exit(EXIT_FAILURE); //} }
int main(int argc, char **argv) { int server_fd, port_number, max_fd, file_descriptors[MAX_NUMBER_USERS], i; int temp_fd, select_result, timer_is_active = FALSE, status_code; char *validation; fd_set file_descriptor_set; check_incorrect_usage(argc, argv); set_log_method(argv); set_lock(); port_number = extract_port_number(argv); server_fd = create_server(port_number, MAX_NUMBER_USERS); log_message("Streams server created", LOG_INFO); register_signal_handlers(); for (i = 0; i < MAX_NUMBER_USERS; i++) { file_descriptors[i] = 0; } // -- SHARED MEMORY AND SEMAPHORES -- shmid = create_shared_memory(); shared_mem_ptr = attach_memory(shmid); init_semaphores(); log_message("Shared memory and semaphores created", LOG_DEBUG); // -- SERVER LOOP -- while (TRUE) { FD_ZERO(&file_descriptor_set); FD_SET(server_fd, &file_descriptor_set); max_fd = server_fd; for (i = 0; i < MAX_NUMBER_USERS; i++) { temp_fd = file_descriptors[i]; if (temp_fd > 0) { FD_SET(temp_fd, &file_descriptor_set); } if (temp_fd > max_fd) { max_fd = temp_fd; } } select_result = select(max_fd + 1, &file_descriptor_set, NULL, NULL, NULL); if (select_result < 0 && errno != EINTR) { log_error("Select call error", LOG_WARNING, errno); continue; } if (FD_ISSET(server_fd, &file_descriptor_set)) { if ((temp_fd = accept(server_fd, NULL, 0)) < 0) { log_error("Could not accept incoming connection", LOG_ALERT, errno); exit(EXIT_FAILURE); } log_client_connection(temp_fd); for (i = 0; i < MAX_NUMBER_USERS; i++) { if (file_descriptors[i] != 0) continue; file_descriptors[i] = temp_fd; break; } } for (i = 0; i < MAX_NUMBER_USERS; i++) { temp_fd = file_descriptors[i]; if (!FD_ISSET(temp_fd, &file_descriptor_set)) continue; char *message = NULL; if ((message = (char *) calloc(MESSAGE_LENGTH, sizeof(char))) == NULL) { log_error("Memory allocation error", LOG_ALERT, errno); exit(EXIT_FAILURE); } if (recv(temp_fd, message, MESSAGE_LENGTH, 0) <= 0) // Disconnected { log_message("Client disconnected", LOG_INFO); close(temp_fd); file_descriptors[i] = 0; } else // Message sent to server { struct message_t mess=decode(message); if( (status_code = mess.type) == ERROR_MESSAGE) { continue; } if (get_game_phase() == REGISTER_PHASE) { if (status_code != 1) { // TODO Send message back to user? log_message("Currently register phase. User can only register", LOG_DEBUG); continue; } if (!timer_is_active) { log_message("Starting register timer", LOG_DEBUG); alarm(WAIT_TIME); timer_is_active = TRUE; } char *new_user = (char *) malloc(MAX_ARRAY_SIZE * sizeof(char)); sprintf(new_user, "User '%s' asks for registration. Adding user in memory.", (char *) mess.payload); log_message(new_user, LOG_INFO); // Add a player to the shared memory semaphore_down(SEMAPHORE_ACCESS); strncpy(shared_mem_ptr->players->name, (char *) mess.payload, strlen(mess.payload)); shared_mem_ptr->players[i].fd = temp_fd; shared_mem_ptr->players[i].score = 15; // TODO A supprimer semaphore_up(SEMAPHORE_ACCESS); validation = encode(VALID_REGISTRATION, "1"); send(temp_fd, validation, strlen(validation), 0); } else // GAME PHASE { log_message("Game phase. Not yet implemented.", LOG_INFO); } } } } return 0; }
int main (int argc, char *argv[]) { short int device = 0; char *device_name = NULL; char *key = NULL; struct input_event ev; printf ("learnkeys (%s, %s)\n", PACKAGE_STRING, PACKAGE_VERSION_SVN_REV); if (argc < 2) { printf ("\nUsage:\n"); printf ("%s config_file_name [input_device_name]\n\n", argv[0]); printf ("config_file_name - location of esekeyd config file\n"); printf ("input_device_name - input (event) device; if given turns off\n"); printf (" of 1st keyboard device\n"); printf ("\nExample:\n"); printf ("%s ~/.esekeyd.conf /dev/input/event3\n", argv[0]); exit (1); } if (argc > 2) { device_name = argv[2]; } else { switch (check_handlers ()) { case -1: printf ("%s: cannot open %s\n", argv[0], INPUT_HANDLERS); return -1; case -2: printf ("%s: evdev handler not found in %s\n", argv[0], INPUT_HANDLERS); return -2; } switch (device = find_input_dev ()) { case -1: printf ("%s: evdev for keyboard not found in %s\n", argv[0], INPUT_HANDLERS); return -3; default: asprintf (&device_name, "%s%hu", EVENT_DEVICE, device); } } if (!(funkey = fopen (device_name, "r"))) { printf ("%s: can`t open %s\n", argv[0], device_name); return -4; } if (!(config = fopen (argv[1], "w"))) { printf ("%s: can`t open %s\n", argv[0], argv[1]); return -5; } fprintf (config, "#\n" "# %s config file\n" "#\n" "\n" "#\n" "# example 1: to run mutt in xterm we must set DISPLAY\n" "# so the command line will be as follows:\n" "#MAIL:/bin/sh -c \"DISPLAY=:0 xterm -e mutt\"\n" "#\n" "# example 2: turn on/off GPS receiver when lid is open/closed\n" "#RADIO(press):echo 1 >/sys/device/platform/gps/gps_power\n" "#RADIO(release):echo 0 >/sys/device/platform/gps/gps_power\n" "#\n" "# example 3: run nautilus when both left meta and e keys are press\n" "#LEFTMETA+E:nautilus\n" "#\n" "\n", PACKAGE_STRING); printf ("\nPres ANY (fun)key... or Ctrl-C to exit...\n\n"); register_signal_handlers(); while (fread (&ev, sizeof (struct input_event), 1, funkey)) { if (ev.code == 28 && ev.type == EV_KEY && ev.value == 1) { printf ("\n"); fclose (funkey); return 0; } if ((key = parse (ev)) != NULL) { printf ("key %s stored in config file\n", key); if (ev.value == 1) fprintf (config, "#%s(press):\n", key); else fprintf (config, "#%s(release):\n", key); } } cleanup (); return 0; }
int main() { if (!register_signal_handlers()) { return EXIT_FAILURE; } try { boost::asio::io_service _io_service; asiotap::tap_adapter tap_adapter(_io_service, asiotap::tap_adapter_layer::ip); stop_function = boost::bind(&close_tap_adapter, boost::ref(tap_adapter)); tap_adapter.open(); asiotap::tap_adapter_configuration configuration {}; configuration.ipv4.network_address = { boost::asio::ip::address_v4::from_string("9.0.0.1"), 24 }; configuration.ipv4.remote_address = boost::asio::ip::address_v4::from_string("9.0.0.0"); configuration.ipv6.network_address = { boost::asio::ip::address_v6::from_string("fe80::c887:eb51:aaaa:bbbb"), 64 }; tap_adapter.configure(configuration); tap_adapter.set_connected_state(true); tap_adapter.async_read(boost::asio::buffer(my_buf, sizeof(my_buf)), boost::bind(&read_done, boost::ref(tap_adapter), _1, _2)); const auto addresses = tap_adapter.get_ip_addresses(); std::cout << "Current IP addresses for the interface:" << std::endl; for(auto&& address : addresses) { std::cout << address << std::endl; } std::cout << "Adding routes" << std::endl; asiotap::route_manager rmgr(_io_service); rmgr.set_route_registration_success_handler([](const asiotap::route_manager::route_type& route){ std::cout << "Added route: " << route << std::endl; }); rmgr.set_route_registration_failure_handler([](const asiotap::route_manager::route_type& route, const boost::system::system_error& ex){ std::cout << "Failure adding route (" << route << "): " << ex.what() << std::endl; }); rmgr.set_route_unregistration_success_handler([](const asiotap::route_manager::route_type& route){ std::cout << "Removed route: " << route << std::endl; }); rmgr.set_route_unregistration_failure_handler([](const asiotap::route_manager::route_type& route, const boost::system::system_error& ex){ std::cout << "Failure removing route (" << route << "): " << ex.what() << std::endl; }); const auto r1 = rmgr.get_route_entry(tap_adapter.get_route(asiotap::to_ip_route(boost::asio::ip::address_v4::from_string("9.0.1.0"), 24))); const auto r2 = rmgr.get_route_entry(tap_adapter.get_route(asiotap::to_ip_route(boost::asio::ip::address_v4::from_string("9.0.2.0"), 24, boost::asio::ip::address_v4::from_string("9.0.1.2")))); _io_service.run(); } catch (std::exception& ex) { std::cerr << "Exception caught: " << ex.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }
int main(int argc, char **argv) { const char *sopt = "hVvdm:p:l:f:F::b:s:t:"; const char *method = NULL, *path = NULL; const char *log_filepath = NULL; const char *pid_filepath; #ifdef CONFIG_FSFREEZE const char *fsfreeze_hook = NULL; #endif const char *state_dir; #ifdef _WIN32 const char *service = NULL; #endif const struct option lopt[] = { { "help", 0, NULL, 'h' }, { "version", 0, NULL, 'V' }, { "logfile", 1, NULL, 'l' }, { "pidfile", 1, NULL, 'f' }, #ifdef CONFIG_FSFREEZE { "fsfreeze-hook", 2, NULL, 'F' }, #endif { "verbose", 0, NULL, 'v' }, { "method", 1, NULL, 'm' }, { "path", 1, NULL, 'p' }, { "daemonize", 0, NULL, 'd' }, { "blacklist", 1, NULL, 'b' }, #ifdef _WIN32 { "service", 1, NULL, 's' }, #endif { "statedir", 1, NULL, 't' }, { NULL, 0, NULL, 0 } }; int opt_ind = 0, ch, daemonize = 0, i, j, len; GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL; GList *blacklist = NULL; GAState *s; module_call_init(MODULE_INIT_QAPI); init_dfl_pathnames(); pid_filepath = dfl_pathnames.pidfile; state_dir = dfl_pathnames.state_dir; while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { switch (ch) { case 'm': method = optarg; break; case 'p': path = optarg; break; case 'l': log_filepath = optarg; break; case 'f': pid_filepath = optarg; break; #ifdef CONFIG_FSFREEZE case 'F': fsfreeze_hook = optarg ? optarg : QGA_FSFREEZE_HOOK_DEFAULT; break; #endif case 't': state_dir = optarg; break; case 'v': /* enable all log levels */ log_level = G_LOG_LEVEL_MASK; break; case 'V': printf("QEMU Guest Agent %s\n", QEMU_VERSION); return 0; case 'd': daemonize = 1; break; case 'b': { if (is_help_option(optarg)) { qmp_for_each_command(ga_print_cmd, NULL); return 0; } for (j = 0, i = 0, len = strlen(optarg); i < len; i++) { if (optarg[i] == ',') { optarg[i] = 0; blacklist = g_list_append(blacklist, &optarg[j]); j = i + 1; } } if (j < i) { blacklist = g_list_append(blacklist, &optarg[j]); } break; } #ifdef _WIN32 case 's': service = optarg; if (strcmp(service, "install") == 0) { const char *fixed_state_dir; /* If the user passed the "-t" option, we save that state dir * in the service. Otherwise we let the service fetch the state * dir from the environment when it starts. */ fixed_state_dir = (state_dir == dfl_pathnames.state_dir) ? NULL : state_dir; if (ga_install_vss_provider()) { return EXIT_FAILURE; } if (ga_install_service(path, log_filepath, fixed_state_dir)) { return EXIT_FAILURE; } return 0; } else if (strcmp(service, "uninstall") == 0) { ga_uninstall_vss_provider(); return ga_uninstall_service(); } else { printf("Unknown service command.\n"); return EXIT_FAILURE; } break; #endif case 'h': usage(argv[0]); return 0; case '?': g_print("Unknown option, try '%s --help' for more information.\n", argv[0]); return EXIT_FAILURE; } } #ifdef _WIN32 /* On win32 the state directory is application specific (be it the default * or a user override). We got past the command line parsing; let's create * the directory (with any intermediate directories). If we run into an * error later on, we won't try to clean up the directory, it is considered * persistent. */ if (g_mkdir_with_parents(state_dir, S_IRWXU) == -1) { g_critical("unable to create (an ancestor of) the state directory" " '%s': %s", state_dir, strerror(errno)); return EXIT_FAILURE; } #endif s = g_malloc0(sizeof(GAState)); s->log_level = log_level; s->log_file = stderr; #ifdef CONFIG_FSFREEZE s->fsfreeze_hook = fsfreeze_hook; #endif g_log_set_default_handler(ga_log, s); g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR); ga_enable_logging(s); s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen", state_dir); s->pstate_filepath = g_strdup_printf("%s/qga.state", state_dir); s->frozen = false; #ifndef _WIN32 /* check if a previous instance of qemu-ga exited with filesystems' state * marked as frozen. this could be a stale value (a non-qemu-ga process * or reboot may have since unfrozen them), but better to require an * uneeded unfreeze than to risk hanging on start-up */ struct stat st; if (stat(s->state_filepath_isfrozen, &st) == -1) { /* it's okay if the file doesn't exist, but if we can't access for * some other reason, such as permissions, there's a configuration * that needs to be addressed. so just bail now before we get into * more trouble later */ if (errno != ENOENT) { g_critical("unable to access state file at path %s: %s", s->state_filepath_isfrozen, strerror(errno)); return EXIT_FAILURE; } } else { g_warning("previous instance appears to have exited with frozen" " filesystems. deferring logging/pidfile creation and" " disabling non-fsfreeze-safe commands until" " guest-fsfreeze-thaw is issued, or filesystems are" " manually unfrozen and the file %s is removed", s->state_filepath_isfrozen); s->frozen = true; } #endif if (ga_is_frozen(s)) { if (daemonize) { /* delay opening/locking of pidfile till filesystems are unfrozen */ s->deferred_options.pid_filepath = pid_filepath; become_daemon(NULL); } if (log_filepath) { /* delay opening the log file till filesystems are unfrozen */ s->deferred_options.log_filepath = log_filepath; } ga_disable_logging(s); qmp_for_each_command(ga_disable_non_whitelisted, NULL); } else { if (daemonize) { become_daemon(pid_filepath); } if (log_filepath) { FILE *log_file = ga_open_logfile(log_filepath); if (!log_file) { g_critical("unable to open specified log file: %s", strerror(errno)); goto out_bad; } s->log_file = log_file; } } /* load persistent state from disk */ if (!read_persistent_state(&s->pstate, s->pstate_filepath, ga_is_frozen(s))) { g_critical("failed to load persistent state"); goto out_bad; } blacklist = ga_command_blacklist_init(blacklist); if (blacklist) { s->blacklist = blacklist; do { g_debug("disabling command: %s", (char *)blacklist->data); qmp_disable_command(blacklist->data); blacklist = g_list_next(blacklist); } while (blacklist); } s->command_state = ga_command_state_new(); ga_command_state_init(s, s->command_state); ga_command_state_init_all(s->command_state); json_message_parser_init(&s->parser, process_event); ga_state = s; #ifndef _WIN32 if (!register_signal_handlers()) { g_critical("failed to register signal handlers"); goto out_bad; } #endif s->main_loop = g_main_loop_new(NULL, false); if (!channel_init(ga_state, method, path)) { g_critical("failed to initialize guest agent channel"); goto out_bad; } #ifndef _WIN32 g_main_loop_run(ga_state->main_loop); #else if (daemonize) { SERVICE_TABLE_ENTRY service_table[] = { { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } }; StartServiceCtrlDispatcher(service_table); } else { g_main_loop_run(ga_state->main_loop); } #endif ga_command_state_cleanup_all(ga_state->command_state); ga_channel_free(ga_state->channel); if (daemonize) { unlink(pid_filepath); } return 0; out_bad: if (daemonize) { unlink(pid_filepath); } return EXIT_FAILURE; }
/* daemon live here, receives command, process it, send back result */ int htxd_start_daemon(htxd *htxd_instance) { int result = 0; int socket_fd; struct sockaddr_in local_address; struct sockaddr_in client_address; socklen_t address_length; int new_fd; char * command_buffer = NULL; char * command_result = NULL; int command_return_code = 0; char trace_string[256]; HTXD_FUNCTION_TRACE(FUN_ENTRY, "htxd_start_daemon"); init_option_list(); htxd_autostart(htxd_instance); /* try autostart if find the autostart flag file */ socket_fd = htxd_create_socket(); result = htxd_set_socket_option(socket_fd); local_address.sin_family = AF_INET; local_address.sin_port = htons (htxd_instance->port_number); local_address.sin_addr.s_addr = INADDR_ANY; memset (&(local_address.sin_zero), '\0', 8); result = htxd_bind_socket(socket_fd, &local_address, htxd_instance->port_number); result = htxd_listen_socket(socket_fd); HTXD_TRACE(LOG_ON, "starting daemon main loop"); do /* this loop make the daemon live */ { do /* this loop listens for incomming messages */ { HTXD_TRACE(LOG_OFF, "daemon wating for command"); result = htxd_select(socket_fd); if(htxd_shutdown_flag == TRUE) { break; } }while( (result == -1) && (errno == EINTR) ); if(htxd_shutdown_flag == TRUE) { break; } new_fd = htxd_accept_connection(socket_fd, &client_address, &address_length); if(new_fd == -1) { if(htxd_shutdown_flag == TRUE) { break; } HTXD_TRACE(LOG_OFF, "select time out"); continue; } HTXD_TRACE(LOG_OFF, "found a command for receiving"); if(htxd_is_profile_initialized(htxd_instance) != TRUE) { HTXD_TRACE(LOG_ON, "initialize HTX profile details"); htxd_init_profile(&(htxd_instance->p_profile)); /* htxd_display_profile(htxd_instance->p_profile); */ /* To DEBUG */ register_signal_handlers(); } /* receive the incomming command */ HTXD_TRACE(LOG_OFF, "daemon receiving command"); command_buffer = htxd_receive_command(new_fd); if(command_buffer == NULL) { return -1; } HTXD_TRACE(LOG_OFF, "command received start<<"); HTXD_TRACE(LOG_OFF, command_buffer); HTXD_TRACE(LOG_OFF, ">> command received end"); htxd_update_command_object(command_buffer); if(command_buffer != NULL) { free(command_buffer); command_buffer = NULL; } /* process the received command */ HTXD_TRACE(LOG_OFF, "daemon start processing command"); command_return_code = htxd_process_command(&command_result); /* handling if command did not generate result buffer */ if(command_result == NULL) { command_result = malloc(HTX_ERR_MESSAGE_LENGTH); if(command_result == NULL) { sprintf(trace_string, "Error : malloc(%d) failed with errno = <%d> while allocating error message", HTX_ERR_MESSAGE_LENGTH, errno); HTXD_TRACE(LOG_ON, trace_string); exit(1); } strcpy(command_result, "No result is generated by the command"); } HTXD_TRACE(LOG_OFF, "command result start<<"); HTXD_TRACE(LOG_OFF, command_result); HTXD_TRACE(LOG_OFF, ">> command result end"); /* send back command result to client */ HTXD_TRACE(LOG_OFF, "daemon sending the result to client"); result = htxd_send_response(new_fd, command_result, command_return_code); if(result == -1) { return result; } if(command_result != 0) { free(command_result); } close(new_fd); } while(htxd_shutdown_flag == FALSE); if(htxd_get_ecg_list_length(htxd_instance->p_ecg_manager) > 0) { /* shutdown all running ecgs and return */ // htxd_shutdown_all_running_ecgs(); } htxd_shutdown_all_mdt(); HTXD_FUNCTION_TRACE(FUN_EXIT, "htxd_start_daemon"); return result; }