static gboolean
backend_repo_enable_thread (PkBackend *backend)
{
GError *error = NULL;
const gchar *repo;
gboolean enabled;
g_return_val_if_fail (pacman != NULL, FALSE);
g_return_val_if_fail (disabled_repos != NULL, FALSE);
g_return_val_if_fail (backend != NULL, FALSE);
repo = pk_backend_get_string (backend, "repo_id");
enabled = pk_backend_get_bool (backend, "enabled");
g_return_val_if_fail (repo != NULL, FALSE);
if (enabled) {
/* check that repo is indeed disabled */
if (g_hash_table_remove (disabled_repos, repo)) {
/* reload configuration to preserve the correct order */
if (disabled_repos_configure (disabled_repos, &error)) {
pk_backend_repo_list_changed (backend);
} else {
backend_error (backend, error);
pk_backend_thread_finished (backend);
return FALSE;
}
} else {
pk_backend_error_code (backend, PK_ERROR_ENUM_REPO_NOT_FOUND, "Could not find repo [%s]", repo);
pk_backend_thread_finished (backend);
return FALSE;
}
} else {
PacmanDatabase *database = pacman_manager_find_sync_database (pacman, repo);
if (database != NULL) {
if (pacman_manager_unregister_database (pacman, database, &error)) {
g_hash_table_insert (disabled_repos, g_strdup (repo), GINT_TO_POINTER (1));
} else {
backend_error (backend, error);
pk_backend_thread_finished (backend);
return FALSE;
}
} else {
pk_backend_error_code (backend, PK_ERROR_ENUM_REPO_NOT_FOUND, "Could not find repo [%s]", repo);
pk_backend_thread_finished (backend);
return FALSE;
}
}
pk_backend_thread_finished (backend);
return TRUE;
}
////////////////////////////////////////////////////////////
// Argument Parsing
////////////////////////////////////////////////////////////
void Sigil::parseOptions(int argc, char *argv[])
{
/* custom parsing, by order of the arguments */
ArgGroup arg_group;
/* Pass through args to frontend/backend. */
arg_group.addGroup(frontend, false);
arg_group.addGroup(backend, true);
arg_group.addGroup(executable, true);
arg_group.parse(argc, argv);
/* The number of 'threads' Sigil2 will use */
/* MDL20160805 Currently only valid with DynamoRIO frontend.
* This will cause 'n' event streams between Sigil2 and DynamoRIO
* to be generated, and 'n' separate backend instances will
* read from those event streams as separate threads */
num_threads = 1;
if (arg_group.getOpt(numthreads).empty() == false)
{
num_threads = stoi(arg_group.getOpt(numthreads));
if (num_threads > 16 || num_threads < 1)
{
SigiLog::fatal("Invalid number of threads specified");
}
}
/* check frontend */
std::string frontend_name;
if (arg_group.getGroup(frontend).empty() == false)
{
frontend_name = arg_group.getGroup(frontend)[0];
}
else /*set default*/
{
frontend_name = "valgrind"; //default
}
std::transform(frontend_name.begin(), frontend_name.end(), frontend_name.begin(), ::tolower);
if (frontend_registry.find(frontend_name) != frontend_registry.cend())
{
start_frontend = [this, arg_group, frontend_name]() mutable
{
Sigil::Args args;
if (arg_group.getGroup(frontend).size() > 1)
{
auto start = arg_group.getGroup(frontend).cbegin() + 1;
auto end = arg_group.getGroup(frontend).cend();
args = {start, end};
}
frontend_registry[frontend_name](arg_group.getGroup(executable),
args,
num_threads,
instance_id);
};
}
else
{
std::string frontend_error(" invalid frontend argument ");
frontend_error.append(frontend_name).append("\n");
frontend_error.append("\tAvailable frontends: ");
for (auto p : frontend_registry)
{
frontend_error.append("\n\t").append(p.first);
}
SigiLog::fatal(frontend_error);
}
/* check backend */
std::string backend_name = arg_group.getGroup(backend)[0];
std::transform(backend_name.begin(), backend_name.end(), backend_name.begin(), ::tolower);
if (backend_registry.find(backend_name) != backend_registry.cend())
{
/* send args to backend */
Sigil::Args args;
if (arg_group.getGroup(backend).size() > 1)
{
auto start = arg_group.getGroup(backend).cbegin() + 1;
auto end = arg_group.getGroup(backend).cend();
args = {start, end};
}
/* Register the backend
*
* Each backend thread creates a new
* backend instance via 'create_backend' */
parse_backend = [this, backend_name, args]()
{
std::get<1>(backend_registry[backend_name])(args);
};
create_backend = std::get<0>(backend_registry[backend_name]);
exit_backend = std::get<2>(backend_registry[backend_name]);
}
else
{
std::string backend_error(" invalid backend argument ");
backend_error.append(backend_name).append("\n");
backend_error.append("\tAvailable backends: ");
for (auto p : backend_registry)
{
backend_error.append("\n\t").append(p.first);
}
SigiLog::fatal(backend_error);
}
}
