BugzillaData *bugzilla_new(const char *url, BugzillaErrorCallback cb, void *cb_data) {
BugzillaData *data = new BugzillaData;
bugzilla_set_error_callback(data, cb, cb_data);
xmlrpc_env_init(&data->xenv);
xmlrpc_client_setup_global_const(&data->xenv);
data->url = url;
/*
* to allow https connections; curl by default refuse connections without valid certificate
* (at least docs says that ;))
*/
gparms_curl.no_ssl_verifypeer = 1;
gparms_curl.no_ssl_verifyhost = 1;
/* only curl transport is supported */
gparms.transport = "curl";
gparms.transportparmsP = &gparms_curl;
xmlrpc_client_create(&data->xenv, XMLRPC_CLIENT_NO_FLAGS, "ede-bug-report", "0.1", &gparms, sizeof(gparms), &data->xcli);
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to init xmlrpc client data (%s)\n", data->xenv.fault_string);
if(cb) cb(data->xenv.fault_string, cb_data);
delete data;
data = NULL;
}
return data;
}
void
xmlrpc_client_init2(xmlrpc_env * const envP,
int const flags,
const char * const appname,
const char * const appversion,
const struct xmlrpc_clientparms * const clientparmsP,
unsigned int const parmSize) {
/*----------------------------------------------------------------------------
This function is not thread-safe.
-----------------------------------------------------------------------------*/
if (globalClientExists)
xmlrpc_faultf(
envP,
"Xmlrpc-c global client instance has already been created "
"(need to call xmlrpc_client_cleanup() before you can "
"reinitialize).");
else {
/* The following call is not thread-safe */
xmlrpc_client_setup_global_const(envP);
if (!envP->fault_occurred) {
xmlrpc_client_create(envP, flags, appname, appversion,
clientparmsP, parmSize, &globalClientP);
if (!envP->fault_occurred)
globalClientExists = true;
if (envP->fault_occurred)
xmlrpc_client_teardown_global_const();
}
}
}
int main(int argc, char *argv[])
{
/* update progname from argv[0] */
set_progname(argv[0]);
const struct ap_Option options[] = {
{'h', "help", ap_no, 0, 0},
{'v', "version", ap_no, 0, 0},
{0, 0, ap_no, 0, 0}
};
if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
critx("could not allocate memory for option parser");
if (ap_error(&parser)) {
errx("%s", ap_error(&parser));
usage(EXIT_FAILURE);
}
/* parse command line */
for (int argind = 0; argind < ap_arguments(&parser); argind++) {
const int code = ap_code(&parser, argind);
switch (code) {
case 0:
break;
case 'h':
usage(EXIT_SUCCESS);
break;
case 'v':
fprintf(stderr, "%s %s\n%s\n%s\n\n%s\n", progname,
FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
exit(EXIT_SUCCESS);
break;
default:
errx("uncaught option: %s", ap_argument(&parser, argind));
usage(EXIT_FAILURE);
break;
}
}
if (!ap_arguments(&parser)) {
errx("no address given");
usage(EXIT_FAILURE);
}
xmlrpc_env rpc_env;
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (int argind = 0; argind < ap_arguments(&parser); argind++)
/* if non-option, it is an address */
if (!ap_code(&parser, argind))
stop_flows(ap_argument(&parser, argind));
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
ap_free(&parser);
}
void
wp_env_init(xmlrpc_env *env, xmlrpc_client **clientP) {
xmlrpc_env_init(env);
xmlrpc_client_setup_global_const(env);
xmlrpc_client_create(env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0,
clientP);
die_if_fault_occurred(env);
}
int main(int argc, char *argv[])
{
char ch, *tok;
int i;
xmlrpc_env rpc_env;
/* update progname from argv[0] */
if (argc > 0) {
/* Strip path */
tok = strrchr(argv[0], '/');
if (tok)
tok++;
else
tok = argv[0];
if (*tok) {
strncpy(progname, tok, sizeof(progname));
progname[sizeof(progname) - 1] = 0;
}
}
#ifdef HAVE_GETOPT_LONG
/* getopt_long isn't portable, it's GNU extension */
struct option lo[] = { {"help", 0, 0, 'h' },
{"version", 0, 0, 'v'},
{0, 0, 0, 0}
};
while ((ch = getopt_long(argc, argv, "hv", lo, 0)) != -1) {
#else
while ((ch = getopt(argc, argv, "hv")) != -1) {
#endif
switch (ch) {
case 'h':
usage(argv[0]);
break;
case 'v':
fprintf(stderr, "flowgrind version: %s\n", FLOWGRIND_VERSION);
exit(0);
break;
default:
usage(argv[0]);
break;
}
}
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (i = optind; i < argc; i++) {
stop_flows(argv[i]);
}
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
return 0;
}
int
main (int const argc, const char **const argv)
{
const char *const serverUrl = "http://oracc.bfos:80/xmlrpc";
const char *const methodName = "sample.add";
xmlrpc_env env;
xmlrpc_client *clientP;
xmlrpc_int adder;
if (argc - 1 > 0)
{
fprintf (stderr, "This program has no arguments\n");
exit (1);
}
/* Initialize our error environment variable */
xmlrpc_env_init (&env);
/* Required before any use of Xmlrpc-c client library: */
xmlrpc_client_setup_global_const (&env);
die_if_fault_occurred (&env);
xmlrpc_client_create (&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0,
&clientP);
die_if_fault_occurred (&env);
for (adder = 0; adder < 3; ++adder)
{
printf ("Making XMLRPC call to server url '%s' method '%s' "
"to request the sum "
"of 5 and %d...\n", serverUrl, methodName, adder);
/* request the remote procedure call */
xmlrpc_client_start_rpcf (&env, clientP, serverUrl, methodName,
handle_sample_add_response, NULL,
"(ii)", (xmlrpc_int32) 5, adder);
die_if_fault_occurred (&env);
}
printf ("RPCs all requested. Waiting for & handling responses...\n");
/*
* Wait for all RPCs to be done. With some transports, this is also
* what causes them to go.
*/
xmlrpc_client_event_loop_finish (clientP);
printf ("All RPCs finished.\n");
xmlrpc_client_destroy (clientP);
xmlrpc_client_teardown_global_const ();
return 0;
}
int
main(int const argc,
const char ** const argv) {
const char * const serverUrl = "http://localhost:8080/RPC2";
xmlrpc_env env;
struct xmlrpc_clientparms clientParms;
xmlrpc_client * clientP;
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
setupSignalHandlers();
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Required before any use of Xmlrpc-c client library: */
xmlrpc_client_setup_global_const(&env);
die_if_fault_occurred(&env);
clientParms.transport = "curl";
/* Create a client object */
xmlrpc_client_create(&env, 0, NULL, NULL,
&clientParms, XMLRPC_CPSIZE(transport),
&clientP);
die_if_fault_occurred(&env);
xmlrpc_client_set_interrupt(clientP, &interrupt);
/* If our server is running 'xmlrpc_sample_add_server' normally, the
RPC will finish almost instantly. UNLESS the adder is 1, in which
case said server is programmed to take 3 seconds to do the
computation, thus allowing us to demonstrate a timeout or CTL-C.
*/
addInterruptibly(clientP, serverUrl, 5, 7);
/* Should finish instantly */
addInterruptibly(clientP, serverUrl, 5, 1);
/* Should time out after 2 seconds */
xmlrpc_env_clean(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_client_teardown_global_const();
return 0;
}
static void
testGlobalConst(void) {
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
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;
}
bool initializeXmlRpc(xmlrpc_env *envP, xmlrpc_client **clientPP)
{
//xmlrpc_client_init2(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
if (*clientPP != NULL)
{
xmlrpc_client_teardown_global_const();
xmlrpc_client_destroy(*clientPP);
*clientPP = NULL;
}
if (*clientPP == NULL)
{
xmlrpc_client_setup_global_const(envP);
xmlrpc_client_create(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0, clientPP);
}
if (envP->fault_occurred)
return false;
return true;
}
static void
testSynchCall(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
xmlrpc_value * resultP;
xmlrpc_value * emptyArrayP;
xmlrpc_server_info * noSuchServerInfoP;
xmlrpc_env_init(&env);
emptyArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
noSuchServerInfoP = xmlrpc_server_info_new(&env, "nosuchserver");
TEST_NO_FAULT(&env);
xmlrpc_client_call2(&env, clientP, noSuchServerInfoP, "nosuchmethod",
emptyArrayP, &resultP);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_client_call2f(&env, clientP, "nosuchserver", "nosuchmethod",
&resultP, "(i)", 7);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_server_info_free(noSuchServerInfoP);
xmlrpc_client_destroy(clientP);
xmlrpc_DECREF(emptyArrayP);
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
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;
}
/*
* Do any per-module initialization that is separate to each
* configured instance of the module. e.g. set up connections
* to external databases, read configuration files, set up
* dictionary entries, etc.
*
* If configuration information is given in the config section
* that must be referenced in later calls, store a handle to it
* in *instance otherwise put a null pointer there.
*/
static int xmlrpc_instantiate(CONF_SECTION * conf, void **instance)
{
rlm_xmlrpc_t *data;
rlm_xmlrpc_client_t *first_client;
rlm_xmlrpc_client_t *client;
xmlrpc_env env;
struct xmlrpc_clientparms clientParms;
struct xmlrpc_curl_xportparms curlParms;
int i, error;
void (*do_auth) ();
/*
* Set up a storage area for instance data
*/
data = rad_malloc(sizeof(*data));
if (!data) {
return -1;
}
memset(data, 0, sizeof(*data));
/*
* If the configuration parameters can't be parsed, then
* fail.
*/
if (cf_section_parse(conf, data, module_config) < 0) {
free(data);
return -1;
}
*instance = data;
#ifdef HAVE_PTHREAD_H
pthread_mutex_init(&data->client_mutex, NULL);
#endif
/*
* network_interface parameter cannot be omitted because the
* XMLRPC_CXPSIZE macro calcs the size from the first parameter
* to the last modified.
* Unfortunately is this the order.
*/
curlParms.network_interface = data->interface;
curlParms.no_ssl_verifypeer = data->no_ssl_verify_peer;
curlParms.no_ssl_verifyhost = data->no_ssl_verify_host;
clientParms.transport = "curl";
clientParms.transportparmsP = &curlParms;
clientParms.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
/*
* Choosing method authentication
*/
if (strcmp(data->auth_type, "auth_basic") == 0) {
do_auth = xmlrpc_server_info_allow_auth_basic;
} else if (strcmp(data->auth_type, "auth_digest") == 0) {
do_auth = xmlrpc_server_info_allow_auth_digest;
} else if (strcmp(data->auth_type, "auth_negotiate") == 0) {
do_auth = xmlrpc_server_info_allow_auth_negotiate;
} else if (strcmp(data->auth_type, "auth_ntlm") == 0) {
do_auth = xmlrpc_server_info_allow_auth_ntlm;
}
/*
* Clients are created into a circular linked list.
* Into this cycle we setup clients and server information objects.
* Server information contains a method to do html authentication.
*/
for (i = 0; i < data->xmlrpc_num_socks; i++) {
client = rad_malloc(sizeof(*client));
if (!client) {
return -1;
}
memset(client, 0, sizeof(*client));
env = client->env;
xmlrpc_env_init(&env);
if (i == 0) {
data->client = client;
first_client = client;
xmlrpc_client_setup_global_const(&env);
} else {
data->client->next = client;
data->client = data->client->next;
}
xmlrpc_client_create(&env, XMLRPC_CLIENT_NO_FLAGS, NAME,
VERSION, &clientParms,
XMLRPC_CPSIZE(transportparm_size), &client->clientP);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
client->serverInfoP = xmlrpc_server_info_new(&env, data->url);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
if (strcmp(data->auth_type, "none") != 0) {
xmlrpc_server_info_set_user(&env, client->serverInfoP,
data->user, data->password);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
do_auth(&env, client->serverInfoP);
error = check_error_and_free(data);
if (error != RLM_MODULE_OK)
return error;
radlog(L_INFO, "\trlm_xmlrpc: client #%d logged in as %s", i, data->user);
}
radlog(L_INFO, "\trlm_xmlrpc: client #%d initialized", i);
}
/*
* closing the circular linked list. data->client helds a pointer
* to the last client used by a thread.
*/
data->client->next = first_client;
data->client = data->client->next;
return 0;
}
static void
testCreateDestroy(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
int interrupt;
xmlrpc_env_init(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Didn't set up global const */
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_client_create(&env, 0, "testprog", "1.0", &clientParms1, 0,
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transport = "curl";
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transport), &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = NULL;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
clientParms1.dialect = xmlrpc_dialect_apache;
clientParms1.progressFn = &myProgress;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(progressFn),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = &curlTransportParms1;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_set_interrupt(clientP, &interrupt);
xmlrpc_client_set_interrupt(clientP, NULL);
xmlrpc_client_destroy(clientP);
testCreateCurlParms();
testCreateSeparateXport();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static int
unenroll_host(const char *server, const char *hostname, const char *ktname, int quiet)
{
int rval = 0;
int ret;
char *ipaserver = NULL;
char *host = NULL;
struct utsname uinfo;
char *principal = NULL;
char *realm = NULL;
krb5_context krbctx = NULL;
krb5_keytab keytab = NULL;
krb5_ccache ccache = NULL;
krb5_principal princ = NULL;
krb5_error_code krberr;
krb5_creds creds;
krb5_get_init_creds_opt gicopts;
char tgs[LINE_MAX];
xmlrpc_env env;
xmlrpc_value * argArrayP = NULL;
xmlrpc_value * paramArrayP = NULL;
xmlrpc_value * paramP = NULL;
xmlrpc_value * resultP = NULL;
xmlrpc_server_info * serverInfoP = NULL;
xmlrpc_value *princP = NULL;
char * url = NULL;
char * user_agent = NULL;
if (server) {
ipaserver = strdup(server);
} else {
char * conf_data = read_config_file(IPA_CONFIG);
if ((ipaserver = getIPAserver(conf_data)) == NULL) {
if (!quiet)
fprintf(stderr, _("Unable to determine IPA server from %s\n"),
IPA_CONFIG);
exit(1);
}
free(conf_data);
}
if (NULL == hostname) {
uname(&uinfo);
host = strdup(uinfo.nodename);
} else {
host = strdup(hostname);
}
if (NULL == strstr(host, ".")) {
if (!quiet)
fprintf(stderr, _("The hostname must be fully-qualified: %s\n"),
host);
rval = 16;
goto cleanup;
}
krberr = krb5_init_context(&krbctx);
if (krberr) {
if (!quiet)
fprintf(stderr, _("Unable to join host: "
"Kerberos context initialization failed\n"));
rval = 1;
goto cleanup;
}
krberr = krb5_kt_resolve(krbctx, ktname, &keytab);
if (krberr != 0) {
if (!quiet)
fprintf(stderr, _("Error resolving keytab: %s.\n"),
error_message(krberr));
rval = 7;
goto cleanup;
}
krberr = krb5_get_default_realm(krbctx, &realm);
if (krberr != 0) {
if (!quiet)
fprintf(stderr, _("Error getting default Kerberos realm: %s.\n"),
error_message(krberr));
rval = 21;
goto cleanup;
}
ret = asprintf(&principal, "host/%s@%s", host, realm);
if (ret == -1)
{
if (!quiet)
fprintf(stderr, _("Out of memory!\n"));
rval = 3;
goto cleanup;
}
krberr = krb5_parse_name(krbctx, principal, &princ);
if (krberr != 0) {
if (!quiet)
fprintf(stderr, _("Error parsing \"%1$s\": %2$s.\n"),
principal, error_message(krberr));
return krberr;
}
strcpy(tgs, KRB5_TGS_NAME);
snprintf(tgs + strlen(tgs), sizeof(tgs) - strlen(tgs), "/%.*s",
(krb5_princ_realm(krbctx, princ))->length,
(krb5_princ_realm(krbctx, princ))->data);
snprintf(tgs + strlen(tgs), sizeof(tgs) - strlen(tgs), "@%.*s",
(krb5_princ_realm(krbctx, princ))->length,
(krb5_princ_realm(krbctx, princ))->data);
memset(&creds, 0, sizeof(creds));
krb5_get_init_creds_opt_init(&gicopts);
krb5_get_init_creds_opt_set_forwardable(&gicopts, 1);
krberr = krb5_get_init_creds_keytab(krbctx, &creds, princ, keytab,
0, tgs, &gicopts);
if (krberr != 0) {
if (!quiet)
fprintf(stderr, _("Error obtaining initial credentials: %s.\n"),
error_message(krberr));
return krberr;
}
krberr = krb5_cc_resolve(krbctx, "MEMORY:ipa-join", &ccache);
if (krberr == 0) {
krberr = krb5_cc_initialize(krbctx, ccache, creds.client);
} else {
if (!quiet)
fprintf(stderr,
_("Unable to generate Kerberos Credential Cache\n"));
rval = 19;
goto cleanup;
}
krberr = krb5_cc_store_cred(krbctx, ccache, &creds);
if (krberr != 0) {
if (!quiet)
fprintf(stderr,
_("Error storing creds in credential cache: %s.\n"),
error_message(krberr));
return krberr;
}
krb5_cc_close(krbctx, ccache);
ccache = NULL;
putenv("KRB5CCNAME=MEMORY:ipa-join");
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
#if 1
ret = asprintf(&url, "https://%s:443/ipa/xml", ipaserver);
#else
ret = asprintf(&url, "http://%s:8888/", ipaserver);
#endif
if (ret == -1)
{
if (!quiet)
fprintf(stderr, _("Out of memory!\n"));
rval = 3;
goto cleanup;
}
serverInfoP = xmlrpc_server_info_new(&env, url);
argArrayP = xmlrpc_array_new(&env);
paramArrayP = xmlrpc_array_new(&env);
paramP = xmlrpc_string_new(&env, host);
xmlrpc_array_append_item(&env, argArrayP, paramP);
xmlrpc_array_append_item(&env, paramArrayP, argArrayP);
xmlrpc_DECREF(paramP);
if ((user_agent = set_user_agent(ipaserver)) == NULL) {
rval = 3;
goto cleanup;
}
callRPC(user_agent, &env, serverInfoP, "host_disable", paramArrayP, &resultP);
if (handle_fault(&env)) {
rval = 17;
goto cleanup;
}
xmlrpc_struct_find_value(&env, resultP, "result", &princP);
if (princP) {
xmlrpc_bool result;
xmlrpc_read_bool(&env, princP, &result);
if (result == 1) {
if (!quiet)
fprintf(stderr, _("Unenrollment successful.\n"));
} else {
if (!quiet)
fprintf(stderr, _("Unenrollment failed.\n"));
}
xmlrpc_DECREF(princP);
} else {
fprintf(stderr, _("result not found in XML-RPC response\n"));
rval = 20;
goto cleanup;
}
cleanup:
free(user_agent);
if (keytab) krb5_kt_close(krbctx, keytab);
free((char *)principal);
free((char *)ipaserver);
if (princ) krb5_free_principal(krbctx, princ);
if (ccache) krb5_cc_close(krbctx, ccache);
if (krbctx) krb5_free_context(krbctx);
free(url);
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return rval;
}
static int
join_krb5(const char *ipaserver, char *hostname, char **hostdn, const char **princ, const char **subject, int force, int quiet) {
xmlrpc_env env;
xmlrpc_value * argArrayP = NULL;
xmlrpc_value * paramArrayP = NULL;
xmlrpc_value * paramP = NULL;
xmlrpc_value * optionsP = NULL;
xmlrpc_value * resultP = NULL;
xmlrpc_value * structP = NULL;
xmlrpc_server_info * serverInfoP = NULL;
struct utsname uinfo;
xmlrpc_value *princP = NULL;
xmlrpc_value *krblastpwdchangeP = NULL;
xmlrpc_value *subjectP = NULL;
xmlrpc_value *hostdnP = NULL;
const char *krblastpwdchange = NULL;
char * url = NULL;
char * user_agent = NULL;
int rval = 0;
int ret;
*hostdn = NULL;
*subject = NULL;
*princ = NULL;
/* Start up our XML-RPC client library. */
xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION);
uname(&uinfo);
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
#if 1
ret = asprintf(&url, "https://%s:443/ipa/xml", ipaserver);
#else
ret = asprintf(&url, "http://%s:8888/", ipaserver);
#endif
if (ret == -1)
{
if (!quiet)
fprintf(stderr, _("Out of memory!\n"));
rval = 3;
goto cleanup;
}
serverInfoP = xmlrpc_server_info_new(&env, url);
argArrayP = xmlrpc_array_new(&env);
paramArrayP = xmlrpc_array_new(&env);
if (hostname == NULL)
paramP = xmlrpc_string_new(&env, uinfo.nodename);
else
paramP = xmlrpc_string_new(&env, hostname);
xmlrpc_array_append_item(&env, argArrayP, paramP);
#ifdef REALM
if (!quiet)
printf("Joining %s to IPA realm %s\n", uinfo.nodename, iparealm);
#endif
xmlrpc_array_append_item(&env, paramArrayP, argArrayP);
xmlrpc_DECREF(paramP);
optionsP = xmlrpc_build_value(&env, "{s:s,s:s}",
"nsosversion", uinfo.release,
"nshardwareplatform", uinfo.machine);
xmlrpc_array_append_item(&env, paramArrayP, optionsP);
xmlrpc_DECREF(optionsP);
if ((user_agent = set_user_agent(ipaserver)) == NULL) {
rval = 3;
goto cleanup;
}
callRPC(user_agent, &env, serverInfoP, "join", paramArrayP, &resultP);
if (handle_fault(&env)) {
rval = 17;
goto cleanup_xmlrpc;
}
/* Return value is the form of an array. The first value is the
* DN, the second a struct of attribute values
*/
xmlrpc_array_read_item(&env, resultP, 0, &hostdnP);
xmlrpc_read_string(&env, hostdnP, (const char **)hostdn);
xmlrpc_DECREF(hostdnP);
xmlrpc_array_read_item(&env, resultP, 1, &structP);
xmlrpc_struct_find_value(&env, structP, "krbprincipalname", &princP);
if (princP) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, princP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, &*princ);
xmlrpc_DECREF(princP);
xmlrpc_DECREF(singleprincP);
} else {
if (!quiet)
fprintf(stderr, _("principal not found in XML-RPC response\n"));
rval = 12;
goto cleanup;
}
xmlrpc_struct_find_value(&env, structP, "krblastpwdchange", &krblastpwdchangeP);
if (krblastpwdchangeP && !force) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, krblastpwdchangeP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, &krblastpwdchange);
xmlrpc_DECREF(krblastpwdchangeP);
if (!quiet)
fprintf(stderr, _("Host is already joined.\n"));
rval = 13;
goto cleanup;
}
xmlrpc_struct_find_value(&env, structP, "ipacertificatesubjectbase", &subjectP);
if (subjectP) {
xmlrpc_value * singleprincP = NULL;
/* FIXME: all values are returned as lists currently. Once this is
* fixed we can read the string directly.
*/
xmlrpc_array_read_item(&env, subjectP, 0, &singleprincP);
xmlrpc_read_string(&env, singleprincP, *&subject);
xmlrpc_DECREF(subjectP);
}
cleanup:
if (argArrayP) xmlrpc_DECREF(argArrayP);
if (paramArrayP) xmlrpc_DECREF(paramArrayP);
if (resultP) xmlrpc_DECREF(resultP);
cleanup_xmlrpc:
free(user_agent);
free(url);
free((char *)krblastpwdchange);
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return rval;
}
