/* 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;
}
