void inicializarLog() {
remove(LOG_PATH);
logFile = log_create(LOG_PATH, "ProcesoNivel", false,
log_level_from_string(configObj->logLevel));
separador_log(configObj->nombre);
}
static void
_init(char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGWINCH, ui_sigwinch_handler);
if (pthread_mutex_init(&lock, NULL) != 0) {
log_error("Mutex init failed");
exit(1);
}
pthread_mutex_lock(&lock);
files_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
log_stderr_init(PROF_LEVEL_ERROR);
if (strcmp(PACKAGE_STATUS, "development") == 0) {
#ifdef HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
session_init();
cmd_init();
log_info("Initialising contact list");
muc_init();
tlscerts_init();
scripts_init();
#ifdef HAVE_LIBOTR
otr_init();
#endif
#ifdef HAVE_LIBGPGME
p_gpg_init();
#endif
#ifdef HAVE_OMEMO
omemo_init();
#endif
atexit(_shutdown);
plugins_init();
#ifdef HAVE_GTK
tray_init();
#endif
inp_nonblocking(TRUE);
ui_resize();
}
int log_set_max_level_from_string(const char *e) {
int t;
t = log_level_from_string(e);
if (t < 0)
return t;
log_set_max_level(t);
return 0;
}
void levantarCfg(char **ip, int32_t *port,t_log_level *log_level, uint8_t *maxThreads, char **nombreArchivo, char** ipCache, int32_t *portCache) {
char *log_level_str;
t_config *s_cfg = config_create("cfgRfs.txt");
if(config_has_property(s_cfg,"port")) {
*port = config_get_int_value(s_cfg,"port");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"ip")) {
*ip = config_get_string_value(s_cfg,"ip");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"log")) {
log_level_str = config_get_string_value(s_cfg,"log");
*log_level = log_level_from_string(log_level_str);
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"hilos")) {
*maxThreads = config_get_int_value(s_cfg,"hilos");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"archivo")) {
*nombreArchivo = config_get_string_value(s_cfg,"archivo");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"delay")) { //delay var global
delay = (config_get_int_value(s_cfg,"delay"))*1000;
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"ipCache")) { //delay var global
*ipCache = config_get_string_value(s_cfg,"ipCache");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"portCache")) { //delay var global
*portCache = config_get_int_value(s_cfg,"portCache");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
}
static void
parse_log_level_option(gchar *log_lvl)
{
gchar **parts = g_strsplit(log_lvl, ",", 0);
for (gchar **part = parts; *part; part++) {
log_level_t lvl;
if (!log_level_from_string(&lvl, *part))
log_set_verbosity("all", lvl);
else {
gchar *sep = strchr(*part, '=');
if (sep && !log_level_from_string(&lvl, sep+1)) {
*sep = '\0';
log_set_verbosity(*part, lvl);
} else
warn("ignoring unrecognized --log option '%s'", *part);
}
}
g_strfreev(parts);
}
static void
_init(char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGWINCH, ui_sigwinch_handler);
_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
log_stderr_init(PROF_LEVEL_ERROR);
if (strcmp(PROF_PACKAGE_STATUS, "development") == 0) {
#ifdef PROF_HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PROF_PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PROF_PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PROF_PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
jabber_init();
cmd_init();
log_info("Initialising contact list");
muc_init();
tlscerts_init();
scripts_init();
#ifdef PROF_HAVE_LIBOTR
otr_init();
#endif
#ifdef PROF_HAVE_LIBGPGME
p_gpg_init();
#endif
atexit(_shutdown);
plugins_init();
#ifdef PROF_HAVE_GTK
if (gtk_ready) {
log_debug("Building GTK icon");
create_tray();
}
#endif
inp_nonblocking(TRUE);
}
static void
_init(const int disable_tls, char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
if (strcmp(PACKAGE_STATUS, "development") == 0) {
#ifdef HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
jabber_init(disable_tls);
cmd_init();
log_info("Initialising contact list");
roster_init();
muc_init();
#ifdef HAVE_LIBOTR
otr_init();
#endif
atexit(_shutdown);
ui_input_nonblocking(TRUE);
}
int main(int argc, char *argv[]) {
logger = log_create("MaRTA.log", "MaRTA", 1, log_level_from_string("TRACE"));
cantJobs = 0;
if (argc != 2) {
log_error(logger, "Missing config file");
freeMaRTA();
return EXIT_FAILURE;
}
if (!initConfig(argv[1])) {
log_error(logger, "Config failed");
freeMaRTA();
return EXIT_FAILURE;
}
nodes = list_create();
signal(SIGINT, freeMaRTA);
initConnection();
list_destroy_and_destroy_elements(nodes, (void *) freeNode);
freeMaRTA();
return EXIT_SUCCESS;
}
void filesystem_initialize() {
mdfs_logger = log_create("filesystem.log", "MDFS", 0, log_level_from_string("TRACE"));
mongo_dir_init();
mongo_file_init();
mongo_node_init();
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_LEVEL_PREFIX
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "identifier", required_argument, NULL, 't' },
{ "priority", required_argument, NULL, 'p' },
{ "level-prefix", required_argument, NULL, ARG_LEVEL_PREFIX },
{}
};
int c;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "+ht:p:", options, NULL)) >= 0)
switch (c) {
case 'h':
help();
return 0;
case ARG_VERSION:
return version();
case 't':
if (isempty(optarg))
arg_identifier = NULL;
else
arg_identifier = optarg;
break;
case 'p':
arg_priority = log_level_from_string(optarg);
if (arg_priority < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse priority value.");
break;
case ARG_LEVEL_PREFIX: {
int k;
k = parse_boolean(optarg);
if (k < 0)
return log_error_errno(k, "Failed to parse level prefix value.");
arg_level_prefix = k;
break;
}
case '?':
return -EINVAL;
default:
assert_not_reached("Unhandled option");
}
return 1;
}
void log_crear(char* log_level, char* ruta_log, char* proceso) {
logger_consola = log_create(ruta_log, proceso, true, log_level_from_string(log_level));
logger_interno = log_create(ruta_log, proceso, false, log_level_from_string(log_level));
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_LEVEL_PREFIX
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "identifier", required_argument, NULL, 't' },
{ "priority", required_argument, NULL, 'p' },
{ "level-prefix", required_argument, NULL, ARG_LEVEL_PREFIX },
{ NULL, 0, NULL, 0 }
};
int c;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "+ht:p:", options, NULL)) >= 0) {
switch (c) {
case 'h':
help();
return 0;
case ARG_VERSION:
puts(PACKAGE_STRING);
puts(SYSTEMD_FEATURES);
return 0;
case 't':
free(arg_identifier);
if (isempty(optarg))
arg_identifier = NULL;
else {
arg_identifier = strdup(optarg);
if (!arg_identifier)
return log_oom();
}
break;
case 'p':
arg_priority = log_level_from_string(optarg);
if (arg_priority < 0) {
log_error("Failed to parse priority value.");
return arg_priority;
}
break;
case ARG_LEVEL_PREFIX: {
int k;
k = parse_boolean(optarg);
if (k < 0) {
log_error("Failed to parse level prefix value.");
return k;
}
arg_level_prefix = k;
break;
}
default:
log_error("Unknown option code %c", c);
return -EINVAL;
}
}
return 1;
}
void logger_initialize(char* file, char* exe_name, char* log_level, int console){
t_log_level elv = log_level_from_string(log_level);
instance = log_create(file, exe_name, console, elv);
}
static int stdout_stream_load(StdoutStream *stream, const char *fname) {
_cleanup_free_ char
*priority = NULL,
*level_prefix = NULL,
*forward_to_syslog = NULL,
*forward_to_kmsg = NULL,
*forward_to_console = NULL,
*stream_id = NULL;
int r;
assert(stream);
assert(fname);
if (!stream->state_file) {
stream->state_file = strappend("/run/systemd/journal/streams/", fname);
if (!stream->state_file)
return log_oom();
}
r = parse_env_file(stream->state_file, NEWLINE,
"PRIORITY", &priority,
"LEVEL_PREFIX", &level_prefix,
"FORWARD_TO_SYSLOG", &forward_to_syslog,
"FORWARD_TO_KMSG", &forward_to_kmsg,
"FORWARD_TO_CONSOLE", &forward_to_console,
"IDENTIFIER", &stream->identifier,
"UNIT", &stream->unit_id,
"STREAM_ID", &stream_id,
NULL);
if (r < 0)
return log_error_errno(r, "Failed to read: %s", stream->state_file);
if (priority) {
int p;
p = log_level_from_string(priority);
if (p >= 0)
stream->priority = p;
}
if (level_prefix) {
r = parse_boolean(level_prefix);
if (r >= 0)
stream->level_prefix = r;
}
if (forward_to_syslog) {
r = parse_boolean(forward_to_syslog);
if (r >= 0)
stream->forward_to_syslog = r;
}
if (forward_to_kmsg) {
r = parse_boolean(forward_to_kmsg);
if (r >= 0)
stream->forward_to_kmsg = r;
}
if (forward_to_console) {
r = parse_boolean(forward_to_console);
if (r >= 0)
stream->forward_to_console = r;
}
if (stream_id) {
sd_id128_t id;
r = sd_id128_from_string(stream_id, &id);
if (r >= 0)
xsprintf(stream->id_field, "_STREAM_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(id));
}
return 0;
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
ARG_NO_PAGER,
ARG_NO_TAIL,
ARG_NEW_ID128,
ARG_ROOT,
ARG_HEADER,
ARG_FULL,
ARG_SETUP_KEYS,
ARG_INTERVAL,
ARG_VERIFY,
ARG_VERIFY_KEY,
ARG_DISK_USAGE,
ARG_SINCE,
ARG_UNTIL,
ARG_USER_UNIT,
ARG_LIST_CATALOG,
ARG_DUMP_CATALOG,
ARG_UPDATE_CATALOG
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version" , no_argument, NULL, ARG_VERSION },
{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
{ "pager-end", no_argument, NULL, 'e' },
{ "follow", no_argument, NULL, 'f' },
{ "output", required_argument, NULL, 'o' },
{ "all", no_argument, NULL, 'a' },
{ "full", no_argument, NULL, ARG_FULL },
{ "lines", optional_argument, NULL, 'n' },
{ "no-tail", no_argument, NULL, ARG_NO_TAIL },
{ "new-id128", no_argument, NULL, ARG_NEW_ID128 },
{ "quiet", no_argument, NULL, 'q' },
{ "merge", no_argument, NULL, 'm' },
{ "this-boot", no_argument, NULL, 'b' },
{ "directory", required_argument, NULL, 'D' },
{ "root", required_argument, NULL, ARG_ROOT },
{ "header", no_argument, NULL, ARG_HEADER },
{ "priority", required_argument, NULL, 'p' },
{ "setup-keys", no_argument, NULL, ARG_SETUP_KEYS },
{ "interval", required_argument, NULL, ARG_INTERVAL },
{ "verify", no_argument, NULL, ARG_VERIFY },
{ "verify-key", required_argument, NULL, ARG_VERIFY_KEY },
{ "disk-usage", no_argument, NULL, ARG_DISK_USAGE },
{ "cursor", required_argument, NULL, 'c' },
{ "since", required_argument, NULL, ARG_SINCE },
{ "until", required_argument, NULL, ARG_UNTIL },
{ "unit", required_argument, NULL, 'u' },
{ "user-unit", required_argument, NULL, ARG_USER_UNIT },
{ "field", required_argument, NULL, 'F' },
{ "catalog", no_argument, NULL, 'x' },
{ "list-catalog", no_argument, NULL, ARG_LIST_CATALOG },
{ "dump-catalog", no_argument, NULL, ARG_DUMP_CATALOG },
{ "update-catalog",no_argument, NULL, ARG_UPDATE_CATALOG },
{ "reverse", no_argument, NULL, 'r' },
{ NULL, 0, NULL, 0 }
};
int c, r;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "hefo:an::qmbD:p:c:u:F:xr", options, NULL)) >= 0) {
switch (c) {
case 'h':
help();
return 0;
case ARG_VERSION:
puts(PACKAGE_STRING);
puts(SYSTEMD_FEATURES);
return 0;
case ARG_NO_PAGER:
arg_no_pager = true;
break;
case 'e':
arg_pager_end = true;
if (arg_lines < 0)
arg_lines = 1000;
break;
case 'f':
arg_follow = true;
break;
case 'o':
arg_output = output_mode_from_string(optarg);
if (arg_output < 0) {
log_error("Unknown output format '%s'.", optarg);
return -EINVAL;
}
if (arg_output == OUTPUT_EXPORT ||
arg_output == OUTPUT_JSON ||
arg_output == OUTPUT_JSON_PRETTY ||
arg_output == OUTPUT_JSON_SSE ||
arg_output == OUTPUT_CAT)
arg_quiet = true;
break;
case ARG_FULL:
arg_full = true;
break;
case 'a':
arg_all = true;
break;
case 'n':
if (optarg) {
r = safe_atoi(optarg, &arg_lines);
if (r < 0 || arg_lines < 0) {
log_error("Failed to parse lines '%s'", optarg);
return -EINVAL;
}
} else {
int n;
/* Hmm, no argument? Maybe the next
* word on the command line is
* supposed to be the argument? Let's
* see if there is one, and is
* parsable as a positive
* integer... */
if (optind < argc &&
safe_atoi(argv[optind], &n) >= 0 &&
n >= 0) {
arg_lines = n;
optind++;
} else
arg_lines = 10;
}
break;
case ARG_NO_TAIL:
arg_no_tail = true;
break;
case ARG_NEW_ID128:
arg_action = ACTION_NEW_ID128;
break;
case 'q':
arg_quiet = true;
break;
case 'm':
arg_merge = true;
break;
case 'b':
arg_this_boot = true;
break;
case 'D':
arg_directory = optarg;
break;
case ARG_ROOT:
arg_root = optarg;
break;
case 'c':
arg_cursor = optarg;
break;
case ARG_HEADER:
arg_action = ACTION_PRINT_HEADER;
break;
case ARG_VERIFY:
arg_action = ACTION_VERIFY;
break;
case ARG_DISK_USAGE:
arg_action = ACTION_DISK_USAGE;
break;
#ifdef HAVE_GCRYPT
case ARG_SETUP_KEYS:
arg_action = ACTION_SETUP_KEYS;
break;
case ARG_VERIFY_KEY:
arg_action = ACTION_VERIFY;
arg_verify_key = optarg;
arg_merge = false;
break;
case ARG_INTERVAL:
r = parse_sec(optarg, &arg_interval);
if (r < 0 || arg_interval <= 0) {
log_error("Failed to parse sealing key change interval: %s", optarg);
return -EINVAL;
}
break;
#else
case ARG_SETUP_KEYS:
case ARG_VERIFY_KEY:
case ARG_INTERVAL:
log_error("Forward-secure sealing not available.");
return -ENOTSUP;
#endif
case 'p': {
const char *dots;
dots = strstr(optarg, "..");
if (dots) {
char *a;
int from, to, i;
/* a range */
a = strndup(optarg, dots - optarg);
if (!a)
return log_oom();
from = log_level_from_string(a);
to = log_level_from_string(dots + 2);
free(a);
if (from < 0 || to < 0) {
log_error("Failed to parse log level range %s", optarg);
return -EINVAL;
}
arg_priorities = 0;
if (from < to) {
for (i = from; i <= to; i++)
arg_priorities |= 1 << i;
} else {
for (i = to; i <= from; i++)
arg_priorities |= 1 << i;
}
} else {
int p, i;
p = log_level_from_string(optarg);
if (p < 0) {
log_error("Unknown log level %s", optarg);
return -EINVAL;
}
arg_priorities = 0;
for (i = 0; i <= p; i++)
arg_priorities |= 1 << i;
}
break;
}
case ARG_SINCE:
r = parse_timestamp(optarg, &arg_since);
if (r < 0) {
log_error("Failed to parse timestamp: %s", optarg);
return -EINVAL;
}
arg_since_set = true;
break;
case ARG_UNTIL:
r = parse_timestamp(optarg, &arg_until);
if (r < 0) {
log_error("Failed to parse timestamp: %s", optarg);
return -EINVAL;
}
arg_until_set = true;
break;
case 'u':
r = strv_extend(&arg_system_units, optarg);
if (r < 0)
return log_oom();
break;
case ARG_USER_UNIT:
r = strv_extend(&arg_user_units, optarg);
if (r < 0)
return log_oom();
break;
case '?':
return -EINVAL;
case 'F':
arg_field = optarg;
break;
case 'x':
arg_catalog = true;
break;
case ARG_LIST_CATALOG:
arg_action = ACTION_LIST_CATALOG;
break;
case ARG_DUMP_CATALOG:
arg_action = ACTION_DUMP_CATALOG;
break;
case ARG_UPDATE_CATALOG:
arg_action = ACTION_UPDATE_CATALOG;
break;
case 'r':
arg_reverse = true;
break;
default:
log_error("Unknown option code %c", c);
return -EINVAL;
}
}
if (arg_follow && !arg_no_tail && arg_lines < 0)
arg_lines = 10;
if (arg_since_set && arg_until_set && arg_since > arg_until) {
log_error("--since= must be before --until=.");
return -EINVAL;
}
if (arg_cursor && arg_since_set) {
log_error("Please specify either --since= or --cursor=, not both.");
return -EINVAL;
}
if (arg_follow && arg_reverse) {
log_error("Please specify either --reverse= or --follow=, not both.");
return -EINVAL;
}
return 1;
}
