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;
}
