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