/* SET LOG */ static void quote_log( struct Client *source_p, int newval ) { const char *log_level_as_string; if (newval >= 0) { if (newval < L_WARN) { sendto_one(source_p, ":%s NOTICE %s :LOG must be > %d (L_WARN)", me.name, source_p->name, L_WARN); return; } if (newval > L_DEBUG) { newval = L_DEBUG; } set_log_level(newval); log_level_as_string = get_log_level_as_string(newval); sendto_realops_flags(UMODE_ALL, L_ALL,"%s has changed LOG level to %i (%s)", source_p->name, newval, log_level_as_string); } else { sendto_one(source_p, ":%s NOTICE %s :LOG level is currently %i (%s)", me.name, source_p->name, get_log_level(), get_log_level_as_string(get_log_level())); } }
int http_open(file_source_t* src, file_handle_t* handler, char* filename, int flags){ http_file_handler_t* ofh = (http_file_handler_t*)handler; request_rec* req_r = (request_rec*)src->context; size_t size; int error_code; hls_cache_line_t cl; if (filename[0] == 0) return 0; ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: trying to open HTTP data source %s", filename); strncpy(ofh->link, filename, sizeof(ofh->link)); ofh->r = req_r; ofh->content_length = 0; ofh->last_error_code = 0; ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: trying to read first %d bytes to and cache it", (int)(sizeof(cl.buffer))); http_read(ofh, cl.buffer, sizeof(cl.buffer), 0, flags); ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: got content length %d bytes", (int)ofh->content_length); return ofh->content_length != 0; }
int xml_config_log(const xml_config_t *config) { char *facility = NULL, *level = NULL; int ret = OBIX_ERR_INVALID_ARGUMENT; if (!(level = xml_config_get_str(config, XP_LOG_LEVEL))) { log_error("Failed to get %s settings", XP_LOG_LEVEL); goto failed; } if (!(facility = xml_config_get_str(config, XP_LOG_FACILITY))) { log_error("Failed to get %s settings", XP_LOG_FACILITY); goto failed; } log_useSyslog(get_log_facility(facility)); log_setLevel(get_log_level(level)); ret = OBIX_SUCCESS; /* Fall through */ failed: if (facility) { free(facility); } if (level) { free(level); } return ret; }
void set_progress_display(std::string description, unsigned int steps) { if (get_log_level() == PROGRESS) { IMP_USAGE_CHECK(!internal::progress, "There is already a progress bar."); std::cout << description << std::endl; internal::progress.reset(new boost::progress_display(steps)); } }
size_t in_fd_t::readv(iovec *iov, size_t cnt) { ssize_t res = ::readv(fd, iov, cnt); if(res < 0) throw exception_sys_t(get_log_level(), errno, "readv: %m"); return res; }
void Logger::incr_log_level(LogLevel level) { if (get_log_level() < level) { set_log_level(level); } }
void LogStream::set_stream(TextOutput out) { // temporarily disable writes, otherwise at log level MEMORY the log is // displayed using the old out_ object, which is in the process of being // freed (generally this leads to a segfault) LogLevel old = get_log_level(); set_log_level(SILENT); out_ = out; set_log_level(old); }
void SetLogState::set(LogLevel l) { reset(); if (l != DEFAULT) { level_ = get_log_level(); set_log_level(l); } else { level_ = DEFAULT; } }
static void init_global_config(global_conf_st *g_conf, char *file) { if (NULL == file) { fprintf(stderr, "config file is wrong\n"); exit(1); } int L_level = 0; xode pnode = xode_from_file(file); if (NULL == pnode) { fprintf(stderr, "config file is wrong\n"); exit(1); } int max_thread = xode_get_integer(pnode, "maxThread"); if (max_thread != -1) { g_conf->max_thread = max_thread; } int max_msg_queue_len = xode_get_integer(pnode, "maxMsgQueueLen"); if (max_msg_queue_len != -1) { g_conf->max_msg_queue_len = max_msg_queue_len; } char *log_file = xode_get_string(pnode, "logDir"); char *redis_conf = xode_get_string(pnode, "redisConf"); char *reload_file = xode_get_string(pnode, "reloadFile"); if (log_file == NULL || redis_conf == NULL || reload_file == NULL) { fprintf(stderr, "conf file format wrong ,can't file logDir or redisConf or reload_file\n"); exit(1); } snprintf(g_conf->log_dir, sizeof(g_conf->log_dir), "%s", log_file); snprintf(g_conf->reload_file, sizeof(g_conf->reload_file), "%s", reload_file); snprintf(g_conf->redis_config, sizeof(g_conf->redis_config), "%s", redis_conf); char *log_level = xode_get_string(pnode, "logLevel"); if (log_level != NULL) { L_level = get_log_level(log_level); } char program[128]; memset(program, 0, sizeof(program)); init_mq(g_conf, pnode); snprintf(program, sizeof(program), "%s-%s", PROGRAM, g_conf->receive_mq->task_name); gozap_log_init(g_conf->log_dir, L_level, program); g_conf->redis_client = redis_client_init(g_conf->redis_config); return; }
void add_to_progress_display(unsigned int step) { if (get_log_level() == PROGRESS) { IMP_USAGE_CHECK(internal::progress, "There is no progress bar."); for (unsigned int i = 0; i < step; ++i) { ++(*internal::progress); } if (internal::progress->count() == internal::progress->expected_count()) { internal::progress.reset(); } } }
double Simulator::do_simulate(double time) { IMP_FUNCTION_LOG; set_was_used(true); ParticleIndexes ps = get_simulation_particle_indexes(); setup(ps); double target = current_time_ + time; boost::scoped_ptr<boost::progress_display> pgs; if (get_log_level() == PROGRESS) { pgs.reset(new boost::progress_display(time / max_time_step_)); } while (current_time_ < target) { last_time_step_ = do_step(ps, max_time_step_); current_time_ += last_time_step_; update_states(); if (get_log_level() == PROGRESS) { ++(*pgs); } } return Optimizer::get_scoring_function()->evaluate(false); }
static inline void init() { AM_LOCK(); if (AM_UNLIKELY(!AO_load_acquire_read(&isInitialized))) { if (0 == isInitialized) { get_log_level(); get_log_target(); get_timestamp_setting(); AO_store_release_write(&isInitialized, 1); } } AM_UNLOCK(); }
static void edit_control(struct v4l2_camera *cam) { struct v4l2_control ctrl; int cur_level = get_log_level(); int c; set_log_level(DEBUG); camera_query_support_control(cam); scanf("%d%x%d", &c, &ctrl.id, &ctrl.value); if (c == 1) camera_set_control(cam, &ctrl); else camera_get_control(cam, &ctrl); LOGI("%d\n", ctrl.value); set_log_level(cur_level); }
int console_log_level(int msg_level) { int log_level = get_log_level(); if (log_level < 0) return CONSOLE_LOG_NONE; if (msg_level <= log_level) return CONSOLE_LOG_ALL; if (CONFIG(CONSOLE_CBMEM) && (msg_level <= BIOS_DEBUG)) return CONSOLE_LOG_FAST; return 0; }
void TraceLog::fill_log(const char *fmt, ...) { if (get_log_level() > TBSYS_LOGGER._level) { LogBuffer &log_buffer = get_logbuffer(); if (0 == log_buffer.prev_timestamp) { log_buffer.start_timestamp = tbsys::CTimeUtil::getTime(); log_buffer.prev_timestamp = log_buffer.start_timestamp; } } else { va_list args; va_start(args, fmt); LogBuffer &log_buffer = get_logbuffer(); int64_t valid_buffer_size = LogBuffer::LOG_BUFFER_SIZE - log_buffer.cur_pos; if (0 < valid_buffer_size) { int64_t ret = 0; ret = vsnprintf(log_buffer.buffer + log_buffer.cur_pos, valid_buffer_size, fmt, args); log_buffer.cur_pos += ((0 < ret && valid_buffer_size > ret) ? ret : 0); if (-1 < ret && valid_buffer_size > ret) { valid_buffer_size -= ret; int64_t cur_time = tbsys::CTimeUtil::getTime(); if (0 < valid_buffer_size) { if (0 != log_buffer.prev_timestamp) { ret = snprintf(log_buffer.buffer + log_buffer.cur_pos, valid_buffer_size, " timeu=%lu | ", cur_time - log_buffer.prev_timestamp); } else { ret = snprintf(log_buffer.buffer + log_buffer.cur_pos, valid_buffer_size, " | "); log_buffer.start_timestamp = cur_time; } log_buffer.cur_pos += ((0 < ret && valid_buffer_size > ret) ? ret : 0); } log_buffer.prev_timestamp = cur_time; } log_buffer.buffer[log_buffer.cur_pos] = '\0'; } va_end(args); } }
static void sighandler(gpointer x) { sigset_t ss; int ret; struct timespec ts; sigemptyset(&ss); sigaddset(&ss, SIGINT); sigaddset(&ss, SIGTERM); sigaddset(&ss, SIGUSR1); sigaddset(&ss, SIGUSR2); ts.tv_sec = 0; ts.tv_nsec = 100000000; /* 0.1 sec */ while (!g_shutdown) { ret = sigtimedwait(&ss, NULL, &ts); if (ret == -1) { if (errno == EAGAIN || errno == EINTR) continue; abort(); } if (ret == SIGINT || ret == SIGTERM) g_shutdown = 1; else if (ret == SIGUSR1) { if (get_log_level() > 0) { g_atomic_int_add(&log_level, -1); setlogmask(LOG_UPTO(get_log_level())); ilog(get_log_level(), "Set log level to %d\n", get_log_level()); } } else if (ret == SIGUSR2) { if (get_log_level() < 7) { g_atomic_int_add(&log_level, 1); setlogmask(LOG_UPTO(get_log_level())); ilog(get_log_level(), "Set log level to %d\n", get_log_level()); } } else abort(); } }
asmlinkage void console_init(void) { init_log_level(); if (CONFIG(DEBUG_CONSOLE_INIT)) car_set_var(console_inited, 1); if (CONFIG(EARLY_PCI_BRIDGE) && !ENV_SMM && !ENV_RAMSTAGE) pci_early_bridge_init(); console_hw_init(); car_set_var(console_inited, 1); printk(BIOS_NOTICE, "\n\ncoreboot-%s%s %s " ENV_STRING " starting (log level: %i)...\n", coreboot_version, coreboot_extra_version, coreboot_build, get_log_level()); }
void layout_log(const swayc_t *c, int depth) { if (L_DEBUG > get_log_level()) return; int i, d; int e = c->children ? c->children->length : 0; container_log(c, depth); if (e) { for (i = 0; i < e; ++i) { fputc('|',stderr); for (d = 0; d < depth; ++d) fputc('-', stderr); layout_log(c->children->items[i], depth + 1); } } if (c->type == C_WORKSPACE) { e = c->floating?c->floating->length:0; if (e) { for (i = 0; i < e; ++i) { fputc('|',stderr); for (d = 0; d < depth; ++d) fputc('=', stderr); layout_log(c->floating->items[i], depth + 1); } } } }
int win32_log_print(int prio, const char *tag, const char *fmt, ...) { static char msg[1024] = {0}; va_list ap; va_start(ap, fmt); #ifdef SAVE_LOG_FILE char header[128] = {0}; _snprintf_s(header, 128, "[%s] %s", tag, fmt); int cnt = _vsnprintf_s(msg, sizeof(msg), header, ap); apLog::print(0, get_log_level2(prio), "%s", msg); // "%s", msg : avoid url "%" error #else int64_t msec = 0;//getNowMs(); _snprintf_s(msg, 1024, "[0 sec] [%s] [%s] %s\n", get_log_level(prio), tag, fmt); int cnt = vprintf(msg, ap); #endif va_end(ap); return cnt; }
static void dump_cert(struct dtls_cert *cert) { FILE *fp; char *buf; size_t len; if (get_log_level() < LOG_DEBUG) return; /* cert */ fp = open_memstream(&buf, &len); PEM_write_X509(fp, cert->x509); fclose(fp); ilog(LOG_DEBUG, "Dump of DTLS certificate:"); buf_dump_free(buf, len); /* key */ fp = open_memstream(&buf, &len); PEM_write_PrivateKey(fp, cert->pkey, NULL, NULL, 0, 0, NULL); fclose(fp); ilog(LOG_DEBUG, "Dump of DTLS private key:"); buf_dump_free(buf, len); }
int http_read(file_handle_t* handler, void* output_buffer, int data_size, int offset_from_file_start, int flags){ http_file_handler_t* ofh = (http_file_handler_t*)handler; long long bytes_read = 0; request_rec* req_r = ofh->r; apr_pool_t* cache_pool = NULL; hls_cache_line_t* cache_line = NULL; long long full_size = 0; // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 0"); if (offset_from_file_start == 0 && data_size == sizeof(cache_line->buffer)){ apr_pool_userdata_get(&cache_pool, HLS_GLOBAL_CACHE_NAME, req_r->server->process->pool); if (cache_pool){ // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 2"); apr_pool_userdata_get(&cache_line, ofh->link, cache_pool); }else{ apr_pool_create(&cache_pool, req_r->server->process->pool); if (cache_pool){ //ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "cache created"); apr_pool_userdata_set(cache_pool, HLS_GLOBAL_CACHE_NAME, NULL, req_r->server->process->pool); } } // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 3"); if (cache_pool && !cache_line){ // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 4"); cache_line = (char*)apr_pcalloc(cache_pool, sizeof(hls_cache_line_t)); if (cache_line){ // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 5"); cache_line->size = 0; memset(cache_line->buffer, 0 , sizeof(cache_line->buffer)); apr_pool_userdata_set(cache_line, ofh->link, NULL, cache_pool); //ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "put file size to cache. file =%s, size=%d", filename, (int)size); } } if (cache_line){ //ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "cache found"); if (cache_line->buffer[0] == 0 && cache_line->buffer[1] == 0 && cache_line->buffer[2] == 0 && cache_line->buffer[3] == 0 || (flags & FIRST_ACCESS)){ // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 6 %s with data offset = %d, data_size=%d", ofh->link, (int)offset_from_file_start, (int)data_size ); CURLcode res = curl_get_data(ofh->link, output_buffer, offset_from_file_start, data_size, &bytes_read, flags, &full_size); ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: get header data returns result %d", (int)res); if (res == CURLE_OK){ ofh->content_length = cache_line->size = full_size; memcpy(cache_line->buffer, output_buffer, min(sizeof(cache_line->buffer),bytes_read)); return bytes_read; } }else{ //ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "get values from cache"); memcpy(output_buffer, cache_line->buffer, min(sizeof(cache_line->buffer),cache_line->size)); } // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 8"); ofh->content_length = cache_line->size; ofh->last_error_code = 0; return cache_line->size; } } // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 9 %s with data offset = %d, data_size=%d", ofh->link, (int)offset_from_file_start, (int)data_size ); CURLcode res = curl_get_data(ofh->link, output_buffer, offset_from_file_start, data_size, &bytes_read, flags, &full_size); if (ofh->content_length == 0) ofh->content_length = full_size; ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: get data returns result %d", (int)res); // ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "http read 10"); //ap_log_error(APLOG_MARK, APLOG_ERR, 0, req_r->server, "reading non cached data filename=%s, offset=%d, size=%d", ofh->link, offset_from_file_start, data_size); if (res == CURLE_OK){ return bytes_read; } return 0;//return number of bytes }
int main(int argc, char *argv[]) { const char *homedir; parse_arguments(argc, argv); flowlist=malloc(sizeof(flist_t)); flist_init(flowlist); clientlist = malloc(sizeof(flist_t)); flist_init(clientlist); gflist = malloc(sizeof(global_function_list_t)); gflist->fflist=malloc(sizeof(flist_t)); flist_init(gflist->fflist); gflist->lock = 0; homedir = getenv("HOME"); if (homedir == NULL) { fputs("Environment variable HOME not set. Giving up.\n", stderr); exit( 1); } mapid_conf = printf_string( CONFDIR"/"CONF_FILE ); printf("using %s\n", mapid_conf); log_level = get_log_level(mapid_conf); // get log level from mapi.conf if (log_to_syslog) // logging to syslog is enabled open_syslog(log_level, "MAPID"); log_to_file = set_logging_to_file(mapid_conf, &log_fd_info, &log_fd_debug); // support for logging to file if (log_to_syslog == 0 && log_to_file == 0) log_level = LOGGING_DISABLED; if (log_to_syslog == 0) printf("logging to syslog: disabled\n"); else printf("logging to syslog: enabled - LogLevel: %d\n", log_level); if (log_to_file) { daemon_started(log_fd_info, "MAPID", daemonize, 0); daemon_started(log_fd_debug, "MAPID", daemonize, 0); } if (log_to_syslog) log_message( "MAPID was started %s%s", daemonize ? " ( is running as daemon )" : ""); drvlist = load_drivers(); if (drvlist == NULL) { DEBUG_CMD(Debug_Message("ERROR: No MAPI drivers found")); exit(EXIT_FAILURE); } // Grab some signals so we can mapid_shutdown gracefully signal(SIGTERM, mapid_shutdown); signal(SIGQUIT, mapid_shutdown); signal(SIGINT, mapid_shutdown); if (daemonize) continue_as_daemon(); mapidcom(); mapid_shutdown(0); // wait for shutdown to finish // espenb TODO: use pthread_cond_wait (or similar) instead while (running_shutdown != 2) usleep(10000); return 0; }
void wat_log(int level, char *msg) { if(get_log_level() >= level){ printf("%s", msg); } }
static void _task_finish(task_exit_msg_t *msg) { char *tasks = NULL, *hosts = NULL; bool build_task_string = false; uint32_t rc = 0; int normal_exit = 0; static int reduce_task_exit_msg = -1; static int msg_printed = 0, last_task_exit_rc; const char *task_str = _taskstr(msg->num_tasks); if (reduce_task_exit_msg == -1) { char *ptr = getenv("SLURM_SRUN_REDUCE_TASK_EXIT_MSG"); if (ptr && atoi(ptr) != 0) reduce_task_exit_msg = 1; else reduce_task_exit_msg = 0; } verbose("Received task exit notification for %d %s (status=0x%04x).", msg->num_tasks, task_str, msg->return_code); /* Only build the "tasks" and "hosts" strings as needed. Buidling them * can take multiple milliseconds */ if (WIFEXITED(msg->return_code)) { if ((rc = WEXITSTATUS(msg->return_code)) == 0) { if (get_log_level() >= LOG_LEVEL_VERBOSE) build_task_string = true; } else { build_task_string = true; } } else if (WIFSIGNALED(msg->return_code)) { if (local_srun_job->state >= SRUN_JOB_CANCELLED) { if (get_log_level() >= LOG_LEVEL_VERBOSE) build_task_string = true; } else { build_task_string = true; } } if (build_task_string) { tasks = _task_array_to_string(msg->num_tasks, msg->task_id_list); hosts = _task_ids_to_host_list(msg->num_tasks, msg->task_id_list); } slurm_mutex_lock(&launch_lock); if (WIFEXITED(msg->return_code)) { if ((rc = WEXITSTATUS(msg->return_code)) == 0) { verbose("%s: %s %s: Completed", hosts, task_str, tasks); normal_exit = 1; } else if (_is_openmpi_port_error(rc)) { _handle_openmpi_port_error(tasks, hosts, local_srun_job->step_ctx); } else if ((reduce_task_exit_msg == 0) || (msg_printed == 0) || (msg->return_code != last_task_exit_rc)) { error("%s: %s %s: Exited with exit code %d", hosts, task_str, tasks, rc); msg_printed = 1; } if (!WIFEXITED(*local_global_rc) || (rc > WEXITSTATUS(*local_global_rc))) *local_global_rc = msg->return_code; } else if (WIFSIGNALED(msg->return_code)) { const char *signal_str = strsignal(WTERMSIG(msg->return_code)); char * core_str = ""; #ifdef WCOREDUMP if (WCOREDUMP(msg->return_code)) core_str = " (core dumped)"; #endif if (local_srun_job->state >= SRUN_JOB_CANCELLED) { verbose("%s: %s %s: %s%s", hosts, task_str, tasks, signal_str, core_str); } else if ((reduce_task_exit_msg == 0) || (msg_printed == 0) || (msg->return_code != last_task_exit_rc)) { error("%s: %s %s: %s%s", hosts, task_str, tasks, signal_str, core_str); msg_printed = 1; } if (*local_global_rc == NO_VAL) *local_global_rc = msg->return_code; } xfree(tasks); xfree(hosts); _update_task_exit_state(msg->num_tasks, msg->task_id_list, !normal_exit); if (task_state_first_abnormal_exit(task_state) && _kill_on_bad_exit()) launch_p_step_terminate(); if (task_state_first_exit(task_state) && (opt.max_wait > 0)) _setup_max_wait_timer(); last_task_exit_rc = msg->return_code; slurm_mutex_unlock(&launch_lock); }
int DEFAULT_CC main(int argc, char **argv) { tbus waiters[4]; int pid = 0; char text[256]; char* log_path; char *display_text; char log_file[256]; enum logReturns error; struct log_config logconfig; unsigned int log_level; g_init("xrdp-chansrv"); /* os_calls */ log_path = get_log_path(); if (log_path == 0) { g_writeln("error reading CHANSRV_LOG_PATH and HOME environment variable"); g_deinit(); return 1; } read_ini(); pid = g_getpid(); log_level = get_log_level(g_getenv("CHANSRV_LOG_LEVEL"), LOG_LEVEL_ERROR); /* starting logging subsystem */ g_memset(&logconfig, 0, sizeof(struct log_config)); logconfig.program_name = "XRDP-Chansrv"; g_snprintf(log_file, 255, "%s/xrdp-chansrv.log", log_path); g_writeln("chansrv::main: using log file [%s]", log_file); if (g_file_exist(log_file)) { g_file_delete(log_file); } logconfig.log_file = log_file; logconfig.fd = -1; logconfig.log_level = log_level; logconfig.enable_syslog = 0; logconfig.syslog_level = 0; error = log_start_from_param(&logconfig); if (error != LOG_STARTUP_OK) { switch (error) { case LOG_ERROR_MALLOC: g_writeln("error on malloc. cannot start logging. quitting."); break; case LOG_ERROR_FILE_OPEN: g_writeln("error opening log file [%s]. quitting.", getLogFile(text, 255)); break; default: g_writeln("log_start error"); break; } g_deinit(); return 1; } LOGM((LOG_LEVEL_ALWAYS, "main: app started pid %d(0x%8.8x)", pid, pid)); /* set up signal handler */ g_signal_kill(term_signal_handler); /* SIGKILL */ g_signal_terminate(term_signal_handler); /* SIGTERM */ g_signal_user_interrupt(term_signal_handler); /* SIGINT */ g_signal_pipe(nil_signal_handler); /* SIGPIPE */ g_signal_child_stop(child_signal_handler); /* SIGCHLD */ g_signal_segfault(segfault_signal_handler); display_text = g_getenv("DISPLAY"); LOGM((LOG_LEVEL_INFO, "main: DISPLAY env var set to %s", display_text)); get_display_num_from_display(display_text); if (g_display_num == 0) { LOGM((LOG_LEVEL_ERROR, "main: error, display is zero")); g_deinit(); return 1; } LOGM((LOG_LEVEL_INFO, "main: using DISPLAY %d", g_display_num)); g_snprintf(text, 255, "xrdp_chansrv_%8.8x_main_term", pid); g_term_event = g_create_wait_obj(text); g_snprintf(text, 255, "xrdp_chansrv_%8.8x_thread_done", pid); g_thread_done_event = g_create_wait_obj(text); g_snprintf(text, 255, "xrdp_chansrv_%8.8x_exec", pid); g_exec_event = g_create_wait_obj(text); g_exec_mutex = tc_mutex_create(); g_exec_sem = tc_sem_create(0); tc_thread_create(channel_thread_loop, 0); while (g_term_event > 0 && !g_is_wait_obj_set(g_term_event)) { waiters[0] = g_term_event; waiters[1] = g_exec_event; if (g_obj_wait(waiters, 2, 0, 0, 0) != 0) { LOGM((LOG_LEVEL_ERROR, "main: error, g_obj_wait failed")); break; } if (g_is_wait_obj_set(g_term_event)) { break; } if (g_is_wait_obj_set(g_exec_event)) { g_reset_wait_obj(g_exec_event); run_exec(); } } while (g_thread_done_event > 0 && !g_is_wait_obj_set(g_thread_done_event)) { /* wait for thread to exit */ if (g_obj_wait(&g_thread_done_event, 1, 0, 0, 0) != 0) { LOGM((LOG_LEVEL_ERROR, "main: error, g_obj_wait failed")); break; } } /* cleanup */ main_cleanup(); LOGM((LOG_LEVEL_INFO, "main: app exiting pid %d(0x%8.8x)", pid, pid)); g_deinit(); return 0; }
static void control_ng_incoming(struct obj *obj, str *buf, const endpoint_t *sin, char *addr, struct udp_listener *ul) { struct control_ng *c = (void *) obj; bencode_buffer_t bencbuf; bencode_item_t *dict, *resp; str cmd, cookie, data, reply, *to_send, callid; const char *errstr; struct iovec iov[3]; unsigned int iovlen; GString *log_str; struct control_ng_stats* cur = get_control_ng_stats(c,&sin->address); str_chr_str(&data, buf, ' '); if (!data.s || data.s == buf->s) { ilog(LOG_WARNING, "Received invalid data on NG port (no cookie) from %s: "STR_FORMAT, addr, STR_FMT(buf)); return; } bencode_buffer_init(&bencbuf); resp = bencode_dictionary(&bencbuf); cookie = *buf; cookie.len -= data.len; *data.s++ = '\0'; data.len--; errstr = "Invalid data (no payload)"; if (data.len <= 0) goto err_send; to_send = cookie_cache_lookup(&c->cookie_cache, &cookie); if (to_send) { ilog(LOG_INFO, "Detected command from %s as a duplicate", addr); resp = NULL; goto send_only; } dict = bencode_decode_expect_str(&bencbuf, &data, BENCODE_DICTIONARY); errstr = "Could not decode dictionary"; if (!dict) goto err_send; bencode_dictionary_get_str(dict, "command", &cmd); errstr = "Dictionary contains no key \"command\""; if (!cmd.s) goto err_send; bencode_dictionary_get_str(dict, "call-id", &callid); log_info_str(&callid); ilog(LOG_INFO, "Received command '"STR_FORMAT"' from %s", STR_FMT(&cmd), addr); if (get_log_level() >= LOG_DEBUG) { log_str = g_string_sized_new(256); g_string_append_printf(log_str, "Dump for '"STR_FORMAT"' from %s: ", STR_FMT(&cmd), addr); pretty_print(dict, log_str); ilog(LOG_DEBUG, "%.*s", (int) log_str->len, log_str->str); g_string_free(log_str, TRUE); } errstr = NULL; if (!str_cmp(&cmd, "ping")) { bencode_dictionary_add_string(resp, "result", "pong"); g_atomic_int_inc(&cur->ping); } else if (!str_cmp(&cmd, "offer")) { errstr = call_offer_ng(dict, c->callmaster, resp, addr, sin); g_atomic_int_inc(&cur->offer); } else if (!str_cmp(&cmd, "answer")) { errstr = call_answer_ng(dict, c->callmaster, resp); g_atomic_int_inc(&cur->answer); } else if (!str_cmp(&cmd, "delete")) { errstr = call_delete_ng(dict, c->callmaster, resp); g_atomic_int_inc(&cur->delete); }
int argt_func(int argc, char **argv) { int opt, ret = 1; struct option longopts[] = { { "help", 0, NULL, 'h' }, //1 { "version", 0, NULL, 'v' }, //2 { "save", 0, NULL, 's' }, //3 { "read", 0, NULL, 'r' }, //4 { "show", 0, NULL, 'c' }, //5 { "selist", 0, NULL, 'l' }, //6 { "loglevel", 1, NULL, 'L' }, //7 { "id", 1, NULL, 'N' }, //8 { "addr", 1, NULL, 'A' }, //9 { "rip", 1, NULL, 'I' }, //10 { "rport", 1, NULL, 'P' }, //11 { 0, 0, 0, 0 }, }; cfg.rf433.net_id = RF433_CFG_NET_ID; cfg.rf433.local_addr = RF433_CFG_LOCAL_ADDR; cfg.rf433.m_mask = 0; cfg.socket.server_ip.s_addr = inet_addr(RF433_CFG_SRV_IP); cfg.socket.server_port = RF433_CFG_UDP_PORT; cfg.socket.m_mask = 0; se433_set.se433_addr = 0; se433_set.op = 0; if (argc <= 1) { printf(USAGE); ret = 0; goto err; } while ((opt = getopt_long(argc, argv, "hvsrclL:N:A:I:P:", longopts, NULL)) != -1) { switch (opt) { case 's': // save opt_id = MSG_REQ_SAVE_CFG; break; case 'r': // read opt_id = MSG_REQ_READ_CFG; break; case 'c': // show opt_id = MSG_REQ_GET_CFG; break; case 'l': // se433 list opt_id = MSG_REQ_GET_SE433L; break; case 'L': // loglevel if ((get_log_level(optarg, &log_level)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } opt_id = MSG_REQ_SET_LOG; break; case 'N': // netid if ((get_netid(optarg, &cfg.rf433.net_id)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } cfg.rf433.m_mask |= RF433_MASK_NET_ID; opt_id = MSG_REQ_SET_CFG; break; case 'A': // addr if ((get_local_addr(optarg, &cfg.rf433.local_addr)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } cfg.rf433.m_mask |= RF433_MASK_RCV_ADDR; opt_id = MSG_REQ_SET_CFG; break; #if 0 case 'E': // seadd if ((get_se433_addr(optarg, &se433_set.se433_addr)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } se433_set.op = SE433_OP_ADD; break; case 'D': // sedel if ((get_se433_addr(optarg, &se433_set.se433_addr)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } se433_set.op = SE433_OP_DEL; break; #endif case 'I': // rip if ((get_ip(optarg, &cfg.socket.server_ip)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } cfg.socket.m_mask |= SOCK_MASK_SER_IP; opt_id = MSG_REQ_SET_CFG; break; case 'P': // rport if ((get_port(optarg, &cfg.socket.server_port)) == -1) { fprintf(stderr, "\n invalid value (%s)\n\n", optarg); ret = -1; goto err; } cfg.socket.m_mask |= SOCK_MASK_UDP_PORT; opt_id = MSG_REQ_SET_CFG; break; case 'h': case 'v': printf(USAGE); ret = 0; goto err; break; default: fprintf(stderr, "%s: invalid opt (%c)\n\n", argv[0], opt); printf(USAGE); ret = 0; goto err; break; } } err: return ret; }