void connman_dbus_property_append_fixed_array(DBusMessageIter *iter, const char *key, int type, void *val, int len) { DBusMessageIter value, array; const char *variant_sig, *array_sig; switch (type) { case DBUS_TYPE_BYTE: variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING; array_sig = DBUS_TYPE_BYTE_AS_STRING; break; default: return; } dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, variant_sig, &value); dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, array_sig, &array); dbus_message_iter_append_fixed_array(&array, type, val, len); dbus_message_iter_close_container(&value, &array); dbus_message_iter_close_container(iter, &value); }
static void cb_GetCapabilities(DBusConnection *connection, DBusMessage *message) { DBusMessage *message_reply = NULL; DBusMessageIter arguments; const char *capabilities[] = { "body" }; const char **capabilities_pointer = capabilities; size_t capabilities_amount = 1; message_reply = dbus_message_new_method_return(message); dbus_message_iter_init_append(message_reply, &arguments); if(!dbus_message_iter_append_fixed_array(&arguments, DBUS_TYPE_STRING, &capabilities_pointer, capabilities_amount)) { fprintf(stderr, "Failed to append capabilities.\n"); return; } if(!dbus_connection_send(connection, message_reply, NULL)) { fprintf(stderr, "Failed to send capabilities.\n"); } dbus_connection_flush(connection); dbus_message_unref(message_reply); }
void pa_dbus_append_proplist(DBusMessageIter *iter, pa_proplist *proplist) { DBusMessageIter dict_iter; DBusMessageIter dict_entry_iter; DBusMessageIter array_iter; void *state = NULL; const char *key; pa_assert(iter); pa_assert(proplist); pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{say}", &dict_iter)); while ((key = pa_proplist_iterate(proplist, &state))) { const void *value = NULL; size_t nbytes; pa_assert_se(pa_proplist_get(proplist, key, &value, &nbytes) >= 0); pa_assert_se(dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter)); pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, &key)); pa_assert_se(dbus_message_iter_open_container(&dict_entry_iter, DBUS_TYPE_ARRAY, "y", &array_iter)); pa_assert_se(dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, &value, nbytes)); pa_assert_se(dbus_message_iter_close_container(&dict_entry_iter, &array_iter)); pa_assert_se(dbus_message_iter_close_container(&dict_iter, &dict_entry_iter)); } pa_assert_se(dbus_message_iter_close_container(iter, &dict_iter)); }
static void append_array_variant(DBusMessageIter *iter, int type, void *val, int n_elements) { DBusMessageIter variant, array; char type_sig[2] = { type, '\0' }; char array_sig[3] = { DBUS_TYPE_ARRAY, type, '\0' }; dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, array_sig, &variant); dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig, &array); if (dbus_type_is_fixed(type) == TRUE) { dbus_message_iter_append_fixed_array(&array, type, val, n_elements); } else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) { const char ***str_array = val; int i; for (i = 0; i < n_elements; i++) dbus_message_iter_append_basic(&array, type, &((*str_array)[i])); } dbus_message_iter_close_container(&variant, &array); dbus_message_iter_close_container(iter, &variant); }
static DBusHandlerResult request_graphics_get_data(DBusConnection *connection, DBusMessage *message) { struct graphics *graphics; char *data; struct graphics_data_image *image; DBusMessage *reply; graphics = object_get_from_message(message, "graphics"); if (! graphics) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &data, DBUS_TYPE_INVALID)) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; image=graphics_get_data(graphics, data); if (image) { DBusMessageIter iter1,iter2; reply = dbus_message_new_method_return(message); #if 0 dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID); #endif dbus_message_iter_init_append(reply, &iter1); dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, "y", &iter2); if (image->data && image->size) dbus_message_iter_append_fixed_array(&iter2, DBUS_TYPE_BYTE, &image->data, image->size); dbus_message_iter_close_container(&iter1, &iter2); dbus_connection_send (connection, reply, NULL); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
EAPI Eina_Bool eldbus_message_iter_fixed_array_append(Eldbus_Message_Iter *iter, int type, const void *array, unsigned int size) { ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE); EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE); EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_type_is_basic(type), EINA_FALSE); return dbus_message_iter_append_fixed_array(&iter->dbus_iterator, type, &array, (int)size); }
static void write_setup(DBusMessageIter *iter, void *user_data) { struct iovec *iov = user_data; DBusMessageIter array; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "y", &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &iov->iov_base, iov->iov_len); dbus_message_iter_close_container(iter, &array); }
static void message_append_byte_array(DBusMessage *msg, const uint8_t *bytes, size_t len) { DBusMessageIter iter, array; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "y", &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &bytes, len); dbus_message_iter_close_container(&iter, &array); }
static void read_cb(struct gatt_db_attribute *attrib, int err, const uint8_t *value, size_t length, void *user_data) { DBusMessageIter *array = user_data; if (err) return; dbus_message_iter_append_fixed_array(array, DBUS_TYPE_BYTE, &value, length); }
static int append_rdata(DBusMessage *message, const void *rdata, size_t size) { DBusMessageIter iter, sub; assert(message); dbus_message_iter_init_append(message, &iter); if (!(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub)) || !(dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &rdata, size)) || !(dbus_message_iter_close_container(&iter, &sub))) return -1; return 0; }
static bool chr_read(struct characteristic *chr, DBusMessageIter *iter) { DBusMessageIter array; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &chr->value, chr->vlen); dbus_message_iter_close_container(iter, &array); return true; }
static bool desc_read(struct descriptor *desc, DBusMessageIter *iter) { DBusMessageIter array; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); if (desc->vlen && desc->value) dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &desc->value, desc->vlen); dbus_message_iter_close_container(iter, &array); return true; }
static gboolean get_configuration(const GDBusPropertyTable *property, DBusMessageIter *iter, void *data) { struct media_transport *transport = data; DBusMessageIter array; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &transport->configuration, transport->size); dbus_message_iter_close_container(iter, &array); return TRUE; }
static gboolean chr_get_value(const GDBusPropertyTable *property, DBusMessageIter *iter, void *user_data) { struct characteristic *chr = user_data; DBusMessageIter array; printf("Characteristic(%s): Get(\"Value\")\n", chr->uuid); dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &chr->value, chr->vlen); dbus_message_iter_close_container(iter, &array); return TRUE; }
static ssize_t synce_write(void *object, const void *buf, size_t count) { struct synce_context *context = object; DBusMessage *msg; DBusMessageIter iter, array_iter; DBusPendingCall *call; const char *type = obex_get_type(context->os); if (context->lasterr == 0) return count; if (!context->conn_obj) return -EFAULT; msg = dbus_message_new_method_call(SYNCE_BUS_NAME, context->conn_obj, SYNCE_CONN_INTERFACE, "Process"); if (!msg) return -EFAULT; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array_iter); dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, &buf, count); dbus_message_iter_close_container(&iter, &array_iter); dbus_message_append_args(msg, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID); if (!dbus_connection_send_with_reply(context->dbus_conn, msg, &call, -1)) { error("D-Bus call to %s failed.", SYNCE_CONN_INTERFACE); dbus_message_unref(msg); return -EPERM; } dbus_pending_call_set_notify(call, process_cb, context, NULL); dbus_message_unref(msg); dbus_pending_call_unref(call); return -EAGAIN; }
static void set_pid(DBusMessageIter *props, int pid) { DBusMessageIter t, a, v; const char *key = "PIDs"; const char *type_str = "au"; const dbus_int32_t pids[] = { pid }; const dbus_int32_t *p = pids; dbus_message_iter_open_container(props, DBUS_TYPE_STRUCT, NULL, &t); dbus_message_iter_append_basic(&t, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&t, 'v', type_str, &v); dbus_message_iter_open_container(&v, 'a', "u", &a); dbus_message_iter_append_fixed_array(&a, 'u', &p, 1); dbus_message_iter_close_container(&v, &a); dbus_message_iter_close_container(&t, &v); dbus_message_iter_close_container(props, &t); }
static gboolean desc_get_value(const GDBusPropertyTable *property, DBusMessageIter *iter, void *user_data) { struct descriptor *desc = user_data; DBusMessageIter array; printf("Descriptor(%s): Get(\"Value\")\n", desc->uuid); dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); if (desc->vlen && desc->value) dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &desc->value, desc->vlen); dbus_message_iter_close_container(iter, &array); return TRUE; }
static int append_string_list(DBusMessage *message, AvahiStringList *txt) { DBusMessageIter iter, sub; int r = -1; AvahiStringList *p; assert(message); dbus_message_iter_init_append(message, &iter); /* Reverse the string list, so that we can pass it in-order to the server */ txt = avahi_string_list_reverse(txt); if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "ay", &sub)) goto fail; /* Assemble the AvahiStringList into an Array of Array of Bytes to send over dbus */ for (p = txt; p != NULL; p = p->next) { DBusMessageIter sub2; const uint8_t *data = p->text; if (!(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &sub2)) || !(dbus_message_iter_append_fixed_array(&sub2, DBUS_TYPE_BYTE, &data, p->size)) || !(dbus_message_iter_close_container(&sub, &sub2))) goto fail; } if (!dbus_message_iter_close_container(&iter, &sub)) goto fail; r = 0; fail: /* Reverse the string list to the original state */ txt = avahi_string_list_reverse(txt); return r; }
static void qDBusDataToIterator(DBusMessageIter* it, const QDBusData& var) { switch (var.type()) { case QDBusData::Bool: { dbus_bool_t value = var.toBool(); dbus_message_iter_append_basic(it, DBUS_TYPE_BOOLEAN, &value); break; } case QDBusData::Byte: { Q_UINT8 value = var.toByte(); dbus_message_iter_append_basic(it, DBUS_TYPE_BYTE, &value); break; } case QDBusData::Int16: { Q_INT16 value = var.toInt16(); dbus_message_iter_append_basic(it, DBUS_TYPE_INT16, &value); break; } case QDBusData::UInt16: { Q_UINT16 value = var.toUInt16(); dbus_message_iter_append_basic(it, DBUS_TYPE_UINT16, &value); break; } case QDBusData::Int32: { Q_INT32 value = var.toInt32(); dbus_message_iter_append_basic(it, DBUS_TYPE_INT32, &value); break; } case QDBusData::UInt32: { Q_UINT32 value = var.toUInt32(); dbus_message_iter_append_basic(it, DBUS_TYPE_UINT32, &value); break; } case QDBusData::Int64: { Q_INT64 value = var.toInt64(); dbus_message_iter_append_basic(it, DBUS_TYPE_INT64, &value); break; } case QDBusData::UInt64: { Q_UINT64 value = var.toUInt64(); dbus_message_iter_append_basic(it, DBUS_TYPE_UINT64, &value); break; } case QDBusData::Double: { double value = var.toDouble(); dbus_message_iter_append_basic(it, DBUS_TYPE_DOUBLE, &value); break; } case QDBusData::String: qAppendToMessage(it, var.toString()); break; case QDBusData::ObjectPath: qAppendToMessage(it, var.toObjectPath()); break; case QDBusData::List: { QDBusDataList list = var.toList(); QCString signature = 0; if (list.hasContainerItemType()) signature = list.containerItemType().buildDBusSignature(); else signature = qDBusTypeForQDBusType(list.type()); DBusMessageIter sub; dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, signature.data(), &sub); const QValueList<QDBusData> valueList = var.toQValueList(); QValueList<QDBusData>::ConstIterator listIt = valueList.begin(); QValueList<QDBusData>::ConstIterator listEndIt = valueList.end(); for (; listIt != listEndIt; ++listIt) { qDBusDataToIterator(&sub, *listIt); } dbus_message_iter_close_container(it, &sub); break; } case QDBusData::Map: { switch (var.keyType()) { case QDBusData::Byte: qDBusByteKeyMapToIterator(it, var); break; case QDBusData::Int16: qDBusInt16KeyMapToIterator(it, var); break; case QDBusData::UInt16: qDBusUInt16KeyMapToIterator(it, var); break; case QDBusData::Int32: qDBusInt32KeyMapToIterator(it, var); break; case QDBusData::UInt32: qDBusUInt32KeyMapToIterator(it, var); break; case QDBusData::Int64: qDBusInt64KeyMapToIterator(it, var); break; case QDBusData::UInt64: qDBusUInt64KeyMapToIterator(it, var); break; case QDBusData::String: qDBusStringKeyMapToIterator(it, var); break; case QDBusData::ObjectPath: qDBusObjectPathKeyMapToIterator(it, var); break; default: qWarning("QDBusMarshall: unhandled map key type %s " "at marshalling", QDBusData::typeName(var.keyType())); break; } break; } case QDBusData::Variant: { QDBusVariant variant = var.toVariant(); if (variant.signature.isEmpty() || !variant.value.isValid()) break; DBusMessageIter sub; dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT, variant.signature.utf8(), &sub); qDBusDataToIterator(&sub, variant.value); dbus_message_iter_close_container(it, &sub); break; } case QDBusData::Struct: { QValueList<QDBusData> memberList = var.toStruct(); if (memberList.isEmpty()) break; DBusMessageIter sub; dbus_message_iter_open_container(it, DBUS_TYPE_STRUCT, NULL, &sub); QValueList<QDBusData>::ConstIterator memberIt = memberList.begin(); QValueList<QDBusData>::ConstIterator memberEndIt = memberList.end(); for (; memberIt != memberEndIt; ++memberIt) { qDBusDataToIterator(&sub, *memberIt); } dbus_message_iter_close_container(it, &sub); } #if 0 case QVariant::ByteArray: { const QByteArray array = var.toByteArray(); const char* cdata = array.data(); DBusMessageIter sub; dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub); dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.size()); dbus_message_iter_close_container(it, &sub); break; } #endif default: //qWarning("Don't know how to handle type %s", var.typeName()); break; } }
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); } }
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 register_machine(pid_t pid, const char *dest) { int rc; DBusError err; DBusConnection *conn; DBusMessageIter args; DBusMessage *req, *rep; DBusMessageIter uuid_iter, scope_iter; _free_ char *name = NULL; char *app = "pflask"; unsigned char uuid[16]; char *type = "container"; dbus_error_init(&err); rc = asprintf(&name, "pflask-%d", pid); if (rc < 0) fail_printf("OOM"); conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err); if (dbus_error_is_set(&err)) return; req = dbus_message_new_method_call( "org.freedesktop.machine1", "/org/freedesktop/machine1", "org.freedesktop.machine1.Manager", "CreateMachine" ); dbus_message_iter_init_append(req, &args); /* name */ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &name)) fail_printf("OOM"); /* id */ if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "y", &uuid_iter)) fail_printf("OOM"); if (!dbus_message_iter_append_fixed_array(&uuid_iter, DBUS_TYPE_BYTE, uuid, 0)) fail_printf("OOM"); if (!dbus_message_iter_close_container(&args, &uuid_iter)) fail_printf("OOM"); /* service */ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &app)) fail_printf("OOM"); /* type */ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type)) fail_printf("OOM"); /* leader */ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &pid)) fail_printf("OOM"); /* root */ if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &dest)) fail_printf("OOM"); /* scope properties */ if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "(sv)", &scope_iter)) fail_printf("OOM"); if (!dbus_message_iter_close_container(&args, &scope_iter)) fail_printf("OOM"); rep = dbus_connection_send_with_reply_and_block(conn, req, -1, &err); if (dbus_error_is_set(&err)) goto done; dbus_message_unref(rep); done: dbus_message_unref(req); dbus_connection_close(conn); dbus_error_free(&err); }
/** Helper for appending GConfValue to dbus message * * @param reply DBusMessage under construction * @param conf GConfValue to be added to the reply * * @return TRUE if the value was succesfully appended, or FALSE on failure */ static gboolean append_gconf_value_to_dbus_message(DBusMessage *reply, GConfValue *conf) { const char *sig = 0; DBusMessageIter body, variant, array; if( !(sig = value_signature(conf)) ) { goto bailout_message; } dbus_message_iter_init_append(reply, &body); if( !dbus_message_iter_open_container(&body, DBUS_TYPE_VARIANT, sig, &variant) ) { goto bailout_message; } switch( conf->type ) { case GCONF_VALUE_STRING: { const char *arg = gconf_value_get_string(conf) ?: ""; dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &arg); } break; case GCONF_VALUE_INT: { dbus_int32_t arg = gconf_value_get_int(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_INT32, &arg); } break; case GCONF_VALUE_FLOAT: { double arg = gconf_value_get_float(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_DOUBLE, &arg); } break; case GCONF_VALUE_BOOL: { dbus_bool_t arg = gconf_value_get_bool(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_BOOLEAN, &arg); } break; case GCONF_VALUE_LIST: if( !(sig = type_signature(gconf_value_get_list_type(conf))) ) { goto bailout_variant; } if( !dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, sig, &array) ) { goto bailout_variant; } switch( gconf_value_get_list_type(conf) ) { case GCONF_VALUE_STRING: { int cnt = 0; const char **arg = string_array_from_gconf_value(conf, &cnt); for( int i = 0; i < cnt; ++i ) { const char *str = arg[i]; dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &str); } g_free(arg); } break; case GCONF_VALUE_INT: { int cnt = 0; dbus_int32_t *arg = int_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_INT32, &arg, cnt); g_free(arg); } break; case GCONF_VALUE_FLOAT: { int cnt = 0; double *arg = float_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_DOUBLE, &arg, cnt); g_free(arg); } break; case GCONF_VALUE_BOOL: { int cnt = 0; dbus_bool_t *arg = bool_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BOOLEAN, &arg, cnt); g_free(arg); } break; default: goto bailout_array; } if( !dbus_message_iter_close_container(&variant, &array) ) { goto bailout_variant; } break; default: goto bailout_variant; } if( !dbus_message_iter_close_container(&body, &variant) ) { goto bailout_message; } return TRUE; bailout_array: dbus_message_iter_abandon_container(&variant, &array); bailout_variant: dbus_message_iter_abandon_container(&body, &variant); bailout_message: return FALSE; }
gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy, const char *name, int type, const void *value, size_t size, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant, array; DBusPendingCall *call; char array_sig[3]; char type_sig[2]; if (!proxy || !name || !value) return FALSE; if (!dbus_type_is_basic(type)) return FALSE; client = proxy->client; if (!client) return FALSE; data = g_try_new0(struct set_property_data, 1); if (!data) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set"); if (!msg) { g_free(data); return FALSE; } array_sig[0] = DBUS_TYPE_ARRAY; array_sig[1] = (char) type; array_sig[2] = '\0'; type_sig[0] = (char) type; type_sig[1] = '\0'; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, array_sig, &variant); dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig, &array); if (dbus_type_is_fixed(type)) dbus_message_iter_append_fixed_array(&array, type, &value, size); else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) { const char **str = (const char **) value; size_t i; for (i = 0; i < size; i++) dbus_message_iter_append_basic(&array, type, &str[i]); } dbus_message_iter_close_container(&variant, &array); dbus_message_iter_close_container(&iter, &variant); if (g_dbus_send_message_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, set_property_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; }
static dbus_bool_t GalagoNotification_messageAppendIconHint( DBusMessageIter *iter, const Image *image) { DBusMessageIter entryIter; const char *str = "icon_data"; DBusMessageIter varIter; DBusMessageIter structIter; DBusMessageIter arrayIter; if (!dbus_message_iter_open_container( iter, DBUS_TYPE_DICT_ENTRY, NULL, &entryIter)) return FALSE; if (!dbus_message_iter_append_basic(&entryIter, DBUS_TYPE_STRING, &str)) return FALSE; if (!dbus_message_iter_open_container( &entryIter, DBUS_TYPE_VARIANT, "(iiibiiay)", &varIter)) return FALSE; if (!dbus_message_iter_open_container( &varIter, DBUS_TYPE_STRUCT, NULL, &structIter)) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_INT32, &(image->width))) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_INT32, &(image->height))) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_INT32, &(image->rowstride))) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_BOOLEAN, &(image->hasAlpha))) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_INT32, &(image->bitsPerSample))) return FALSE; if (!dbus_message_iter_append_basic( &structIter, DBUS_TYPE_INT32, &(image->channels))) return FALSE; if (!dbus_message_iter_open_container( &structIter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &arrayIter)) return FALSE; if (!dbus_message_iter_append_fixed_array( &arrayIter, DBUS_TYPE_BYTE, &(image->data), image->dataLength)) return FALSE; if (!dbus_message_iter_close_container(&structIter, &arrayIter)) return FALSE; if (!dbus_message_iter_close_container(&varIter, &structIter)) return FALSE; if (!dbus_message_iter_close_container(&entryIter, &varIter)) return FALSE; if (!dbus_message_iter_close_container(iter, &entryIter)) return FALSE; return TRUE; }
int main() { DBusConnection* connection; DBusError error; DBusMessage* msg; DBusMessage* reply = NULL; dbus_int32_t int_32 = -32; double d = 1.1234; char* str = "DBus Testing"; const char* sign; const char* sub_sign; const char* iter_sign; const char* iter_sign1; dbus_int32_t type; dbus_int32_t arr[] = {0,1,2,3,4,5,6,7,8,9}; dbus_int32_t* v_arr = arr; DBusMessageIter iter; DBusMessageIter sub_iter; DBusMessageIter sub_iter1; struct SignTest { int num1; int num2; int num3; }st; dbus_error_init(&error); connection = dbus_bus_get(DBUS_BUS_SESSION, &error); if(!connection || dbus_error_is_set(&error)) return handle_error(&error); msg = dbus_message_new_method_call("Test.Method.Call", "/Test/Method/Object", NULL, "sign_test"); if(!msg) { std_log(LOG_FILENAME_LINE, "msg is NULL"); create_xml(1); return 1; } st.num1 = 100; st.num2 = 200; st.num3 = 300; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &int_32); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &str); dbus_message_iter_open_container(&iter, DBUS_TYPE_STRUCT, NULL, &sub_iter); dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_INT32, &st.num1); dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_INT32, &st.num2); dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_INT32, &st.num3); dbus_message_iter_close_container(&iter, &sub_iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_INT32_AS_STRING, &sub_iter1); dbus_message_iter_append_fixed_array(&sub_iter1, DBUS_TYPE_INT32, &v_arr, 10); dbus_message_iter_close_container(&iter, &sub_iter1); dbus_message_iter_append_basic(&iter, DBUS_TYPE_DOUBLE, &d); reply = dbus_connection_send_with_reply_and_block(connection, msg, 10000, &error); if(!reply) return handle_error(&error); if(!dbus_message_get_args(reply, &error, DBUS_TYPE_SIGNATURE, &sign, DBUS_TYPE_SIGNATURE, &sub_sign, DBUS_TYPE_INT32, &type, DBUS_TYPE_SIGNATURE, &iter_sign, DBUS_TYPE_SIGNATURE, &iter_sign1, DBUS_TYPE_INVALID)) return handle_error(&error); std_log(LOG_FILENAME_LINE, "Signature :: %s\n\tSubSignature :: %s\n\tType :: %c\n\tMessageIterSignature :: %s\n\tMessageIterSignature1 :: %s", sign, sub_sign, type, iter_sign, iter_sign1); if(!dbus_message_has_signature(msg, sign)) { std_log(LOG_FILENAME_LINE, "Signature returned is not correct."); create_xml(1); return 1; } if(strcmp("i", iter_sign)) { std_log(LOG_FILENAME_LINE, "Signature returned is not correct."); create_xml(1); return 1; } if(strcmp("(iii)", sub_sign)) { std_log(LOG_FILENAME_LINE, "SubSignature returned is not correct."); create_xml(1); return 1; } if(strcmp("(iii)", iter_sign1)) { std_log(LOG_FILENAME_LINE, "SubSignature returned is not correct."); create_xml(1); return 1; } if('i' != type) { std_log(LOG_FILENAME_LINE, "type returned is not correct"); create_xml(1); return 1; } dbus_message_unref(msg); dbus_message_unref(reply); dbus_connection_unref(connection); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); return 0; }
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; }
static int tapi_transceive(uint8_t ctrl_idx, uint32_t se_idx, uint8_t *apdu, size_t apdu_length, transceive_cb_t cb, void *context) { DBusMessage *message; DBusMessageIter iter; DBusMessageIter value, array; DBusPendingCall *call; struct tapi_transceive_context *ctx; int err; DBG("%zd APDU %p", apdu_length, apdu); if (default_modem == NULL) { err = -EIO; goto fail; } ctx = g_try_malloc0(sizeof(struct tapi_transceive_context)); if (ctx == NULL) { err = -ENOMEM; goto fail; } ctx->context = context; ctx->cb = cb; message = dbus_message_new_method_call(TELEPHONY_SERVICE, default_modem->path, SIM_INTERFACE, TRANSFER_APDU); if (message == NULL) { err = -ENOMEM; goto fail; } dbus_message_iter_init_append(message, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING, &value); dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &apdu, apdu_length); dbus_message_iter_close_container(&value, &array); dbus_message_iter_close_container(&iter, &value); if (dbus_connection_send_with_reply(connection, message, &call, -1) == FALSE) { DBG("Failed to Transfer APDU through UICC"); dbus_message_unref(message); err = -EINVAL; goto fail; } if (call == NULL) { DBG("D-Bus connection not available"); dbus_message_unref(message); err = -EINVAL; goto fail; } dbus_pending_call_set_notify(call, tapi_transfer_apdu_reply, ctx, NULL); dbus_message_unref(message); return 0; fail: cb(context, NULL, 0, err); if (ctx != NULL) g_free(ctx); return err; }
static int method_get_clipboard(LassiConnection *lc, DBusMessage *m) { DBusError e; char *type; gboolean primary; DBusMessage *n = NULL; gint32 f; gpointer p = NULL; int l = 0; DBusMessageIter iter, sub; gboolean b; dbus_error_init(&e); if (!(dbus_message_get_args(m, &e, DBUS_TYPE_BOOLEAN, &primary, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID))) { g_warning("Received invalid message: %s", e.message); dbus_error_free(&e); return -1; } if ((primary && (lc->server->primary_connection || lc->server->primary_empty)) || (!primary && (lc->server->clipboard_connection || lc->server->clipboard_empty))) { n = dbus_message_new_error(m, LASSI_INTERFACE ".NotOwner", "We're not the clipboard owner"); goto finish; } if (lassi_clipboard_get(&lc->server->clipboard_info, primary, type, &f, &p, &l) < 0) { n = dbus_message_new_error(m, LASSI_INTERFACE ".ClipboardFailure", "Failed to read clipboard data"); goto finish; } if (l > dbus_connection_get_max_message_size(lc->dbus_connection)*9/10) { n = dbus_message_new_error(m, LASSI_INTERFACE ".TooLarge", "Clipboard data too large"); goto finish; } n = dbus_message_new_method_return(m); g_assert(n); dbus_message_iter_init_append(n, &iter); b = dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &f); g_assert(b); b = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &sub); g_assert(b); b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &p, l); g_assert(b); b = dbus_message_iter_close_container(&iter, &sub); g_assert(b); finish: g_assert(n); dbus_connection_send(lc->dbus_connection, n, NULL); dbus_message_unref(n); g_free(p); return 0; }
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; }