void expo_parameters_load(expo_parameters & params,
boost::shared_ptr<sfl::OptionDictionary> opt)
{
string_to(opt->GetOption("model_security_distance"), params.model_security_distance);
string_to(opt->GetOption("model_wheelbase"), params.model_wheelbase);
string_to(opt->GetOption("model_wheelradius"), params.model_wheelradius);
string_to(opt->GetOption("model_qd_max"), params.model_qd_max);
string_to(opt->GetOption("model_qdd_max"), params.model_qdd_max);
string_to(opt->GetOption("model_sd_max"), params.model_sd_max);
string_to(opt->GetOption("model_thetad_max"), params.model_thetad_max);
string_to(opt->GetOption("model_sdd_max"), params.model_sdd_max);
string_to(opt->GetOption("model_thetadd_max"), params.model_thetadd_max);
string_to(opt->GetOption("dwa_dimension"), params.dwa_dimension);
string_to(opt->GetOption("dwa_grid_width"), params.dwa_grid_width);
string_to(opt->GetOption("dwa_grid_height"), params.dwa_grid_height);
string_to(opt->GetOption("dwa_grid_resolution"), params.dwa_grid_resolution);
string_to(opt->GetOption("dwa_alpha_distance"), params.dwa_alpha_distance);
string_to(opt->GetOption("dwa_alpha_heading"), params.dwa_alpha_heading);
string_to(opt->GetOption("dwa_alpha_speed"), params.dwa_alpha_speed);
string_to_bool(opt->GetOption("dwa_use_tobi_distobj"), params.dwa_use_tobi_distobj);
string_to(opt->GetOption("dwa_tobi_distobj_blur"), params.dwa_tobi_distobj_blur);
string_to_bool(opt->GetOption("bband_enabled"), params.bband_enabled);
string_to(opt->GetOption("bband_shortpath"), params.bband_shortpath);
string_to(opt->GetOption("bband_longpath"), params.bband_longpath);
string_to(opt->GetOption("bband_maxignoredistance"), params.bband_maxignoredistance);
string_to(opt->GetOption("mp_dtheta_starthoming"), params.mp_dtheta_starthoming);
string_to(opt->GetOption("mp_dtheta_startaiming"), params.mp_dtheta_startaiming);
}
bool
load_config(const char *pathname)
{
int i;
header_t *h;
List = hl_load_config(pathname); /* Ignore invalid lines */
if (List == NULL) {
fprintf(stderr, "Could load configuration file (%d: %s)\n",
errno, strerror(errno));
return false;
}
for (i = 0; i < List->count; i++) {
h = &List->data[i];
if (0 == strcasecmp(h->name, "DEBUG_MODE"))
Config.debug = string_to_bool(h->value);
else if (0 == strcasecmp(h->name, "FORK_BACKGROUND"))
Config.background = string_to_bool(h->value);
else if (0 == strcasecmp(h->name, "UPDATE_PASSWORD"))
Config.update_passwd = string_to_bool(h->value);
else if (0 == strcasecmp(h->name, "CONNECTION_RETRY"))
Config.conn_retry = atoi(h->value);
/* Ignore invalid or unconcerned options */
}
return true;
}
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);
}
}
static SquashStatus
squash_csc_parse_option (SquashOptions* options, const char* key, const char* value) {
SquashCscOptions* opts = (SquashCscOptions*) options;
char* endptr = NULL;
assert (opts != NULL);
if (strcasecmp (key, "level") == 0) {
const int level = strtol (value, &endptr, 0);
if ( *endptr == '\0' && level >= 1 && level <= 5 ) {
opts->level = level;
} else {
return squash_error (SQUASH_BAD_VALUE);
}
} else if (strcasecmp (key, "dict-size") == 0) {
const unsigned long dict_size = strtol (value, &endptr, 0);
if ( *endptr == '\0' && dict_size >= 32768 && dict_size <= 1073741824 ) {
opts->dict_size = (uint32_t) dict_size;
} else {
return squash_error (SQUASH_BAD_VALUE);
}
} else if (strcasecmp (key, "delta-filter") == 0) {
bool res;
if (string_to_bool(value, &res)) {
opts->enable_delta = res;
} else {
return squash_error (SQUASH_BAD_VALUE);
}
} else if (strcasecmp (key, "exe-filter") == 0) {
bool res;
if (string_to_bool(value, &res)) {
opts->enable_exe = res;
} else {
return squash_error (SQUASH_BAD_VALUE);
}
} else if (strcasecmp (key, "txt-filter") == 0) {
bool res;
if (string_to_bool(value, &res)) {
opts->enable_txt = res;
} else {
return squash_error (SQUASH_BAD_VALUE);
}
} else {
return squash_error (SQUASH_BAD_PARAM);
}
return SQUASH_OK;
}
int try_get_map_string_item_as_bool(map_string_t *ms, const char *key, int *value)
{
GET_ITEM_OR_RETURN(option, ms, key);
*value = string_to_bool(option);
return true;
}
//
// tries to make a boolean parse var
PARSE_VAR *use_one_parse_token_bool(const char *buf) {
PARSE_VAR *var = NULL;
if(string_is_bool(buf)) {
var = newParseVar(PARSE_VAR_BOOL);
var->bool_val = string_to_bool(buf);
}
return var;
}
int ask_yes_no_yesforever(const char *key, const char *question)
{
INITIALIZE_LIBREPORT();
const char *yes = _("y");
const char *no = _("N");
const char *forever = _("f");
{ /* Use response from REPORT_CLIENT_RESPONSE environment variable.
*
* The forever response is not allowed in this case.
* There is no serious reason for that, it is just decision.
* (It doesn't make much sense to allow the forever answer here.)
*/
const char *env_response = getenv("REPORT_CLIENT_RESPONSE");
if (env_response)
return strncasecmp(yes, env_response, strlen(yes)) == 0;
}
{ /* Load an value for the key from user setting.
* NO means 'Don't ask me again, I said yes forever'.
*/
const char *option = get_user_setting(key);
if (option && string_to_bool(option) == false)
return 1;
}
if (is_slave_mode())
printf(REPORT_PREFIX_ASK_YES_NO_YESFOREVER "%s %s\n", key, question);
else
printf("%s [%s/%s/%s] ", question, yes, no, forever);
fflush(stdout);
if (!is_slave_mode() && is_noninteractive_mode())
{
putchar('\n');
fflush(stdout);
return 0;
}
char response[16];
if (NULL == fgets(response, sizeof(response), stdin))
return 0;
if ((is_slave_mode() && response[0] == 'f') || strncasecmp(forever, response, strlen(forever)) == 0)
{
/* NO means 'Don't ask me again, I said yes forever'. */
set_user_setting(key, "no");
return 1;
}
else
set_user_setting(key, "yes");
return ((is_slave_mode() && response[0] == 'y') || strncasecmp(yes, response, strlen(yes)) == 0);
}
/*
* Loads uReport configuration from various sources.
*
* Replaces a value of an already configured option only if the
* option was found in a configuration source.
*
* @param config a server configuration to be populated
*/
static void load_ureport_server_config(struct ureport_server_config *config)
{
const char *environ;
environ = getenv("uReport_URL");
config->ur_url = environ ? environ : config->ur_url;
environ = getenv("uReport_SSLVerify");
config->ur_ssl_verify = environ ? string_to_bool(environ) : config->ur_ssl_verify;
}
bool get_global_stop_on_not_reportable(void)
{
assert_global_configuration_initialized();
char *env_create_private = getenv(STOP_ON_NOT_REPORTABLE);
if (env_create_private == NULL)
return true;
return string_to_bool(env_create_private);
}
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");
}
bool get_global_create_private_ticket(void)
{
assert_global_configuration_initialized();
char *env_create_private = getenv(CREATE_PRIVATE_TICKET);
if (env_create_private == NULL)
return false;
return string_to_bool(env_create_private);
}
bool property_get_bool(const std::string &key, bool default_value)
{
std::string value;
bool result;
if (property_get(key, value) && string_to_bool(value, result)) {
return result;
}
return default_value;
}
const char *abrt_init(char **argv)
{
char *env_verbose = getenv("ABRT_VERBOSE");
if (env_verbose)
g_verbose = atoi(env_verbose);
g_progname = strrchr(argv[0], '/');
if (g_progname)
g_progname++;
else
g_progname = argv[0];
char *pfx = getenv("ABRT_PROG_PREFIX");
if (pfx && string_to_bool(pfx))
msg_prefix = g_progname;
return g_progname;
}
const char *abrt_init(char **argv)
{
if (!load_global_configuration())
error_msg_and_die("Cannot continue without libreport global configuration.");
char *env_verbose = getenv("ABRT_VERBOSE");
if (env_verbose)
g_verbose = atoi(env_verbose);
g_progname = strrchr(argv[0], '/');
if (g_progname)
g_progname++;
else
g_progname = argv[0];
char *pfx = getenv("ABRT_PROG_PREFIX");
if (pfx && string_to_bool(pfx))
msg_prefix = g_progname;
return g_progname;
}
int client_set_property_command(int argc, char** argv) {
char* action = (argc > 1) ? argv[1] : "toggle";
HSClient* client = get_current_client();
if (!client) {
// nothing to do
return 0;
}
struct {
char* name;
void (*func)(HSClient*, bool);
bool* value;
} properties[] = {
{ "fullscreen", client_set_fullscreen, &client->fullscreen },
{ "pseudotile", client_set_pseudotile, &client->pseudotile },
};
// find the property
int i;
for (i = 0; i < LENGTH(properties); i++) {
if (!strcmp(properties[i].name, argv[0])) {
break;
}
}
if (i >= LENGTH(properties)) {
return HERBST_INVALID_ARGUMENT;
}
// if found, then change it
bool old_value = *(properties[i].value);
bool state = string_to_bool(action, *(properties[i].value));
if (state != old_value) {
properties[i].func(client, state);
}
return 0;
}
inline bool string_to_type(const std::string& value)
{
return string_to_bool(value);
}
static void report_to_bugzilla(const char *dump_dir_name, map_string_h *settings)
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
xfunc_die(); /* dd_opendir already emitted error msg */
problem_data_t *problem_data = create_problem_data_from_dump_dir(dd);
dd_close(dd);
const char *env;
const char *login;
const char *password;
const char *bugzilla_xmlrpc;
const char *bugzilla_url;
bool ssl_verify;
env = getenv("Bugzilla_Login");
login = env ? env : get_map_string_item_or_empty(settings, "Login");
env = getenv("Bugzilla_Password");
password = env ? env : get_map_string_item_or_empty(settings, "Password");
if (!login[0] || !password[0])
error_msg_and_die(_("Empty login or password, please check your configuration"));
env = getenv("Bugzilla_BugzillaURL");
bugzilla_url = env ? env : get_map_string_item_or_empty(settings, "BugzillaURL");
if (!bugzilla_url[0])
bugzilla_url = "https://bugzilla.redhat.com";
bugzilla_xmlrpc = xasprintf("%s"XML_RPC_SUFFIX, bugzilla_url);
env = getenv("Bugzilla_SSLVerify");
ssl_verify = string_to_bool(env ? env : get_map_string_item_or_empty(settings, "SSLVerify"));
const char *component = get_problem_item_content_or_NULL(problem_data, FILENAME_COMPONENT);
const char *duphash = get_problem_item_content_or_NULL(problem_data, FILENAME_DUPHASH);
if (!duphash)
error_msg_and_die(_("Essential file '%s' is missing, can't continue.."),
FILENAME_DUPHASH);
if (!*duphash)
error_msg_and_die(_("Essential file '%s' is empty, can't continue.."),
FILENAME_DUPHASH);
const char *release = get_problem_item_content_or_NULL(problem_data, FILENAME_OS_RELEASE);
if (!release) /* Old dump dir format compat. Remove in abrt-2.1 */
release = get_problem_item_content_or_NULL(problem_data, "release");
struct abrt_xmlrpc *client = abrt_xmlrpc_new_client(bugzilla_xmlrpc, ssl_verify);
log(_("Logging into Bugzilla at %s"), bugzilla_url);
rhbz_login(client, login, password);
log(_("Checking for duplicates"));
char *product = NULL;
char *version = NULL;
parse_release_for_bz(release, &product, &version);
free(version);
xmlrpc_value *result;
if (strcmp(product, "Fedora") == 0)
result = rhbz_search_duphash(client, component, product, duphash);
else
result = rhbz_search_duphash(client, component, NULL, duphash);
xmlrpc_value *all_bugs = rhbz_get_member("bugs", result);
xmlrpc_DECREF(result);
if (!all_bugs)
error_msg_and_die(_("Missing mandatory member 'bugs'"));
int all_bugs_size = rhbz_array_size(all_bugs);
// When someone clones bug it has same duphash, so we can find more than 1.
// Need to be checked if component is same.
VERB3 log("Bugzilla has %i reports with same duphash '%s'",
all_bugs_size, duphash);
int bug_id = -1, dependent_bug = -1;
struct bug_info *bz = NULL;
if (all_bugs_size > 0)
{
bug_id = rhbz_bug_id(all_bugs);
xmlrpc_DECREF(all_bugs);
bz = rhbz_bug_info(client, bug_id);
if (strcmp(bz->bi_product, product) != 0)
{
dependent_bug = bug_id;
/* found something, but its a different product */
free_bug_info(bz);
xmlrpc_value *result = rhbz_search_duphash(client, component,
product, duphash);
xmlrpc_value *all_bugs = rhbz_get_member("bugs", result);
xmlrpc_DECREF(result);
all_bugs_size = rhbz_array_size(all_bugs);
if (all_bugs_size > 0)
{
bug_id = rhbz_bug_id(all_bugs);
bz = rhbz_bug_info(client, bug_id);
}
xmlrpc_DECREF(all_bugs);
}
}
free(product);
if (all_bugs_size == 0) // Create new bug
{
log(_("Creating a new bug"));
bug_id = rhbz_new_bug(client, problem_data, bug_id);
log("Adding attachments to bug %i", bug_id);
char bug_id_str[sizeof(int)*3 + 2];
sprintf(bug_id_str, "%i", bug_id);
rhbz_attachments(client, bug_id_str, problem_data);
log(_("Logging out"));
rhbz_logout(client);
log("Status: NEW %s/show_bug.cgi?id=%u", bugzilla_url, bug_id);
abrt_xmlrpc_free_client(client);
return;
}
// decision based on state
log(_("Bug is already reported: %i"), bz->bi_id);
if ((strcmp(bz->bi_status, "CLOSED") == 0)
&& (strcmp(bz->bi_resolution, "DUPLICATE") == 0))
{
struct bug_info *origin;
origin = rhbz_find_origin_bug_closed_duplicate(client, bz);
if (origin)
{
free_bug_info(bz);
bz = origin;
}
}
if (strcmp(bz->bi_status, "CLOSED") != 0)
{
if ((strcmp(bz->bi_reporter, login) != 0)
&& (!g_list_find_custom(bz->bi_cc_list, login, (GCompareFunc)g_strcmp0)))
{
log(_("Add %s to CC list"), login);
rhbz_mail_to_cc(client, bz->bi_id, login);
}
char *dsc = make_description_comment(problem_data);
if (dsc)
{
const char *package = get_problem_item_content_or_NULL(problem_data,
FILENAME_PACKAGE);
const char *release = get_problem_item_content_or_NULL(problem_data,
FILENAME_OS_RELEASE);
if (!release) /* Old dump dir format compat. Remove in abrt-2.1 */
release = get_problem_item_content_or_NULL(problem_data, "release");
const char *arch = get_problem_item_content_or_NULL(problem_data,
FILENAME_ARCHITECTURE);
const char *is_private = get_problem_item_content_or_NULL(problem_data,
"is_private");
char *full_dsc = xasprintf("Package: %s\n"
"Architecture: %s\n"
"OS Release: %s\n"
"%s", package, arch, release, dsc);
log(_("Adding new comment to bug %d"), bz->bi_id);
free(dsc);
int is_priv = is_private && string_to_bool(is_private);
rhbz_add_comment(client, bz->bi_id, full_dsc, is_priv);
free(full_dsc);
}
}
log(_("Logging out"));
rhbz_logout(client);
log("Status: %s%s%s %s/show_bug.cgi?id=%u",
bz->bi_status,
bz->bi_resolution ? " " : "",
bz->bi_resolution ? bz->bi_resolution : "",
bugzilla_url,
bz->bi_id);
dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
char *msg = xasprintf("Bugzilla: URL=%s/show_bug.cgi?id=%u", bugzilla_url, bz->bi_id);
add_reported_to(dd, msg);
free(msg);
dd_close(dd);
}
free_problem_data(problem_data);
free_bug_info(bz);
abrt_xmlrpc_free_client(client);
}
static void create_and_send_email(
const char *dump_dir_name,
map_string_h *settings)
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
exit(1); /* error msg is already logged by dd_opendir */
problem_data_t *problem_data = create_problem_data_from_dump_dir(dd);
dd_close(dd);
char* env;
env = getenv("Mailx_Subject");
const char *subject = (env ? env : get_map_string_item_or_NULL(settings, "Subject") ? : "[abrt] full crash report");
env = getenv("Mailx_EmailFrom");
const char *email_from = (env ? env : get_map_string_item_or_NULL(settings, "EmailFrom") ? : "user@localhost");
env = getenv("Mailx_EmailTo");
const char *email_to = (env ? env : get_map_string_item_or_NULL(settings, "EmailTo") ? : "root@localhost");
env = getenv("Mailx_SendBinaryData");
bool send_binary_data = string_to_bool(env ? env : get_map_string_item_or_empty(settings, "SendBinaryData"));
char **args = NULL;
unsigned arg_size = 0;
args = append_str_to_vector(args, &arg_size, "/bin/mailx");
char *dsc = make_description_mailx(problem_data);
if (send_binary_data)
{
GHashTableIter iter;
char *name;
struct problem_item *value;
g_hash_table_iter_init(&iter, problem_data);
while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
{
if (value->flags & CD_FLAG_BIN)
{
args = append_str_to_vector(args, &arg_size, "-a");
args = append_str_to_vector(args, &arg_size, value->content);
}
}
}
args = append_str_to_vector(args, &arg_size, "-s");
args = append_str_to_vector(args, &arg_size, subject);
args = append_str_to_vector(args, &arg_size, "-r");
args = append_str_to_vector(args, &arg_size, email_from);
args = append_str_to_vector(args, &arg_size, email_to);
log(_("Sending an email..."));
exec_and_feed_input(dsc, args);
free(dsc);
while (*args)
free(*args++);
args -= arg_size;
free(args);
free_problem_data(problem_data);
dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
char *msg = xasprintf("email: %s", email_to);
add_reported_to(dd, msg);
free(msg);
dd_close(dd);
}
log("Email was sent to: %s", email_to);
}
static void add_option_to_table(gpointer data, gpointer user_data)
{
event_option_t *option = data;
GtkGrid *option_table = user_data;
if (option->is_advanced)
option_table = GTK_GRID(g_object_get_data(G_OBJECT(option_table), "advanced-options"));
GtkWidget *label;
GtkWidget *option_input;
unsigned last_row;
char *option_label;
if (option->eo_label != NULL)
option_label = xstrdup(option->eo_label);
else
{
option_label = xstrdup(option->eo_name ? option->eo_name : "");
/* Replace '_' with ' ' */
char *p = option_label - 1;
while (*++p)
if (*p == '_')
*p = ' ';
}
switch (option->eo_type)
{
case OPTION_TYPE_TEXT:
case OPTION_TYPE_NUMBER:
case OPTION_TYPE_PASSWORD:
last_row = add_one_row_to_grid(option_table);
label = gtk_label_new_justify_left(option_label);
gtk_grid_attach(option_table, label,
/*left,top:*/ 0, last_row,
/*width,height:*/ 1, 1);
option_input = gtk_entry_new();
gtk_widget_set_hexpand(option_input, TRUE);
if (option->eo_value != NULL)
gtk_entry_set_text(GTK_ENTRY(option_input), option->eo_value);
gtk_grid_attach(option_table, option_input,
/*left,top:*/ 1, last_row,
/*width,height:*/ 1, 1);
g_option_list = add_option_widget(g_option_list, option_input, option);
if (option->eo_type == OPTION_TYPE_PASSWORD)
{
gtk_entry_set_visibility(GTK_ENTRY(option_input), 0);
last_row = add_one_row_to_grid(option_table);
GtkWidget *pass_cb = gtk_check_button_new_with_label(_("Show password"));
gtk_grid_attach(option_table, pass_cb,
/*left,top:*/ 1, last_row,
/*width,height:*/ 1, 1);
g_signal_connect(pass_cb, "toggled", G_CALLBACK(on_show_pass_cb), option_input);
has_password_option = true;
}
break;
case OPTION_TYPE_HINT_HTML:
label = gtk_label_new(option_label);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), /*x,yalign:*/ 0.0, 0.0);
make_label_autowrap_on_resize(GTK_LABEL(label));
last_row = add_one_row_to_grid(option_table);
gtk_grid_attach(option_table, label,
/*left,top:*/ 0, last_row,
/*width,height:*/ 2, 1);
break;
case OPTION_TYPE_BOOL:
last_row = add_one_row_to_grid(option_table);
option_input = gtk_check_button_new_with_label(option_label);
gtk_grid_attach(option_table, option_input,
/*left,top:*/ 0, last_row,
/*width,height:*/ 2, 1);
if (option->eo_value != NULL)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(option_input),
string_to_bool(option->eo_value));
g_option_list = add_option_widget(g_option_list, option_input, option);
break;
default:
//option_input = gtk_label_new_justify_left("WTF?");
log("unsupported option type");
free(option_label);
return;
}
if (option->eo_note_html)
{
label = gtk_label_new(option->eo_note_html);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), /*x,yalign:*/ 0.0, 0.0);
make_label_autowrap_on_resize(GTK_LABEL(label));
last_row = add_one_row_to_grid(option_table);
gtk_grid_attach(option_table, label,
/*left,top:*/ 1, last_row,
/*top,heigh:*/ 1, 1);
}
free(option_label);
}
static int run_ask_yes_no_save_generic_result_dialog(ask_yes_no_dialog_flags flags,
const char *key,
const char *message,
GtkWindow *parent)
{
INITIALIZE_LIBREPORT();
const char *ask_result = get_user_setting(key);
if (ask_result)
{
const bool ret = string_to_bool(ask_result);
if (!(flags & ASK_YES_NO__YESFOREVER))
return ret;
/* ASK_YES_NO__YESFOREVER */
if (ret == false)
/* Do you want to be asked? -> No, I don't. Do whatever you want */
return true;
/* CONTINUE becuase saved value is "yes" and it means 'Ask me!' */
}
GtkWidget *dialog = gtk_message_dialog_new(parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s", message);
/* let's try to use the text as markup
* this allows us to use hyperlinks to man pages */
gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), message);
/* Follow GTK3's yes-no-buttons order:
* [No] [Yes]
*/
GtkWidget *no_button = gtk_dialog_add_button(GTK_DIALOG(dialog), _("_No"), GTK_RESPONSE_NO);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Yes"), GTK_RESPONSE_YES);
gint response = GTK_RESPONSE_NO;
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(save_dialog_response), &response);
GtkWidget *ask_yes_no_cb = gtk_check_button_new_with_label(_("Don't ask me again"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
ask_yes_no_cb, TRUE, TRUE, 0);
if (flags & ASK_YES_NO__YESFOREVER)
{
/* Don't check the box by default. If the box is checked the 'No'
* button is disabled and we don't want to force users to click on
* 'Yes' button. */
g_signal_connect(ask_yes_no_cb, "toggled",
G_CALLBACK(on_toggle_ask_yes_no_yesforever_cb), (gpointer)no_button);
}
/* Esc -> No, Enter -> Yes */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES);
gtk_widget_show(ask_yes_no_cb);
gtk_dialog_run(GTK_DIALOG(dialog));
if (flags & ASK_YES_NO__YESFOREVER)
/* the box is checked -> Don't ask me again and my response is always 'Yes' */
set_user_setting(key, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ask_yes_no_cb)) ? "no" : "yes");
else if (flags & ASK_YES_NO__SAVE_RESULT)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ask_yes_no_cb)))
/* the box is checked -> remember my current answer */
set_user_setting(key, response == GTK_RESPONSE_YES ? "yes" : "no");
}
else /* should not happen */
error_msg("BUG:%s:%d %s() unknown type (0x%x) of ask_yes_no dialog",
__FILE__, __LINE__, __func__, flags);
gtk_widget_destroy(dialog);
return response == GTK_RESPONSE_YES;
}
static GtkSourceLanguage *
process_language_node (xmlTextReaderPtr reader, const gchar *filename)
{
xmlChar *version;
xmlChar *tmp;
xmlChar *untranslated_name;
GtkSourceLanguage *lang;
lang = g_object_new (GTK_SOURCE_TYPE_LANGUAGE, NULL);
lang->priv->lang_file_name = g_strdup (filename);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "translation-domain");
lang->priv->translation_domain = g_strdup ((gchar*) tmp);
xmlFree (tmp);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "hidden");
if (tmp != NULL)
lang->priv->hidden = string_to_bool ((gchar*) tmp);
else
lang->priv->hidden = FALSE;
xmlFree (tmp);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "mimetypes");
if (tmp != NULL)
g_hash_table_insert (lang->priv->properties,
g_strdup ("mimetypes"),
g_strdup ((char*) tmp));
xmlFree (tmp);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "globs");
if (tmp != NULL)
g_hash_table_insert (lang->priv->properties,
g_strdup ("globs"),
g_strdup ((char*) tmp));
xmlFree (tmp);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "_name");
if (tmp == NULL)
{
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "name");
if (tmp == NULL)
{
g_warning ("Impossible to get language name from file '%s'",
filename);
g_object_unref (lang);
return NULL;
}
lang->priv->name = g_strdup ((char*) tmp);
untranslated_name = tmp;
}
else
{
lang->priv->name = _gtk_source_language_translate_string (lang, (gchar*) tmp);
untranslated_name = tmp;
}
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "id");
if (tmp != NULL)
{
lang->priv->id = g_ascii_strdown ((gchar*) tmp, -1);
}
else
{
lang->priv->id = g_ascii_strdown ((gchar*) untranslated_name, -1);
}
xmlFree (tmp);
xmlFree (untranslated_name);
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "_section");
if (tmp == NULL)
{
tmp = xmlTextReaderGetAttribute (reader, BAD_CAST "section");
if (tmp == NULL)
lang->priv->section = g_strdup (DEFAULT_SECTION);
else
lang->priv->section = g_strdup ((gchar *) tmp);
xmlFree (tmp);
}
else
{
lang->priv->section = _gtk_source_language_translate_string (lang, (gchar*) tmp);
xmlFree (tmp);
}
version = xmlTextReaderGetAttribute (reader, BAD_CAST "version");
if (version == NULL)
{
g_warning ("Impossible to get version number from file '%s'",
filename);
g_object_unref (lang);
return NULL;
}
if (xmlStrcmp (version , BAD_CAST "1.0") == 0)
{
lang->priv->version = GTK_SOURCE_LANGUAGE_VERSION_1_0;
}
else if (xmlStrcmp (version, BAD_CAST "2.0") == 0)
{
lang->priv->version = GTK_SOURCE_LANGUAGE_VERSION_2_0;
}
else
{
g_warning ("Unsupported language spec version '%s' in file '%s'",
(gchar*) version, filename);
xmlFree (version);
g_object_unref (lang);
return NULL;
}
xmlFree (version);
if (lang->priv->version == GTK_SOURCE_LANGUAGE_VERSION_2_0)
process_properties (reader, lang);
return lang;
}
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);
}
}
void argument_parser::parse(string_vector & tokens)
{
for(std::size_t i = 0, end = tokens.size(); i < end; i++)
{
std::string const & token = tokens[i];
if(token.empty())
continue;
if(token[0] == '-')
{
std::string name = token.substr(1);
variable_vector::iterator iterator = std::find(variables.begin(), variables.end(), name);
if(iterator == variables.end())
continue;
argument_variable & variable = *iterator;
i++;
if(i == end)
throw exception("Variable \"" + name + "\" is lacking an argument");
std::string argument = tokens[i];
switch(variable.type)
{
case argument_variable_type_bool:
{
bool value;
if(!string_to_bool(argument, value))
throw exception("Invalid boolean value specified for variable \"" + name + "\"");
*reinterpret_cast<bool *>(variable.address) = value;
break;
}
case argument_variable_type_string:
*reinterpret_cast<std::string *>(variable.address) = argument;
break;
default:
throw exception("Unknown variable type encountered in argument parser");
break;
}
variable.handled = true;
}
}
BOOST_FOREACH(argument_variable & variable, variables)
{
if(!variable.handled)
{
if(variable.required)
throw exception("Required variable \"" + variable.name + "\" has not been specified");
else if(variable.default_value)
{
switch(variable.type)
{
case argument_variable_type_bool:
variable.set_default_value<bool>();
break;
case argument_variable_type_string:
variable.set_default_value<std::string>();
break;
}
}
}
}
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"\b [-v] -d DIR [-o FILE] [-a yes/no] [-r]\n"
"\n"
"Prints problem information to standard output or FILE"
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_o = 1 << 2,
OPT_a = 1 << 3,
OPT_r = 1 << 4,
};
/* 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" , _("Dump directory")),
OPT_STRING('o', NULL, &output_file , "FILE" , _("Output file")),
OPT_STRING('a', NULL, &append , "yes/no", _("Append to, or overwrite FILE")),
OPT_BOOL( 'r', NULL, NULL , _("Create reported_to in DIR")),
OPT_END()
};
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
if (output_file)
{
if (string_to_bool(append))
open_mode = "a";
if (!freopen(output_file, open_mode, stdout))
perror_msg_and_die("Can't open '%s'", output_file);
}
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
return 1; /* error message is already logged */
problem_data_t *problem_data = create_problem_data_from_dump_dir(dd);
dd_close(dd);
char *dsc = make_description_logger(problem_data);
fputs(dsc, stdout);
if (open_mode[0] == 'a')
fputs("\nEND:\n\n", stdout);
free(dsc);
free_problem_data(problem_data);
if (output_file)
{
if (opts & OPT_r)
{
dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
char *msg = xasprintf("file: %s", output_file);
add_reported_to(dd, msg);
free(msg);
dd_close(dd);
}
}
const char *format = (open_mode[0] == 'a' ? _("The report was appended to %s") : _("The report was stored to %s"));
log(format, output_file);
}
return 0;
}
/* This is my own parsing system for command-line options. It's nothing
special, but it works.
Given argc and argv, check to see if option argnum matches the string
optname. If so, parse its value according to the type flag. Store the
result in result if it matches, and return TRUE; return FALSE if it
doesn't match. argnum is a pointer so that it can be incremented in
cases like "-width 80". defval is the default value, which is only
meaningful for boolean options (so that just "-ml" can toggle the
value of the ml option.) */
static int extract_value(int argc, char *argv[], char *optname, int type,
int *argnum, int *result, int defval)
{
int optlen, val;
char *cx, *origcx, firstch;
optlen = strlen(optname);
origcx = argv[*argnum];
cx = origcx;
firstch = *cx;
cx++;
if (strncmp(cx, optname, optlen))
return FALSE;
cx += optlen;
switch (type) {
case ex_Void:
if (*cx)
return FALSE;
*result = TRUE;
return TRUE;
case ex_Int:
if (*cx == '\0') {
if ((*argnum)+1 >= argc) {
cx = "";
}
else {
(*argnum) += 1;
cx = argv[*argnum];
}
}
val = atoi(cx);
if (val == 0 && cx[0] != '0') {
printf("%s: %s must be followed by a number\n",
argv[0], origcx);
errflag = TRUE;
return FALSE;
}
*result = val;
return TRUE;
case ex_Bool:
if (*cx == '\0') {
if ((*argnum)+1 >= argc) {
val = -1;
}
else {
char *cx2 = argv[(*argnum)+1];
val = string_to_bool(cx2);
if (val != -1)
(*argnum) += 1;
}
}
else {
val = string_to_bool(cx);
if (val == -1) {
printf("%s: %s must be followed by a boolean value\n",
argv[0], origcx);
errflag = TRUE;
return FALSE;
}
}
if (val == -1)
val = !defval;
*result = val;
return TRUE;
case ex_Str:
if (*cx == '\0') {
if ((*argnum)+1 >= argc) {
cx = "";
}
else {
(*argnum) += 1;
cx = argv[*argnum];
}
}
strncpy(extracted_string, cx, STRBUFLEN-1);
extracted_string[STRBUFLEN-1] = '\0';
*result = 1;
return TRUE;
}
return FALSE;
}
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");
}
