bool load_app_conf_file(const char *application_name, map_string_t *settings)
{
char *app_conf_path = get_conf_path(application_name);
bool result = load_conf_file(app_conf_path, settings, false);
free(app_conf_path);
return result;
}
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);
}
void builtin_source(t_cmd *cmd, UNSEDP t_fds *fd, t_sh *shell)
{
char *source;
source = ".42conf";
if (cmd->argv[1] != NULL)
source = cmd->argv[1];
free_ptr_tab((void**)shell->alias_tab, &free);
shell->alias_tab = NULL;
load_conf_file(source, shell, &new_conf_set);
}
bool load_user_settings(const char *application_name)
{
if (conf_path)
free(conf_path);
conf_path = get_conf_path(application_name);
if (user_settings)
free_map_string(user_settings);
user_settings = new_map_string();
return load_conf_file(conf_path, user_settings, false);
}
int main(int argc, char **argv)
{
abrt_init(argv);
map_string_h *settings = new_map_string();
const char *dump_dir_name = ".";
GList *conf_file = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"\b [-v] -c CONFFILE -d DIR\n"
"\n"
"Reports problem to Bugzilla"
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
};
/* 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_LIST( 'c', NULL, &conf_file , "FILE", _("Configuration file (may be given many times)")),
OPT_END()
};
/*unsigned opts =*/ parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
while (conf_file)
{
char *fn = (char *)conf_file->data;
VERB1 log("Loading settings from '%s'", fn);
load_conf_file(fn, settings, /*skip key w/o values:*/ true);
VERB3 log("Loaded '%s'", fn);
conf_file = g_list_remove(conf_file, fn);
}
VERB1 log("Initializing XML-RPC library");
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
if (env.fault_occurred)
error_msg_and_die("XML-RPC Fault: %s(%d)", env.fault_string, env.fault_code);
xmlrpc_env_clean(&env);
report_to_bugzilla(dump_dir_name, settings);
free_map_string(settings);
return 0;
}
static int storaged_initialize() {
int status = -1;
DEBUG_FUNCTION;
// Load configuration
if (load_conf_file() != 0) {
fprintf(stderr, "can't load settings from config file\n");
goto out;
}
status = 0;
out:
return status;
}
static int load_conf(const char *conf_filename)
{
map_string_t *settings = new_map_string();
if (conf_filename != NULL)
{
if (!load_conf_file(conf_filename, settings, false))
error_msg("Can't open '%s'", conf_filename);
}
else
{
conf_filename = "abrt-action-save-package-data.conf";
if (!load_abrt_conf_file(conf_filename, settings))
error_msg("Can't load '%s'", conf_filename);
}
ParseCommon(settings, conf_filename);
free_map_string(settings);
load_gpg_keys();
return 0;
}
int main(int argc, char **argv)
{
abrt_init(argv);
const char *dump_dir_name = ".";
const char *conf_file = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"\b [-v] -d DIR [-c CONFFILE]\n"
"\n"
"Sends contents of a dump directory DIR via email"
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
};
/* 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('c', NULL, &conf_file , "CONFFILE", _("Config file")),
OPT_END()
};
/*unsigned opts =*/ parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
map_string_h *settings = new_map_string();
if (conf_file)
load_conf_file(conf_file, settings, /*skip key w/o values:*/ true);
create_and_send_email(dump_dir_name, settings);
free_map_string(settings);
return 0;
}
static void report_to_kerneloops(
const char *dump_dir_name,
map_string_t *settings)
{
problem_data_t *problem_data = create_problem_data_for_reporting(dump_dir_name);
if (!problem_data)
xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */
const char *backtrace = problem_data_get_content_or_NULL(problem_data, FILENAME_BACKTRACE);
if (!backtrace)
error_msg_and_die("Error sending kernel oops due to missing backtrace");
const char *env = getenv("KerneloopsReporter_SubmitURL");
const char *submitURL = (env ? env : get_map_string_item_or_empty(settings, "SubmitURL"));
if (!submitURL[0])
submitURL = "http://oops.kernel.org/submitoops.php";
log(_("Submitting oops report to %s"), submitURL);
CURLcode ret = http_post_to_kerneloops_site(submitURL, backtrace);
if (ret != CURLE_OK)
error_msg_and_die("Kernel oops has not been sent due to %s", curl_easy_strerror(ret));
problem_data_free(problem_data);
/* Server replies with:
* 200 thank you for submitting the kernel oops information
* RemoteIP: 34192fd15e34bf60fac6a5f01bba04ddbd3f0558
* - no URL or bug ID apparently...
*/
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
report_result_t rr = { .label = (char *)"kerneloops" };
rr.url = (char *)submitURL;
add_reported_to_entry(dd, &rr);
dd_close(dd);
}
log("Kernel oops report was uploaded");
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
map_string_t *settings = new_map_string();
const char *dump_dir_name = ".";
GList *conf_file = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"& [-v] [-c CONFFILE]... -d DIR\n"
"\n"
"Reports kernel oops to kerneloops.org (or similar) site.\n"
"\n"
"Files with names listed in $EXCLUDE_FROM_REPORT are not included\n"
"into the tarball.\n"
"\n"
"CONFFILE lines should have 'PARAM = VALUE' format.\n"
"Recognized string parameter: SubmitURL.\n"
"Parameter can be overridden via $KerneloopsReporter_SubmitURL."
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
};
/* 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_LIST( 'c', NULL, &conf_file , "FILE", _("Configuration file")),
OPT_END()
};
/*unsigned opts =*/ parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
while (conf_file)
{
char *fn = (char *)conf_file->data;
log_notice("Loading settings from '%s'", fn);
load_conf_file(fn, settings, /*skip key w/o values:*/ false);
log_debug("Loaded '%s'", fn);
conf_file = g_list_remove(conf_file, fn);
}
report_to_kerneloops(dump_dir_name, settings);
free_map_string(settings);
return 0;
}
int
main (int argc, char **argv)
{
int i;
char *p;
edg_wll_GssStatus gss_stat;
int ret;
FILE *pidf;
#ifndef IL_NOTIFICATIONS
p = strdup(argv[0]);
program_name = basename(p);
if (strcmp(program_name, "glite-lb-proxy-interlogd") == 0) {
file_prefix = DEFAULT_PROXY_PREFIX;
socket_path = DEFAULT_PROXY_SOCKET;
pidfile = DEFAULT_PROXY_PIDFILE;
}
free(p);
#endif
program_name = argv[0];
setlinebuf(stdout);
setlinebuf(stderr);
if ((p = getenv("EDG_WL_INTERLOG_TIMEOUT"))) TIMEOUT = atoi(p);
i = decode_switches (argc, argv);
if(glite_common_log_init()) {
fprintf(stderr, "glite_common_log_init() failed, exiting.\n");
exit(EXIT_FAILURE);
}
/* parse config file, if any */
if(conf_file != NULL) {
config = load_conf_file(conf_file);
}
/* check for reasonable queue lengths */
if((queue_size_low == 0 && queue_size_high > 0) ||
(queue_size_low > queue_size_high)) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "max queue length -Q must be greater than low queue length -q, both or none must be specified!");
exit(EXIT_FAILURE);
}
/* force -b if we do not have log server */
if(log_server == NULL) {
log_server = strdup(DEFAULT_LOG_SERVER);
bs_only = 1;
}
/* initialize error reporting */
if(init_errors()) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to initialize error message subsystem. Exiting.");
exit(EXIT_FAILURE);
}
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR
|| signal(SIGABRT, handle_signal) == SIG_ERR
|| signal(SIGTERM, handle_signal) == SIG_ERR
|| signal(SIGINT, handle_signal) == SIG_ERR) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to setup signal handlers: %s, exiting.",
strerror(errno));
exit(EXIT_FAILURE);
}
/* just try it before deamonizing to be able to complain aloud */
if (!(pidf = fopen(pidfile,"w"))) {
perror(pidfile);
exit(EXIT_FAILURE);
}
fclose(pidf);
if(!debug &&
(daemon(0,0) < 0)) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to daemonize itself: %s, exiting.",
strerror(errno));
exit(EXIT_FAILURE);
}
pidf = fopen(pidfile,"w");
assert(pidf); /* XXX */
fprintf(pidf,"%d\n",getpid());
fclose(pidf);
umask(S_IRWXG | S_IRWXO);
#ifdef LB_PERF
/* this must be called after installing signal handlers */
glite_wll_perftest_init(NULL, /* host */
NULL, /* user */
NULL, /* test name */
event_source,
njobs);
#endif
if(input_queue_attach() < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to initialize input queue: %s",
error_get_msg());
exit(EXIT_FAILURE);
}
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Initialized input queue.");
/* initialize output queues */
if(queue_list_init(log_server) < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to initialize output event queues: %s",
error_get_msg());
exit(EXIT_FAILURE);
}
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Initialized event queues.");
if(lazy_close)
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, " using lazy mode when closing connections, timeout %d",
default_close_timeout);
/* get credentials */
if (CAcert_dir)
setenv("X509_CERT_DIR", CAcert_dir, 1);
if(edg_wll_gss_initialize()) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to initialize GSS.");
exit(EXIT_FAILURE);
}
ret = edg_wll_gss_watch_creds(cert_file,&cert_mtime);
if (ret < 0)
glite_common_log(LOG_CATEGORY_SECURITY,LOG_PRIORITY_WARN,"edg_wll_gss_watch_creds failed, unable to access credentials\n");
cred_handle = malloc(sizeof(*cred_handle));
if(cred_handle == NULL) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to allocate structure for credentials.");
exit(EXIT_FAILURE);
}
cred_handle->creds = NULL;
cred_handle->counter = 0;
ret = edg_wll_gss_acquire_cred(cert_file, key_file, GSS_C_INITIATE, &cred_handle->creds, &gss_stat);
if (ret) {
char *gss_err = NULL;
if (ret == EDG_WLL_GSS_ERROR_GSS)
edg_wll_gss_get_error(&gss_stat, "edg_wll_gss_acquire_cred_gsi()", &gss_err);
glite_common_log(LOG_CATEGORY_SECURITY, LOG_PRIORITY_FATAL, "Failed to load GSI credential: %s",
(gss_err) ? gss_err : "edg_wll_gss_acquire_cred_gsi() failed");
if (gss_err)
free(gss_err);
if(gss_stat.minor_status != 0) {
exit(EXIT_FAILURE);
} else {
glite_common_log(LOG_CATEGORY_SECURITY, LOG_PRIORITY_WARN, "Continuing unauthenticated (yet).");
}
}
if(cred_handle && cred_handle->creds) {
glite_common_log(LOG_CATEGORY_SECURITY, LOG_PRIORITY_INFO, "Using certificate %s", cred_handle->creds->name);
}
/* parse config, initialize plugins */
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Initializing plugins:\n");
if(config) {
char *s = strstr(config, "[interlogd]");
char *p;
char name[MAXPATHLEN+1];
if(s) {
/* next line */
s = strchr(s, '\n');
if(s) s++;
while(s) {
if(*s == 0 || *s == '[')
break;
/* parse line */
p = strchr(s, '\n');
if(p) {
*p = 0;
}
/* XXX possible overflow by long line in config file */
ret = sscanf(s, " plugin =%s", name);
if(p) *p = '\n';
if(ret > 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, " loading plugin %s\n", name);
if(plugin_mgr_init(name, config) < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_ERROR, "Failed to load plugin %s: %s\n", name, error_get_msg());
}
}
s = p + 1;
}
}
}
#ifndef PERF_EMPTY
/* find all unsent events waiting in files */
#ifdef LB_PERF
if(norecover) {
if(event_store_init(file_prefix) < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to initialize event stores: %s",
error_get_msg());
exit(EXIT_FAILURE);
}
} else
#endif
{
pthread_t rid;
if(pthread_create(&rid, NULL, recover_thread, NULL) < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Failed to start recovery thread: %s", strerror(errno));
exit(EXIT_FAILURE);
}
pthread_detach(rid);
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Started recovery thread.");
}
#endif
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Using %d threads for parallel delivery.", parallel);
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Entering main loop.");
/* do the work */
if(loop() < 0) {
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_FATAL, "Fatal error: %s", error_get_msg());
if (killflg) {
input_queue_detach();
unlink(pidfile);
exit(EXIT_FAILURE);
}
}
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO, "Done!");
input_queue_detach();
unlink(pidfile);
exit (0);
}
static void load_config_files(const char *dir_path)
{
DIR *dir;
struct dirent *dent;
/* Load .conf files */
dir = opendir(dir_path);
if (!dir)
return;
while ((dent = readdir(dir)) != NULL)
{
char *ext = strrchr(dent->d_name, '.');
if (!ext)
continue;
if (strcmp(ext + 1, "conf") != 0)
continue;
char *fullname = concat_path_file(dir_path, dent->d_name);
*ext = '\0';
event_config_t *event_config = get_event_config(dent->d_name);
bool new_config = (!event_config);
if (new_config)
event_config = new_event_config();
map_string_h *keys_and_values = new_map_string();
load_conf_file(fullname, keys_and_values, /*skipKeysWithoutValue:*/ false);
free(fullname);
/* Insert or replace every key/value from keys_and_values to event_config->option */
GHashTableIter iter;
char *name;
char *value;
g_hash_table_iter_init(&iter, keys_and_values);
while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
{
event_option_t *opt;
GList *elem = g_list_find_custom(event_config->options, name,
cmp_event_option_name_with_string);
if (elem)
{
opt = elem->data;
// log("conf: replacing '%s' value:'%s'->'%s'", name, opt->value, value);
free(opt->eo_value);
}
else
{
// log("conf: new value %s='%s'", name, value);
opt = new_event_option();
opt->eo_name = xstrdup(name);
}
opt->eo_value = xstrdup(value);
if (!elem)
event_config->options = g_list_append(event_config->options, opt);
}
free_map_string(keys_and_values);
if (new_config)
g_hash_table_replace(g_event_config_list, xstrdup(dent->d_name), event_config);
}
closedir(dir);
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
const char *dump_dir_name = ".";
const char *conf_file = CONF_DIR"/plugins/upload.conf";
const char *url = NULL;
const char *ssh_public_key = NULL;
const char *ssh_private_key = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"& [-v] -d DIR [-c CONFFILE] [-u URL] [-b FILE] [-r FILE]\n"
"\n"
"Uploads compressed tarball of problem directory DIR to URL.\n"
"If URL is not specified, creates tarball in "LARGE_DATA_TMP_DIR" and exits.\n"
"\n"
"URL should have form 'protocol://[user[:pass]@]host/dir/[file.tar.gz]'\n"
"where protocol can be http(s), ftp, scp, or file.\n"
"File protocol can't have user and host parts: 'file:///dir/[file.tar.gz].'\n"
"If URL ends with a slash, the archive name will be generated and appended\n"
"to URL; otherwise, URL will be used as full file name.\n"
"\n"
"Files with names listed in $EXCLUDE_FROM_REPORT are not included\n"
"into the tarball.\n"
"\n"
"\n""If not specified, CONFFILE defaults to "CONF_DIR"/plugins/upload.conf"
"\n""Its lines should have 'PARAM = VALUE' format."
"Recognized string parameter: URL.\n"
"Parameter can be overridden via $Upload_URL."
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
OPT_u = 1 << 3,
OPT_b = 1 << 4,
OPT_r = 1 << 5,
};
/* 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('c', NULL, &conf_file , "CONFFILE", _("Config file")),
OPT_STRING('u', NULL, &url , "URL" , _("Base URL to upload to")),
OPT_STRING('b', "pubkey", &ssh_public_key , "FILE" , _("SSH public key file")),
OPT_STRING('r', "key", &ssh_private_key, "FILE" , _("SSH private key file")),
OPT_END()
};
/*unsigned opts =*/ parse_opts(argc, argv, program_options, program_usage_string);
export_abrt_envvars(0);
// 2015-10-16 (jfilak):
// It looks like there is no demand for encryption and other archive
// types. Configurable ExcludeFiles sounds reasonable to me, I am
// not sure about globbing though.
//
//Encrypt = yes
//ArchiveType = .tar.bz2
//
//TODO:
//ExcludeFiles = foo,bar*,b*z
map_string_t *settings = new_map_string();
if (conf_file)
load_conf_file(conf_file, settings, /*skip key w/o values:*/ false);
char *input_url = NULL;
const char *conf_url = getenv("Upload_URL");
if (!conf_url || conf_url[0] == '\0')
conf_url = url;
if (!conf_url || conf_url[0] == '\0')
conf_url = get_map_string_item_or_empty(settings, "URL");
if (!conf_url || conf_url[0] == '\0')
conf_url = input_url = ask_url(_("Please enter a URL (scp, ftp, etc.) where the problem data is to be exported:"));
set_map_string_item_from_string(settings, "UploadUsername", getenv("Upload_Username"));
set_map_string_item_from_string(settings, "UploadPassword", getenv("Upload_Password"));
/* set SSH keys */
if (ssh_public_key)
set_map_string_item_from_string(settings, "SSHPublicKey", ssh_public_key);
else if (getenv("Upload_SSHPublicKey") != NULL)
set_map_string_item_from_string(settings, "SSHPublicKey", getenv("Upload_SSHPublicKey"));
if (ssh_private_key)
set_map_string_item_from_string(settings, "SSHPrivateKey", ssh_private_key);
else if (getenv("Upload_SSHPrivateKey") != NULL)
set_map_string_item_from_string(settings, "SSHPrivateKey", getenv("Upload_SSHPrivateKey"));
char *remote_name = NULL;
const int result = create_and_upload_archive(dump_dir_name, conf_url, settings, &remote_name);
if (result != 0)
goto finito;
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
report_result_t *result;
result = report_result_new_with_label_from_env("upload");
report_result_set_url(result, remote_name);
add_reported_to_entry(dd, result);
report_result_free(result);
dd_close(dd);
}
free(remote_name);
finito:
free(input_url);
free_map_string(settings);
return result;
}
int main (int ac, char **av)
{
char *cmd = *av;
char *cname;
unsigned long delimiters[MAX_DELIMITER];
char *localmappers[MAX_LOCALMAPPER];
char *nameprep_version = NULL;
int ndelimiters = 0;
int nlocalmappers = 0;
char *in_code = NULL;
char *out_code = NULL;
char *resconf_file = NULL;
int no_resconf = 0;
char *encoding_alias = NULL;
int flags = DEFAULT_FLAGS;
FILE *fp;
idn_result_t r;
idn_resconf_t resconf1, resconf2;
idn_converter_t conv;
int exit_value;
#ifdef HAVE_SETLOCALE
(void) setlocale (LC_ALL, "");
#endif
/*
* If the command name begins with 'r', reverse mode is assumed.
*/
if ((cname = strrchr (cmd, '/')) != NULL)
cname++;
else
cname = cmd;
if (cname[0] == 'r')
flags |= FLAG_REVERSE;
ac--;
av++;
while (ac > 0 && **av == '-')
{
#define OPT_MATCH(opt) (strcmp(*av, opt) == 0)
#define MUST_HAVE_ARG if (ac < 2) print_usage(cmd)
#define APPEND_LIST(array, size, item, what) \
if (size >= (sizeof(array) / sizeof(array[0]))) { \
errormsg("too many " what "\n"); \
exit(1); \
} \
array[size++] = item; \
ac--; av++
if (OPT_MATCH ("-in") || OPT_MATCH ("-i"))
{
MUST_HAVE_ARG;
in_code = av[1];
ac--;
av++;
}
else if (OPT_MATCH ("-out") || OPT_MATCH ("-o"))
{
MUST_HAVE_ARG;
out_code = av[1];
ac--;
av++;
}
else if (OPT_MATCH ("-conf") || OPT_MATCH ("-c"))
{
MUST_HAVE_ARG;
resconf_file = av[1];
ac--;
av++;
}
else if (OPT_MATCH ("-nameprep") || OPT_MATCH ("-n"))
{
MUST_HAVE_ARG;
nameprep_version = av[1];
ac--;
av++;
}
else if (OPT_MATCH ("-noconf") || OPT_MATCH ("-C"))
{
no_resconf = 1;
}
else if (OPT_MATCH ("-reverse") || OPT_MATCH ("-r"))
{
flags |= FLAG_REVERSE;
}
else if (OPT_MATCH ("-nolocalmap") || OPT_MATCH ("-L"))
{
flags &= ~FLAG_LOCALMAP;
}
else if (OPT_MATCH ("-nonameprep") || OPT_MATCH ("-N"))
{
flags &= ~FLAG_NAMEPREP;
}
else if (OPT_MATCH ("-unassigncheck") || OPT_MATCH ("-u"))
{
flags |= FLAG_UNASSIGNCHECK;
}
else if (OPT_MATCH ("-nounassigncheck") || OPT_MATCH ("-U"))
{
flags &= ~FLAG_UNASSIGNCHECK;
}
else if (OPT_MATCH ("-nobidicheck") || OPT_MATCH ("-B"))
{
flags &= ~FLAG_BIDICHECK;
}
else if (OPT_MATCH ("-noasciicheck") || OPT_MATCH ("-A"))
{
flags &= ~FLAG_ASCIICHECK;
}
else if (OPT_MATCH ("-nolengthcheck"))
{
flags &= ~FLAG_LENGTHCHECK;
}
else if (OPT_MATCH ("-noroundtripcheck"))
{
flags &= ~FLAG_ROUNDTRIPCHECK;
}
else if (OPT_MATCH ("-whole") || OPT_MATCH ("-w"))
{
flags &= ~FLAG_SELECTIVE;
}
else if (OPT_MATCH ("-localmap"))
{
MUST_HAVE_ARG;
APPEND_LIST (localmappers, nlocalmappers, av[1], "local maps");
}
else if (OPT_MATCH ("-delimiter"))
{
unsigned long v;
MUST_HAVE_ARG;
v = get_ucs (av[1]);
APPEND_LIST (delimiters, ndelimiters, v, "delimiter maps");
}
else if (OPT_MATCH ("-alias") || OPT_MATCH ("-a"))
{
MUST_HAVE_ARG;
encoding_alias = av[1];
ac--;
av++;
}
else if (OPT_MATCH ("-flush"))
{
flush_every_line = 1;
}
else if (OPT_MATCH ("-version") || OPT_MATCH ("-v"))
{
print_version ();
}
else
{
print_usage (cmd);
}
#undef OPT_MATCH
#undef MUST_HAVE_ARG
#undef APPEND_LIST
ac--;
av++;
}
if (ac > 1)
print_usage (cmd);
/* Initialize. */
if ((r = idn_resconf_initialize ()) != idn_success)
{
errormsg ("error initializing library\n");
return (1);
}
/*
* Create resource contexts.
* `resconf1' and `resconf2' are almost the same but local and
* IDN encodings are reversed.
*/
resconf1 = NULL;
resconf2 = NULL;
if (idn_resconf_create (&resconf1) != idn_success || idn_resconf_create (&resconf2) != idn_success)
{
errormsg ("error initializing configuration contexts\n");
return (1);
}
/* Load configuration file. */
if (no_resconf)
{
set_defaults (resconf1);
set_defaults (resconf2);
}
else
{
load_conf_file (resconf1, resconf_file);
load_conf_file (resconf2, resconf_file);
}
/* Set encoding alias file. */
if (encoding_alias != NULL)
set_encoding_alias (encoding_alias);
/* Set input codeset. */
if (flags & FLAG_REVERSE)
{
if (in_code == NULL)
{
conv = idn_resconf_getidnconverter (resconf1);
if (conv == NULL)
{
errormsg ("cannot get the IDN encoding.\n" "please specify an appropriate one " "with `-in' option.\n");
exit (1);
}
idn_resconf_setlocalconverter (resconf2, conv);
idn_converter_destroy (conv);
}
else
{
set_idncode (resconf1, in_code);
set_localcode (resconf2, in_code);
}
}
else
{
if (in_code == NULL)
{
conv = idn_resconf_getlocalconverter (resconf1);
if (conv == NULL)
{
errormsg ("cannot get the local encoding.\n"
"please specify an appropriate one " "with `-in' option.\n");
exit (1);
}
idn_resconf_setidnconverter (resconf2, conv);
idn_converter_destroy (conv);
}
else
{
set_localcode (resconf1, in_code);
set_idncode (resconf2, in_code);
}
}
/* Set output codeset. */
if (flags & FLAG_REVERSE)
{
if (out_code == NULL)
{
conv = idn_resconf_getlocalconverter (resconf1);
if (conv == NULL)
{
errormsg ("cannot get the local encoding.\n"
"please specify an appropriate one " "with `-out' option.\n");
exit (1);
}
idn_resconf_setidnconverter (resconf2, conv);
idn_converter_destroy (conv);
}
else
{
set_localcode (resconf1, out_code);
set_idncode (resconf2, out_code);
}
}
else
{
if (out_code == NULL)
{
conv = idn_resconf_getidnconverter (resconf1);
if (conv == NULL)
{
errormsg ("cannot get the IDN encoding.\n"
"please specify an appropriate one " "with `-out' option.\n");
exit (1);
}
idn_resconf_setlocalconverter (resconf2, conv);
idn_converter_destroy (conv);
}
else
{
set_idncode (resconf1, out_code);
set_localcode (resconf2, out_code);
}
}
/* Set delimiter map(s). */
if (ndelimiters > 0)
{
set_delimitermapper (resconf1, delimiters, ndelimiters);
set_delimitermapper (resconf2, delimiters, ndelimiters);
}
/* Set local map(s). */
if (nlocalmappers > 0)
{
set_localmapper (resconf1, localmappers, nlocalmappers);
set_localmapper (resconf2, localmappers, nlocalmappers);
}
/* Set NAMEPREP version. */
if (nameprep_version != NULL)
{
set_nameprep (resconf1, nameprep_version);
set_nameprep (resconf2, nameprep_version);
}
idn_res_enable (1);
/* Open input file. */
if (ac > 0)
{
if ((fp = fopen (av[0], "r")) == NULL)
{
errormsg ("cannot open file %s: %s\n", av[0], strerror (errno));
return (1);
}
}
else
{
fp = stdin;
}
/* Do the conversion. */
if (flags & FLAG_REVERSE)
exit_value = decode_file (resconf1, resconf2, fp, flags);
else
exit_value = encode_file (resconf1, resconf2, fp, flags);
idn_resconf_destroy (resconf1);
idn_resconf_destroy (resconf2);
return exit_value;
}
int main(int argc, char **argv)
{
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
abrt_init(argv);
struct ureport_server_config config;
ureport_server_config_init(&config);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_u = 1 << 2,
OPT_k = 1 << 3,
OPT_t = 1 << 4,
OPT_h = 1 << 5,
OPT_i = 1 << 6,
};
int ret = 1; /* "failure" (for now) */
int insecure = !config.ur_ssl_verify;
const char *conf_file = UREPORT_CONF_FILE_PATH;
const char *arg_server_url = NULL;
const char *client_auth = NULL;
const char *http_auth = NULL;
GList *auth_items = NULL;
const char *dump_dir_path = ".";
const char *ureport_hash = NULL;
int ureport_hash_from_rt = 0;
int rhbz_bug = -1;
int rhbz_bug_from_rt = 0;
const char *email_address = NULL;
int email_address_from_env = 0;
char *comment = NULL;
int comment_file = 0;
char *attach_value = NULL;
char *attach_value_from_rt = NULL;
char *attach_value_from_rt_data = NULL;
char *report_result_type = NULL;
char *attach_type = NULL;
struct dump_dir *dd = NULL;
struct options program_options[] = {
OPT__VERBOSE(&g_verbose),
OPT__DUMP_DIR(&dump_dir_path),
OPT_STRING('u', "url", &arg_server_url, "URL", _("Specify server URL")),
OPT_BOOL('k', "insecure", &insecure,
_("Allow insecure connection to ureport server")),
OPT_STRING('t', "auth", &client_auth, "SOURCE", _("Use client authentication")),
OPT_STRING('h', "http-auth", &http_auth, "CREDENTIALS", _("Use HTTP Authentication")),
OPT_LIST('i', "auth_items", &auth_items, "AUTH_ITEMS", _("Additional files included in 'auth' key")),
OPT_STRING('c', NULL, &conf_file, "FILE", _("Configuration file")),
OPT_STRING('a', "attach", &ureport_hash, "BTHASH",
_("bthash of uReport to attach (conflicts with -A)")),
OPT_BOOL('A', "attach-rt", &ureport_hash_from_rt,
_("attach to a bthash from reported_to (conflicts with -a)")),
OPT_STRING('e', "email", &email_address, "EMAIL",
_("contact e-mail address (requires -a|-A, conflicts with -E)")),
OPT_BOOL('E', "email-env", &email_address_from_env,
_("contact e-mail address from environment or configuration file (requires -a|-A, conflicts with -e)")),
OPT_INTEGER('b', "bug-id", &rhbz_bug,
_("attach RHBZ bug (requires -a|-A, conflicts with -B)")),
OPT_BOOL('B', "bug-id-rt", &rhbz_bug_from_rt,
_("attach last RHBZ bug from reported_to (requires -a|-A, conflicts with -b)")),
OPT_STRING('o', "comment", &comment, "DESCRIPTION",
_("attach short text (requires -a|-A, conflicts with -D)")),
OPT_BOOL('O', "comment-file", &comment_file,
_("attach short text from comment (requires -a|-A, conflicts with -d)")),
/* va l ue */
OPT_STRING('l', "value", &attach_value, "DATA",
_("attach value (requires -a|-A and -T, conflicts with -L)")),
OPT_STRING('L', "value-rt", &attach_value_from_rt, "FIELD",
_("attach data of FIELD [URL] of the last report result (requires -a|-A, -r and -T, conflicts with -l)")),
OPT_STRING('r', "report-result-type", &report_result_type, "REPORT_RESULT_TYPE",
_("use REPORT_RESULT_TYPE when looking for FIELD in reported_to (used only with -L)")),
OPT_STRING('T', "type", &attach_type, "ATTACHMENT_TYPE",
_("attach DATA as ureport attachment ATTACHMENT_TYPE (used only with -l|-L)")),
OPT_END(),
};
const char *program_usage_string = _(
"& [-v] [-c FILE] [-u URL] [-k] [-t SOURCE] [-h CREDENTIALS]\n"
" [-A -a bthash -B -b bug-id -E -e email -O -o comment] [-d DIR]\n"
" [-A -a bthash -T ATTACHMENT_TYPE -r REPORT_RESULT_TYPE -L RESULT_FIELD] [-d DIR]\n"
" [-A -a bthash -T ATTACHMENT_TYPE -l DATA] [-d DIR]\n"
"& [-v] [-c FILE] [-u URL] [-k] [-t SOURCE] [-h CREDENTIALS] [-i AUTH_ITEMS] [-d DIR]\n"
"\n"
"Upload micro report or add an attachment to a micro report\n"
"\n"
"Reads the default configuration from "UREPORT_CONF_FILE_PATH
);
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
map_string_t *settings = new_map_string();
load_conf_file(conf_file, settings, /*skip key w/o values:*/ false);
ureport_server_config_load(&config, settings);
if (opts & OPT_u)
ureport_server_config_set_url(&config, xstrdup(arg_server_url));
if (opts & OPT_k)
config.ur_ssl_verify = !insecure;
if (opts & OPT_t)
ureport_server_config_set_client_auth(&config, client_auth);
if (opts & OPT_h)
ureport_server_config_load_basic_auth(&config, http_auth);
if (opts & OPT_i)
{
g_list_free_full(config.ur_prefs.urp_auth_items, free);
config.ur_prefs.urp_auth_items = auth_items;
}
if (!config.ur_url)
ureport_server_config_set_url(&config, xstrdup(DEFAULT_WEB_SERVICE_URL));
if (ureport_hash && ureport_hash_from_rt)
error_msg_and_die("You need to pass either -a bthash or -A");
if (rhbz_bug >= 0 && rhbz_bug_from_rt)
error_msg_and_die("You need to pass either -b bug-id or -B");
if (email_address && email_address_from_env)
error_msg_and_die("You need to pass either -e bthash or -E");
if (comment && comment_file)
error_msg_and_die("You need to pass either -o comment or -O");
if (attach_value && attach_value_from_rt)
error_msg_and_die("You need to pass either -l url or -L");
if ((attach_value || attach_value_from_rt) && attach_type == NULL)
error_msg_and_die("You need to pass -T together with -l and -L");
if (attach_value_from_rt)
{
if (report_result_type == NULL)
error_msg_and_die("You need to pass -r together with -L");
/* If you introduce a new recognized value, don't forget to update
* the documentation and the conditions below. */
if (strcmp(attach_value_from_rt, "URL") != 0)
error_msg_and_die("-L accepts only 'URL'");
}
if (ureport_hash_from_rt || rhbz_bug_from_rt || comment_file || attach_value_from_rt)
{
dd = dd_opendir(dump_dir_path, DD_OPEN_READONLY);
if (!dd)
xfunc_die();
if (ureport_hash_from_rt)
{
report_result_t *ureport_result = find_in_reported_to(dd, "uReport");
if (!ureport_result || !ureport_result->bthash)
error_msg_and_die(_("This problem does not have an uReport assigned."));
/* sorry, this will be leaked */
ureport_hash = xstrdup(ureport_result->bthash);
free_report_result(ureport_result);
}
if (rhbz_bug_from_rt)
{
report_result_t *bz_result = find_in_reported_to(dd, "Bugzilla");
if (!bz_result || !bz_result->url)
error_msg_and_die(_("This problem has not been reported to Bugzilla."));
char *bugid_ptr = strstr(bz_result->url, "show_bug.cgi?id=");
if (!bugid_ptr)
error_msg_and_die(_("Unable to find bug ID in bugzilla URL '%s'"), bz_result->url);
bugid_ptr += strlen("show_bug.cgi?id=");
/* we're just reading int, sscanf works fine */
if (sscanf(bugid_ptr, "%d", &rhbz_bug) != 1)
error_msg_and_die(_("Unable to parse bug ID from bugzilla URL '%s'"), bz_result->url);
free_report_result(bz_result);
}
if (comment_file)
{
comment = dd_load_text(dd, FILENAME_COMMENT);
if (comment == NULL)
error_msg_and_die(_("Cannot attach comment from 'comment' file"));
if (comment[0] == '\0')
error_msg_and_die(_("'comment' file is empty"));
}
if (attach_value_from_rt)
{
report_result_t *result = find_in_reported_to(dd, report_result_type);
if (!result)
error_msg_and_die(_("This problem has not been reported to '%s'."), report_result_type);
/* If you introduce a new attach_value_from_rt recognized value,
* this condition will become invalid. */
if (!result->url)
error_msg_and_die(_("The report result '%s' is missing URL."), report_result_type);
/* Avoid the need to duplicate the string. */
attach_value = attach_value_from_rt_data = result->url;
result->url = NULL;
free_report_result(result);
}
dd_close(dd);
}
if (email_address_from_env)
{
UREPORT_OPTION_VALUE_FROM_CONF(settings, "ContactEmail", email_address, (const char *));
if (!email_address)
error_msg_and_die(_("Neither environment variable 'uReport_ContactEmail' nor configuration option 'ContactEmail' is set"));
}
if (ureport_hash)
{
if (rhbz_bug < 0 && !email_address && !comment && !attach_value)
error_msg_and_die(_("You need to specify bug ID, contact email, comment or all of them"));
if (rhbz_bug >= 0)
{
if (ureport_attach_int(ureport_hash, "RHBZ", rhbz_bug, &config))
goto finalize;
}
if (email_address)
{
if (ureport_attach_string(ureport_hash, "email", email_address, &config))
goto finalize;
}
if (comment)
{
if (ureport_attach_string(ureport_hash, "comment", comment, &config))
goto finalize;
}
if (attach_value)
{
if (ureport_attach_string(ureport_hash, attach_type, attach_value, &config))
goto finalize;
}
ret = 0;
goto finalize;
}
if (!ureport_hash && (rhbz_bug >= 0 || email_address))
error_msg_and_die(_("You need to specify bthash of the uReport to attach."));
struct ureport_preferences *prefs = &(config.ur_prefs);
prefs->urp_flags |= UREPORT_PREF_FLAG_RETURN_ON_FAILURE;
char *json_ureport = ureport_from_dump_dir_ext(dump_dir_path, prefs);
if (!json_ureport)
{
error_msg(_("Failed to generate microreport from the problem data"));
goto finalize;
}
struct ureport_server_response *response = ureport_submit(json_ureport, &config);
free(json_ureport);
if (!response)
goto finalize;
if (!response->urr_is_error)
{
log_notice("is known: %s", response->urr_value);
ret = 0; /* "success" */
if (!ureport_server_response_save_in_dump_dir(response, dump_dir_path, &config))
xfunc_die();
/* If a reported problem is not known then emit NEEDMORE */
if (strcmp("true", response->urr_value) == 0)
{
log(_("This problem has already been reported."));
if (response->urr_message)
log("%s", response->urr_message);
ret = EXIT_STOP_EVENT_RUN;
}
}
else
error_msg(_("Server responded with an error: '%s'"), response->urr_value);
ureport_server_response_free(response);
finalize:
free(attach_value_from_rt_data);
if (config.ur_prefs.urp_auth_items == auth_items)
config.ur_prefs.urp_auth_items = NULL;
free_map_string(settings);
ureport_server_config_destroy(&config);
return ret;
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
const char *program_usage_string = _(
"\n& [-vf] [-c CONFFILE]... [-F FMTFILE] [-A FMTFILE2] -d DIR"
"\nor:"
"\n& [-v] [-c CONFFILE]... [-d DIR] -t[ID] FILE..."
"\nor:"
"\n& [-v] [-c CONFFILE]... [-d DIR] -t[ID] -w"
"\nor:"
"\n& [-v] [-c CONFFILE]... -h DUPHASH"
"\n"
"\nReports problem to MantisBT."
"\n"
"\nThe tool reads DIR. Then it tries to find an issue"
"\nwith the same abrt_hash in custom field 'abrt_hash'."
"\n"
"\nIf such issue is not found, then a new issue is created. Elements of DIR"
"\nare stored in the issue as part of issue description or as attachments,"
"\ndepending on their type and size."
"\n"
"\nOtherwise, if such issue is found and it is marked as CLOSED DUPLICATE,"
"\nthe tool follows the chain of duplicates until it finds a non-DUPLICATE issue."
"\nThe tool adds a new comment to found issue."
"\n"
"\nThe URL to new or modified issue is printed to stdout and recorded in"
"\n'reported_to' element."
"\n"
"\nOption -t uploads FILEs to the already created issue on MantisBT site."
"\nThe issue ID is retrieved from directory specified by -d DIR."
"\nIf problem data in DIR was never reported to MantisBT, upload will fail."
"\n"
"\nOption -tID uploads FILEs to the issue with specified ID on MantisBT site."
"\n-d DIR is ignored."
"\n"
"\nOption -r sets the last url from reporter_to element which is prefixed with"
"\nTRACKER_NAME to URL field. This option is applied only when a new issue is to be"
"\nfiled. The default value is 'ABRT Server'"
"\n"
"\nIf not specified, CONFFILE defaults to "CONF_DIR"/plugins/mantisbt.conf"
"\nand user's local ~"USER_HOME_CONFIG_PATH"/mantisbt.conf."
"\nIts lines should have 'PARAM = VALUE' format."
"\nRecognized string parameters: MantisbtURL, Login, Password, Project, ProjectVersion."
"\nRecognized boolean parameter (VALUE should be 1/0, yes/no): SSLVerify, CreatePrivate."
"\nUser's local configuration overrides the system wide configuration."
"\nParameters can be overridden via $Mantisbt_PARAM environment variables."
"\n"
"\nFMTFILE default to "CONF_DIR"/plugins/mantisbt_format.conf."
"\nFMTFILE2 default to "CONF_DIR"/plugins/mantisbt_formatdup.conf."
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
OPT_F = 1 << 3,
OPT_A = 1 << 4,
OPT_t = 1 << 5,
OPT_f = 1 << 6,
OPT_h = 1 << 7,
OPT_r = 1 << 8,
OPT_D = 1 << 9,
};
const char *dump_dir_name = ".";
GList *conf_file = NULL;
const char *fmt_file = CONF_DIR"/plugins/mantisbt_format.conf";
const char *fmt_file2 = CONF_DIR"/plugins/mantisbt_formatdup.conf";
char *abrt_hash = NULL;
char *ticket_no = NULL;
const char *tracker_str = "ABRT Server";
char *debug_str = NULL;
mantisbt_settings_t mbt_settings = { 0 };
/* 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_LIST( 'c', NULL, &conf_file , "FILE" , _("Configuration file (may be given many times)")),
OPT_STRING( 'F', NULL, &fmt_file , "FILE" , _("Formatting file for initial comment")),
OPT_STRING( 'A', NULL, &fmt_file2 , "FILE" , _("Formatting file for duplicates")),
OPT_OPTSTRING('t', "ticket", &ticket_no , "ID" , _("Attach FILEs [to issue with this ID]")),
OPT_BOOL( 'f', NULL, NULL, _("Force reporting even if this problem is already reported")),
OPT_STRING( 'h', "duphash", &abrt_hash, "DUPHASH", _("Print BUG_ID which has given DUPHASH")),
OPT_STRING( 'r', "tracker", &tracker_str, "TRACKER_NAME", _("A name of bug tracker for an additional URL from 'reported_to'")),
OPT_OPTSTRING('D', "debug", &debug_str , "STR" , _("Debug")),
OPT_END()
};
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
argv += optind;
export_abrt_envvars(0);
map_string_t *settings = new_map_string();
{
char *local_conf = NULL;
if (!conf_file)
{
conf_file = g_list_append(conf_file, (char*) CONF_DIR"/plugins/mantisbt.conf");
local_conf = xasprintf("%s"USER_HOME_CONFIG_PATH"/mantisbt.conf", getenv("HOME"));
conf_file = g_list_append(conf_file, local_conf);
}
while (conf_file)
{
char *fn = (char *)conf_file->data;
log_notice("Loading settings from '%s'", fn);
load_conf_file(fn, settings, /*skip key w/o values:*/ false);
log_debug("Loaded '%s'", fn);
conf_file = g_list_delete_link(conf_file, conf_file);
}
free(local_conf);
struct dump_dir *dd = NULL;
if (abrt_hash == NULL)
{
dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
error_msg_and_die(_("Can't open problem dir '%s'."), dump_dir_name);
}
set_settings(&mbt_settings, settings, dd);
dd_close(dd);
/* WRONG! set_settings() does not copy the strings, it merely sets up pointers
* to settings[] dictionary:
*/
/*free_map_string(settings);*/
}
/* No connection is opened between client and server. Users authentication
* is performed on every SOAP method call. In the first step we verify the
* credentials by calling 'mc_login' method. In the case the credentials are
* correctly applies the reporter uses them in the next requests. It is not
* necessary to call 'mc_login' method because the method provides only
* verification of credentials.
*/
verify_credentials(&mbt_settings);
if (abrt_hash)
{
log_warning(_("Looking for similar problems in MantisBT"));
GList *ids = mantisbt_search_by_abrt_hash(&mbt_settings, abrt_hash);
mantisbt_settings_free(&mbt_settings);
if (ids == NULL)
return EXIT_FAILURE;
puts(ids->data);
response_values_free(ids);
return EXIT_SUCCESS;
}
mantisbt_get_project_id_from_name(&mbt_settings);
if (opts & OPT_t)
{
if (!argv[0])
show_usage_and_die(program_usage_string, program_options);
if (!ticket_no)
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
xfunc_die();
report_result_t *reported_to = find_in_reported_to(dd, "MantisBT");
dd_close(dd);
if (!reported_to || !reported_to->url)
error_msg_and_die(_("Can't get MantisBT ID because this problem has not yet been reported to MantisBT."));
char *url = reported_to->url;
reported_to->url = NULL;
free_report_result(reported_to);
if (prefixcmp(url, mbt_settings.m_mantisbt_url) != 0)
error_msg_and_die(_("This problem has been reported to MantisBT '%s' which differs from the configured MantisBT '%s'."), url, mbt_settings.m_mantisbt_url);
ticket_no = strrchr(url, '=');
if (!ticket_no)
error_msg_and_die(_("Malformed url to MantisBT '%s'."), url);
/* won't ever call free on it - it simplifies the code a lot */
ticket_no = xstrdup(ticket_no + 1);
log_warning(_("Using MantisBT ID '%s'"), ticket_no);
}
/* Attach files to existing MantisBT issues */
while (*argv)
{
const char *path = *argv++;
char *filename = basename(path);
log_warning(_("Attaching file '%s' to issue %s"), filename, ticket_no);
mantisbt_attach_file(&mbt_settings, ticket_no, filename, path);
}
return 0;
}
/* Create new issue in MantisBT */
if (!(opts & OPT_f))
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
xfunc_die();
report_result_t *reported_to = find_in_reported_to(dd, "MantisBT");
dd_close(dd);
if (reported_to && reported_to->url)
{
char *msg = xasprintf(_("This problem was already reported to MantisBT (see '%s')."
" Do you still want to create a new issue?"),
reported_to->url);
int yes = ask_yes_no(msg);
free(msg);
if (!yes)
return 0;
}
free_report_result(reported_to);
}
problem_data_t *problem_data = create_problem_data_for_reporting(dump_dir_name);
if (!problem_data)
xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */
const char *category = problem_data_get_content_or_die(problem_data, FILENAME_COMPONENT);
const char *duphash = problem_data_get_content_or_die(problem_data, FILENAME_DUPHASH);
if (opts & OPT_D)
{
problem_formatter_t *pf = problem_formatter_new();
problem_formatter_add_section(pf, PR_SEC_ADDITIONAL_INFO, /* optional section */ 0);
if (problem_formatter_load_file(pf, fmt_file))
error_msg_and_die("Invalid format file: %s", fmt_file);
problem_report_t *pr = NULL;
if (problem_formatter_generate_report(pf, problem_data, &pr))
error_msg_and_die("Failed to format issue report from problem data");
printf("summary: %s\n"
"\n"
"Description:\n%s\n"
"Additional info:\n%s\n"
, problem_report_get_summary(pr)
, problem_report_get_description(pr)
, problem_report_get_section(pr, PR_SEC_ADDITIONAL_INFO)
);
puts("attachments:");
for (GList *a = problem_report_get_attachments(pr); a != NULL; a = g_list_next(a))
printf(" %s\n", (const char *)a->data);
problem_report_free(pr);
problem_formatter_free(pf);
exit(0);
}
unsigned long bug_id = 0;
/* If REMOTE_RESULT contains "DUPLICATE 12345", we consider it a dup of 12345
* and won't search on MantisBT server.
*/
char *remote_result;
remote_result = problem_data_get_content_or_NULL(problem_data, FILENAME_REMOTE_RESULT);
if (remote_result)
{
char *cmd = strtok(remote_result, " \n");
char *id = strtok(NULL, " \n");
if (!prefixcmp(cmd, "DUPLICATE"))
{
errno = 0;
char *e;
bug_id = strtoul(id, &e, 10);
if (errno || id == e || *e != '\0' || bug_id > INT_MAX)
{
/* error / no digits / illegal trailing chars / too big a number */
bug_id = 0;
}
}
}
mantisbt_issue_info_t *ii;
if (!bug_id)
{
log_warning(_("Checking for duplicates"));
int existing_id = -1;
int crossver_id = -1;
{
/* Figure out whether we want to match category
* when doing dup search.
*/
const char *category_substitute = is_in_comma_separated_list(category, mbt_settings.m_DontMatchComponents) ? NULL : category;
/* We don't do dup detection across versions (see below why),
* but we do add a note if cross-version potential dup exists.
* For that, we search for cross version dups first:
*/
// SOAP API searching method is not in the final version, it's possible the project will be string
GList *crossver_bugs_ids = mantisbt_search_duplicate_issues(&mbt_settings, category_substitute, /*version*/ NULL, duphash);
unsigned crossver_bugs_count = g_list_length(crossver_bugs_ids);
log_debug("MantisBT has %i reports with duphash '%s' including cross-version ones",
crossver_bugs_count, duphash);
if (crossver_bugs_count > 0)
crossver_id = atoi(g_list_first(crossver_bugs_ids)->data);
if (crossver_bugs_count > 0)
{
// SOAP API searching method is not in the final version, it's possible the project will be string
GList *dup_bugs_ids = mantisbt_search_duplicate_issues(&mbt_settings, category_substitute, mbt_settings.m_project_version, duphash);
unsigned dup_bugs_count = g_list_length(dup_bugs_ids);
log_debug("MantisBT has %i reports with duphash '%s'",
dup_bugs_count, duphash);
if (dup_bugs_count > 0)
existing_id = atoi(g_list_first(dup_bugs_ids)->data);
}
}
if (existing_id < 0)
{
/* Create new issue */
log_warning(_("Creating a new issue"));
problem_formatter_t *pf = problem_formatter_new();
problem_formatter_add_section(pf, PR_SEC_ADDITIONAL_INFO, 0);
if (problem_formatter_load_file(pf, fmt_file))
error_msg_and_die(_("Invalid format file: %s"), fmt_file);
problem_report_t *pr = NULL;
if (problem_formatter_generate_report(pf, problem_data, &pr))
error_msg_and_die(_("Failed to format problem data"));
if (crossver_id >= 0)
problem_report_buffer_printf(
problem_report_get_buffer(pr, PR_SEC_DESCRIPTION),
"\nPotential duplicate: issue %u\n", crossver_id);
problem_formatter_free(pf);
/* get tracker URL if exists */
struct dump_dir *dd = dd_opendir(dump_dir_name, 0);
char *tracker_url = NULL;
if (dd)
{
report_result_t *reported_to = find_in_reported_to(dd, tracker_str);
dd_close(dd);
if (reported_to && reported_to->url)
{
log_warning(_("Adding External URL to issue"));
tracker_url = xstrdup(reported_to->url);
free_report_result(reported_to);
}
}
int new_id = mantisbt_create_new_issue(&mbt_settings, problem_data, pr, tracker_url);
free(tracker_url);
if (new_id == -1)
return EXIT_FAILURE;
log_warning(_("Adding attachments to issue %i"), new_id);
char *new_id_str = xasprintf("%u", new_id);
for (GList *a = problem_report_get_attachments(pr); a != NULL; a = g_list_next(a))
{
const char *item_name = (const char *)a->data;
struct problem_item *item = problem_data_get_item_or_NULL(problem_data, item_name);
if (!item)
continue;
else if (item->flags & CD_FLAG_TXT)
mantisbt_attach_data(&mbt_settings, new_id_str, item_name, item->content, strlen(item->content));
else if (item->flags & CD_FLAG_BIN)
mantisbt_attach_file(&mbt_settings, new_id_str, item_name, item->content);
}
free(new_id_str);
problem_report_free(pr);
ii = mantisbt_issue_info_new();
ii->mii_id = new_id;
ii->mii_status = xstrdup("new");
goto finish;
}
bug_id = existing_id;
}
ii = mantisbt_get_issue_info(&mbt_settings, bug_id);
log_warning(_("Bug is already reported: %i"), ii->mii_id);
/* Follow duplicates */
if ((strcmp(ii->mii_status, "closed") == 0)
&& (strcmp(ii->mii_resolution, "duplicate") == 0)
) {
mantisbt_issue_info_t *origin = mantisbt_find_origin_bug_closed_duplicate(&mbt_settings, ii);
if (origin)
{
mantisbt_issue_info_free(ii);
ii = origin;
}
}
/* TODO CC list
* Is no MantisBT SOAP API method which allows adding users to CC list
* without updating issue.
*/
/* Add comment and bt */
const char *comment = problem_data_get_content_or_NULL(problem_data, FILENAME_COMMENT);
if (comment && comment[0])
{
problem_formatter_t *pf = problem_formatter_new();
if (problem_formatter_load_file(pf, fmt_file2))
error_msg_and_die(_("Invalid duplicate format file: '%s"), fmt_file2);
problem_report_t *pr;
if (problem_formatter_generate_report(pf, problem_data, &pr))
error_msg_and_die(_("Failed to format duplicate comment from problem data"));
const char *mbtcomment = problem_report_get_description(pr);
int dup_comment = is_comment_dup(ii->mii_notes, mbtcomment);
if (!dup_comment)
{
log_warning(_("Adding new comment to issue %d"), ii->mii_id);
mantisbt_add_issue_note(&mbt_settings, ii->mii_id, mbtcomment);
const char *bt = problem_data_get_content_or_NULL(problem_data, FILENAME_BACKTRACE);
unsigned rating = 0;
const char *rating_str = problem_data_get_content_or_NULL(problem_data, FILENAME_RATING);
/* python doesn't have rating file */
if (rating_str)
rating = xatou(rating_str);
if (bt && rating > ii->mii_best_bt_rating)
{
char *bug_id_str = xasprintf("%i", ii->mii_id);
log_warning(_("Attaching better backtrace"));
// find unique filename of attachment
char *name = NULL;
for (int i = 0;; ++i)
{
if (i == 0)
name = xasprintf("%s", FILENAME_BACKTRACE);
else
name = xasprintf("%s%d", FILENAME_BACKTRACE, i);
if (g_list_find_custom(ii->mii_attachments, name, (GCompareFunc) strcmp) == NULL)
break;
free(name);
}
mantisbt_attach_data(&mbt_settings, bug_id_str, name, bt, strlen(bt));
free(name);
free(bug_id_str);
}
}
else
log_warning(_("Found the same comment in the issue history, not adding a new one"));
problem_report_free(pr);
problem_formatter_free(pf);
}
finish:
log_warning(_("Status: %s%s%s %s/view.php?id=%u"),
ii->mii_status,
ii->mii_resolution ? " " : "",
ii->mii_resolution ? ii->mii_resolution : "",
mbt_settings.m_mantisbt_url,
ii->mii_id);
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
report_result_t rr = { .label = (char *)"MantisBT" };
rr.url = xasprintf("%s/view.php?id=%u", mbt_settings.m_mantisbt_url, ii->mii_id);
add_reported_to_entry(dd, &rr);
free(rr.url);
dd_close(dd);
}
mantisbt_settings_free(&mbt_settings);
return 0;
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"\n& [-vbf] [-g GROUP-NAME]... [-c CONFFILE]... [-F FMTFILE] [-A FMTFILE2] -d DIR"
"\nor:"
"\n& [-v] [-c CONFFILE]... [-d DIR] -t[ID] FILE..."
"\nor:"
"\n& [-v] [-c CONFFILE]... [-d DIR] -t[ID] -w"
"\nor:"
"\n& [-v] [-c CONFFILE]... -h DUPHASH"
"\n"
"\nReports problem to Bugzilla."
"\n"
"\nThe tool reads DIR. Then it logs in to Bugzilla and tries to find a bug"
"\nwith the same abrt_hash:HEXSTRING in 'Whiteboard'."
"\n"
"\nIf such bug is not found, then a new bug is created. Elements of DIR"
"\nare stored in the bug as part of bug description or as attachments,"
"\ndepending on their type and size."
"\n"
"\nOtherwise, if such bug is found and it is marked as CLOSED DUPLICATE,"
"\nthe tool follows the chain of duplicates until it finds a non-DUPLICATE bug."
"\nThe tool adds a new comment to found bug."
"\n"
"\nThe URL to new or modified bug is printed to stdout and recorded in"
"\n'reported_to' element."
"\n"
"\nOption -t uploads FILEs to the already created bug on Bugzilla site."
"\nThe bug ID is retrieved from directory specified by -d DIR."
"\nIf problem data in DIR was never reported to Bugzilla, upload will fail."
"\n"
"\nOption -tID uploads FILEs to the bug with specified ID on Bugzilla site."
"\n-d DIR is ignored."
"\n"
"\nOption -w adds bugzilla user to bug's CC list."
"\n"
"\nIf not specified, CONFFILE defaults to "CONF_DIR"/plugins/bugzilla.conf"
"\nIts lines should have 'PARAM = VALUE' format."
"\nRecognized string parameters: BugzillaURL, Login, Password, OSRelease."
"\nRecognized boolean parameter (VALUE should be 1/0, yes/no): SSLVerify."
"\nParameters can be overridden via $Bugzilla_PARAM environment variables."
"\n"
"\nFMTFILE and FMTFILE2 default to "CONF_DIR"/plugins/bugzilla_format.conf"
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
OPT_F = 1 << 3,
OPT_A = 1 << 4,
OPT_t = 1 << 5,
OPT_b = 1 << 6,
OPT_f = 1 << 7,
OPT_w = 1 << 8,
OPT_h = 1 << 9,
OPT_g = 1 << 10,
OPT_D = 1 << 11,
};
const char *dump_dir_name = ".";
GList *conf_file = NULL;
const char *fmt_file = CONF_DIR"/plugins/bugzilla_format.conf";
const char *fmt_file2 = fmt_file;
char *abrt_hash = NULL;
char *ticket_no = NULL;
char *debug_str = NULL;
GList *group = NULL;
/* 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_LIST( 'c', NULL, &conf_file , "FILE" , _("Configuration file (may be given many times)")),
OPT_STRING( 'F', NULL, &fmt_file , "FILE" , _("Formatting file for initial comment")),
OPT_STRING( 'A', NULL, &fmt_file2 , "FILE" , _("Formatting file for duplicates")),
OPT_OPTSTRING('t', "ticket", &ticket_no , "ID" , _("Attach FILEs [to bug with this ID]")),
OPT_BOOL( 'b', NULL, NULL, _("When creating bug, attach binary files too")),
OPT_BOOL( 'f', NULL, NULL, _("Force reporting even if this problem is already reported")),
OPT_BOOL( 'w', NULL, NULL, _("Add bugzilla user to CC list [of bug with this ID]")),
OPT_STRING( 'h', "duphash", &abrt_hash, "DUPHASH", _("Print BUG_ID which has given DUPHASH")),
OPT_LIST( 'g', "group", &group , "GROUP" , _("Restrict access to this group only")),
OPT_OPTSTRING('D', "debug", &debug_str , "STR" , _("Debug")),
OPT_END()
};
unsigned opts = parse_opts(argc, argv, program_options, program_usage_string);
argv += optind;
export_abrt_envvars(0);
map_string_t *settings = new_map_string();
struct bugzilla_struct rhbz = { 0 };
{
if (!conf_file)
conf_file = g_list_append(conf_file, (char*) CONF_DIR"/plugins/bugzilla.conf");
while (conf_file)
{
char *fn = (char *)conf_file->data;
VERB1 log("Loading settings from '%s'", fn);
load_conf_file(fn, settings, /*skip key w/o values:*/ false);
VERB3 log("Loaded '%s'", fn);
conf_file = g_list_delete_link(conf_file, conf_file);
}
set_settings(&rhbz, settings);
/* WRONG! set_settings() does not copy the strings, it merely sets up pointers
* to settings[] dictionary:
*/
/*free_map_string(settings);*/
}
VERB1 log("Initializing XML-RPC library");
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
if (env.fault_occurred)
abrt_xmlrpc_die(&env);
xmlrpc_env_clean(&env);
struct abrt_xmlrpc *client;
client = abrt_xmlrpc_new_client(rhbz.b_bugzilla_xmlrpc, rhbz.b_ssl_verify);
unsigned rhbz_ver = rhbz_version(client);
if (abrt_hash)
{
log(_("Looking for similar problems in bugzilla"));
char *hash;
if (prefixcmp(abrt_hash, "abrt_hash:"))
hash = xasprintf("abrt_hash:%s", abrt_hash);
else
hash = xstrdup(abrt_hash);
/* it's Fedora specific */
xmlrpc_value *all_bugs = rhbz_search_duphash(client,
/*product:*/ "Fedora",
/*version:*/ NULL,
/*component:*/ NULL,
hash);
free(hash);
unsigned all_bugs_size = rhbz_array_size(all_bugs);
if (all_bugs_size > 0)
{
int bug_id = rhbz_get_bug_id_from_array0(all_bugs, rhbz_ver);
printf("%i\n", bug_id);
}
return EXIT_SUCCESS;
}
if (rhbz.b_login[0] == '\0')
{
free(rhbz.b_login);
rhbz.b_login = ask_bz_login(_("Login is not provided by configuration. Please enter your BZ login:"******"Password is not provided by configuration. Please enter the password for '%s':"), rhbz.b_login);
rhbz.b_password = ask_bz_password(question);
free(question);
}
if (opts & OPT_t)
{
if ((!argv[0] && !(opts & OPT_w)) || (argv[0] && (opts & OPT_w)))
show_usage_and_die(program_usage_string, program_options);
if (!ticket_no)
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
xfunc_die();
report_result_t *reported_to = find_in_reported_to(dd, "Bugzilla:");
dd_close(dd);
if (!reported_to || !reported_to->url)
error_msg_and_die(_("Can't get Bugzilla ID because this problem has not yet been reported to Bugzilla."));
char *url = reported_to->url;
reported_to->url = NULL;
free_report_result(reported_to);
if (prefixcmp(url, rhbz.b_bugzilla_url) != 0)
error_msg_and_die(_("This problem has been reported to Bugzilla '%s' which differs from the configured Bugzilla '%s'."), url, rhbz.b_bugzilla_url);
ticket_no = strrchr(url, '=');
if (!ticket_no)
error_msg_and_die(_("Malformed url to Bugzilla '%s'."), url);
/* won't ever call free on it - it simplifies the code a lot */
ticket_no = xstrdup(ticket_no + 1);
log(_("Using Bugzilla ID '%s'"), ticket_no);
}
login(client, &rhbz);
if (opts & OPT_w)
rhbz_mail_to_cc(client, xatoi_positive(ticket_no), rhbz.b_login, /* require mail notify */ 0);
else
{ /* Attach files to existing BZ */
while (*argv)
{
const char *filename = *argv++;
VERB1 log("Attaching file '%s' to bug %s", filename, ticket_no);
int fd = open(filename, O_RDONLY);
if (fd < 0)
{
perror_msg("Can't open '%s'", filename);
continue;
}
struct stat st;
if (fstat(fd, &st) != 0 || !S_ISREG(st.st_mode))
{
error_msg("'%s': not a regular file", filename);
close(fd);
continue;
}
rhbz_attach_fd(client, ticket_no, filename, fd, /*flags*/ 0);
close(fd);
}
}
log(_("Logging out"));
rhbz_logout(client);
#if 0 /* enable if you search for leaks (valgrind etc) */
abrt_xmlrpc_free_client(client);
#endif
return 0;
}
/* Create new bug in Bugzilla */
if (!(opts & OPT_f))
{
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (!dd)
xfunc_die();
report_result_t *reported_to = find_in_reported_to(dd, "Bugzilla:");
dd_close(dd);
if (reported_to && reported_to->url)
{
char *msg = xasprintf("This problem was already reported to Bugzilla (see '%s')."
" Do you still want to create a new bug?",
reported_to->url);
int yes = ask_yes_no(msg);
free(msg);
if (!yes)
return 0;
}
free_report_result(reported_to);
}
problem_data_t *problem_data = create_problem_data_for_reporting(dump_dir_name);
if (!problem_data)
xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */
const char *component = problem_data_get_content_or_die(problem_data, FILENAME_COMPONENT);
const char *duphash = problem_data_get_content_or_NULL(problem_data, FILENAME_DUPHASH);
//COMPAT, remove after 2.1 release
if (!duphash) duphash = problem_data_get_content_or_die(problem_data, "global_uuid");
if (!rhbz.b_product || !*rhbz.b_product) /* if not overridden or empty... */
{
free(rhbz.b_product);
free(rhbz.b_product_version);
map_string_t *osinfo = new_map_string();
problem_data_get_osinfo(problem_data, osinfo);
parse_osinfo_for_bz(osinfo, &rhbz.b_product, &rhbz.b_product_version);
free_map_string(osinfo);
if (!rhbz.b_product)
error_msg_and_die(_("Can't determine Bugzilla Product from problem data."));
}
if (opts & OPT_D)
{
GList *comment_fmt_spec = load_bzrep_conf_file(fmt_file);
struct strbuf *bzcomment_buf = strbuf_new();
generate_bz_comment(bzcomment_buf, problem_data, comment_fmt_spec);
char *bzcomment = strbuf_free_nobuf(bzcomment_buf);
char *summary = create_summary_string(problem_data, comment_fmt_spec);
printf("summary: %s\n"
"\n"
"%s"
, summary, bzcomment
);
free(bzcomment);
free(summary);
exit(0);
}
login(client, &rhbz);
int bug_id = 0;
/* If REMOTE_RESULT contains "DUPLICATE 12345", we consider it a dup of 12345
* and won't search on bz server.
*/
char *remote_result;
remote_result = problem_data_get_content_or_NULL(problem_data, FILENAME_REMOTE_RESULT);
if (remote_result)
{
char *cmd = strtok(remote_result, " \n");
char *id = strtok(NULL, " \n");
if (!prefixcmp(cmd, "DUPLICATE"))
{
errno = 0;
char *e;
bug_id = strtoul(id, &e, 10);
if (errno || id == e || *e != '\0' || bug_id > INT_MAX)
{
/* error / no digits / illegal trailing chars / too big a number */
bug_id = 0;
}
}
}
struct bug_info *bz = NULL;
if (!bug_id)
{
log(_("Checking for duplicates"));
int existing_id = -1;
int crossver_id = -1;
{
/* Figure out whether we want to match component
* when doing dup search.
*/
const char *component_substitute = is_in_comma_separated_list(component, rhbz.b_DontMatchComponents) ? NULL : component;
/* We don't do dup detection across versions (see below why),
* but we do add a note if cross-version potential dup exists.
* For that, we search for cross version dups first:
*/
xmlrpc_value *crossver_bugs = rhbz_search_duphash(client, rhbz.b_product, /*version:*/ NULL,
component_substitute, duphash);
unsigned crossver_bugs_count = rhbz_array_size(crossver_bugs);
VERB3 log("Bugzilla has %i reports with duphash '%s' including cross-version ones",
crossver_bugs_count, duphash);
if (crossver_bugs_count > 0)
crossver_id = rhbz_get_bug_id_from_array0(crossver_bugs, rhbz_ver);
xmlrpc_DECREF(crossver_bugs);
if (crossver_bugs_count > 0)
{
/* In dup detection we require match in product *and version*.
* Otherwise we sometimes have bugs in e.g. Fedora 17
* considered to be dups of Fedora 16 bugs.
* Imagine that F16 is "end-of-lifed" - allowing cross-version
* match will make all newly detected crashes DUPed
* to a bug in a dead release.
*/
xmlrpc_value *dup_bugs = rhbz_search_duphash(client, rhbz.b_product,
rhbz.b_product_version, component_substitute, duphash);
unsigned dup_bugs_count = rhbz_array_size(dup_bugs);
VERB3 log("Bugzilla has %i reports with duphash '%s'",
dup_bugs_count, duphash);
if (dup_bugs_count > 0)
existing_id = rhbz_get_bug_id_from_array0(dup_bugs, rhbz_ver);
xmlrpc_DECREF(dup_bugs);
}
}
if (existing_id < 0)
{
/* Create new bug */
log(_("Creating a new bug"));
GList *comment_fmt_spec = load_bzrep_conf_file(fmt_file);
struct strbuf *bzcomment_buf = strbuf_new();
generate_bz_comment(bzcomment_buf, problem_data, comment_fmt_spec);
if (crossver_id >= 0)
strbuf_append_strf(bzcomment_buf, "\nPotential duplicate: bug %u\n", crossver_id);
char *bzcomment = strbuf_free_nobuf(bzcomment_buf);
char *summary = create_summary_string(problem_data, comment_fmt_spec);
int new_id = rhbz_new_bug(client, problem_data, rhbz.b_product, rhbz.b_product_version,
summary, bzcomment,
group
);
free(bzcomment);
free(summary);
if (new_id == -1)
{
error_msg_and_die(_("Failed to create a new bug."));
}
log(_("Adding attachments to bug %i"), new_id);
char new_id_str[sizeof(int)*3 + 2];
sprintf(new_id_str, "%i", new_id);
attach_files(client, new_id_str, problem_data, comment_fmt_spec);
//TODO: free_comment_fmt_spec(comment_fmt_spec);
bz = new_bug_info();
bz->bi_status = xstrdup("NEW");
bz->bi_id = new_id;
goto log_out;
}
bug_id = existing_id;
}
bz = rhbz_bug_info(client, bug_id);
log(_("Bug is already reported: %i"), bz->bi_id);
/* Follow duplicates */
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)
{
/* Add user's login to CC if not there already */
if (strcmp(bz->bi_reporter, rhbz.b_login) != 0
&& !g_list_find_custom(bz->bi_cc_list, rhbz.b_login, (GCompareFunc)g_strcmp0)
) {
log(_("Adding %s to CC list"), rhbz.b_login);
rhbz_mail_to_cc(client, bz->bi_id, rhbz.b_login, RHBZ_NOMAIL_NOTIFY);
}
/* Add comment and bt */
const char *comment = problem_data_get_content_or_NULL(problem_data, FILENAME_COMMENT);
if (comment && comment[0])
{
GList *comment_fmt_spec = load_bzrep_conf_file(fmt_file2);
struct strbuf *bzcomment_buf = strbuf_new();
generate_bz_comment(bzcomment_buf, problem_data, comment_fmt_spec);
char *bzcomment = strbuf_free_nobuf(bzcomment_buf);
//TODO: free_comment_fmt_spec(comment_fmt_spec);
int dup_comment = is_comment_dup(bz->bi_comments, bzcomment);
if (!dup_comment)
{
log(_("Adding new comment to bug %d"), bz->bi_id);
rhbz_add_comment(client, bz->bi_id, bzcomment, 0);
free(bzcomment);
const char *bt = problem_data_get_content_or_NULL(problem_data, FILENAME_BACKTRACE);
unsigned rating = 0;
const char *rating_str = problem_data_get_content_or_NULL(problem_data, FILENAME_RATING);
/* python doesn't have rating file */
if (rating_str)
rating = xatou(rating_str);
if (bt && rating > bz->bi_best_bt_rating)
{
char bug_id_str[sizeof(int)*3 + 2];
sprintf(bug_id_str, "%i", bz->bi_id);
log(_("Attaching better backtrace"));
rhbz_attach_blob(client, bug_id_str, FILENAME_BACKTRACE, bt, strlen(bt),
RHBZ_NOMAIL_NOTIFY);
}
}
else
{
free(bzcomment);
log(_("Found the same comment in the bug history, not adding a new one"));
}
}
}
log_out:
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 : "",
rhbz.b_bugzilla_url,
bz->bi_id);
struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
if (dd)
{
char *msg = xasprintf("Bugzilla: URL=%s/show_bug.cgi?id=%u", rhbz.b_bugzilla_url, bz->bi_id);
add_reported_to(dd, msg);
free(msg);
dd_close(dd);
}
#if 0 /* enable if you search for leaks (valgrind etc) */
free(rhbz.b_product);
free(rhbz.b_product_version);
problem_data_free(problem_data);
free_bug_info(bz);
abrt_xmlrpc_free_client(client);
#endif
return 0;
}
int main(int argc, char **argv)
{
abrt_init(argv);
/* I18n */
setlocale(LC_ALL, "");
#if ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
const char *dump_dir_name = ".";
const char *conf_file = CONF_DIR"/plugins/upload.conf";
const char *url = NULL;
/* Can't keep these strings/structs static: _() doesn't support that */
const char *program_usage_string = _(
"& [-v] -d DIR [-c CONFFILE] [-u URL]\n"
"\n"
"Uploads compressed tarball of problem directory DIR to URL.\n"
"If URL is not specified, creates tarball in "LARGE_DATA_TMP_DIR" and exits.\n"
"\n"
"URL should have form 'protocol://[user[:pass]@]host/dir/[file.tar.gz]'\n"
"where protocol can be http(s), ftp, scp, or file.\n"
"File protocol can't have user and host parts: 'file:///dir/[file.tar.gz].'\n"
"If URL ends with a slash, the archive name will be generated and appended\n"
"to URL; otherwise, URL will be used as full file name.\n"
"\n"
"Files with names listed in $EXCLUDE_FROM_REPORT are not included\n"
"into the tarball.\n"
"\n"
"\n""If not specified, CONFFILE defaults to "CONF_DIR"/plugins/upload.conf"
"\n""Its lines should have 'PARAM = VALUE' format."
"Recognized string parameter: URL.\n"
"Parameter can be overridden via $Upload_URL."
);
enum {
OPT_v = 1 << 0,
OPT_d = 1 << 1,
OPT_c = 1 << 2,
OPT_u = 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('c', NULL, &conf_file , "CONFFILE", _("Config file")),
OPT_STRING('u', NULL, &url , "URL" , _("Base URL to upload to")),
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 (url)
replace_map_string_item(settings, xstrdup("URL"), xstrdup(url));
if (conf_file)
load_conf_file(conf_file, settings, /*skip key w/o values:*/ false);
int result = create_and_upload_archive(dump_dir_name, settings);
free_map_string(settings);
return result;
}
