static void
profile_print_with_attrs (const char *type, DBusMessage *message,
struct timeval *t, ProfileAttributeFlags attrs)
{
printf (PROFILE_TIMED_FORMAT, type, t->tv_sec, t->tv_usec);
if (attrs & PROFILE_ATTRIBUTE_FLAG_SERIAL)
printf ("\t%u", dbus_message_get_serial (message));
if (attrs & PROFILE_ATTRIBUTE_FLAG_REPLY_SERIAL)
printf ("\t%u", dbus_message_get_reply_serial (message));
if (attrs & PROFILE_ATTRIBUTE_FLAG_SENDER)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_sender (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_DESTINATION)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_destination (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_PATH)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_path (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_INTERFACE)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_interface (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_MEMBER)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_member (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_ERROR_NAME)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_error_name (message)));
printf ("\n");
}
static DBusHandlerResult
default_message_filter
( DBusConnection *connection,
DBusMessage *message,
void *p
)
{
DBusConnectionState *cs = p;
uint32_t type =dbus_message_get_type( message ),
serial =dbus_message_get_serial( message );
uint8_t reply =dbus_message_get_no_reply( message )==0;
const char
*path = dbus_message_get_path( message ),
*dest = dbus_message_get_destination( message ),
*member = dbus_message_get_member( message ),
*interface=dbus_message_get_interface( message ),
*sender =dbus_message_get_sender( message ),
*signature=dbus_message_get_signature( message );
connection = connection;
if(cs->mf)
return
(*(cs->mf))( cs, type, reply, serial, dest, path, member, interface, 0L,
sender, signature, message, 0L, 0L, 0L, cs->def_mf_obj
) ;
return HANDLED;
}
/**
* @brief Optionally prints a trace of a D-Bus message depending on the "level".
*
* @param [in] level Trace mask controlling whether trace appears.
* @param [in] msg The D-Bus message to trace.
*/
void
l2dbus_traceMessage
(
unsigned level,
struct DBusMessage* msg
)
{
const cdbus_Char* msgTypeStr ="UNKNOWN";
cdbus_Int32 msgType = DBUS_MESSAGE_TYPE_INVALID;
const cdbus_Char* path = NULL;
const cdbus_Char* intf = NULL;
const cdbus_Char* name = NULL;
const cdbus_Char* dest = NULL;
const cdbus_Char* errName = NULL;
if ( NULL != msg )
{
msgType = dbus_message_get_type(msg);
msgTypeStr = dbus_message_type_to_string(msgType);
if ( (DBUS_MESSAGE_TYPE_METHOD_CALL == msgType) ||
(DBUS_MESSAGE_TYPE_SIGNAL == msgType) )
{
path = dbus_message_get_path(msg);
intf = dbus_message_get_interface(msg);
name = dbus_message_get_member(msg);
l2dbus_trace(level, "(Ser=%u) [%s] <%s> %s%s%s",
dbus_message_get_serial(msg),
msgTypeStr,
path ? path : "",
intf ? intf : "",
intf ? "." : "",
name ? name : "");
}
else if (DBUS_MESSAGE_TYPE_METHOD_RETURN == msgType)
{
dest = dbus_message_get_destination(msg);
l2dbus_trace(level, "(RSer=%u) [%s] -> %s",
dbus_message_get_reply_serial(msg),
msgTypeStr,
dest ? dest : "");
}
else if (DBUS_MESSAGE_TYPE_ERROR == msgType )
{
errName = dbus_message_get_error_name(msg);
l2dbus_trace(level, "(RSer=%u) [%s] %s",
dbus_message_get_reply_serial(msg),
msgTypeStr,
errName ? errName : "");
}
else
{
l2dbus_trace(level, "(Ser=%u) [%s]",
dbus_message_get_serial(msg),
msgTypeStr);
}
}
}
/*
* On success @param msg is unref'd or its ref is stolen by the returned
* Eldbus_Pending.
*/
Eldbus_Pending *
_eldbus_connection_send(Eldbus_Connection *conn, Eldbus_Message *msg, Eldbus_Message_Cb cb, const void *cb_data, double timeout)
{
Eldbus_Pending *pending;
Eldbus_Message *error_msg;
DBG("conn=%p, msg=%p, cb=%p, cb_data=%p, timeout=%f",
conn, msg, cb, cb_data, timeout);
if (!cb)
{
dbus_connection_send(conn->dbus_conn, msg->dbus_msg, NULL);
eldbus_message_unref(msg);
return NULL;
}
pending = calloc(1, sizeof(Eldbus_Pending));
EINA_SAFETY_ON_NULL_RETURN_VAL(pending, NULL);
pending->cb = cb;
pending->cb_data = cb_data;
pending->conn = conn;
pending->dest = eina_stringshare_add(dbus_message_get_destination(msg->dbus_msg));
pending->interface = eina_stringshare_add(dbus_message_get_interface(msg->dbus_msg));
pending->method = eina_stringshare_add(dbus_message_get_member(msg->dbus_msg));
pending->path = eina_stringshare_add(dbus_message_get_path(msg->dbus_msg));
/* Steal the reference */
pending->msg_sent = msg;
EINA_MAGIC_SET(pending, ELDBUS_PENDING_MAGIC);
if (!dbus_connection_send_with_reply(conn->dbus_conn,
msg->dbus_msg,
&pending->dbus_pending, timeout))
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.NoConnection",
"Eldbus_Connection was closed.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (!pending->dbus_pending)
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.Error",
"dbus_pending is NULL.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (dbus_pending_call_set_notify(pending->dbus_pending, cb_pending, pending, NULL))
return pending;
dbus_pending_call_cancel(pending->dbus_pending);
error_msg = _eldbus_message_error_get(pending->msg_sent,
"org.enlightenment.DBus.Error",
"Error when try set callback to message.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
static int ldbus_message_get_destination(lua_State *L) {
DBusMessage *message = check_DBusMessage(L, 1);
const char * destination = dbus_message_get_destination(message);
if (destination == NULL) {
lua_pushnil(L);
} else {
lua_pushstring(L, destination);
}
return 1;
}
void
print_message (DBusMessage *message, dbus_bool_t literal)
{
DBusMessageIter iter;
const char *sender;
const char *destination;
int message_type;
message_type = dbus_message_get_type (message);
sender = dbus_message_get_sender (message);
destination = dbus_message_get_destination (message);
if (!literal)
{
printf ("%s sender=%s -> dest=%s",
type_to_name (message_type),
sender ? sender : "(null sender)",
destination ? destination : "(null destination)");
switch (message_type)
{
case DBUS_MESSAGE_TYPE_METHOD_CALL:
case DBUS_MESSAGE_TYPE_SIGNAL:
printf (" serial=%u path=%s; interface=%s; member=%s\n",
dbus_message_get_serial (message),
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN:
printf (" reply_serial=%u\n",
dbus_message_get_reply_serial (message));
break;
case DBUS_MESSAGE_TYPE_ERROR:
printf (" error_name=%s reply_serial=%u\n",
dbus_message_get_error_name (message),
dbus_message_get_reply_serial (message));
break;
default:
printf ("\n");
break;
}
}
dbus_message_iter_init (message, &iter);
print_iter (&iter, literal, 1);
fflush (stdout);
}
static DBusHandlerResult
filter_func(DBusConnection *conn, DBusMessage *bus_msg, void *data)
{
const char *method = dbus_message_get_member(bus_msg);
const char *iface = dbus_message_get_interface(bus_msg);
const char *sender = dbus_message_get_sender(bus_msg);
const char *path = dbus_message_get_path(bus_msg);
PyObject *py_args = pydbus_import(bus_msg);
if (!dbus_message_has_destination(bus_msg, config_unique_address)
&& strncmp(dbus_message_get_destination(bus_msg), DBUS_SERVICE_NAME, strlen(DBUS_SERVICE_NAME))) {
return DBUS_HANDLER_RESULT_HANDLED;
}
switch (dbus_message_get_type(bus_msg)) {
case DBUS_MESSAGE_TYPE_METHOD_CALL:
if (my_proc.nr_children > MAX_PROC) {
// Busy
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
else {
log_debug("Got message '%s.%s' from '%s'\n", iface, method, sender);
if (strcmp(config_interface, iface) == 0 && strcmp(path, "/") == 0) {
// "setLocale" and "cancel" methods are handled in main process
if (strcmp(method, "setLocale") == 0 || strcmp(method, "cancel") == 0 || strcmp(method, "listRunning") == 0) {
handle_core_message(bus_msg, path, iface, method, sender, py_args);
}
else {
// Else, handle in child process
proc_fork(handle_message, bus_msg);
}
}
else {
// Else, handle in child process
proc_fork(handle_message, bus_msg);
}
break;
}
case DBUS_MESSAGE_TYPE_SIGNAL:
log_debug("Got signal '%s.%s' from '%s'\n", iface, method, sender);
break;
}
return DBUS_HANDLER_RESULT_HANDLED;
}
/* D-BUS filter to set *@successp and quit the main loop as soon as
* it sees a LaunchApplication request on the session bus. */
static DBusHandlerResult filter(DBusConnection *con, DBusMessage *msg,
void *successp)
{
char const *str;
if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL
&& (str = dbus_message_get_destination(msg)) != NULL
&& !strcmp(str, "com.nokia.HildonDesktop.AppMgr")
&& (str = dbus_message_get_interface(msg)) != NULL
&& !strcmp(str, "com.nokia.HildonDesktop.AppMgr")
&& (str = dbus_message_get_member(msg)) != NULL
&& !strcmp(str, "LaunchApplication"))
{
*(int *)successp = 1;
g_main_loop_quit(Loop);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} /* filter */
DBusMessage *
dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusError *error)
{
DBusPendingCall *pending;
SpiReentrantCallClosure *closure;
const char *unique_name = dbus_bus_get_unique_name (bus);
const char *destination = dbus_message_get_destination (message);
struct timeval tv;
DBusMessage *ret;
if (unique_name && destination &&
strcmp (destination, unique_name) != 0)
return dbus_connection_send_with_reply_and_block (bus, message, dbind_timeout, error);
closure = g_new0 (SpiReentrantCallClosure, 1);
closure->reply = NULL;
atspi_dbus_connection_setup_with_g_main(bus, NULL);
if (!dbus_connection_send_with_reply (bus, message, &pending, dbind_timeout))
return NULL;
if (!pending)
return NULL;
dbus_pending_call_set_notify (pending, set_reply, (void *) closure, g_free);
closure->reply = NULL;
gettimeofday (&tv, NULL);
dbus_pending_call_ref (pending);
while (!closure->reply)
{
if (!dbus_connection_read_write_dispatch (bus, dbind_timeout) ||
time_elapsed (&tv) > dbind_timeout)
{
dbus_pending_call_unref (pending);
return NULL;
}
}
ret = closure->reply;
dbus_pending_call_unref (pending);
return ret;
}
int dbusrecv_getmsg(DBusMessage *message, char **pp_buf, int *p_length)
{
DBusMessageIter iter;
#ifdef DBUSRECV_MSG_DEBUG
int message_type = 0;
const char *sender = NULL;
const char *destination = NULL;
#endif
int bytecount = 0;
if (NULL == message)
{
printf("dbusrecv_getmsg: invalid parameters!\n");
return -1;
}
#ifdef DBUSRECV_MSG_DEBUG
message_type = dbus_message_get_type (message);
sender = dbus_message_get_sender (message);
destination = dbus_message_get_destination (message);
#endif
dbus_message_iter_init (message, &iter);
bytecount = loop_iter(&iter, 1, pp_buf, p_length);
#ifdef DBUSRECV_MSG_DEBUG
if (bytecount > 0)
{
int i=0;
char *p = *pp_buf;
printf("-------------start(len=%d)-----------\n", bytecount);
for (i=0; i<bytecount; i++)
printf("%02x ", p[i]);
printf("\n-------------end----------------\n");
}
#endif
return bytecount;
}
static gboolean media_endpoint_async_call(DBusMessage *msg,
struct media_endpoint *endpoint,
media_endpoint_cb_t cb,
void *user_data,
GDestroyNotify destroy)
{
struct endpoint_request *request;
request = g_new0(struct endpoint_request, 1);
/* Timeout should be less than avdtp request timeout (4 seconds) */
if (dbus_connection_send_with_reply(btd_get_dbus_connection(),
msg, &request->call,
REQUEST_TIMEOUT) == FALSE) {
error("D-Bus send failed");
g_free(request);
return FALSE;
}
dbus_pending_call_set_notify(request->call, endpoint_reply, request,
NULL);
request->endpoint = endpoint;
request->msg = msg;
request->cb = cb;
request->destroy = destroy;
request->user_data = user_data;
endpoint->requests = g_slist_append(endpoint->requests, request);
DBG("Calling %s: name = %s path = %s", dbus_message_get_member(msg),
dbus_message_get_destination(msg),
dbus_message_get_path(msg));
return TRUE;
}
static DBusHandlerResult message_func(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
LOG("message_func");
LOG("got dbus message sent to %s %s %s",
dbus_message_get_destination(message),
dbus_message_get_interface(message),
dbus_message_get_path(message));
struct interface_data *iface;
const GDBusMethodTable *method;
const char *interface;
interface = dbus_message_get_interface(message);
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
for (method = iface->methods; method &&
method->name && method->function; method++) {
if (dbus_message_is_method_call(message, iface->name,
method->name) == FALSE)
continue;
if (g_dbus_args_have_signature(method->in_args,
message) == FALSE)
continue;
return process_message(connection, message, method,
iface->user_data);
}
handle_exit(NULL);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/* DBus filter function */
static DBusHandlerResult
filter_function (DBusConnection *connection, DBusMessage *message, void *userdata)
{
DBusError err;
DBusMessage *reply;
if (!check_priv (halctx, connection, message, dbus_message_get_path (message),
"org.freedesktop.hal.power-management.lcd-panel")) {
return DBUS_HANDLER_RESULT_HANDLED;
}
#ifdef DEBUG_OMAP_BL
dbg ("filter_function: sender=%s destination=%s obj_path=%s interface=%s method=%s",
dbus_message_get_sender (message),
dbus_message_get_destination (message),
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
#endif
reply = NULL;
dbus_error_init (&err);
if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"SetBrightness")) {
int brightness;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID)) {
if (brightness < 0 || brightness > 228) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.LaptopPanel.Invalid",
"Brightness has to be between 0 and 228!");
} else {
int return_code;
bl_data.set_backlight_level (&bl_data, brightness);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
return_code = 0;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &return_code,
DBUS_TYPE_INVALID);
}
dbus_connection_send (connection, reply, NULL);
}
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"GetBrightness")) {
int brightness;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INVALID)) {
brightness = bl_data.get_backlight_level (&bl_data);
if (brightness < bl_data.bl_min)
brightness = bl_data.bl_min;
if (brightness > bl_data.bl_max)
brightness = bl_data.bl_max;
/* dbg ("getting brightness, it's %d", brightness); */
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
}
error:
if (reply != NULL)
dbus_message_unref (reply);
LIBHAL_FREE_DBUS_ERROR (&err);
return DBUS_HANDLER_RESULT_HANDLED;
}
static int create_configuration(DBusMessage *msg, connection_ready_cb callback)
{
DBusMessage *new_msg = NULL;
DBusPendingCall *call;
DBusMessageIter iter, array, new_iter, new_dict;
const char *type = NULL, *name = NULL;
const char *host = NULL, *domain = NULL;
char *ident, *me = NULL;
int err = 0;
dbus_bool_t result;
struct connection_data *data;
struct config_create_data *user_data = NULL;
GSList *networks = NULL;
/*
* We copy the old message data into new message. We cannot
* just use the old message as is because the user route
* information is not in the same format in vpnd.
*/
new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
dbus_message_iter_init_append(new_msg, &new_iter);
connman_dbus_dict_open(&new_iter, &new_dict);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
void *item_value;
const char *key;
int value_type;
dbus_message_iter_recurse(&array, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
value_type = dbus_message_iter_get_arg_type(&value);
item_value = NULL;
switch (value_type) {
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(&value, &item_value);
if (g_str_equal(key, "Type") == TRUE) {
type = (const char *)item_value;
} else if (g_str_equal(key, "Name") == TRUE) {
name = (const char *)item_value;
} else if (g_str_equal(key, "Host") == TRUE) {
host = (const char *)item_value;
} else if (g_str_equal(key, "VPN.Domain") == TRUE) {
domain = (const char *)item_value;
}
DBG("%s %s", key, (char *)item_value);
if (item_value != NULL)
connman_dbus_dict_append_basic(&new_dict, key,
value_type, &item_value);
break;
case DBUS_TYPE_ARRAY:
if (g_str_equal(key, "Networks") == TRUE) {
networks = get_user_networks(&value);
connman_dbus_dict_append_array(&new_dict,
"UserRoutes",
DBUS_TYPE_DICT_ENTRY,
append_routes,
networks);
}
break;
}
dbus_message_iter_next(&array);
}
connman_dbus_dict_close(&new_iter, &new_dict);
DBG("VPN type %s name %s host %s domain %s networks %p",
type, name, host, domain, networks);
if (host == NULL || domain == NULL) {
err = -EINVAL;
goto done;
}
if (type == NULL || name == NULL) {
err = -EOPNOTSUPP;
goto done;
}
ident = g_strdup_printf("%s_%s", host, domain);
set_dbus_ident(ident);
DBG("ident %s", ident);
data = g_hash_table_lookup(vpn_connections, ident);
if (data != NULL) {
if (data->call != NULL || data->cb_data != NULL) {
DBG("create configuration call already pending");
err = -EINPROGRESS;
goto done;
}
} else {
char *path = g_strdup_printf("%s/connection/%s", VPN_PATH,
ident);
data = create_connection_data(path);
g_free(path);
if (data == NULL) {
err = -ENOMEM;
goto done;
}
g_hash_table_insert(vpn_connections, g_strdup(ident), data);
}
/*
* User called net.connman.Manager.ConnectProvider if we are here.
* So use the data from original message in the new msg.
*/
me = g_strdup(dbus_message_get_destination(msg));
dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE);
dbus_message_set_path(new_msg, "/");
dbus_message_set_destination(new_msg, VPN_SERVICE);
dbus_message_set_sender(new_msg, me);
dbus_message_set_member(new_msg, "Create");
user_data = g_try_new0(struct config_create_data, 1);
if (user_data == NULL) {
err = -ENOMEM;
goto done;
}
user_data->callback = callback;
user_data->message = dbus_message_ref(msg);
user_data->path = NULL;
DBG("cb %p msg %p", user_data, msg);
result = dbus_connection_send_with_reply(connection, new_msg,
&call, DBUS_TIMEOUT);
if (result == FALSE || call == NULL) {
err = -EIO;
goto done;
}
dbus_pending_call_set_notify(call, configuration_create_reply,
user_data, NULL);
data->call = call;
done:
if (new_msg != NULL)
dbus_message_unref(new_msg);
if (networks != NULL)
g_slist_free_full(networks, destroy_route);
g_free(me);
return err;
}
VIR_MOCK_WRAP_RET_ARGS(dbus_connection_send_with_reply_and_block,
DBusMessage *,
DBusConnection *, connection,
DBusMessage *, message,
int, timeout_milliseconds,
DBusError *, error)
{
DBusMessage *reply = NULL;
const char *service = dbus_message_get_destination(message);
const char *member = dbus_message_get_member(message);
VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block);
if (STREQ(service, "org.freedesktop.PolicyKit1") &&
STREQ(member, "CheckAuthorization")) {
char *type;
char *pidkey;
unsigned int pidval;
char *timekey;
unsigned long long timeval;
char *uidkey;
int uidval;
char *actionid;
char **details;
size_t detailslen;
int allowInteraction;
char *cancellationId;
const char **retdetails = NULL;
size_t retdetailslen = 0;
const char *retdetailscancelled[] = {
"polkit.dismissed", "true",
};
int is_authorized = 1;
int is_challenge = 0;
if (virDBusMessageRead(message,
"(sa{sv})sa&{ss}us",
&type,
3,
&pidkey, "u", &pidval,
&timekey, "t", &timeval,
&uidkey, "i", &uidval,
&actionid,
&detailslen,
&details,
&allowInteraction,
&cancellationId) < 0)
goto error;
if (STREQ(actionid, "org.libvirt.test.success")) {
is_authorized = 1;
is_challenge = 0;
} else if (STREQ(actionid, "org.libvirt.test.challenge")) {
is_authorized = 0;
is_challenge = 1;
} else if (STREQ(actionid, "org.libvirt.test.cancelled")) {
is_authorized = 0;
is_challenge = 0;
retdetails = retdetailscancelled;
retdetailslen = ARRAY_CARDINALITY(retdetailscancelled) / 2;
} else if (STREQ(actionid, "org.libvirt.test.details")) {
size_t i;
is_authorized = 0;
is_challenge = 0;
for (i = 0; i < detailslen / 2; i++) {
if (STREQ(details[i * 2],
"org.libvirt.test.person") &&
STREQ(details[(i * 2) + 1],
"Fred")) {
is_authorized = 1;
is_challenge = 0;
}
}
} else {
is_authorized = 0;
is_challenge = 0;
}
VIR_FREE(type);
VIR_FREE(pidkey);
VIR_FREE(timekey);
VIR_FREE(uidkey);
VIR_FREE(actionid);
VIR_FREE(cancellationId);
virStringListFreeCount(details, detailslen);
if (virDBusCreateReply(&reply,
"(bba&{ss})",
is_authorized,
is_challenge,
retdetailslen,
retdetails) < 0)
goto error;
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
return reply;
error:
virDBusMessageUnref(reply);
return NULL;
}
static DBusHandlerResult
ac_manage_dbus_message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) {
DBusMessage *reply = NULL;
char sender[20];
syslog(LOG_DEBUG, "message type = %s, message path = %s, message member = %s\n",
dbus_message_type_to_string(dbus_message_get_type(message)),
dbus_message_get_path(message), dbus_message_get_member(message));
if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_DBUS_OBJPATH)) {
if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_LOG_DEBUG)) {
reply = ac_manage_dbus_config_log_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TOKEN_DEBUG)) {
reply = ac_manage_dbus_config_token_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_PROXY_PFM_CONFIG)) {
reply = ac_manage_dbus_proxy_pfm_config(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_MANUAL_SET_MIB_ACIF_STATS)) {
reply = ac_manage_dbus_manual_mib_acif_stats(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_MIB_ACIF_STATS)) {
reply = ac_manage_dbus_show_mib_acif_stats(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_GET_MIB_LOCALSLOT_ACIF_STATS)) {
reply = ac_manage_dbus_get_mib_localslot_acif_stats(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_MIB_ACCUMULATE_ACIF_STATS)) {
reply = ac_manage_dbus_show_mib_accumulate_acif_stats(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_RADIUS_CONFIG)) {
reply = ac_manage_dbus_show_radius_config(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_IP_PORT_CHECK)) {
reply = ac_manage_dbus_web_ip_port_check(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_EDIT)) {
reply = ac_manage_dbus_web_edit(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_SHOW)) {
reply = ac_manage_dbus_web_show(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_CONF)) {
reply = ac_manage_dbus_web_conf(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_DOWNLOAD)) {
reply = ac_manage_dbus_web_download(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_SHOW_PAGES)) {
reply = ac_manage_dbus_web_show_pages(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_WEB_DEL_PAGES)) {
reply = ac_manage_dbus_web_del_pages(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_DBUS_INTERFACE, AC_MANAGE_DBUS_EXTEND_COMMAND_EXEC)) {
reply = ac_manage_dbus_extend_command_exec(connection, message, user_data);
}
}
else if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_SNMP_DBUS_OBJPATH)) {
if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_SERVICE)) {
reply = ac_manage_dbus_config_snmp_service(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_COLLECTION_MODE)) {
reply = ac_manage_dbus_config_snmp_collection_mode(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_PFM_REQUESTPKTS)) {
reply = ac_manage_dbus_config_snmp_pfm_requestpkts(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_PFM_REQUESTPKTS_IPV6)) {
reply = ac_manage_dbus_config_snmp_pfm_requestpkts_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_VERSION_MODE)) {
reply = ac_manage_dbus_config_snmp_version_mode(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_CACHETIME)) {
reply = ac_manage_dbus_config_snmp_cachetime(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_ADD_COMMUNITY)) {
reply = ac_manage_dbus_config_snmp_add_community(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_ADD_COMMUNITY_IPV6)) {
reply = ac_manage_dbus_config_snmp_add_community_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_SET_COMMUNITY)) {
reply = ac_manage_dbus_config_snmp_set_community(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_SET_COMMUNITY_IPV6)) {
reply = ac_manage_dbus_config_snmp_set_community_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_DEL_COMMUNITY)) {
reply = ac_manage_dbus_config_snmp_del_community(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_DEL_COMMUNITY_IPV6)) {
reply = ac_manage_dbus_config_snmp_del_community_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_VIEW)) {
reply = ac_manage_dbus_config_snmp_view(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CHECK_SNMP_VIEW)) {
reply = ac_manage_dbus_check_snmp_view(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_VIEW_OID)) {
reply = ac_manage_dbus_config_snmp_view_oid(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_ADD_GROUP)) {
reply = ac_manage_dbus_config_snmp_add_group(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_DEL_GROUP)) {
reply = ac_manage_dbus_config_snmp_del_group(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_ADD_V3USER)) {
reply = ac_manage_dbus_config_snmp_add_v3user(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_DEL_V3USER)) {
reply = ac_manage_dbus_config_snmp_del_v3user(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_SERVICE)) {
reply = ac_manage_dbus_config_trap_service(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_CONFIG_RECEIVER)) {
reply = ac_manage_dbus_config_trap_config_receiver(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_DEL_RECEIVER)) {
reply = ac_manage_dbus_config_trap_del_receiver(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_SWITCH)) {
reply = ac_manage_dbus_config_trap_switch(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_GROUP_SWITCH)) {
reply = ac_manage_dbus_config_trap_group_switch(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_INSTANCE_HEARTBEAT)) {
reply = ac_manage_dbus_config_trap_instance_heartbeat(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CLEAR_TRAP_INSTANCE_HEARTBEAT)) {
reply = ac_manage_dbus_clear_trap_instance_heartbeat(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_PARAMETER)) {
reply = ac_manage_dbus_config_trap_parameter(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_MANUAL_INSTANCE)) {
reply = ac_manage_dbus_config_snmp_manual_instance(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_UPDATE_SYSINFO)) {
reply = ac_manage_dbus_config_snmp_update_sysinfo(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_MANUAL_INSTANCE)) {
reply = ac_manage_dbus_show_snmp_manual_instance(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_STATE)) {
reply = ac_manage_dbus_show_snmp_state(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_STATE)) {
reply = ac_manage_dbus_show_trap_state(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_BASE_INFO)) {
reply = ac_manage_dbus_show_snmp_base_info(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_PFM_INTERFACE)) {
reply = ac_manage_dbus_show_snmp_pfm_interface(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_PFM_INTERFACE_IPV6)) {
reply = ac_manage_dbus_show_snmp_pfm_interface_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_RUNNING_CONFIG)) {
reply = ac_manage_dbus_show_snmp_running_config(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_COMMUNITY)) {
reply = ac_manage_dbus_show_snmp_community(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_COMMUNITY_IPV6)) {
reply = ac_manage_dbus_show_snmp_community_ipv6(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_VIEW)) {
reply = ac_manage_dbus_show_snmp_view(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_GROUP)) {
reply = ac_manage_dbus_show_snmp_group(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_V3USER)) {
reply = ac_manage_dbus_show_snmp_v3user(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_RECEIVER)) {
reply = ac_manage_dbus_show_trap_receiver(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_SWITCH)) {
reply = ac_manage_dbus_show_trap_switch(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_INSTANCE_HEARTBEAT)) {
reply = ac_manage_dbus_show_trap_instance_heartbeat(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_PARAMETER)) {
reply = ac_manage_dbus_show_trap_parameter(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SNMP_LOG_DEBUG)) {
reply = ac_manage_dbus_show_snmp_log_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_LOG_DEBUG)) {
reply = ac_manage_dbus_config_snmp_log_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TRAP_LOG_DEBUG)) {
reply = ac_manage_dbus_show_trap_log_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_TRAP_LOG_DEBUG)) {
reply = ac_manage_dbus_config_trap_log_debug(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SNMP_SYSOID_BOARDTYPE)) {
reply = ac_manage_dbus_config_snmp_sysoid_boardtype(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_SNMP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_MEM_STATUE_DOG)) {
reply = ac_manage_dbus_config_mem_status_dog(connection, message, user_data);
}
}
else if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_TCRULE_DBUS_OBJPATH)) {
if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_FLOW_CONTROL_SERVICE)) {
reply = ac_manage_dbus_config_flow_control_service(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_ADD_TCRULE)) {
reply = ac_manage_dbus_add_tcrule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_OFFSET_TCRULE)) {
reply = ac_manage_dbus_offset_tcrule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_DELETE_TCRULE)) {
reply = ac_manage_dbus_delete_tcrule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_FLOW_CONTROL_SERVICE)) {
reply = ac_manage_dbus_show_flow_control_service(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TCRULE)) {
reply = ac_manage_dbus_show_tcrule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TCRULE_OFFSET)) {
reply = ac_manage_dbus_show_tcrule_offset(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_TCRULE_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TCRULE_RUNNING_CONFIG)) {
reply = ac_manage_dbus_show_tcrule_running_config(connection, message, user_data);
}
}
else if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_FIREWALL_DBUS_OBJPATH)) {
if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_FIREWALL_SERVICE)) {
reply = ac_manage_dbus_config_firewall_service(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_FIREWALL_RULE)) {
reply = ac_manage_dbus_config_firewall_rule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_CHANGE_FIREWALL_INDEX)) {
reply = ac_manage_dbus_change_firewall_index(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_DELETE_FIREWALL_RULE)) {
reply = ac_manage_dbus_del_firewall_rule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_NAT_UDP_TIMEOUT)) {
reply = ac_manage_dbus_config_nat_udp_timeout(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_FIREWALL_RULE)) {
reply = ac_manage_dbus_show_firewall_rule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_STRICT_ACCESS_LEVEL)) {
reply = ac_manage_dbus_config_strict_access_level(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_FIREWALL_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_STRICT_ACCESS)) {
reply = ac_manage_dbus_show_strict_access(connection, message, user_data);
}
}
else if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_NTP_DBUS_OBJPATH)) {
if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_NTP_RULE)) {
reply = ac_manage_dbus_show_ntp_rule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_ADD_NTPSERVER)) {
reply = ac_manage_dbus_add_ntpserver(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_INSIDE_NTP)) {
reply = ac_manage_dbus_inside_ntp(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_NTP_STATUS)) {
reply = ac_manage_dbus_set_ntp_status(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_CLENA_NTP)) {
reply = ac_manage_dbus_clean_ntp(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_NTP_PFM_REQUESTPKTS)) {
reply = ac_manage_dbus_config_ntp_pfm_requestpkts(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_TIMEZONE)) {
reply = ac_manage_dbus_set_timezone(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_ADD_NTPCLIENT)) {
reply = ac_manage_dbus_add_ntpclient(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_NTPCLIENT)) {
reply = ac_manage_dbus_show_ntpclient(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_NTPUPSERVER)) {
reply = ac_manage_dbus_show_ntpupserver(connection, message, user_data);
}
if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_TIME)) {
reply = ac_manage_dbus_show_time(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_TIME)) {
reply = ac_manage_dbus_set_time(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_NTP_RUNNING_CONFIG)) {
reply = ac_manage_dbus_show_ntp_running_config(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_ADD_SYSLOGRULE)) {
reply = ac_manage_dbus_add_syslogrule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_SYSLOG_STATUS)) {
reply = ac_manage_dbus_set_syslog_status(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SHOW_SYSLOG_RULE)) {
reply = ac_manage_dbus_show_syslog_rule(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_SAVE_SYSLOG)) {
reply = ac_manage_dbus_save_syslog(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SYSLOGUPLOAD_PFM_REQUESTPKTS)) {
reply = ac_manage_dbus_config_syslogupload_pfm_requestpkts(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_NTP_DBUS_INTERFACE, AC_MANAGE_DBUS_CONFIG_SYSLOGRULE)) {
reply = ac_manage_dbus_config_syslogrule(connection, message, user_data);
}
}
else if(0 == strcmp(dbus_message_get_path(message), AC_MANAGE_ACINFO_DBUS_OBJPATH)){
if(dbus_message_is_method_call(message, AC_MANAGE_ACINFO_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_ACINFO_VALUE)) {
reply = ac_manage_dbus_set_acinfo_value(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_ACINFO_DBUS_INTERFACE, AC_MANAGE_DBUS_SET_BKACINFO_VALUE)) {
reply = ac_manage_dbus_set_bkacinfo_value(connection, message, user_data);
}
else if(dbus_message_is_method_call(message, AC_MANAGE_ACINFO_DBUS_INTERFACE, AC_MANAGE_DBUS_DEL_AC_VERSION_FILE_VALUE)) {
reply = ac_manage_dbus_del_ac_version_file_value(connection, message, user_data);
}
}
if (reply) {
syslog(LOG_DEBUG, "reply destination %s\n", dbus_message_get_destination(reply));
memset(sender,0, sizeof(sender));
strcpy(sender, dbus_message_get_destination(reply));
dbus_connection_send (connection, reply, NULL);
dbus_connection_flush(connection);
dbus_message_unref (reply);
}
return DBUS_HANDLER_RESULT_HANDLED ;
}
void
handle_dbus_message(DBusMessage *msg)
{
int state;
char **new_uris;
int uri_count;
GstState pipeline_state;
int hemp_state;
int i;
int new_head = 0; /* is there a new hotlist head?
If so, play means skip */
if (!strncmp (HEMP_DBUS_DESTINATION, dbus_message_get_destination(msg),
strlen(HEMP_DBUS_DESTINATION))) {
dbus_message_get_args (msg, NULL,
DBUS_TYPE_INT32, &state,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
&new_uris, &uri_count,
DBUS_TYPE_INVALID);
for (i = 0; i<uri_count; i++) {
g_queue_push_head(hotlist,
new_playlist_entry(new_uris[i]));
new_head = 1;
}
if (uri_count) write_playlist();
if (!GST_IS_ELEMENT(pipeline)) init_pipeline();
gst_element_get_state(GST_ELEMENT (pipeline),
&pipeline_state,
NULL,
GST_CLOCK_TIME_NONE);
if (pipeline_state == GST_STATE_PAUSED) {
hemp_state = HEMP_STATE_PAUSED;
} else {
hemp_state = HEMP_STATE_PLAYING;
}
switch (state) {
case HEMP_STATE_TOGGLE:
if (pipeline_state == GST_STATE_PLAYING) {
gst_element_set_state (GST_ELEMENT (pipeline),
GST_STATE_PAUSED);
} else {
gst_element_set_state (GST_ELEMENT (pipeline),
GST_STATE_PLAYING);
}
break;
case HEMP_STATE_SKIP:
next(hemp_state, 1);
break;
case HEMP_STATE_PREVIOUS:
previous(hemp_state);
break;
case HEMP_STATE_PLAYING:
if (new_head) {
next(HEMP_STATE_PLAYING, 0);
} else {
gst_element_set_state (GST_ELEMENT (pipeline),
GST_STATE_PLAYING);
}
break;
case HEMP_STATE_PAUSED:
gst_element_set_state (GST_ELEMENT (pipeline),
GST_STATE_PAUSED);
break;
case HEMP_STATE_STOP:
drop_pipeline(0);
break;
case HEMP_STATE_PING:
printf("ping!\n");
break;
default:
printf("Unknown state %d\n", state);
}
}
}
VIR_MOCK_WRAP_RET_ARGS(dbus_connection_send_with_reply_and_block,
DBusMessage *,
DBusConnection *, connection,
DBusMessage *, message,
int, timeout_milliseconds,
DBusError *, error)
{
DBusMessage *reply = NULL;
const char *service = dbus_message_get_destination(message);
const char *member = dbus_message_get_member(message);
VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block);
if (STREQ(service, "org.freedesktop.machine1")) {
if (getenv("FAIL_BAD_SERVICE")) {
dbus_set_error_const(error,
"org.freedesktop.systemd.badthing",
"Something went wrong creating the machine");
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
} else if (STREQ(service, "org.freedesktop.login1")) {
char *supported = getenv("RESULT_SUPPORT");
DBusMessageIter iter;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING,
&supported))
goto error;
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListActivatableNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.machine1";
const char *svc3 = "org.freedesktop.login1";
DBusMessageIter iter;
DBusMessageIter sub;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
"s", &sub);
if (!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc1))
goto error;
if (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.systemd1";
const char *svc3 = "org.freedesktop.login1";
DBusMessageIter iter;
DBusMessageIter sub;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
"s", &sub);
if (!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc1))
goto error;
if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
return reply;
error:
dbus_message_unref(reply);
return NULL;
}
VIR_MOCK_WRAP_RET_ARGS(dbus_connection_send_with_reply_and_block,
DBusMessage *,
DBusConnection *, connection,
DBusMessage *, message,
int, timeout_milliseconds,
DBusError *, error)
{
DBusMessage *reply = NULL;
const char *service = dbus_message_get_destination(message);
const char *member = dbus_message_get_member(message);
size_t i;
size_t nargs = 0;
char **args = NULL;
char *type = NULL;
VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block);
if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = VIR_FIREWALL_FIREWALLD_SERVICE;
DBusMessageIter iter;
DBusMessageIter sub;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
"s", &sub);
if (!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc1))
goto error;
if (!fwDisabled &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else if (STREQ(service, VIR_FIREWALL_FIREWALLD_SERVICE) &&
STREQ(member, "passthrough")) {
bool isAdd = false;
bool doError = false;
if (virDBusMessageDecode(message,
"sa&s",
&type,
&nargs,
&args) < 0)
goto error;
for (i = 0; i < nargs; i++) {
/* Fake failure on the command with this IP addr */
if (STREQ(args[i], "-A")) {
isAdd = true;
} else if (isAdd && STREQ(args[i], "192.168.122.255")) {
doError = true;
}
}
if (fwBuf) {
if (STREQ(type, "ipv4"))
virBufferAddLit(fwBuf, IPTABLES_PATH);
else if (STREQ(type, "ipv4"))
virBufferAddLit(fwBuf, IP6TABLES_PATH);
else
virBufferAddLit(fwBuf, EBTABLES_PATH);
}
for (i = 0; i < nargs; i++) {
if (fwBuf) {
virBufferAddLit(fwBuf, " ");
virBufferEscapeShell(fwBuf, args[i]);
}
}
if (fwBuf)
virBufferAddLit(fwBuf, "\n");
if (doError) {
dbus_set_error_const(error,
"org.firewalld.error",
"something bad happened");
} else {
if (nargs == 1 &&
STREQ(type, "ipv4") &&
STREQ(args[0], "-L")) {
if (virDBusCreateReply(&reply,
"s", TEST_FILTER_TABLE_LIST) < 0)
goto error;
} else if (nargs == 3 &&
STREQ(type, "ipv4") &&
STREQ(args[0], "-t") &&
STREQ(args[1], "nat") &&
STREQ(args[2], "-L")) {
if (virDBusCreateReply(&reply,
"s", TEST_NAT_TABLE_LIST) < 0)
goto error;
} else {
if (virDBusCreateReply(&reply,
"s", "success") < 0)
goto error;
}
}
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
cleanup:
VIR_FREE(type);
for (i = 0; i < nargs; i++)
VIR_FREE(args[i]);
VIR_FREE(args);
return reply;
error:
virDBusMessageUnref(reply);
reply = NULL;
if (error && !dbus_error_is_set(error))
dbus_set_error_const(error,
"org.firewalld.error",
"something unexpected happened");
goto cleanup;
}
/**
* Description:
* WSM module Dbus handler
*
*/
static DBusHandlerResult wsm_dbus_msg_handler (
DBusConnection *conn,
DBusMessage *msg,
void *user_data)
{
DBusMessage *reply = NULL;
unsigned char wsm_dbus_vrid_path[WSM_PATH_MAX] = {0};
#ifndef _DISTRIBUTION_
sprintf(wsm_dbus_vrid_path, "%s%d", WSM_DBUS_OBJPATH, vrrid);
#else
sprintf(wsm_dbus_vrid_path, "%s%d_%d", WSM_DBUS_OBJPATH,local, vrrid);
#endif
if (strcmp(dbus_message_get_path(msg), wsm_dbus_vrid_path) != 0)
{
WSMLog(L_CRIT, "%s: Dbus Path match error.\n", __func__);
return DBUS_HANDLER_RESULT_HANDLED;
}
WSMLog(L_INFO,"message path %s\n",dbus_message_get_path(msg));
WSMLog(L_INFO,"message interface %s\n",dbus_message_get_interface(msg));
WSMLog(L_INFO,"message member %s\n",dbus_message_get_member(msg));
WSMLog(L_INFO,"message destination %s\n",dbus_message_get_destination(msg));
WSMLog(L_INFO,"message type %d\n",dbus_message_get_type(msg));
if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SET_TUNNEL))
reply = wsm_dbus_set_ipfwd_state(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_WTP_LIST))
reply = wsm_dbus_show_wtp_list(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_LOG_WSM_STATE))
reply = wsm_dbus_show_log_wsm_state(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SET_LOG_WSM_LEVEL))
reply = wsm_dbus_set_log_wsm_level(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_WTP_WTPID))
reply = wsm_dbus_show_wtp_by_wtpid(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_BSS_BSSID))
reply = wsm_dbus_show_bss_bssid(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_STA_STAMAC))
reply = wsm_dbus_show_sta_stamac(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SET_WSM_WATCHDOG_STATE))
reply = wsm_dbus_set_wsm_watchdog_state(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SHOW_WSM_WATCH_DOG_STATE))
reply = wsm_dbus_show_wsm_watchdog_state(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CAPWAP_TUNNEL_SHOW_RUNNING))
reply = wsm_dbus_capwap_tunnel_show_running(conn, msg, user_data);
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_METHOD_SET_WSM_ERROR_HANDLE_STATE)){
reply = wsm_dbus_set_wsm_error_handle_state(conn,msg,user_data);
}else if(dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_METHOD_CHECKING)){
reply = wsm_dbus_checking_wsm(conn,msg,user_data);
}
else if(dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_METHOD_QUIT)){
reply = wsm_dbus_method_quit(conn,msg,user_data);
}
else if (dbus_msg_is_method_call(msg, WSM_DBUS_INTERFACE, WSM_DBUS_CONF_SET_TUNNEL_WSM_RX_TX))
reply = wsm_dbus_set_wsm_receive_transmit_func(conn, msg, user_data);
if (reply)
{
dbus_connection_send (conn, reply, NULL);
dbus_connection_flush(conn);
dbus_message_unref (reply);
}
return DBUS_HANDLER_RESULT_HANDLED ;
}
const char* EdbusMessage::destination(void) const {
if(!dm || !dm->msg)
return NULL;
return dbus_message_get_destination(dm->msg);
}
EAPI const char *
eldbus_message_destination_get(const Eldbus_Message *msg)
{
ELDBUS_MESSAGE_CHECK_RETVAL(msg, NULL);
return dbus_message_get_destination(msg->dbus_msg);
}
const gchar *
ibus_message_get_destination (IBusMessage *message)
{
return dbus_message_get_destination (message);
}
