static dbus_bool_t
generate_trivial_inner (DBusMessageDataIter *iter,
DBusMessage **message_p)
{
DBusMessage *message;
switch (iter_get_sequence (iter))
{
case 0:
message = dbus_message_new_method_call ("org.freedesktop.TextEditor",
"/foo/bar",
"org.freedesktop.DocumentFactory",
"Create");
break;
case 1:
message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
set_reply_serial (message);
break;
case 2:
message = dbus_message_new_signal ("/foo/bar",
"org.freedesktop.DocumentFactory",
"Created");
break;
case 3:
message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
if (!dbus_message_set_error_name (message,
"org.freedesktop.TestErrorName"))
_dbus_assert_not_reached ("oom");
{
DBusMessageIter iter;
const char *v_STRING = "This is an error";
dbus_message_iter_init_append (message, &iter);
if (!dbus_message_iter_append_basic (&iter,
DBUS_TYPE_STRING,
&v_STRING))
_dbus_assert_not_reached ("oom");
}
set_reply_serial (message);
break;
default:
return FALSE;
}
if (message == NULL)
_dbus_assert_not_reached ("oom");
*message_p = message;
return TRUE;
}
int main()
{
DBusMessage* msg;
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
if(!msg)
{
std_log(LOG_FILENAME_LINE,"Fail to create Message");
create_xml(1);
return 1;
}
if(DBUS_MESSAGE_TYPE_METHOD_CALL != dbus_message_get_type(msg))
{
std_log(LOG_FILENAME_LINE,"Mismatch in Message type.");
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE,"Test Successful");
create_xml(0);
return 0;
}
int main()
{
DBusMessage* msg;
char* path = "/";
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
if(!msg)
{
std_log(LOG_FILENAME_LINE,"Fail to create Message");
create_xml(1);
return 1;
}
if(!dbus_message_set_path(msg, path))
{
std_log(LOG_FILENAME_LINE,"Not enough Memory.");
create_xml(1);
return 1;
}
if(strcmp(path, dbus_message_get_path(msg)))
{
std_log(LOG_FILENAME_LINE,"Path is not correct");
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE,"Test Successful");
create_xml(0);
return 0;
}
/*!
Constructs an empty QDBusArgument argument.
An empty QDBusArgument object does not allow either reading or
writing to be performed.
*/
QDBusArgument::QDBusArgument()
{
QDBusMarshaller *dd = new QDBusMarshaller;
d = dd;
// create a new message with any type, we won't sent it anyways
dd->message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
dbus_message_iter_init_append(dd->message, &dd->iterator);
}
static int ldbus_message_new(lua_State *L) {
int message_type = dbus_message_type_from_string(luaL_checkstring(L, 1));
DBusMessage * message = dbus_message_new(message_type);
if (message == NULL) {
return luaL_error(L, LDBUS_NO_MEMORY);
}
push_DBusMessage(L, message);
return 1;
}
static DBusMessage*
simple_method_return (void)
{
DBusMessage *message;
message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
if (message == NULL)
_dbus_assert_not_reached ("oom");
set_reply_serial (message);
return message;
}
static DBusMessage *
build_reply_from_jsval(SeedContext ctx,
const char *signature,
const char *sender,
dbus_uint32_t serial,
SeedValue rval,
SeedException *exception)
{
DBusMessage *reply;
DBusMessageIter arg_iter;
DBusSignatureIter sig_iter;
gboolean marshalled = FALSE;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_set_destination(reply, sender);
dbus_message_set_reply_serial(reply, serial);
dbus_message_set_no_reply(reply, TRUE);
dbus_message_iter_init_append(reply, &arg_iter);
if (seed_value_is_undefined (ctx, rval) || g_str_equal(signature, ""))
{
/* We don't want to send anything in these cases so skip the
* marshalling altogether.
*/
return reply;
}
dbus_signature_iter_init(&sig_iter, signature);
if (signature_has_one_element(signature))
{
marshalled = seed_js_one_value_to_dbus(ctx, rval, &arg_iter, &sig_iter, exception);
}
else
{
if (!seed_value_is_object (ctx, rval))
{
g_warning("Signature has multiple items but return value is not an array");
return reply;
}
marshalled = seed_js_values_to_dbus(ctx, 0, rval, &arg_iter, &sig_iter, exception);
}
if (!marshalled) {
/* replace our planned reply with an error */
dbus_message_unref(reply);
if (!dbus_reply_from_exception_and_sender(ctx, sender, serial, &reply, exception))
g_warning ("conversion of dbus return value failed but no exception was set?");
}
return reply;
}
DBusMessage * dbus_connection_send_with_reply_and_block (
DBusConnection *connection,
DBusMessage *message,
int timeout_milliseconds,
DBusError *error)
{
Q_UNUSED(connection);
Q_UNUSED(message);
Q_UNUSED(timeout_milliseconds);
Q_UNUSED(error);
Ut_VolumeBarLogic::dbus_connection_send_with_reply_and_block = true;
return dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
static gboolean
dbus_reply_from_exception_and_sender(SeedContext ctx,
const gchar *sender,
dbus_uint32_t serial,
DBusMessage **reply_p,
SeedException *exception)
{
SeedValue name_val;
gchar *s;
const gchar *name = NULL;
*reply_p = NULL;
if (seed_value_is_undefined (ctx, *exception) ||
seed_value_is_null (ctx, *exception) ||
!seed_value_is_object (ctx, *exception))
return FALSE;
name_val = seed_object_get_property(ctx, *exception, "dbusErrorName");
name = seed_value_to_string (ctx, name_val, NULL);
s = seed_exception_to_string (ctx, *exception);
g_warning("JS exception we will send as dbus reply to %s: %s",
sender,
s);
*reply_p = dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
dbus_message_set_destination(*reply_p, sender);
dbus_message_set_reply_serial(*reply_p, serial);
dbus_message_set_no_reply(*reply_p, TRUE);
dbus_message_set_error_name(*reply_p, name ? name : DBUS_ERROR_FAILED);
if (s != NULL) {
DBusMessageIter iter;
dbus_message_iter_init_append(*reply_p, &iter);
if (!dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING,
&s)) {
dbus_message_unref(*reply_p);
g_free(s);
return FALSE;
}
g_free(s);
}
return TRUE;
}
static DBusMessage*
simple_error (void)
{
DBusMessage *message;
message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
if (message == NULL)
_dbus_assert_not_reached ("oom");
if (!dbus_message_set_error_name (message, "foo.bar"))
_dbus_assert_not_reached ("oom");
set_reply_serial (message);
return message;
}
int bind_dbus_message_new( lua_State * const _L)
{
utils_check_nargs( _L, 1);
int message_type = utils_convert_to_message_type( _L, 1);
DBusMessage *message = dbus_message_new( message_type);
if( message == 0x0)
{
lua_pushnil( _L);
return 1;
}
else
{
return push_dbus_message( _L, message);
}
}
DBusMessage * dbus_message_new_method_call (
const char *bus_name,
const char *path,
const char *interface,
const char *method)
{
Q_UNUSED(bus_name);
Q_UNUSED(path);
Q_UNUSED(interface);
Q_UNUSED(method);
Ut_VolumeBarLogic::dbus_message_new_method_call = true;
DBusMessage *dbm = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
if(dbm == 0)
QTest::qWarn("DBusMessage == NULL");
return dbm;
}
static void prop_entry_update(struct prop_entry *prop, DBusMessageIter *iter)
{
DBusMessage *msg;
DBusMessageIter base;
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
if (msg == NULL)
return;
dbus_message_iter_init_append(msg, &base);
iter_append_iter(&base, iter);
if (prop->msg != NULL)
dbus_message_unref(prop->msg);
prop->msg = dbus_message_copy(msg);
dbus_message_unref(msg);
}
static struct sbus_request *
mock_sbus_request(TALLOC_CTX *mem_ctx, uid_t client)
{
struct sbus_request *sr;
sr = talloc_zero(mem_ctx, struct sbus_request);
assert_non_null(sr);
sr->conn = talloc_zero(sr, struct sbus_connection);
assert_non_null(sr->conn);
sr->message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
assert_non_null(sr->message);
dbus_message_set_serial(sr->message, 1);
sr->client = client;
return sr;
}
void sbus_int_test_get_uid(void **state)
{
errno_t ret;
struct tevent_req *req;
DBusMessage *reply;
struct sbus_get_id_ctx *test_ctx = talloc_get_type(*state,
struct sbus_get_id_ctx);
uint32_t uid;
test_ctx->expected = 42;
uid = test_ctx->expected;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
assert_non_null(reply);
dbus_message_append_args(reply,
DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
will_return(__wrap_dbus_pending_call_steal_reply, reply);
req = sbus_get_sender_id_send(test_ctx, test_ctx->stc->ev,
test_ctx->conn, __FILE__);
tevent_req_set_callback(req, sbus_int_test_get_uid_done, test_ctx);
ret = test_ev_loop(test_ctx->stc);
assert_int_equal(ret, EOK);
assert_int_equal(test_ctx->last_hash_lookup, HASH_ERROR_KEY_NOT_FOUND);
/* Now do the same lookup again, just make sure the result was cached */
req = sbus_get_sender_id_send(test_ctx, test_ctx->stc->ev,
test_ctx->conn, __FILE__);
tevent_req_set_callback(req, sbus_int_test_get_uid_done, test_ctx);
ret = test_ev_loop(test_ctx->stc);
assert_int_equal(ret, EOK);
assert_int_equal(test_ctx->last_hash_lookup, HASH_SUCCESS);
}
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;
}
int main()
{
DBusMessage* msg;
dbus_int32_t data_slot = -1;
TestData data;
TestData* data1;
DBusFreeFunction free_data;
//_LIT(KOOM, "Out of Memory");
//_LIT(KFreeFail, "Free Function is not called");
//_LIT(KDataFail, "Fail to retrieve data");
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
if(!dbus_message_allocate_data_slot(&data_slot))
{
std_log(LOG_FILENAME_LINE,"Out of Memory");
create_xml(1);
return 1;
}
data.num = 20;
data.str = (char*)malloc(data.num);
data_free_flag = FALSE;
strcpy(data.str, "CheckDBus");
free_data = Free_Test_Data;
if(!dbus_message_set_data(msg, data_slot, (void*)&data, free_data))
{
std_log(LOG_FILENAME_LINE,"Out of Memory");
create_xml(1);
return 1;
}
data1 = (TestData*)dbus_message_get_data(msg, data_slot);
if(!data1)
{
std_log(LOG_FILENAME_LINE,"Fail to retrieve data");
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE,"Data :: \n\tInteger value(20) = %d\n\tString value(CheckDBus) = %s", data1->num, data1->str);
data.num = 30;
data.str = (char*)malloc(data.num);
data_free_flag = FALSE;
strcpy(data.str, "CheckDBusFree");
free_data = Free_Test_Data;
if(!dbus_message_set_data(msg, data_slot, (void*)&data, free_data))
{
std_log(LOG_FILENAME_LINE,"Out of Memory");
create_xml(1);
return 1;
}
if(!data_free_flag)
{
std_log(LOG_FILENAME_LINE,"Free Function is not called");
create_xml(1);
return 1;
}
dbus_message_free_data_slot(&data_slot);
std_log(LOG_FILENAME_LINE,"Test Successful");
create_xml(0);
return 0;
}
void test_el_to_dict(void **state)
{
TALLOC_CTX *tmp_ctx;
DBusMessage *message;
dbus_bool_t dbret;
DBusMessageIter iter;
DBusMessageIter iter_dict;
struct ldb_message_element *el;
errno_t ret;
char *attr_name;
char *attr_val;
tmp_ctx = talloc_new(NULL);
assert_non_null(tmp_ctx);
message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
assert_non_null(message);
el = talloc(tmp_ctx, 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(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(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));
talloc_free(tmp_ctx);
}
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.PolicyKit1") &&
STREQ(member, "CheckAuthorization")) {
char *type;
char *pidkey;
unsigned int pidval;
char *timekey;
unsigned long long timeval;
char *uidkey;
int uidval;
char *actionid;
char **details;
size_t detailslen;
int allowInteraction;
char *cancellationId;
const char **retdetails = NULL;
size_t retdetailslen = 0;
const char *retdetailscancelled[] = {
"polkit.dismissed", "true",
};
int is_authorized = 1;
int is_challenge = 0;
if (virDBusMessageRead(message,
"(sa{sv})sa&{ss}us",
&type,
3,
&pidkey, "u", &pidval,
&timekey, "t", &timeval,
&uidkey, "i", &uidval,
&actionid,
&detailslen,
&details,
&allowInteraction,
&cancellationId) < 0)
goto error;
if (STREQ(actionid, "org.libvirt.test.success")) {
is_authorized = 1;
is_challenge = 0;
} else if (STREQ(actionid, "org.libvirt.test.challenge")) {
is_authorized = 0;
is_challenge = 1;
} else if (STREQ(actionid, "org.libvirt.test.cancelled")) {
is_authorized = 0;
is_challenge = 0;
retdetails = retdetailscancelled;
retdetailslen = ARRAY_CARDINALITY(retdetailscancelled) / 2;
} else if (STREQ(actionid, "org.libvirt.test.details")) {
size_t i;
is_authorized = 0;
is_challenge = 0;
for (i = 0; i < detailslen / 2; i++) {
if (STREQ(details[i * 2],
"org.libvirt.test.person") &&
STREQ(details[(i * 2) + 1],
"Fred")) {
is_authorized = 1;
is_challenge = 0;
}
}
} else {
is_authorized = 0;
is_challenge = 0;
}
VIR_FREE(type);
VIR_FREE(pidkey);
VIR_FREE(timekey);
VIR_FREE(uidkey);
VIR_FREE(actionid);
VIR_FREE(cancellationId);
virStringListFreeCount(details, detailslen);
if (virDBusCreateReply(&reply,
"(bba&{ss})",
is_authorized,
is_challenge,
retdetailslen,
retdetails) < 0)
goto error;
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
return reply;
error:
virDBusMessageUnref(reply);
return NULL;
}
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);
size_t i;
size_t nargs = 0;
char **args = NULL;
char *type = NULL;
VIR_MOCK_REAL_INIT(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:
virDBusMessageUnref(reply);
reply = NULL;
if (error && !dbus_error_is_set(error))
dbus_set_error_const(error,
"org.firewalld.error",
"something unexpected happened");
goto cleanup;
}
IBusMessage *
ibus_message_new (gint message_type)
{
return dbus_message_new (message_type);
}
static int create_configuration(DBusMessage *msg, connection_ready_cb callback)
{
DBusMessage *new_msg = NULL;
DBusPendingCall *call;
DBusMessageIter iter, array, new_iter, new_dict;
const char *type = NULL, *name = NULL;
const char *host = NULL, *domain = NULL;
char *ident, *me = NULL;
int err = 0;
dbus_bool_t result;
struct connection_data *data;
struct config_create_data *user_data = NULL;
GSList *networks = NULL;
/*
* We copy the old message data into new message. We cannot
* just use the old message as is because the user route
* information is not in the same format in vpnd.
*/
new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
dbus_message_iter_init_append(new_msg, &new_iter);
connman_dbus_dict_open(&new_iter, &new_dict);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
void *item_value;
const char *key;
int value_type;
dbus_message_iter_recurse(&array, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
value_type = dbus_message_iter_get_arg_type(&value);
item_value = NULL;
switch (value_type) {
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(&value, &item_value);
if (g_str_equal(key, "Type") == TRUE) {
type = (const char *)item_value;
} else if (g_str_equal(key, "Name") == TRUE) {
name = (const char *)item_value;
} else if (g_str_equal(key, "Host") == TRUE) {
host = (const char *)item_value;
} else if (g_str_equal(key, "VPN.Domain") == TRUE) {
domain = (const char *)item_value;
}
DBG("%s %s", key, (char *)item_value);
if (item_value != NULL)
connman_dbus_dict_append_basic(&new_dict, key,
value_type, &item_value);
break;
case DBUS_TYPE_ARRAY:
if (g_str_equal(key, "Networks") == TRUE) {
networks = get_user_networks(&value);
connman_dbus_dict_append_array(&new_dict,
"UserRoutes",
DBUS_TYPE_DICT_ENTRY,
append_routes,
networks);
}
break;
}
dbus_message_iter_next(&array);
}
connman_dbus_dict_close(&new_iter, &new_dict);
DBG("VPN type %s name %s host %s domain %s networks %p",
type, name, host, domain, networks);
if (host == NULL || domain == NULL) {
err = -EINVAL;
goto done;
}
if (type == NULL || name == NULL) {
err = -EOPNOTSUPP;
goto done;
}
ident = g_strdup_printf("%s_%s", host, domain);
set_dbus_ident(ident);
DBG("ident %s", ident);
data = g_hash_table_lookup(vpn_connections, ident);
if (data != NULL) {
if (data->call != NULL || data->cb_data != NULL) {
DBG("create configuration call already pending");
err = -EINPROGRESS;
goto done;
}
} else {
char *path = g_strdup_printf("%s/connection/%s", VPN_PATH,
ident);
data = create_connection_data(path);
g_free(path);
if (data == NULL) {
err = -ENOMEM;
goto done;
}
g_hash_table_insert(vpn_connections, g_strdup(ident), data);
}
/*
* User called net.connman.Manager.ConnectProvider if we are here.
* So use the data from original message in the new msg.
*/
me = g_strdup(dbus_message_get_destination(msg));
dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE);
dbus_message_set_path(new_msg, "/");
dbus_message_set_destination(new_msg, VPN_SERVICE);
dbus_message_set_sender(new_msg, me);
dbus_message_set_member(new_msg, "Create");
user_data = g_try_new0(struct config_create_data, 1);
if (user_data == NULL) {
err = -ENOMEM;
goto done;
}
user_data->callback = callback;
user_data->message = dbus_message_ref(msg);
user_data->path = NULL;
DBG("cb %p msg %p", user_data, msg);
result = dbus_connection_send_with_reply(connection, new_msg,
&call, DBUS_TIMEOUT);
if (result == FALSE || call == NULL) {
err = -EIO;
goto done;
}
dbus_pending_call_set_notify(call, configuration_create_reply,
user_data, NULL);
data->call = call;
done:
if (new_msg != NULL)
dbus_message_unref(new_msg);
if (networks != NULL)
g_slist_free_full(networks, destroy_route);
g_free(me);
return err;
}
