static DBusMessage*
service_property_get (GkdSecretService *self, DBusMessage *message)
{
DBusMessage *reply = NULL;
DBusMessageIter iter;
const gchar *interface;
const gchar *name;
if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
return NULL;
if (!gkd_dbus_interface_match (SECRET_SERVICE_INTERFACE, interface))
return dbus_message_new_error_printf (message, DBUS_ERROR_FAILED,
"Object does not have properties on interface '%s'",
interface);
/* The "Collections" property */
if (g_str_equal (name, "Collections")) {
reply = dbus_message_new_method_return (message);
dbus_message_iter_init_append (reply, &iter);
gkd_secret_objects_append_collection_paths (self->objects, &iter, message);
/* No such property */
} else {
reply = dbus_message_new_error_printf (message, DBUS_ERROR_FAILED,
"Object does not have the '%s' property", name);
}
return reply;
}
static DBusHandlerResult handle_set(DBusConnection *conn, DBusMessage *msg, pa_dbusobj_server_lookup *sl) {
DBusHandlerResult r = DBUS_HANDLER_RESULT_HANDLED;
const char* interface;
const char* property;
DBusMessage *reply = NULL;
pa_assert(conn);
pa_assert(msg);
pa_assert(sl);
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) {
if (!(reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, "Invalid arguments"))) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!dbus_connection_send(conn, reply, NULL)) {
r = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto finish;
}
r = DBUS_HANDLER_RESULT_HANDLED;
goto finish;
}
if (*interface && !pa_streq(interface, INTERFACE)) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!pa_streq(property, "Address")) {
if (!(reply = dbus_message_new_error_printf(msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "%s: No such property", property))) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!dbus_connection_send(conn, reply, NULL)) {
r = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto finish;
}
r = DBUS_HANDLER_RESULT_HANDLED;
goto finish;
}
if (!(reply = dbus_message_new_error_printf(msg, DBUS_ERROR_ACCESS_DENIED, "%s: Property not settable", property))) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!dbus_connection_send(conn, reply, NULL)) {
r = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto finish;
}
r = DBUS_HANDLER_RESULT_HANDLED;
finish:
if (reply)
dbus_message_unref(reply);
return r;
}
static void
setting_arrived(const char *key,
const char *value,
void *data)
{
SettingArrivedData *sad = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter variant_iter;
if (value == NULL) {
g_debug("No value known for '%s' with type '%s'",
value, sad->signature);
reply = dbus_message_new_error_printf(sad->method_call, HIPPO_DBUS_PREFS_ERROR_NOT_FOUND,
_("No value known for key '%s'"), key);
goto out;
}
reply = dbus_message_new_method_return(sad->method_call);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sad->signature,
&variant_iter);
if (!parse_and_append_value(sad->signature,
value,
&variant_iter,
FALSE)) {
g_debug("Failed to parse '%s' as type '%s'",
value, sad->signature);
dbus_message_unref(reply);
reply = dbus_message_new_error_printf(sad->method_call, HIPPO_DBUS_PREFS_ERROR_WRONG_TYPE,
_("Value was '%s' not parseable as type '%s'"),
value, sad->signature);
goto out;
} else {
g_debug(" parsed value '%s' as type '%s'", value, sad->signature);
}
dbus_message_iter_close_container(&iter, &variant_iter);
out:
dbus_connection_send(sad->connection, reply, NULL);
dbus_message_unref(reply);
dbus_message_unref(sad->method_call);
g_object_unref(sad->settings);
dbus_connection_unref(sad->connection);
g_free(sad);
}
static DBusMessage*
service_property_getall (GkdSecretService *self, DBusMessage *message)
{
DBusMessage *reply = NULL;
DBusMessageIter array;
DBusMessageIter dict;
DBusMessageIter iter;
const gchar *interface;
const gchar *name;
if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID))
return NULL;
if (!gkd_dbus_interface_match (SECRET_SERVICE_INTERFACE, interface))
return dbus_message_new_error_printf (message, DBUS_ERROR_FAILED,
"Object does not have properties on interface '%s'",
interface);
reply = dbus_message_new_method_return (message);
dbus_message_iter_init_append (reply, &iter);
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &array);
name = "Collections";
dbus_message_iter_open_container (&array, DBUS_TYPE_DICT_ENTRY, NULL, &dict);
dbus_message_iter_append_basic (&dict, DBUS_TYPE_STRING, &name);
gkd_secret_objects_append_collection_paths (self->objects, &dict, message);
dbus_message_iter_close_container (&array, &dict);
dbus_message_iter_close_container (&iter, &array);
return reply;
}
static DBusMessage*
service_method_create_collection (GkdSecretService *self, DBusMessage *message)
{
DBusMessageIter iter, array;
GckAttributes *attrs;
GkdSecretCreate *create;
DBusMessage *reply;
const gchar *path;
const gchar *alias;
const char *caller;
const gchar *coll;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}s"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gck_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) {
gck_attributes_unref (attrs);
return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties");
}
if (!dbus_message_iter_next (&iter))
g_return_val_if_reached (NULL);
dbus_message_iter_get_basic (&iter, &alias);
/* Empty alias is no alias */
if (alias) {
if (!alias[0]) {
alias = NULL;
} else if (!g_str_equal (alias, "default")) {
gck_attributes_unref (attrs);
return dbus_message_new_error (message, DBUS_ERROR_NOT_SUPPORTED,
"Only the 'default' alias is supported");
}
}
gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
/* Create the prompt object, for the password */
caller = dbus_message_get_sender (message);
create = gkd_secret_create_new (self, caller, attrs, alias);
gck_attributes_unref (attrs);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create));
gkd_secret_service_publish_dispatch (self, caller,
GKD_SECRET_DISPATCH (create));
coll = "/";
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &coll,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
g_object_unref (create);
return reply;
}
DBusMessage*
gkd_secret_error_no_such_object (DBusMessage *message)
{
g_return_val_if_fail (message, NULL);
return dbus_message_new_error_printf (message, SECRET_ERROR_NO_SUCH_OBJECT,
"The '%s' object does not exist", dbus_message_get_path (message));
}
static inline DBusMessage* FcitxXkbDBusUnknownMethod(DBusMessage *msg)
{
DBusMessage* reply = dbus_message_new_error_printf(msg,
DBUS_ERROR_UNKNOWN_METHOD,
"No such method with signature (%s)",
dbus_message_get_signature(msg));
return reply;
}
static DBusMessage*
handle_set_preference(void *object,
DBusMessage *message,
DBusError *error)
{
DBusMessage *reply;
HippoSettings *settings;
DBusMessageIter iter;
DBusMessageIter variant_iter;
const char *key;
char *value_signature;
char *value;
DBusConnection *dbus_connection;
dbus_connection = object;
dbus_message_iter_init(message, &iter);
key = NULL;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &variant_iter);
value_signature = dbus_message_iter_get_signature(&variant_iter);
if (!signature_is_supported(value_signature)) {
reply = dbus_message_new_error_printf(message,
DBUS_ERROR_INVALID_ARGS,
_("Unable to handle values of type '%s' right now"),
value_signature);
g_free(value_signature);
return reply;
}
value = string_value_from_variant(&variant_iter, value_signature);
g_free(value_signature);
settings = get_and_ref_settings(dbus_connection);
hippo_settings_set(settings, key, value);
g_free(value);
g_object_unref(settings);
/* Just an empty "ack" reply */
reply = dbus_message_new_method_return(message);
return reply;
}
DBusMessage* FcitxDBusPropertySet(void* arg, const FcitxDBusPropertyTable* propertTable, DBusMessage* message)
{
DBusError error;
dbus_error_init(&error);
char *interface;
char *property;
DBusMessage* reply = NULL;
DBusMessageIter args, variant;
dbus_message_iter_init(message, &args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING)
goto dbus_property_set_end;
dbus_message_iter_get_basic(&args, &interface);
dbus_message_iter_next(&args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING)
goto dbus_property_set_end;
dbus_message_iter_get_basic(&args, &property);
dbus_message_iter_next(&args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_VARIANT)
goto dbus_property_set_end;
dbus_message_iter_recurse(&args, &variant);
int index = 0;
while (propertTable[index].interface != NULL) {
if (strcmp(propertTable[index].interface, interface) == 0
&& strcmp(propertTable[index].name, property) == 0)
break;
index ++;
}
if (propertTable[index].setfunc) {
propertTable[index].setfunc(arg, &variant);
reply = dbus_message_new_method_return(message);
}
else {
reply = dbus_message_new_error_printf(message, DBUS_ERROR_UNKNOWN_PROPERTY, "No such property ('%s.%s')", interface, property);
}
dbus_property_set_end:
if (!reply)
reply = FcitxDBusPropertyUnknownMethod(message);
return reply;
}
static DBusMessage*
service_method_create_collection (GkdSecretService *self, DBusMessage *message)
{
DBusMessageIter iter, array;
GP11Attributes *attrs;
GkdSecretCreate *create;
ServiceClient *client;
DBusMessage *reply;
const gchar *path;
const char *caller;
const gchar *coll;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gp11_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, attrs)) {
gp11_attributes_unref (attrs);
return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties");
}
gp11_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
/* Create the prompt object, for the password */
caller = dbus_message_get_sender (message);
create = gkd_secret_create_new (self, caller, attrs);
gp11_attributes_unref (attrs);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create));
client = g_hash_table_lookup (self->clients, caller);
g_return_val_if_fail (client, NULL);
g_hash_table_replace (client->prompts, (gpointer)path, create);
coll = "/";
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &coll,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *dbus_del_lease(DBusMessage* message)
{
struct dhcp_lease *lease;
DBusMessageIter iter;
const char *ipaddr;
DBusMessage *reply;
struct all_addr addr;
dbus_bool_t ret = 1;
time_t now = dnsmasq_time();
if (!dbus_message_iter_init(message, &iter))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected string as first argument");
dbus_message_iter_get_basic(&iter, &ipaddr);
if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))
lease = lease_find_by_addr(addr.addr.addr4);
#ifdef HAVE_DHCP6
else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))
lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0);
#endif
else
return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s'", ipaddr);
if (lease)
{
lease_prune(lease, now);
lease_update_file(now);
lease_update_dns(0);
}
else
ret = 0;
if ((reply = dbus_message_new_method_return(message)))
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage*
service_property_getall (GkdSecretService *self, DBusMessage *message)
{
DBusMessage *reply = NULL;
DBusMessageIter iter;
const gchar *interface;
if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID))
return NULL;
if (!gkd_dbus_interface_match (SECRET_SERVICE_INTERFACE, interface))
return dbus_message_new_error_printf (message, DBUS_ERROR_FAILED,
"Object does not have properties on interface '%s'",
interface);
reply = dbus_message_new_method_return (message);
dbus_message_iter_init_append (reply, &iter);
service_append_all_properties (self, &iter);
return reply;
}
DBusMessage* FcitxDBusPropertyGet(void* arg, const FcitxDBusPropertyTable* propertTable, DBusMessage* message)
{
DBusError error;
dbus_error_init(&error);
char *interface;
char *property;
DBusMessage* reply = NULL;
if (dbus_message_get_args(message, &error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &property,
DBUS_TYPE_INVALID)) {
int index = 0;
while (propertTable[index].interface != NULL) {
if (strcmp(propertTable[index].interface, interface) == 0
&& strcmp(propertTable[index].name, property) == 0)
break;
index ++;
}
if (propertTable[index].interface) {
DBusMessageIter args, variant;
reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(reply, &args);
dbus_message_iter_open_container(&args, DBUS_TYPE_VARIANT, propertTable[index].type, &variant);
if (propertTable[index].getfunc)
propertTable[index].getfunc(arg, &variant);
dbus_message_iter_close_container(&args, &variant);
}
else {
reply = dbus_message_new_error_printf(message, DBUS_ERROR_UNKNOWN_PROPERTY, "No such property ('%s.%s')", interface, property);
}
}
else {
reply = FcitxDBusPropertyUnknownMethod(message);
}
return reply;
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
char *dup = NULL;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
strings ? "Expected array of string" : "Expected array of string arrays");
}
mark_servers(SERV_FROM_DBUS);
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
int flags = 0;
char interface[IF_NAMESIZE];
char *str_addr, *str_domain = NULL;
if (strings)
{
dbus_message_iter_get_basic(&array_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty string");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
break;
strcpy(str_domain, str);
/* point to address part of old string for error message */
if ((str_addr = strrchr(str, '/')))
str = str_addr+1;
if ((str_addr = strrchr(str_domain, '/')))
{
if (*str_domain != '/' || str_addr == str_domain)
{
error = dbus_message_new_error_printf(message,
DBUS_ERROR_INVALID_ARGS,
"No domain terminator '%s'",
str);
break;
}
*str_addr++ = 0;
str_domain++;
}
else
{
str_addr = str_domain;
str_domain = NULL;
}
}
else
{
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
break;
strcpy(str_addr, str);
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* parse the IP address */
if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* 0.0.0.0 for server address == NULL, for Dbus */
if (addr.in.sin_family == AF_INET &&
addr.in.sin_addr.s_addr == 0)
flags |= SERV_NO_ADDR;
if (strings)
{
char *p;
do {
if (str_domain)
{
if ((p = strchr(str_domain, '/')))
*p++ = 0;
}
else
p = NULL;
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
} while ((str_domain = p));
}
else
{
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
}
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_servers();
if (dup)
free(dup);
return error;
}
DBusMessage*
hippo_dbus_handle_set_preference(HippoDBus *dbus,
DBusMessage *message)
{
DBusMessage *reply;
HippoSettings *settings;
DBusMessageIter iter;
DBusMessageIter variant_iter;
const char *key;
int value_type;
char *value;
if (!dbus_message_has_signature(message, "sv")) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Expected two arguments, the string key and the variant value"));
}
dbus_message_iter_init(message, &iter);
key = NULL;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &variant_iter);
value_type = dbus_message_iter_get_arg_type(&variant_iter);
value = NULL;
switch (value_type) {
case DBUS_TYPE_STRING:
{
const char *v_STRING;
dbus_message_iter_get_basic(&variant_iter, &v_STRING);
value = g_strdup(v_STRING);
}
break;
case DBUS_TYPE_INT32:
{
dbus_int32_t v_INT32;
dbus_message_iter_get_basic(&variant_iter, &v_INT32);
value = g_strdup_printf("%d", v_INT32);
}
break;
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t v_BOOLEAN;
dbus_message_iter_get_basic(&variant_iter, &v_BOOLEAN);
value = g_strdup_printf("%s", v_BOOLEAN ? "true" : "false");
}
break;
default:
return dbus_message_new_error_printf(message,
DBUS_ERROR_INVALID_ARGS,
_("Unable to handle values of type '%c' right now"), value_type);
break;
}
settings = get_and_ref_settings(hippo_dbus_get_connection(dbus));
hippo_settings_set(settings, key, value);
g_free(value);
g_object_unref(settings);
/* Just an empty "ack" reply */
reply = dbus_message_new_method_return(message);
return reply;
}
static DBusHandlerResult object_handler(
DBusConnection *c,
DBusMessage *m,
void *userdata) {
rd_device *d;
DBusError error;
DBusMessage *reply = NULL;
dbus_error_init(&error);
d = userdata;
assert(d->ref >= 1);
if (dbus_message_is_method_call(
m,
"org.freedesktop.ReserveDevice1",
"RequestRelease")) {
int32_t priority;
dbus_bool_t ret;
if (!dbus_message_get_args(
m,
&error,
DBUS_TYPE_INT32, &priority,
DBUS_TYPE_INVALID))
goto invalid;
ret = FALSE;
if (priority > d->priority && d->request_cb) {
d->ref++;
if (d->request_cb(d, 0) > 0) {
ret = TRUE;
d->gave_up = 1;
}
rd_release(d);
}
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_BOOLEAN, &ret,
DBUS_TYPE_INVALID))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(
m,
"org.freedesktop.DBus.Properties",
"Get")) {
const char *interface, *property;
if (!dbus_message_get_args(
m,
&error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &property,
DBUS_TYPE_INVALID))
goto invalid;
if (strcmp(interface, "org.freedesktop.ReserveDevice1") == 0) {
const char *empty = "";
if (strcmp(property, "ApplicationName") == 0 && d->application_name) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_STRING,
d->application_name ? (const char * const *) &d->application_name : &empty))
goto oom;
} else if (strcmp(property, "ApplicationDeviceName") == 0) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_STRING,
d->application_device_name ? (const char * const *) &d->application_device_name : &empty))
goto oom;
} else if (strcmp(property, "Priority") == 0) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_INT32,
&d->priority))
goto oom;
} else {
if (!(reply = dbus_message_new_error_printf(
m,
DBUS_ERROR_UNKNOWN_METHOD,
"Unknown property %s",
property)))
goto oom;
}
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
} else if (dbus_message_is_method_call(
m,
"org.freedesktop.DBus.Introspectable",
"Introspect")) {
const char *i = introspection;
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_STRING,
&i,
DBUS_TYPE_INVALID))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
invalid:
if (reply)
dbus_message_unref(reply);
if (!(reply = dbus_message_new_error(
m,
DBUS_ERROR_INVALID_ARGS,
"Invalid arguments")))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_HANDLED;
oom:
if (reply)
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected array of string arrays");
}
mark_dbus();
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
char interface[IF_NAMESIZE];
char *str_addr;
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* dup the string because it gets modified during parsing */
str_addr = strdup(str);
if (!str_addr)
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Out of memory parsing IP address");
break;
}
/* parse the IP address */
addr_err = parse_server(str_addr, &addr, &source_addr, &interface, NULL);
free(str_addr);
if (addr_err)
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(&addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_dbus();
return error;
}
static void
service_dispatch_message (GkdSecretService *self, DBusMessage *message)
{
DBusMessage *reply = NULL;
const gchar *caller;
ServiceClient *client;
const gchar *path;
gpointer object;
g_assert (GKD_SECRET_IS_SERVICE (self));
g_assert (message);
/* The first thing we do is try to allocate a client context */
caller = dbus_message_get_sender (message);
if (caller == NULL) {
reply = dbus_message_new_error (message, DBUS_ERROR_FAILED,
"Could not not identify calling client application");
dbus_connection_send (self->connection, reply, NULL);
dbus_message_unref (reply);
return;
}
client = g_hash_table_lookup (self->clients, caller);
if (client == NULL) {
initialize_service_client (self, message);
return; /* This function called again, when client is initialized */
}
path = dbus_message_get_path (message);
g_return_if_fail (path);
/* Dispatched to a session or prompt */
if (object_path_has_prefix (path, SECRET_SESSION_PREFIX) ||
object_path_has_prefix (path, SECRET_PROMPT_PREFIX)) {
object = g_hash_table_lookup (client->dispatch, path);
if (object == NULL)
reply = gkd_secret_error_no_such_object (message);
else
reply = gkd_secret_dispatch_message (GKD_SECRET_DISPATCH (object), message);
/* Dispatched to a collection, off it goes */
} else if (object_path_has_prefix (path, SECRET_COLLECTION_PREFIX) ||
object_path_has_prefix (path, SECRET_ALIAS_PREFIX)) {
reply = gkd_secret_objects_dispatch (self->objects, message);
/* Addressed to the service */
} else if (g_str_equal (path, SECRET_SERVICE_PATH)) {
reply = service_message_handler (self, message);
}
/* Should we send an error? */
if (!reply && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
if (!dbus_message_get_no_reply (message)) {
reply = dbus_message_new_error_printf (message, DBUS_ERROR_UNKNOWN_METHOD,
"Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
dbus_message_get_member (message),
dbus_message_get_signature (message),
dbus_message_get_interface (message));
}
}
if (reply) {
dbus_connection_send (self->connection, reply, NULL);
dbus_message_unref (reply);
}
}
static DBusMessage *dbus_add_lease(DBusMessage* message)
{
struct dhcp_lease *lease;
const char *ipaddr, *hwaddr, *hostname, *tmp;
const unsigned char* clid;
int clid_len, hostname_len, hw_len, hw_type;
dbus_uint32_t expires, ia_id;
dbus_bool_t is_temporary;
struct all_addr addr;
time_t now = dnsmasq_time();
unsigned char dhcp_chaddr[DHCP_CHADDR_MAX];
DBusMessageIter iter, array_iter;
if (!dbus_message_iter_init(message, &iter))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected string as first argument");
dbus_message_iter_get_basic(&iter, &ipaddr);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected string as second argument");
dbus_message_iter_get_basic(&iter, &hwaddr);
dbus_message_iter_next(&iter);
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected byte array as third argument");
dbus_message_iter_recurse(&iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &hostname, &hostname_len);
tmp = memchr(hostname, '\0', hostname_len);
if (tmp)
{
if (tmp == &hostname[hostname_len - 1])
hostname_len--;
else
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Hostname contains an embedded NUL character");
}
dbus_message_iter_next(&iter);
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected byte array as fourth argument");
dbus_message_iter_recurse(&iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &clid, &clid_len);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as fifth argument");
dbus_message_iter_get_basic(&iter, &expires);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as sixth argument");
dbus_message_iter_get_basic(&iter, &ia_id);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as sixth argument");
dbus_message_iter_get_basic(&iter, &is_temporary);
if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))
{
if (ia_id != 0 || is_temporary)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"ia_id and is_temporary must be zero for IPv4 lease");
if (!(lease = lease_find_by_addr(addr.addr.addr4)))
lease = lease4_allocate(addr.addr.addr4);
}
#ifdef HAVE_DHCP6
else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))
{
if (!(lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0)))
lease = lease6_allocate(&addr.addr.addr6,
is_temporary ? LEASE_TA : LEASE_NA);
lease_set_iaid(lease, ia_id);
}
#endif
else
return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s'", ipaddr);
hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL,
&hw_type);
if (hw_type == 0 && hw_len != 0)
hw_type = ARPHRD_ETHER;
lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type,
clid_len, now, 0);
lease_set_expires(lease, expires, now);
if (hostname_len != 0)
lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL);
lease_update_file(now);
lease_update_dns(0);
return NULL;
}
static void
setting_arrived(const char *key,
const char *value,
void *data)
{
SettingArrivedData *sad = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter variant_iter;
if (value == NULL) {
reply = dbus_message_new_error_printf(sad->method_call, HIPPO_DBUS_PREFS_ERROR_NOT_FOUND,
_("No value known for key '%s'"), key);
goto out;
}
reply = dbus_message_new_method_return(sad->method_call);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sad->signature,
&variant_iter);
switch (*(sad->signature)) {
case DBUS_TYPE_STRING:
dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_STRING, &value);
break;
case DBUS_TYPE_INT32:
{
dbus_int32_t v_INT32;
if (!hippo_parse_int32(value, &v_INT32)) {
dbus_message_unref(reply);
reply = dbus_message_new_error_printf(sad->method_call, HIPPO_DBUS_PREFS_ERROR_WRONG_TYPE,
_("Value was '%s' not parseable as an INT32"), value);
goto out;
}
dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_INT32, &v_INT32);
}
break;
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t v_BOOLEAN;
if (strcmp(value, "true") == 0)
v_BOOLEAN = TRUE;
else if (strcmp(value, "false") == 0)
v_BOOLEAN = FALSE;
else {
dbus_message_unref(reply);
reply = dbus_message_new_error_printf(sad->method_call, HIPPO_DBUS_PREFS_ERROR_WRONG_TYPE,
_("Value was '%s' not parseable as a BOOLEAN"), value);
goto out;
}
dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_BOOLEAN, &v_BOOLEAN);
}
break;
}
dbus_message_iter_close_container(&iter, &variant_iter);
out:
dbus_connection_send(sad->connection, reply, NULL);
dbus_message_unref(reply);
dbus_message_unref(sad->method_call);
g_object_unref(sad->settings);
dbus_connection_unref(sad->connection);
g_free(sad);
}
