/**
* \internal
* \brief Chcek sanity of a key
*
* \retval 0 sane
* \retval non-zero bonkers
*/
static int
check_key_sanity(const char *key)
{
static const char VALID_CHARS[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-.";
char sanitized_key[PATH_MAX];
if (mh_strlen_zero(key)) {
mh_err("key cannot be empty");
return -1;
}
if (g_str_has_prefix(key, ".")) {
mh_err("Invalid key filename %s", key);
return -1;
}
mh_string_copy(sanitized_key, key, sizeof(sanitized_key));
g_strcanon(sanitized_key, VALID_CHARS, '!');
if (strchr(sanitized_key, '!') != NULL) {
mh_err("Invalid key filename %s", sanitized_key);
return -1;
}
return 0;
}
gboolean
SrvAgent::invoke(qmf::AgentSession session, qmf::AgentEvent event,
gpointer user_data)
{
if (event.getType() == qmf::AGENT_METHOD && event.hasDataAddr()) {
if (event.getDataAddr().getName() == "Services") {
return invoke_services(session, event, user_data);
} else if (event.getDataAddr().getName() == "Resources") {
return invoke_resources(session, event, user_data);
} else {
mh_err("Unknown agent: %s", event.getDataAddr().getName().c_str());
}
}
mh_err("Unhandled message");
return TRUE;
}
ObjectManager& ObjectManager::operator+=(MatahariObject* object)
{
object->publish(_impl->_session);
if (!object->getAddr().isValid()) {
mh_err("Failed to publish object");
return *this;
}
_impl->_objects[object->getAddr()] = object;
return *this;
}
static enum mh_result
set_key(const char *key, const char *contents)
{
char key_file[PATH_MAX];
if (check_key_sanity(key)) {
return MH_RES_INVALID_ARGS;
}
if (!g_file_test(keys_dir_get(), G_FILE_TEST_IS_DIR) &&
g_mkdir(keys_dir_get(), 0755) < 0) {
mh_err("Could not create keys directory %s", keys_dir_get());
return MH_RES_OTHER_ERROR;
}
g_snprintf(key_file, sizeof(key_file), "%s%s", keys_dir_get(), key);
if (!g_file_set_contents(key_file, contents, strlen(contents), NULL)) {
mh_err("Could not set file %s", key_file);
return MH_RES_OTHER_ERROR;
}
return MH_RES_SUCCESS;
}
gboolean
Resources_invoke(Matahari *matahari, const char *name, const char *standard,
const char *provider, const char *agent, const char *action,
unsigned int interval, GHashTable *parameters,
unsigned int timeout, unsigned int expected_rc,
const char *userdata_in, DBusGMethodInvocation *context)
{
GError* error = NULL;
svc_action_t *op = NULL;
GList *standards;
struct invoke_cb_data *data;
if (!check_authorization(RESOURCES_INTERFACE_NAME ".invoke",
&error, context)) {
dbus_g_method_return_error(context, error);
g_error_free(error);
return FALSE;
}
// Check if standard is valid
standards = resources_list_standards();
if (g_list_find_custom(standards, standard, (GCompareFunc) strcasecmp) == NULL) {
mh_err("%s is not a known resource standard", standard);
error = g_error_new(MATAHARI_ERROR, MH_RES_NOT_IMPLEMENTED,
"%s is not a known resource standard", standard);
dbus_g_method_return_error(context, error);
g_error_free(error);
g_list_free_full(standards, free);
return FALSE;
}
g_list_free_full(standards, free);
op = resources_action_create(name, standard, provider, agent, action,
0, timeout, g_hash_table_ref(parameters));
op->expected_rc = expected_rc;
if (!(data = malloc(1 * sizeof(struct invoke_cb_data)))) {
services_action_free(op);
return FALSE;
}
data->context = context;
data->userdata = strdup(userdata_in);
op->cb_data = data;
services_action_async(op, invoke_cb);
return FALSE;
}
bool ObjectManager::invoke(qmf::AgentSession& session,
qmf::AgentEvent& event) const
{
if (event.hasDataAddr()) {
MatahariObject *obj = _impl->find(event.getDataAddr());
if (obj) {
return obj->invoke(session, event);
}
mh_err("Target of method call not found");
}
return false;
}
svc_action_t *resources_action_create(
const char *name, const char *standard, const char *provider, const char *agent,
const char *action, int interval, int timeout, GHashTable *params)
{
svc_action_t *op;
op = calloc(1, sizeof(svc_action_t));
op->opaque = calloc(1, sizeof(svc_action_private_t));
op->rsc = strdup(name);
op->action = strdup(action);
op->interval = interval;
op->timeout = timeout;
op->standard = strdup(standard);
op->agent = strdup(agent);
op->sequence = ++operations;
asprintf(&op->id, "%s_%s_%d", name, action, interval);
if(strcmp(standard, "ocf") == 0) {
op->provider = strdup(provider);
op->params = params;
asprintf(&op->opaque->exec, "%s/resource.d/%s/%s",
OCF_ROOT, provider, agent);
op->opaque->args[0] = strdup(op->opaque->exec);
op->opaque->args[1] = strdup(action);
} else if(strcmp(standard, "lsb") == 0 || strcmp(standard, "windows") == 0) {
services_os_set_exec(op);
} else {
mh_err("Unknown resource standard: %s", standard);
services_action_free(op);
op = NULL;
}
return op;
}
gboolean
SrvAgent::invoke_resources(qmf::AgentSession session, qmf::AgentEvent event,
gpointer user_data)
{
const std::string& methodName(event.getMethodName());
if (event.getType() != qmf::AGENT_METHOD) {
return TRUE;
}
qpid::types::Variant::Map& args = event.getArguments();
if (methodName == "list_standards") {
event.addReturnArgument("standards", standards);
} else if (methodName == "list_providers") {
GList *gIter = NULL;
GList *providers = NULL;
_qtype::Variant::List p_list;
providers = resources_list_providers(args["standard"].asString().c_str());
for (gIter = providers; gIter != NULL; gIter = gIter->next) {
p_list.push_back((const char *) gIter->data);
}
event.addReturnArgument("providers", p_list);
} else if (methodName == "list") {
GList *gIter = NULL;
GList *agents = NULL;
const char *standard = "ocf";
const char *provider = "heartbeat";
_qtype::Variant::List t_list;
if(args.count("standard") > 0) {
standard = args["standard"].asString().c_str();
}
if(args.count("provider") > 0) {
provider = args["provider"].asString().c_str();
}
agents = resources_list_agents(standard, provider);
for (gIter = agents; gIter != NULL; gIter = gIter->next) {
t_list.push_back((const char *) gIter->data);
}
event.addReturnArgument("agents", t_list);
} else if (methodName == "invoke") {
svc_action_t *op = NULL;
bool valid_standard = false;
_qtype::Variant::List::iterator iter;
_qtype::Variant::Map map;
if(args.count("parameters") == 1) {
map = args["parameters"].asMap();
}
GHashTable *params = qmf_map_to_hash(map);
int32_t interval = 0;
int32_t timeout = 60000;
const char *agent = NULL;
const char *standard = "ocf";
const char *provider = "heartbeat";
for ( iter=standards.begin() ; iter != standards.end(); iter++ ) {
if(args["standard"].asString() == (*iter).asString()) {
valid_standard = true;
break;
}
}
if(valid_standard == false) {
mh_err("%s is not a known resource standard", args["standard"].asString().c_str());
session.raiseException(event, MH_NOT_IMPLEMENTED);
return TRUE;
}
if(args.count("standard") > 0) {
standard = args["standard"].asString().c_str();
}
if(args.count("provider") > 0) {
provider = args["provider"].asString().c_str();
}
if(args.count("agent") > 0) {
agent = args["agent"].asString().c_str();
} else {
agent = args["name"].asString().c_str();
}
if(args.count("interval") > 0) {
interval = args["interval"].asInt32();
}
if(args.count("timeout") > 0) {
timeout = args["timeout"].asInt32();
}
op = resources_action_create(
args["name"].asString().c_str(),
standard, provider, agent,
args["action"].asString().c_str(),
interval, timeout, params);
if(args.count("expected-rc") == 1) {
op->expected_rc = args["expected-rc"].asInt32();
}
action_async(SRV_RESOURCES, session, event, op, true);
return TRUE;
} else if (methodName == "cancel") {
services_action_cancel(
args["name"].asString().c_str(),
args["action"].asString().c_str(),
args["interval"].asInt32());
} else {
session.raiseException(event, MH_NOT_IMPLEMENTED);
return TRUE;
}
session.methodSuccess(event);
return TRUE;
}
