void parse_osinfo_for_rhts(map_string_t *osinfo, char** product, char** version)
{
const char *name = get_map_string_item_or_NULL(osinfo, "REDHAT_SUPPORT_PRODUCT");
if (!name)
name = get_map_string_item_or_NULL(osinfo, OSINFO_NAME);
const char *version_id = get_map_string_item_or_NULL(osinfo, "REDHAT_SUPPORT_PRODUCT_VERSION");
if (!version_id)
version_id = get_map_string_item_or_NULL(osinfo, OSINFO_VERSION_ID);
if (name && version_id)
{
*product = xstrdup(name);
*version = xstrdup(version_id);
return;
}
const char *pretty = get_map_string_item_or_NULL(osinfo, OSINFO_PRETTY_NAME);
if (pretty)
{
parse_release_for_rhts(pretty, product, version);
return;
}
/* something bad happend */
*product = NULL;
*version = NULL;
}
void
ureport_server_config_load_basic_auth(struct ureport_server_config *config,
const char *http_auth_pref)
{
if (http_auth_pref == NULL)
return;
map_string_t *settings = NULL;
char *tmp_password = NULL;
char *tmp_username = NULL;
const char *username = NULL;
const char *password = NULL;
if (strcmp(http_auth_pref, "rhts-credentials") == 0)
{
settings = new_map_string();
char *local_conf = xasprintf("%s"USER_HOME_CONFIG_PATH"/rhtsupport.conf", getenv("HOME"));
if (!load_plugin_conf_file("rhtsupport.conf", settings, /*skip key w/o values:*/ false) &&
!load_conf_file(local_conf, settings, /*skip key w/o values:*/ false))
error_msg_and_die("Could not get RHTSupport credentials");
free(local_conf);
username = get_map_string_item_or_NULL(settings, "Login");
password = get_map_string_item_or_NULL(settings, "Password");
if (config->ur_url == NULL)
ureport_server_config_set_url(config, xstrdup(RHSM_WEB_SERVICE_URL));
}
else
{
username = tmp_username = xstrdup(http_auth_pref);
password = strchr(tmp_username, ':');
if (password != NULL)
/* It is "char *", see strchr() few lines above. */
*((char *)(password++)) = '\0';
}
if (password == NULL)
{
char *message = xasprintf("Please provide uReport server password for user '%s':", username);
password = tmp_password = ask_password(message);
free(message);
if (strcmp(password, "") == 0)
error_msg_and_die("Cannot continue without uReport server password!");
}
ureport_server_config_set_basic_auth(config, username, password);
free(tmp_password);
free(tmp_username);
free_map_string(settings);
}
static void set_settings(struct bugzilla_struct *b, map_string_t *settings)
{
const char *environ;
environ = getenv("Bugzilla_Login");
b->b_login = xstrdup(environ ? environ : get_map_string_item_or_empty(settings, "Login"));
environ = getenv("Bugzilla_Password");
b->b_password = xstrdup(environ ? environ : get_map_string_item_or_empty(settings, "Password"));
environ = getenv("Bugzilla_BugzillaURL");
b->b_bugzilla_url = environ ? environ : get_map_string_item_or_empty(settings, "BugzillaURL");
if (!b->b_bugzilla_url[0])
b->b_bugzilla_url = "https://bugzilla.redhat.com";
else
{
/* We don't want trailing '/': "https://host/dir/" -> "https://host/dir" */
char *last_slash = strrchr(b->b_bugzilla_url, '/');
if (last_slash && last_slash[1] == '\0')
*last_slash = '\0';
}
b->b_bugzilla_xmlrpc = concat_path_file(b->b_bugzilla_url, "xmlrpc.cgi");
environ = getenv("Bugzilla_Product");
if (environ)
{
b->b_product = xstrdup(environ);
environ = getenv("Bugzilla_ProductVersion");
if (environ)
b->b_product_version = xstrdup(environ);
}
else
{
const char *option = get_map_string_item_or_NULL(settings, "Product");
if (option)
b->b_product = xstrdup(option);
option = get_map_string_item_or_NULL(settings, "ProductVersion");
if (option)
b->b_product_version = xstrdup(option);
}
if (!b->b_product)
{ /* Compat, remove it later (2014?). */
environ = getenv("Bugzilla_OSRelease");
if (environ)
parse_release_for_bz(environ, &b->b_product, &b->b_product_version);
}
environ = getenv("Bugzilla_SSLVerify");
b->b_ssl_verify = string_to_bool(environ ? environ : get_map_string_item_or_empty(settings, "SSLVerify"));
environ = getenv("Bugzilla_DontMatchComponents");
b->b_DontMatchComponents = environ ? environ : get_map_string_item_or_empty(settings, "DontMatchComponents");
}
static void ParseCommon(map_string_t *settings, const char *conf_filename)
{
const char *value;
value = get_map_string_item_or_NULL(settings, "OpenGPGCheck");
if (value)
{
settings_bOpenGPGCheck = string_to_bool(value);
remove_map_string_item(settings, "OpenGPGCheck");
}
value = get_map_string_item_or_NULL(settings, "BlackList");
if (value)
{
settings_setBlackListedPkgs = parse_list(value);
remove_map_string_item(settings, "BlackList");
}
value = get_map_string_item_or_NULL(settings, "BlackListedPaths");
if (value)
{
settings_setBlackListedPaths = parse_list(value);
remove_map_string_item(settings, "BlackListedPaths");
}
value = get_map_string_item_or_NULL(settings, "ProcessUnpackaged");
if (value)
{
settings_bProcessUnpackaged = string_to_bool(value);
remove_map_string_item(settings, "ProcessUnpackaged");
}
value = get_map_string_item_or_NULL(settings, "Interpreters");
if (value)
{
settings_Interpreters = parse_list(value);
remove_map_string_item(settings, "Interpreters");
}
map_string_iter_t iter;
const char *name;
/*char *value; - already declared */
init_map_string_iter(&iter, settings);
while (next_map_string_iter(&iter, &name, &value))
{
error_msg("Unrecognized variable '%s' in '%s'", name, conf_filename);
}
}
void parse_osinfo(const char *osinfo_bytes, map_string_t *osinfo)
{
const char *cursor = osinfo_bytes;
unsigned line = 0;
while (cursor[0] != '\0')
{
++line;
if (cursor[0] == '#')
goto skip_line;
const char *key_end = strchrnul(cursor, '=');
if (key_end[0] == '\0')
{
log_notice("os-release:%u: non empty last line", line);
break;
}
if (key_end - cursor == 0)
{
log_notice("os-release:%u: 0 length key", line);
goto skip_line;
}
const char *value_end = strchrnul(cursor, '\n');
if (key_end > value_end)
{
log_notice("os-release:%u: missing '='", line);
goto skip_line;
}
char *key = xstrndup(cursor, key_end - cursor);
if (get_map_string_item_or_NULL(osinfo, key) != NULL)
{
log_notice("os-release:%u: redefines key '%s'", line, key);
}
char *value = xstrndup(key_end + 1, value_end - key_end - 1);
unescape_osnifo_value(value, value);
log_debug("os-release:%u: parsed line: '%s'='%s'", line, key, value);
/* The difference between replace and insert is that if the key already
* exists in the GHashTable, it gets replaced by the new key. The old
* key and the old value are freed. */
replace_map_string_item(osinfo, key, value);
cursor = value_end;
if (value_end[0] == '\0')
{
log_notice("os-release:%u: the last value is not terminated by newline", line);
}
else
++cursor;
continue;
skip_line:
cursor = strchrnul(cursor, '\n');
cursor += (cursor[0] != '\0');
}
}
static void load_gpg_keys(void)
{
map_string_t *settings = new_map_string();
if (!load_abrt_conf_file(GPG_CONF, settings))
{
error_msg("Can't load '%s'", GPG_CONF);
return;
}
const char *gpg_keys_dir = get_map_string_item_or_NULL(settings, "GPGKeysDir");
if (strcmp(gpg_keys_dir, "") != 0)
{
log_debug("Reading gpg keys from '%s'", gpg_keys_dir);
GHashTable *done_set = g_hash_table_new(g_str_hash, g_str_equal);
GList *gpg_files = get_file_list(gpg_keys_dir, NULL /* we don't care about the file ext */);
for (GList *iter = gpg_files; iter; iter = g_list_next(iter))
{
const char *key_path = fo_get_fullpath((file_obj_t *)iter->data);
if (g_hash_table_contains(done_set, key_path))
continue;
g_hash_table_insert(done_set, (gpointer)key_path, NULL);
log_debug("Loading gpg key '%s'", key_path);
settings_setOpenGPGPublicKeys = g_list_append(settings_setOpenGPGPublicKeys, xstrdup(key_path));
}
g_list_free_full(gpg_files, (GDestroyNotify)free_file_obj);
g_hash_table_destroy(done_set);
}
}
static int interactive_upload_file(const char *url, const char *file_name,
map_string_t *settings, char **remote_name)
{
post_state_t *state = new_post_state(POST_WANT_ERROR_MSG);
state->username = get_map_string_item_or_NULL(settings, "UploadUsername");
char *password_inp = NULL;
if (state->username != NULL && state->username[0] != '\0')
{
/* Load Password only if Username is configured, it doesn't make */
/* much sense to load Password without Username. */
state->password = get_map_string_item_or_NULL(settings, "UploadPassword");
if (state->password == NULL)
{
/* Be permissive and nice, ask only once and don't check */
/* the result. User can dismiss this prompt but the upload */
/* may work somehow??? */
char *msg = xasprintf(_("Please enter password for uploading:"), state->username);
state->password = password_inp = ask_password(msg);
free(msg);
}
}
/* set SSH keys */
state->client_ssh_public_keyfile = get_map_string_item_or_NULL(settings, "SSHPublicKey");
state->client_ssh_private_keyfile = get_map_string_item_or_NULL(settings, "SSHPrivateKey");
if (state->client_ssh_public_keyfile != NULL)
log_debug("Using SSH public key '%s'", state->client_ssh_public_keyfile);
if (state->client_ssh_private_keyfile != NULL)
log_debug("Using SSH private key '%s'", state->client_ssh_private_keyfile);
char *tmp = upload_file_ext(state, url, file_name, UPLOAD_FILE_HANDLE_ACCESS_DENIALS);
if (remote_name)
*remote_name = tmp;
else
free(tmp);
free(password_inp);
free_post_state(state);
/* return 0 on success */
return tmp == NULL;
}
static void
parse_osinfo_for_mantisbt(map_string_t *osinfo, char** project, char** version)
{
const char *name = get_map_string_item_or_NULL(osinfo, "CENTOS_MANTISBT_PROJECT");
if (!name)
name = get_map_string_item_or_NULL(osinfo, OSINFO_NAME);
const char *version_id = get_map_string_item_or_NULL(osinfo, "CENTOS_MANTISBT_PROJECT_VERSION");
if (!version_id)
version_id = get_map_string_item_or_NULL(osinfo, OSINFO_VERSION_ID);
if (name && version_id)
{
*project = xstrdup(name);
*version = xstrdup(version_id);
return;
}
/* something bad happend */
*project = NULL;
*version = NULL;
}
string_vector_ptr_t get_global_always_excluded_elements(void)
{
assert_global_configuration_initialized();
char *env_exclude = getenv("EXCLUDE_FROM_REPORT");
const char *gc_exclude = get_map_string_item_or_NULL(s_global_settings, OPT_NAME_EXCLUDED_ELEMENTS);
if (env_exclude != NULL && gc_exclude == NULL)
return string_vector_new_from_string(env_exclude);
if (env_exclude == NULL && gc_exclude != NULL)
return string_vector_new_from_string(gc_exclude);
if (env_exclude == NULL && gc_exclude == NULL)
return string_vector_new_from_string(NULL);
char *joined_exclude = xasprintf("%s, %s", env_exclude, gc_exclude);
string_vector_ptr_t ret = string_vector_new_from_string(joined_exclude);
free(joined_exclude);
return ret;
}
const char *get_app_user_setting(map_string_t *settings, const char *name)
{
return get_map_string_item_or_NULL(settings, name);
}
static void ParseCommon(map_string_t *settings, const char *conf_filename)
{
const char *value;
value = get_map_string_item_or_NULL(settings, "WatchCrashdumpArchiveDir");
if (value)
{
g_settings_sWatchCrashdumpArchiveDir = xstrdup(value);
remove_map_string_item(settings, "WatchCrashdumpArchiveDir");
}
value = get_map_string_item_or_NULL(settings, "MaxCrashReportsSize");
if (value)
{
char *end;
errno = 0;
unsigned long ul = strtoul(value, &end, 10);
if (errno || end == value || *end != '\0' || ul > INT_MAX)
error_msg("Error parsing %s setting: '%s'", "MaxCrashReportsSize", value);
else
g_settings_nMaxCrashReportsSize = ul;
remove_map_string_item(settings, "MaxCrashReportsSize");
}
value = get_map_string_item_or_NULL(settings, "DumpLocation");
if (value)
{
g_settings_dump_location = xstrdup(value);
remove_map_string_item(settings, "DumpLocation");
}
else
g_settings_dump_location = xstrdup(DEFAULT_DUMP_LOCATION);
value = get_map_string_item_or_NULL(settings, "DeleteUploaded");
if (value)
{
g_settings_delete_uploaded = string_to_bool(value);
remove_map_string_item(settings, "DeleteUploaded");
}
value = get_map_string_item_or_NULL(settings, "AutoreportingEnabled");
if (value)
{
g_settings_autoreporting = string_to_bool(value);
remove_map_string_item(settings, "AutoreportingEnabled");
}
value = get_map_string_item_or_NULL(settings, "AutoreportingEvent");
if (value)
{
g_settings_autoreporting_event = xstrdup(value);
remove_map_string_item(settings, "AutoreportingEvent");
}
else
g_settings_autoreporting_event = xstrdup("report_uReport");
value = get_map_string_item_or_NULL(settings, "ShortenedReporting");
if (value)
{
g_settings_shortenedreporting = string_to_bool(value);
remove_map_string_item(settings, "ShortenedReporting");
}
else
{
/* Default: enabled for GNOME desktop, else disabled */
const char *desktop_env = getenv("DESKTOP_SESSION");
g_settings_shortenedreporting = (desktop_env && strcasestr(desktop_env, "gnome") != NULL);
}
value = get_map_string_item_or_NULL(settings, "ExploreChroots");
if (value)
{
g_settings_explorechroots = string_to_bool(value);
remove_map_string_item(settings, "ExploreChroots");
}
else
g_settings_explorechroots = false;
value = get_map_string_item_or_NULL(settings, "DebugLevel");
if (value)
{
char *end;
errno = 0;
unsigned long ul = strtoul(value, &end, 10);
if (errno || end == value || *end != '\0' || ul > INT_MAX)
error_msg("Error parsing %s setting: '%s'", "DebugLevel", value);
else
g_settings_debug_level = ul;
remove_map_string_item(settings, "DebugLevel");
}
GHashTableIter iter;
const char *name;
/*char *value; - already declared */
init_map_string_iter(&iter, settings);
while (next_map_string_iter(&iter, &name, &value))
{
error_msg("Unrecognized variable '%s' in '%s'", name, conf_filename);
}
}
int main(int argc, char **argv)
{
abrt_init(argv);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_g = 1 << 2,
OPT_b = 1 << 3,
OPT_u = 1 << 4,
OPT_r = 1 << 5,
};
const char *bugs = NULL, *release = NULL, *dump_dir_path = ".";
/* Keep enum above and order of options below in sync! */
struct options program_options[] = {
OPT__VERBOSE(&g_verbose),
OPT__DUMP_DIR(&dump_dir_path),
OPT_GROUP(""),
OPT_STRING('b', "bugs", &bugs, "ID1[,ID2,...]" , _("List of bug ids")),
OPT_STRING('u', "url", &bodhi_url, "URL", _("Specify a bodhi server url")),
OPT_OPTSTRING('r', "release", &release, "RELEASE", _("Specify a release")),
OPT_END()
};
const char *program_usage_string = _(
"& [-v] [-r[RELEASE]] (-b ID1[,ID2,...] | PKG-NAME) [PKG-NAME]... \n"
"\n"
"Search for updates on bodhi server"
);
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
if (!bugs && !argv[optind])
show_usage_and_die(program_usage_string, program_options);
struct strbuf *query = strbuf_new();
if (bugs)
query = strbuf_append_strf(query, "bugs=%s&", bugs);
if (opts & OPT_r)
{
if (release)
{
/* There are no bodhi updates for Rawhide */
if (strcasecmp(release, "rawhide") == 0)
error_msg_and_die("Release \"%s\" is not supported",release);
query = strbuf_append_strf(query, "releases=%s&", release);
}
else
{
struct dump_dir *dd = dd_opendir(dump_dir_path, DD_OPEN_READONLY);
if (!dd)
xfunc_die();
problem_data_t *problem_data = create_problem_data_from_dump_dir(dd);
dd_close(dd);
if (!problem_data)
xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */
char *product, *version;
map_string_t *osinfo = new_map_string();
problem_data_get_osinfo(problem_data, osinfo);
parse_osinfo_for_rhts(osinfo, &product, &version);
/* There are no bodhi updates for Rawhide */
bool rawhide = strcasecmp(version, "rawhide") == 0;
if (!rawhide)
query = strbuf_append_strf(query, "releases=f%s&", version);
free(product);
free(version);
free_map_string(osinfo);
if (rawhide)
{
strbuf_free(query);
error_msg_and_die("Release \"Rawhide\" is not supported");
}
}
}
if (argv[optind])
{
char *escaped = g_uri_escape_string(argv[optind], NULL, 0);
query = strbuf_append_strf(query, "packages=%s&", escaped);
free(escaped);
}
if (query->buf[query->len - 1] == '&')
query->buf[query->len - 1] = '\0';
log_warning(_("Searching for updates"));
GHashTable *update_hash_tbl = bodhi_query_list(query->buf, release);
strbuf_free(query);
if (!update_hash_tbl || !g_hash_table_size(update_hash_tbl))
{
log_warning(_("No updates for this package found"));
/*if (update_hash_tbl) g_hash_table_unref(update_hash_tbl);*/
return 0;
}
GHashTableIter iter;
char *name;
struct bodhi *b;
struct strbuf *q = strbuf_new();
g_hash_table_iter_init(&iter, update_hash_tbl);
while (g_hash_table_iter_next(&iter, (void **) &name, (void **) &b))
{
char *installed_pkg_nvr = rpm_get_nvr_by_pkg_name(name);
if (installed_pkg_nvr && rpmvercmp(installed_pkg_nvr, b->nvr) >= 0)
{
log_info("Update %s is older or same as local version %s, skipping", b->nvr, installed_pkg_nvr);
free(installed_pkg_nvr);
continue;
}
free(installed_pkg_nvr);
strbuf_append_strf(q, " %s", b->nvr);
}
/*g_hash_table_unref(update_hash_tbl);*/
if (!q->len)
{
/*strbuf_free(q);*/
log_warning(_("Local version of the package is newer than available updates"));
return 0;
}
/* Message is split into text and command in order to make
* translator's job easier
*/
/* We suggest the command which is most likely to exist on user's system,
* and which is familiar to the largest population of users.
* There are other tools (pkcon et al) which might be somewhat more
* convenient (for example, they might be usable from non-root), but they
* might be not present on the system, may evolve or be superseded,
* as it did happen to yum.
*/
map_string_t *settings = new_map_string();
load_abrt_plugin_conf_file("CCpp.conf", settings);
const char *value;
strbuf_prepend_str(q, " update --enablerepo=fedora --enablerepo=updates --enablerepo=updates-testing");
value = get_map_string_item_or_NULL(settings, "PackageManager");
if (value)
strbuf_prepend_str(q, value);
else
strbuf_prepend_str(q, DEFAULT_PACKAGE_MANAGER);
free_map_string(settings);
char *msg = xasprintf(_("An update exists which might fix your problem. "
"You can install it by running: %s. "
"Do you want to continue with reporting the bug?"),
q->buf
);
/*strbuf_free(q);*/
return ask_yes_no(msg) ? 0 : EXIT_STOP_EVENT_RUN;
}
int main(int argc, char **argv)
{
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
abrt_init(argv);
char *i_opt = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"& [options] -d DIR\n"
"\n"
"Analyzes coredump in problem directory DIR, generates and saves backtrace"
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_i = 1 << 2,
OPT_t = 1 << 3,
};
/* Keep enum above and order of options below in sync! */
struct options program_options[] = {
OPT__VERBOSE(&g_verbose),
OPT_STRING( 'd', NULL, &dump_dir_name , "DIR" , _("Problem directory")),
OPT_STRING( 'i', NULL, &i_opt , "DIR1[:DIR2]...", _("Additional debuginfo directories")),
OPT_INTEGER('t', NULL, &exec_timeout_sec, _("Kill gdb if it runs for more than NUM seconds")),
OPT_END()
};
/*unsigned opts =*/ parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
map_string_t *settings = new_map_string();
if (!load_abrt_plugin_conf_file(CCPP_CONF, settings))
error_msg("Can't load '%s'", CCPP_CONF);
const char *value = get_map_string_item_or_NULL(settings, "DebuginfoLocation");
char *debuginfo_location;
if (value)
debuginfo_location = xstrdup(value);
else
debuginfo_location = xstrdup(LOCALSTATEDIR"/cache/abrt-di");
free_map_string(settings);
char *debuginfo_dirs = NULL;
if (i_opt)
debuginfo_dirs = xasprintf("%s:%s", debuginfo_location, i_opt);
/* Create gdb backtrace */
char *backtrace = get_backtrace(dump_dir_name, exec_timeout_sec,
(debuginfo_dirs) ? debuginfo_dirs : debuginfo_location);
free(debuginfo_location);
if (!backtrace)
{
backtrace = xstrdup("");
log_warning("get_backtrace() returns NULL, broken core/gdb?");
}
free(debuginfo_dirs);
free_abrt_conf_data();
/* Store gdb backtrace */
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
return 1;
dd_save_text(dd, FILENAME_BACKTRACE, backtrace);
dd_close(dd);
/* Don't be completely silent. gdb run takes a few seconds,
* it is useful to let user know it (maybe) worked.
*/
log_warning(_("Backtrace is generated and saved, %u bytes"), (int)strlen(backtrace));
free(backtrace);
return 0;
}
int main(int argc, char *argv[])
{
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
abrt_init(argv);
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string_template = _(
"& [-vsoxtf] [-e]/[-c CURSOR] [-d DIR]/[-D]\n"
"\n"
"Extract Xorg crash from systemd-journal\n"
"\n"
"-c and -e options conflicts because both specifies the first read message.\n"
"\n"
"-e is useful only for -f because the following of journal starts by reading \n"
"the entire journal if the last seen possition is not available.\n"
"\n"
"The last seen position is saved in %s\n"
"\n"
"Journal filter is required parameter and must be specified either by parameter\n"
"-j or in %s conf file.\n"
);
char program_usage_string[strlen(program_usage_string_template)
+ strlen(ABRT_JOURNAL_XORG_WATCH_STATE_FILE)
+ strlen(XORG_CONF_PATH)];
sprintf(program_usage_string, program_usage_string_template,
ABRT_JOURNAL_XORG_WATCH_STATE_FILE, XORG_CONF_PATH);
enum {
OPT_v = 1 << 0,
OPT_s = 1 << 1,
OPT_o = 1 << 2,
OPT_d = 1 << 3,
OPT_D = 1 << 4,
OPT_x = 1 << 5,
OPT_t = 1 << 6,
OPT_c = 1 << 7,
OPT_e = 1 << 8,
OPT_f = 1 << 9,
OPT_a = 1 << 10,
OPT_J = 1 << 11,
OPT_j = 1 << 12,
};
char *cursor = NULL;
char *dump_location = NULL;
char *journal_dir = NULL;
GList *journal_filters = NULL;
/* Keep enum above and order of options below in sync! */
struct options program_options[] = {
OPT__VERBOSE(&g_verbose),
OPT_BOOL( 's', NULL, NULL, _("Log to syslog")),
OPT_BOOL( 'o', NULL, NULL, _("Print found crashes on standard output")),
OPT_STRING('d', NULL, &dump_location, "DIR", _("Create new problem directory in DIR for every crash found")),
OPT_BOOL( 'D', NULL, NULL, _("Same as -d DumpLocation, DumpLocation is specified in abrt.conf")),
OPT_BOOL( 'x', NULL, NULL, _("Make the problem directory world readable")),
OPT_BOOL( 't', NULL, NULL, _("Throttle problem directory creation to 1 per second")),
OPT_STRING('c', NULL, &cursor, "CURSOR", _("Start reading systemd-journal from the CURSOR position")),
OPT_BOOL( 'e', NULL, NULL, _("Start reading systemd-journal from the end")),
OPT_BOOL( 'f', NULL, NULL, _("Follow systemd-journal from the last seen position (if available)")),
OPT_BOOL( 'a', NULL, NULL, _("Read journal files from all machines")),
OPT_STRING('J', NULL, &journal_dir, "PATH", _("Read all journal files from directory at PATH")),
OPT_LIST( 'j', NULL, &journal_filters, "FILTER", _("Journal filter e.g. '_COMM=gdm-x-session' (may be given many times)")),
OPT_END()
};
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
msg_prefix = g_progname;
if ((opts & OPT_s) || getenv("ABRT_SYSLOG"))
{
logmode = LOGMODE_JOURNAL;
}
if ((opts & OPT_c) && (opts & OPT_e))
error_msg_and_die(_("You need to specify either -c CURSOR or -e"));
if (opts & OPT_D)
{
if (opts & OPT_d)
show_usage_and_die(program_usage_string, program_options);
load_abrt_conf();
dump_location = g_settings_dump_location;
g_settings_dump_location = NULL;
free_abrt_conf_data();
}
int xorg_utils_flags = 0;
if ((opts & OPT_x))
xorg_utils_flags |= ABRT_XORG_WORLD_READABLE;
if ((opts & OPT_t))
xorg_utils_flags |= ABRT_XORG_THROTTLE_CREATION;
if ((opts & OPT_o))
xorg_utils_flags |= ABRT_XORG_PRINT_STDOUT;
/* get journal filters */
const char *const env_journal_filter = getenv("ABRT_DUMP_JOURNAL_XORG_DEBUG_FILTER");
bool free_filter_list_data = false;
GList *xorg_journal_filter = NULL;
if (env_journal_filter != NULL)
{
xorg_journal_filter = g_list_append(xorg_journal_filter, (gpointer)env_journal_filter);
log_debug("Using journal filter from environment variable");
}
else if (journal_filters != NULL)
{
xorg_journal_filter = journal_filters;
log_debug("Using journal filter passed by parameter -j");
}
else
{
map_string_t *settings = new_map_string();
log_notice("Loading settings from '%s'", XORG_CONF);
load_abrt_plugin_conf_file(XORG_CONF, settings);
log_debug("Loaded '%s'", XORG_CONF);
const char *conf_journal_filters = get_map_string_item_or_NULL(settings, "JournalFilters");
xorg_journal_filter = parse_list(conf_journal_filters);
/* list data will be free by g_list_free_full */
free_filter_list_data = true;
free_map_string(settings);
if (xorg_journal_filter)
log_debug("Using journal filter from conf file %s", XORG_CONF);
}
if (xorg_journal_filter == NULL)
error_msg_and_die(_("Journal filter must be specified either by parameter -j or stored in /etc/abrt/plugins/xorg.conf file"));
abrt_journal_t *journal = NULL;
if ((opts & OPT_J))
{
log_debug("Using journal files from directory '%s'", journal_dir);
if (abrt_journal_open_directory(&journal, journal_dir))
error_msg_and_die(_("Cannot initialize systemd-journal in directory '%s'"), journal_dir);
}
else
{
if (((opts & OPT_a) ? abrt_journal_new_merged : abrt_journal_new)(&journal))
error_msg_and_die(_("Cannot open systemd-journal"));
}
if (abrt_journal_set_journal_filter(journal, xorg_journal_filter) < 0)
error_msg_and_die(_("Cannot filter systemd-journal to Xorg data only"));
/* free filter list */
if (free_filter_list_data)
g_list_free_full(xorg_journal_filter, free);
else
g_list_free(xorg_journal_filter);
if ((opts & OPT_e) && abrt_journal_seek_tail(journal) < 0)
error_msg_and_die(_("Cannot seek to the end of journal"));
if ((opts & OPT_f))
{
if (!cursor)
abrt_journal_restore_position(journal, ABRT_JOURNAL_XORG_WATCH_STATE_FILE);
else if(abrt_journal_set_cursor(journal, cursor))
error_msg_and_die(_("Failed to start watch from cursor '%s'"), cursor);
watch_journald(journal, dump_location, xorg_utils_flags);
abrt_journal_save_current_position(journal, ABRT_JOURNAL_XORG_WATCH_STATE_FILE);
}
else
{
if (cursor && abrt_journal_set_cursor(journal, cursor))
error_msg_and_die(_("Failed to set systemd-journal cursor '%s'"), cursor);
/* Compatibility hack, a watch's callback gets the journal already moved
* to a next message.*/
abrt_journal_next(journal);
GList *crashes = abrt_journal_extract_xorg_crashes(journal);
abrt_xorg_process_list_of_crashes(crashes, dump_location, xorg_utils_flags);
g_list_free_full(crashes, (GDestroyNotify)xorg_crash_info_free);
}
abrt_journal_free(journal);
return EXIT_SUCCESS;
}
static void
set_settings(mantisbt_settings_t *m, map_string_t *settings, struct dump_dir *dd)
{
const char *environ;
environ = getenv("Mantisbt_Login");
m->m_login = xstrdup(environ ? environ : get_map_string_item_or_empty(settings, "Login"));
environ = getenv("Mantisbt_Password");
m->m_password = xstrdup(environ ? environ : get_map_string_item_or_empty(settings, "Password"));
environ = getenv("Mantisbt_MantisbtURL");
m->m_mantisbt_url = environ ? environ : get_map_string_item_or_empty(settings, "MantisbtURL");
if (!m->m_mantisbt_url[0])
m->m_mantisbt_url = "http://localhost/mantisbt";
else
{
/* We don't want trailing '/': "https://host/dir/" -> "https://host/dir" */
char *last_slash = strrchr(m->m_mantisbt_url, '/');
if (last_slash && last_slash[1] == '\0')
*last_slash = '\0';
}
m->m_mantisbt_soap_url = concat_path_file(m->m_mantisbt_url, "api/soap/mantisconnect.php");
environ = getenv("Mantisbt_Project");
if (environ)
{
m->m_project = xstrdup(environ);
environ = getenv("Mantisbt_ProjectVersion");
if (environ)
m->m_project_version = xstrdup(environ);
}
else
{
const char *option = get_map_string_item_or_NULL(settings, "Project");
if (option)
m->m_project = xstrdup(option);
option = get_map_string_item_or_NULL(settings, "ProjectVersion");
if (option)
m->m_project_version = xstrdup(option);
}
if (!m->m_project || !*m->m_project) /* if not overridden or empty... */
{
free(m->m_project);
free(m->m_project_version);
if (dd != NULL)
{
map_string_t *osinfo = new_map_string();
char *os_info_data = dd_load_text(dd, FILENAME_OS_INFO);
parse_osinfo(os_info_data, osinfo);
free(os_info_data);
parse_osinfo_for_mantisbt(osinfo, &m->m_project, &m->m_project_version);
free_map_string(osinfo);
}
}
environ = getenv("Mantisbt_SSLVerify");
m->m_ssl_verify = string_to_bool(environ ? environ : get_map_string_item_or_empty(settings, "SSLVerify"));
environ = getenv("Mantisbt_DontMatchComponents");
m->m_DontMatchComponents = environ ? environ : get_map_string_item_or_empty(settings, "DontMatchComponents");
m->m_create_private = get_global_create_private_ticket();
if (!m->m_create_private)
{
environ = getenv("Mantisbt_CreatePrivate");
m->m_create_private = string_to_bool(environ ? environ : get_map_string_item_or_empty(settings, "CreatePrivate"));
}
log_notice("create private MantisBT ticket: '%s'", m->m_create_private ? "YES": "NO");
}
