/*
Authors:
Pavel Březina <pbrezina@redhat.com>
Copyright (C) 2014 Red Hat
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <talloc.h>
#include <dhash.h>
#include "sbus/sssd_dbus.h"
#include "sbus/sssd_dbus_meta.h"
#include "sbus/sssd_dbus_private.h"
static struct sbus_interface *
const char *iface)
{
}
}
return NULL;
}
static errno_t
struct sbus_interface_list *list,
struct sbus_interface_list **_copy)
{
return EOK;
}
return ENOMEM;
}
/* already in list */
continue;
}
goto done;
}
}
done:
}
return ret;
}
/**
* Object paths that represent all objects under the path:
*/
{
if (len < 2) {
return false;
}
}
/**
* If the path represents a subtree object path, this function will
* remove /~* from the end.
*/
const char *object_path)
{
char *tree_path;
return NULL;
}
if (!sbus_opath_is_subtree(tree_path)) {
return tree_path;
}
/* replace / only if it is not a root path (only slash) */
return tree_path;
}
const char *path)
{
char *subtree;
char *slash;
/* first remove /~* from the end, stop when we have reached the root i.e.
* subtree == "/" */
return NULL;
}
/* Find the first separator and replace the part with asterisk. */
/* we cannot continue up */
return NULL;
}
/* this object path is invalid since it cannot end with slash */
return NULL;
}
/* because object path cannot end with / there is enough space for
* asterisk and terminating zero */
return subtree;
}
/**
* The following path related functions are based on similar code in
* storaged, just tailored to use talloc instead of glib
*/
char *
const char *object_path_part)
{
size_t n;
/* The path must be valid */
if (object_path_part == NULL) {
return NULL;
}
return NULL;
}
goto done;
}
/* Special case for an empty string */
/* the for loop would just fall through */
goto done;
}
}
for (n = 0; object_path_part[n]; n++) {
int c = object_path_part[n];
/* D-Bus spec says:
* *
* * Each element must only contain the ASCII characters
* "[A-Z][a-z][0-9]_"
* */
if ((c >= 'A' && c <= 'Z')
|| (c >= 'a' && c <= 'z')
|| (c >= '0' && c <= '9')) {
goto done;
}
} else {
goto done;
}
}
}
done:
return safe_path;
}
static inline int unhexchar(char c)
{
if (c >= '0' && c <= '9') {
return c - '0';
}
if (c >= 'a' && c <= 'f') {
return c - 'a' + 10;
}
if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
return -1;
}
char *
const char *object_path_part)
{
char *safe_path;
const char *p;
int a, b, c;
return NULL;
}
goto done;
}
/* Special case for the empty string */
goto done;
}
for (p = object_path_part; *p; p++) {
if (*p == '_') {
/* There must be at least two more chars after underscore */
if (p[1] == '\0' || p[2] == '\0') {
goto done;
}
if ((a = unhexchar(p[1])) < 0
|| (b = unhexchar(p[2])) < 0) {
/* Invalid escape code, let's take it literal then */
c = '_';
} else {
c = ((a << 4) | b);
p += 2;
}
} else {
c = *p;
}
goto done;
}
}
done:
return safe_path;
}
char *
const char *base,
const char *part, ...)
{
char *safe_part;
return NULL;
}
goto fail;
}
goto fail;
}
}
return path;
fail:
return NULL;
}
const char *object_path,
const char *prefix,
char ***_components,
{
const char *path;
char **decomposed;
char **unescaped;
int len;
int i;
return ENOMEM;
}
/* Strip prefix from the path. */
goto done;
}
} else {
path = object_path;
}
/* Split the string using / as delimiter. */
/* Unescape parts. */
goto done;
}
for (i = 0; i < len; i++) {
goto done;
}
}
if (_components != NULL) {
}
}
done:
return ret;
}
const char *object_path,
const char *prefix,
char ***_components)
{
char **components;
&components, &len);
return ret;
}
return ERR_SBUS_INVALID_PATH;
}
if (_components != NULL) {
}
return EOK;
}
const char *
const char *prefix)
{
}
return NULL;
}
char *
const char *object_path,
const char *base_path)
{
const char *name;
return NULL;
}
/* if base_path did not end with / */
if (name[0] == '/') {
}
}
static void
void *pvt)
{
char *path;
}
struct sbus_connection *conn,
{
}
static errno_t
const char *object_path,
struct sbus_interface *iface,
bool *_path_known)
{
bool path_known;
int hret;
return ENOMEM;
}
/* create new list item */
return ENOMEM;
}
/* first lookup existing list in hash table */
goto done;
}
if (hret == HASH_SUCCESS) {
/* This object path has already some interface registered. We will
* check for existence of the interface currently being added and
* add it if missing. */
path_known = true;
goto done;
}
goto done;
} else if (hret != HASH_ERROR_KEY_NOT_FOUND) {
goto done;
}
/* otherwise create new hash entry and new list */
path_known = false;
if (hret != HASH_SUCCESS) {
goto done;
}
done:
}
return ret;
}
static bool
const char *object_path)
{
}
/**
* First @object_path is looked up in @table, if it is not found it steps up
* in the path hierarchy and try to lookup the parent node. This continues
* until the root is reached.
*/
struct sbus_interface *
const char *object_path,
const char *iface_name)
{
int hret;
return NULL;
}
if (lookup_path == NULL) {
goto done;
}
while (lookup_path != NULL) {
if (hret == HASH_SUCCESS) {
goto done;
}
} else if (hret != HASH_ERROR_KEY_NOT_FOUND) {
"Unable to search hash table: hret=%d\n", hret);
goto done;
}
/* we will not free lookup path since it is freed with tmp_ctx
* and the object paths are supposed to be small */
}
done:
return iface;
}
/**
* Acquire list of all interfaces that are supported on given object path.
*/
const char *object_path,
struct sbus_interface_list **_list)
{
int hret;
return ENOMEM;
}
goto done;
}
if (lookup_path == NULL) {
goto done;
}
while (lookup_path != NULL) {
if (hret == HASH_SUCCESS) {
goto done;
}
} else if (hret != HASH_ERROR_KEY_NOT_FOUND) {
"Unable to search hash table: hret=%d\n", hret);
goto done;
}
/* we will not free lookup path since it is freed with tmp_ctx
* and the object paths are supposed to be small */
}
done:
return ret;
}
struct sbus_connection *conn,
{
}
struct sbus_nodes_data {
void *handler_data;
};
static errno_t
const char *object_path,
void *handler_data)
{
bool has_key;
int hret;
return ENOMEM;
}
return ENOMEM;
}
if (has_key) {
goto done;
}
goto done;
}
if (hret != HASH_SUCCESS) {
goto done;
}
done:
return ret;
}
const char **
const char *object_path)
{
int hret;
if (hret == HASH_ERROR_KEY_NOT_FOUND) {
return NULL;
} else if (hret != HASH_SUCCESS) {
"Unable to search hash table: hret=%d\n", hret);
return NULL;
}
}
static struct sbus_interface *
const char *object_path,
struct sbus_vtable *iface_vtable,
void *handler_data)
{
return NULL;
}
return NULL;
}
return intf;
}
static DBusHandlerResult
void *user_data);
static errno_t
const char *path)
{
"connection\n", path);
if (sbus_opath_is_subtree(path)) {
return ENOMEM;
}
/* D-Bus does not allow to have both object path and fallback
* registered. Since we handle the real message handlers ourselves
* we will register fallback only in this case. */
}
} else {
if (dbus_error_is_set(&error) &&
/* A fallback is probably already registered. Just return. */
return EOK;
}
}
if (!dbret) {
"%s with D-Bus connection.\n", path);
return ENOMEM;
}
return EOK;
}
struct sbus_vtable *iface_vtable,
const char *object_path,
void *handler_data)
{
bool path_known;
return EINVAL;
}
return ENOMEM;
}
&path_known);
return ret;
}
if (path_known) {
/* this object path is already registered */
return EOK;
}
/* if ret != EOK we will still leave iface in the table, since
* we probably don't have enough memory to remove it correctly anyway */
return ret;
}
/* register standard interfaces with this object path as well */
object_path, conn);
return ret;
}
object_path, conn);
return ret;
}
return ret;
}
struct sbus_iface_map *map,
void *pvt)
{
int i;
return ret;
}
}
return EOK;
}
void
const char *path,
void *data)
{
"%s. Introspection may not work correctly.\n", path);
}
}
{
unsigned long count;
unsigned long i;
int hret;
if (hret != HASH_SUCCESS) {
goto done;
}
for (i = 0; i < count; i++) {
goto done;
}
}
done:
return ret;
}
static void
static DBusHandlerResult
void *handler_data)
{
const char *iface_name;
const char *method_name;
const char *path;
const char *sender;
/* header information */
/* try to find the interface */
path, iface_name);
goto fail;
}
goto fail;
}
/* we have a valid handler, create D-Bus request */
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
/* now get the sender ID */
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
return DBUS_HANDLER_RESULT_HANDLED;
fail: ;
return DBUS_HANDLER_RESULT_HANDLED;
}
static void
{
void *pvt;
return;
}
return;
}