DBusMessage *
gkd_dbus_introspect_handle (DBusMessage *message,
const gchar *data,
const gchar **children)
{
DBusMessage *reply;
GString *output = NULL;
gchar *nodes;
g_return_val_if_fail (message, NULL);
g_return_val_if_fail (data, NULL);
if (dbus_message_is_method_call (message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect") &&
dbus_message_get_args (message, NULL, DBUS_TYPE_INVALID)) {
if (children != NULL) {
output = g_string_new (data);
nodes = build_child_node_xml (dbus_message_get_path (message), children);
if (!string_replace (output, "<!--@children@-->", nodes))
g_warning ("introspection data contained no location for child nodes");
g_free (nodes);
data = output->str;
}
reply = dbus_message_new_method_return (message);
if (!dbus_message_append_args (reply, DBUS_TYPE_STRING, &data, DBUS_TYPE_INVALID))
g_return_val_if_reached (NULL);
if (output)
g_string_free (output, TRUE);
return reply;
}
return NULL;
}
static DBusHandlerResult
no_bus_server_filter (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
ServerData *sd = user_data;
if (dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
{
g_printerr ("Client disconnected from server\n");
sd->n_clients -= 1;
if (sd->n_clients == 0)
g_main_loop_quit (sd->loop);
}
else if (dbus_message_is_method_call (message,
ECHO_INTERFACE,
ECHO_PING_METHOD))
{
sd->handled += 1;
send_echo_method_return (connection, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult
handle_player ( DBusConnection *p_conn, DBusMessage *p_from, void *p_this )
{
if( dbus_message_is_method_call( p_from,
DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
return handle_introspect_player( p_conn, p_from, p_this );
/* here D-Bus method names are associated to an handler */
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Prev", Prev );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Next", Next );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Stop", Stop );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Play", Play );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Pause", Pause );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "Repeat", Repeat );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "VolumeSet", VolumeSet );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "VolumeGet", VolumeGet );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "PositionSet", PositionSet );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "PositionGet", PositionGet );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "GetStatus", GetStatus );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "GetMetadata", GetCurrentMetadata );
METHOD_FUNC( DBUS_MPRIS_PLAYER_INTERFACE, "GetCaps", GetCaps );
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/**
* Server that exposes a method call and waits for it to be called
*/
void listen()
{
DBusMessage* msg;
DBusMessage* reply;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
int ret;
char* param;
printf("Listening for method calls\n");
// initialise the error
dbus_error_init(&err);
// connect to the bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
fprintf(stderr, "Connection Null\n");
exit(1);
}
// request our name on the bus and check for errors
ret = dbus_bus_request_name(conn, "task.method.server", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Name Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
fprintf(stderr, "Not Primary Owner (%d)\n", ret);
exit(1);
}
// loop, testing for new messages
while (true) {
// non blocking read of the next available message
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't got a message
if (NULL == msg) {
sleep(1);
continue;
}
printf("hmm\n");
// check this is a method call for the right interface & method
if (dbus_message_is_method_call(msg, "task.method.Type", "Method"))
reply_to_method_call(msg, conn);
// free the message
dbus_message_unref(msg);
}
// close the connection
dbus_connection_close(conn);
}
static DBusHandlerResult
client_dbus_filter_function (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
GsmDBusClient *client = GSM_DBUS_CLIENT (user_data);
const char *path;
g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
path = dbus_message_get_path (message);
g_debug ("GsmDBusClient: obj_path=%s interface=%s method=%s",
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
if (dbus_message_is_method_call (message, SM_DBUS_CLIENT_PRIVATE_INTERFACE, "EndSessionResponse")) {
g_assert (gsm_client_peek_id (GSM_CLIENT (client)) != NULL);
if (path != NULL && strcmp (path, gsm_client_peek_id (GSM_CLIENT (client))) != 0) {
/* Different object path */
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
handle_end_session_response (client, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusMessage*
gkd_dbus_introspect_handle (DBusMessage *message, const gchar *type)
{
GError *error = NULL;
DBusMessage *reply;
gchar *filename;
gchar *data;
g_return_val_if_fail (message, NULL);
g_return_val_if_fail (type, NULL);
if (dbus_message_is_method_call (message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect") &&
dbus_message_get_args (message, NULL, DBUS_TYPE_INVALID)) {
filename = g_strconcat (INTROSPECTDIR, G_DIR_SEPARATOR_S, "introspect-", type, ".xml", NULL);
g_file_get_contents (filename, &data, NULL, &error);
g_free (filename);
if (error != NULL) {
g_warning ("couldn't load introspect data file: %s: %s",
filename, egg_error_message (error));
g_clear_error (&error);
return NULL;
}
reply = dbus_message_new_method_return (message);
if (!dbus_message_append_args (reply, DBUS_TYPE_STRING, &data, DBUS_TYPE_INVALID))
g_return_val_if_reached (NULL);
g_free (data);
return reply;
}
return NULL;
}
static DBusHandlerResult generic_message(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
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 (dbus_message_has_signature(message,
method->signature) == FALSE)
continue;
if (check_privilege(connection, message, method,
iface->user_data) == TRUE)
return DBUS_HANDLER_RESULT_HANDLED;
return process_message(connection, message, method,
iface->user_data);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult bsd_dbus_message_handler (DBusConnection *connection, DBusMessage *message, void *user_data){
DBusMessage *reply = NULL;
if(message == NULL)
return DBUS_HANDLER_RESULT_HANDLED;
if (strcmp(dbus_message_get_path(message),BSD_DBUS_OBJPATH) == 0) {
if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_BORADS)) {
reply = bsd_copy_files_between_boards(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SYNCHRONIZE_FILES_TO_OTHER_BOARDS)) {
reply = bsd_synchronize_files(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SYNCHRONIZE_FILES_TO_OTHER_BOARDS_V2)) {
reply = bsd_synchronize_files_v2(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_GET_ALIVE_SLOT_IDS)) {
reply = bsd_get_alive_slot_ids(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SET_BSD_DAEMONLOG_LEVEL)) {
reply = bsd_set_daemonlog_level(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_DEVICES)) {
reply = bsd_copy_files_between_devices(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CHECK_DETINATION_BOARD_INFORMATION)) {
reply = bsd_check_destination_board(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CHECK_DETINATION_DEVICE_INFORMATION)) {
reply = bsd_check_destination_device(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CLOSE_TCP_SOCKET)) {
reply = bsd_close_tcp_socket(connection,message,user_data);
}
if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_BORADS_V2)) {
reply = bsd_copy_files_between_boards_v2(connection,message,user_data);
}
}
if (reply) {
dbus_connection_send (connection, reply, NULL);
dbus_connection_flush(connection);
dbus_message_unref (reply);
}
return DBUS_HANDLER_RESULT_HANDLED ;
}
DBusHandlerResult message_handler(DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
char *method = (char *)dbus_message_get_member(message);
DBusMessage *reply = NULL;
if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
{
/* string length: "%s" provides space for termination zero */
if (!introspection_xml &&
(introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name))))
sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name);
if (introspection_xml)
{
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
}
}
else if (strcmp(method, "GetVersion") == 0)
{
char *v = VERSION;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID);
}
else if (strcmp(method, "SetServers") == 0)
{
my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
dbus_read_servers(message);
check_servers();
}
else if (strcmp(method, "SetServersEx") == 0)
{
my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
reply = dbus_read_servers_ex(message);
check_servers();
}
else if (strcmp(method, "ClearCache") == 0)
clear_cache_and_reload(dnsmasq_time());
else
return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
method = user_data; /* no warning */
/* If no reply or no error, return nothing */
if (!reply)
reply = dbus_message_new_method_return(message);
if (reply)
{
dbus_connection_send (connection, reply, NULL);
dbus_message_unref (reply);
}
return (DBUS_HANDLER_RESULT_HANDLED);
}
gboolean
ibus_message_is_method_call (IBusMessage *message,
const gchar *interface,
const gchar *method)
{
return dbus_message_is_method_call (message,
interface,
method);
}
DBusHandlerResult avahi_dbus_msg_domain_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
DBusError error;
DomainBrowserInfo *i = userdata;
assert(c);
assert(m);
assert(i);
dbus_error_init(&error);
avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
dbus_message_get_interface(m),
dbus_message_get_path(m),
dbus_message_get_member(m));
/* Introspection */
if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
return avahi_dbus_handle_introspect(c, m, "DomainBrowser.introspect");
/* Access control */
if (strcmp(dbus_message_get_sender(m), i->client->name))
return avahi_dbus_respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free")) {
if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
avahi_log_warn("Error parsing DomainBrowser::Free message");
goto fail;
}
avahi_dbus_domain_browser_free(i);
return avahi_dbus_respond_ok(c, m);
}
avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
fail:
if (dbus_error_is_set(&error))
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
path_message_func (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
if (dbus_message_is_method_call (message,
"org.freedesktop.TestSuite",
"Echo"))
return handle_echo (connection, message);
else if (dbus_message_is_method_call (message,
"org.freedesktop.TestSuite",
"Exit"))
{
quit ();
return DBUS_HANDLER_RESULT_HANDLED;
}
else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/**
* Returns -1 upon error, 0 when there are no more messages
*/
static int handle_messages(void)
{
DBusMessage *message;
if (!dbus_connection_read_write(connection, 250)) {
fprintf(stderr, "FAIL: Connecion is closed\n");
return -1;
}
for (;;) {
message = dbus_connection_pop_message(connection);
if (message == NULL)
return 0;
log_message(log_fd, "received ", message);
if (dbus_message_is_signal(message, interface, "Signal")) {
dbus_message_unref(message);
continue;
} else
if (dbus_message_is_method_call
(message, interface, "Method")) {
DBusMessage *reply;
reply = dbus_message_new_method_return(message);
dbus_message_unref(message);
log_message(log_fd, "sent ", reply);
dbus_connection_send(connection, reply, NULL);
dbus_connection_flush(connection);
dbus_message_unref(reply);
continue;
} else if (dbus_message_get_type(message) ==
DBUS_MESSAGE_TYPE_METHOD_CALL) {
DBusMessage *reply;
reply =
dbus_message_new_error(message,
DBUS_ERROR_UNKNOWN_METHOD,
NULL);
dbus_message_unref(message);
log_message(log_fd, "sent ", reply);
dbus_connection_send(connection, reply, NULL);
dbus_connection_flush(connection);
dbus_message_unref(reply);
continue;
} else {
dbus_message_unref(message);
continue;
}
}
return 0;
}
void reply(DBusMessage *msg, DBusConnection *conn) {
DBusMessage *reply;
DBusMessageIter args;
long t_response = -1;
double d_response = -1;
if (dbus_message_is_method_call(msg, DBUS_NAMESPACE, "Sunrise")) { t_response = sunrise(msg); }
if (dbus_message_is_method_call(msg, DBUS_NAMESPACE, "Sunset")) { t_response = sunset(msg); }
if (dbus_message_is_method_call(msg, DBUS_NAMESPACE, "Brightness")) { d_response = brightness(msg); }
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append(reply, &args);
if (t_response >= 0) { sendT(conn, reply, &args, t_response); }
if (d_response >= 0) { sendD(conn, reply, &args, d_response); }
dbus_connection_flush(conn);
dbus_message_unref(reply);
}
static DBusHandlerResult
dbus_reg_filter (DBusConnection * connection, DBusMessage * message, void * user_data)
{
if (dbus_message_is_method_call(message, NOTIFICATION_WATCHER_DBUS_ADDR, "RegisterStatusNotifierItem")) {
DBusMessage * reply = dbus_message_new_method_return(message);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult dbus_status_item_filter(DBusConnection *connection,DBusMessage * msg,void */* data*/){
// DEBUG_DBUS_MESSAGE(msg);
DBusMessage * reply;
DBusMessageIter iter;
DBusMessageIter dict;
//DBusMessageIter dictentry;
FXuint serial;
if (dbus_message_has_path(msg,APPLICATION_STATUS_ITEM_PATH)){
DEBUG_DBUS_MESSAGE(msg);
if (dbus_message_has_interface(msg,APPLICATION_STATUS_ITEM_INTERFACE)) {
if (dbus_message_is_method_call(msg,APPLICATION_STATUS_ITEM_INTERFACE,"Activate")){
GMPlayerManager::instance()->cmd_toggle_shown();
return gm_dbus_reply_if_needed(connection,msg);
}
else if (dbus_message_is_method_call(msg,APPLICATION_STATUS_ITEM_INTERFACE,"Scroll")){
FXint delta;
const FXchar * orientation;
if (dbus_message_get_args(msg,NULL,DBUS_TYPE_INT32,&delta,DBUS_TYPE_STRING,&orientation,DBUS_TYPE_INVALID)) {
//FIXME
FXint level = GMPlayerManager::instance()->volume();
level+=(delta/120);
GMPlayerManager::instance()->volume(level);
}
return gm_dbus_reply_if_needed(connection,msg);
}
}
else if (dbus_message_has_interface(msg,DBUS_INTERFACE_INTROSPECTABLE)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_INTROSPECTABLE,"Introspect")){
return gm_dbus_reply_string(connection,msg,appstatus_xml);
}
}
else if (dbus_message_has_interface(msg,DBUS_INTERFACE_PROPERTIES)) {
if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Get")){
GM_DEBUG_PRINT("get\n");
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"GetAll")){
if ((reply=dbus_message_new_method_return(msg))!=NULL) {
dbus_message_iter_init_append(reply,&iter);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&dict);
gm_dbus_dict_append_path(&dict,"Menu",APPLICATION_STATUS_ITEM_MENU_PATH);
gm_dbus_dict_append_string(&dict,"Category","ApplicationStatus");
gm_dbus_dict_append_string(&dict,"Id","gogglesmm");
gm_dbus_dict_append_string(&dict,"IconName","gogglesmm");
gm_dbus_dict_append_string(&dict,"Status","Active");
gm_dbus_dict_append_uint32(&dict,"WindowId",GMPlayerManager::instance()->getMainWindowId());
gm_add_tooltip(&dict);
dbus_message_iter_close_container(&iter,&dict);
dbus_connection_send(connection,reply,&serial);
dbus_message_unref(reply);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call(msg,DBUS_INTERFACE_PROPERTIES,"Set")){
}
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult profile_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
pa_bluetooth_backend *b = userdata;
DBusMessage *r = NULL;
const char *path, *interface, *member;
pa_assert(b);
path = dbus_message_get_path(m);
interface = dbus_message_get_interface(m);
member = dbus_message_get_member(m);
pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
if (!pa_streq(path, HSP_AG_PROFILE) && !pa_streq(path, HSP_HS_PROFILE))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
const char *xml = PROFILE_INTROSPECT_XML;
pa_assert_se(r = dbus_message_new_method_return(m));
pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "Release")) {
pa_log_debug("Release not handled");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "RequestDisconnection")) {
r = profile_request_disconnection(c, m, userdata);
} else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "NewConnection"))
r = profile_new_connection(c, m, userdata);
else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (r) {
pa_assert_se(dbus_connection_send(pa_dbus_connection_get(b->connection), r, NULL));
dbus_message_unref(r);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
_handle_message (DBusConnection *connection, DBusMessage *message, void *data)
{
ServiceData *svc = (ServiceData *)data;
DBusHandlerResult result;
rb_debug ("handling metadata service message: %s", dbus_message_get_member (message));
if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "load")) {
result = rb_metadata_dbus_load (connection, message, svc);
} else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "getSaveableTypes")) {
result = rb_metadata_dbus_get_saveable_types (connection, message, svc);
} else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "save")) {
result = rb_metadata_dbus_save (connection, message, svc);
} else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "ping")) {
result = rb_metadata_dbus_ping (connection, message, svc);
} else {
result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
svc->last_active = time (NULL);
return result;
}
static DBusHandlerResult wbmd_dbus_message_handler (DBusConnection *connection, DBusMessage *message, void *user_data){
DBusMessage *reply = NULL;
if(message == NULL)
return DBUS_HANDLER_RESULT_HANDLED;
if (strcmp(dbus_message_get_path(message),WBMD_DBUS_OBJPATH) == 0) {
if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_CREATE_WBRIDGE)) {
reply = wbmd_dbus_interface_create_wbridge(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SHOW_WBRIDGE_LIST)) {
reply = wbmd_dbus_interface_show_wbridge_list(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_WBRIDGE)) {
reply = wbmd_dbus_interface_wbridge(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SET_WBRIDGE_SNMP)) {
reply = wbmd_dbus_interface_set_wbridge_snmp(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SHOW_WBRIDGE_BASIC_INFO)) {
reply = wbmd_dbus_interface_show_wbridge_basic_info(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SHOW_WBRIDGE_MINT_INFO)) {
reply = wbmd_dbus_interface_show_wbridge_mint_info(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SHOW_WBRIDGE_RF_INFO)) {
reply = wbmd_dbus_interface_show_wbridge_rf_info(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_SHOW_WBRIDGE_RUNNING_CONFIG)) {
reply = wbmd_dbus_interface_show_running_config(connection,message,user_data);
}
else if (dbus_message_is_method_call(message,WBMD_DBUS_INTERFACE,WBMD_DBUS_CONF_METHOD_DELETE_WBRIDGE)) {
reply = wbmd_dbus_interface_delete_wbridge(connection,message,user_data);
}
}
if (reply) {
dbus_connection_send (connection, reply, NULL);
dbus_connection_flush(connection);
dbus_message_unref (reply);
}
return DBUS_HANDLER_RESULT_HANDLED ;
}
/*
* Description:
* Re-format Path string for Hansi N + 1
*
* Parameter:
* same to function dbus_message_is_method_call
*
* Return:
* 0: Failed.
* nonzero: Successed, see return value of dbus_message_is_method_call for detail.
*
*/
unsigned int dbus_msg_is_method_call(DBusMessage *msg, unsigned char *dbus_if, unsigned char *path)
{
unsigned char if_path[128] = {0};
unsigned char cmd_path[128] = {0};
if (get_vrid_path(if_path, dbus_if) == NULL || get_vrid_path(cmd_path, path) == NULL)
{
WSMLog(L_ERR, "%s: get_vrid_path failed\n", __func__);
return 0;
}
return dbus_message_is_method_call(msg, if_path, cmd_path);
}
static DBusHandlerResult
server_message_func (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
if (gconfd_dbus_check_in_shutdown (connection, message))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
{
g_print ("Not a method call\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (g_strcmp0 (dbus_message_get_interface (message),
GCONF_DBUS_SERVER_INTERFACE) != 0)
{
g_print ("Not correct interface: \"%s\"\n",
dbus_message_get_interface (message));
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_GET_DEFAULT_DB))
server_handle_get_default_db (connection, message);
else if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_GET_DB))
server_handle_get_db (connection, message);
else if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_SHUTDOWN))
server_handle_shutdown (connection, message);
else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
filter_session_message (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
TestServiceData *testdata = user_data;
if (dbus_message_is_method_call (message,
"org.freedesktop.DBus.TestSuite.PrivServer",
"GetPrivateAddress"))
{
DBusMessage *reply;
reply = dbus_message_new_method_return (message);
if (reply == NULL)
die ("OOM");
if (!dbus_message_append_args (reply, DBUS_TYPE_STRING,
&(testdata->private_addr),
DBUS_TYPE_INVALID))
die ("OOM");
if (!dbus_connection_send (connection, reply, NULL))
die ("Error sending message");
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call (message,
"org.freedesktop.DBus.TestSuite.PrivServer",
"Quit"))
{
fprintf (stderr, "server exiting loop\n");
_dbus_loop_quit (testdata->loop);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
void dbus_poll(int timeout)
{
DBusMessage *dbus_msg;
dbus_connection_read_write(dbus_conn, timeout);
dbus_msg = dbus_connection_pop_message(dbus_conn);
while (dbus_msg) {
if (dbus_message_is_method_call
(dbus_msg, "org.freedesktop.DBus.Introspectable", "Introspect")) {
dbus_introspect(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"Notify")) {
notify(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"GetCapabilities")) {
getCapabilities(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"GetServerInformation")) {
getServerInformation(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"CloseNotification")) {
closeNotification(dbus_msg);
}
dbus_message_unref(dbus_msg);
dbus_msg = dbus_connection_pop_message(dbus_conn);
}
}
void introspect(DBusMessage *msg, DBusConnection *conn) {
DBusMessage *reply;
if (dbus_message_is_method_call(msg, "org.freedesktop.DBus.Introspectable", "Introspect")) {
char *introspect_xml = &_binary_src_interface_xml_start;
reply = dbus_message_new_method_return(msg);
send(conn, reply, dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspect_xml, DBUS_TYPE_INVALID));
dbus_connection_flush(conn);
dbus_message_unref(reply);
}
}
void
dbus_poll(void) {
DBusMessage *dbus_msg;
/* make timeout smaller if we are displaying a message
* to improve responsivness for mouse clicks
*/
if(msgqueue == NULL) {
dbus_connection_read_write(dbus_conn, DBUS_POLL_TIMEOUT);
} else {
dbus_connection_read_write(dbus_conn, 100);
}
dbus_msg = dbus_connection_pop_message(dbus_conn);
/* we don't have a new message */
if(dbus_msg == NULL) {
return;
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications","Notify")) {
notify(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "GetCapabilities")) {
getCapabilities(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "GetServerInformation")) {
getServerInformation(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "CloseNotification")) {
closeNotification(dbus_msg);
}
dbus_message_unref(dbus_msg);
}
void serve(char *method_name)
{
DBusMessage* msg;
DBusConnection* conn;
DBusError err;
int ret;
if (!method_name) return;
log("Listening for method calls [%s]", method_name);
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
log("Connection Error (%s)", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
log_err("Connection Null");
exit(1);
}
ret = dbus_bus_request_name(conn, SERVER, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
log_err("Name Error (%s)", err.message);
dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
log_err("Not Primary Owner (%d)", ret);
exit(1);
}
while (true) {
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
if (NULL == msg) {
sleep(1);
continue;
}
log_dbg("Received\n");
if (dbus_message_is_method_call(msg, INTERFCE, method_name))
reply_to_method_call(msg, conn);
dbus_message_unref(msg);
}
}
static DBusHandlerResult
dbus_filter (DBusConnection * connection, DBusMessage * message, void * user_data)
{
if (dbus_message_is_method_call(message, NOTIFICATION_WATCHER_DBUS_ADDR, "RegisterStatusNotifierItem")) {
DBusMessage * reply = dbus_message_new_method_return(message);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
/* Let the messages get out, but we're done at this point */
g_timeout_add(50, kill_func, NULL);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/* The content of this function is copied in verbatim
from dbus 0.20 file tools/dbus-print-message.c
*/
static DBusHandlerResult
_filter(DBusConnection *conn, DBusMessage *msg, void *data)
{
const char *sender;
int msg_type;
DBusMessageIter args;
DBusMessage *reply;
char* sigvalue;
msg_type = dbus_message_get_type (msg);
sender = dbus_message_get_sender (msg);
if (dbus_message_is_method_call(msg,
"org.freedesktop.DBus.Introspectable",
"Introspect")) {
const char *introspection_xml;
introspection_xml = get_introspection_xml ();
reply = dbus_message_new_method_return (msg);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &introspection_xml,
DBUS_TYPE_INVALID);
}
if (dbus_message_is_signal(msg,
INTERFACE, // interface name of the signal
NAME)) {
if (dbus_message_iter_init(msg, &args)) {
if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
int redalert = FALSE;
dbus_message_iter_get_basic(&args, &sigvalue);
if (strcmp(sigvalue, REDALERT) == 0) {
redalert = TRUE;
}
if (dbus_message_iter_next(&args)) {
if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
dbus_message_iter_get_basic(&args, &sigvalue);
}
}
alert_func(data, redalert, sigvalue);
return DBUS_HANDLER_RESULT_HANDLED;
}
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult FcitxDBusMenuEventHandler(DBusConnection* connection, DBusMessage* message, void* user_data)
{
FcitxNotificationItem* notificationitem = user_data;
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
DBusMessage *reply = NULL;
boolean flush = false;
if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) {
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_menu_interface, DBUS_TYPE_INVALID);
} else if (dbus_message_is_method_call(message, DBUS_MENU_IFACE, "Event")) {
/* this is no reply */
FcitxDBusMenuEvent(notificationitem, message);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message, DBUS_MENU_IFACE, "GetProperty")) {
reply = FcitxDBusMenuGetProperty(notificationitem, message);
} else if (dbus_message_is_method_call(message, DBUS_MENU_IFACE, "GetLayout")) {
reply = FcitxDBusMenuGetLayout(notificationitem, message);
} else if (dbus_message_is_method_call(message, DBUS_MENU_IFACE, "GetGroupProperties")) {
reply = FcitxDBusMenuGetGroupProperties(notificationitem, message);
} else if (dbus_message_is_method_call(message, DBUS_MENU_IFACE, "AboutToShow")) {
reply = FcitxDBusMenuAboutToShow(notificationitem, message);
} else if (dbus_message_is_method_call(message, DBUS_INTERFACE_PROPERTIES, "Get")) {
reply = FcitxDBusPropertyGet(notificationitem, dbusMenuPropertyTable, message);
} else if (dbus_message_is_method_call(message, DBUS_INTERFACE_PROPERTIES, "Set")) {
reply = FcitxDBusPropertySet(notificationitem, dbusMenuPropertyTable, message);
} else if (dbus_message_is_method_call(message, DBUS_INTERFACE_PROPERTIES, "GetAll")) {
reply = FcitxDBusPropertyGetAll(notificationitem, dbusMenuPropertyTable, message);
}
if (reply) {
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
if (flush) {
dbus_connection_flush(connection);
}
result = DBUS_HANDLER_RESULT_HANDLED;
}
return result;
}
int main()
{
DBusError error;
DBusConnection *connection;
int ret;
dbus_bool_t flag;
dbus_error_init(&error);
connection=dbus_bus_get(DBUS_BUS_SESSION,&error);
if (dbus_error_is_set(&error))
{
printf("error\n");
exit(1);
}
flag=dbus_bus_register(connection,&error);
ret=dbus_bus_request_name(connection,"org.jinhui.dbus",DBUS_NAME_FLAG_ALLOW_REPLACEMENT,&error);
printf("request name successfully\n");
if (dbus_error_is_set(&error))
{
printf("error\n");
exit(1);
}
dbus_bus_add_match(connection, "type='signal',interface='org.jinhui.iface'",&error);
dbus_connection_flush(connection);
DBusMessage *msg;
while ( 1 )
{
flag=dbus_connection_read_write(connection,1);
msg=dbus_connection_pop_message(connection);
if (!flag)
{
printf("Invalid message\n");
continue;
}
//printf("Message received\n");
if (msg!=NULL && dbus_message_is_method_call(msg,"org.jinhui.iface","hello"))
{
printf("send to hello method\n");
reply_to_hello_method(connection,msg);
}
}
dbus_connection_unref(connection);
}
