#include "dbus-transport.h"
#include "dbus-transport-kdbus.h"
-#include <dbus/dbus-transport-protected.h>
+//#include <dbus/dbus-transport-protected.h>
+#include "dbus-transport-protected.h"
#include "dbus-connection-internal.h"
#include "kdbus.h"
#include "dbus-watch.h"
#include "dbus-errors.h"
#include "dbus-bus.h"
+#include "kdbus-common.h"
#include <linux/types.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <openssl/md5.h>
-#define KDBUS_ALIGN8(l) (((l) + 7) & ~7)
-#define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8((s) + KDBUS_PART_HEADER_SIZE)
-
-#define KDBUS_PART_NEXT(part) \
- (typeof(part))(((uint8_t *)part) + KDBUS_ALIGN8((part)->size))
#define KDBUS_PART_FOREACH(part, head, first) \
for (part = (head)->first; \
(uint8_t *)(part) < (uint8_t *)(head) + (head)->size; \
#define MEMFD_SIZE_THRESHOLD (2 * 1024 * 1024LU) // over this memfd is used
#define KDBUS_MSG_DECODE_DEBUG 0
+//#define DBUS_AUTHENTICATION
#define ITER_APPEND_STR(string) \
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &string)) \
return -1;
}
+/*
static int reply_ack(DBusMessage *message, DBusConnection* connection)
{
DBusMessage *reply;
if(add_message_to_received(reply, connection))
return 0;
return -1;
-}
+}*/
/**
* Retrieves file descriptor to memory pool from kdbus module.
item = KDBUS_PART_NEXT(item);
item->type = KDBUS_MSG_DST_NAME;
item->size = KDBUS_PART_HEADER_SIZE + strlen(name) + 1;
- strcpy(item->str, name);
+ memcpy(item->str, name, item->size - KDBUS_PART_HEADER_SIZE);
}
else if (dst_id == KDBUS_DST_ID_BROADCAST)
{
{
if(errno == EINTR)
goto again;
- if((errno == ESRCH) || (errno == ENXIO) || (errno = EADDRNOTAVAIL)) //when recipient is not available on the bus
+ else if(errno == ENXIO) //no such id on the bus
+ {
+ if(!reply_with_error(DBUS_ERROR_NAME_HAS_NO_OWNER, "Name \"%s\" does not exist", dbus_message_get_destination(message), message, transport->base.connection))
+ goto out;
+ }
+ else if((errno == ESRCH) || (errno = EADDRNOTAVAIL)) //when well known name is not available on the bus
{
if(autostart)
{
- //todo start service here, otherwise
if(!reply_with_error(DBUS_ERROR_SERVICE_UNKNOWN, "The name %s was not provided by any .service files", dbus_message_get_destination(message), message, transport->base.connection))
goto out;
}
else
- if(!reply_with_error(DBUS_ERROR_NAME_HAS_NO_OWNER, "Name \"%s\" does not exist", dbus_message_get_destination(message), message, transport->base.connection))
- goto out;
-
+ if(!reply_with_error(DBUS_ERROR_NAME_HAS_NO_OWNER, "Name \"%s\" does not exist", dbus_message_get_destination(message), message, transport->base.connection))
+ goto out;
}
_dbus_verbose("kdbus error sending message: err %d (%m)\n", errno);
ret_size = -1;
return ret_size;
}
-struct nameInfo
-{
- __u64 uniqueId;
- __u64 userId;
- __u64 processId;
- __u32 sec_label_len;
- char *sec_label;
-};
-
/**
* Performs kdbus query of id of the given name
*
* @param ownerID place to store id of the name
* @return 0 on success, -errno if failed
*/
-static int kdbus_NameQuery(char* name, int fd, struct nameInfo* pInfo)
+int kdbus_NameQuery(const char* name, DBusTransport* transport, struct nameInfo* pInfo)
{
struct kdbus_cmd_name_info *msg;
struct kdbus_item *item;
item = msg->items;
item->type = KDBUS_NAME_INFO_ITEM_NAME;
item->size = item_size;
- strcpy(item->str, name);
+ memcpy(item->str, name, strlen(name) + 1);
again:
- ret = ioctl(fd, KDBUS_CMD_NAME_QUERY, msg);
+ ret = ioctl(((DBusTransportSocket*)transport)->fd, KDBUS_CMD_NAME_QUERY, msg);
if (ret < 0)
{
if(errno == EINTR)
goto again;
+ if(errno == EAGAIN)
+ goto again;
else if(ret == -ENOBUFS)
{
msg = realloc(msg, msg->size); //prepare memory
pInfo->uniqueId = msg->id;
pInfo->userId = msg->creds.uid;
pInfo->processId = msg->creds.pid;
-_dbus_verbose ("I'm alive 1\n");
item = msg->items;
while((uint8_t *)(item) < (uint8_t *)(msg) + msg->size)
{
if(item->type == KDBUS_NAME_INFO_ITEM_SECLABEL)
{
- pInfo->sec_label_len = item->size - KDBUS_PART_HEADER_SIZE - 1;
+ pInfo->sec_label_len = item->size - KDBUS_PART_HEADER_SIZE - 1;
if(pInfo->sec_label_len != 0)
+ {
pInfo->sec_label = malloc(pInfo->sec_label_len);
- if(pInfo->sec_label == NULL)
- ret = -1;
- else
- memcpy(pInfo->sec_label, item->data, pInfo->sec_label_len);
-
+ if(pInfo->sec_label == NULL)
+ ret = -1;
+ else
+ memcpy(pInfo->sec_label, item->data, pInfo->sec_label_len);
+ }
break;
}
item = KDBUS_PART_NEXT(item);
return ret;
}
-static struct kdbus_policy *make_policy_name(const char *name)
-{
- struct kdbus_policy *p;
- __u64 size;
-
- size = offsetof(struct kdbus_policy, name) + strlen(name) + 1;
- p = malloc(size);
- if (!p)
- return NULL;
- memset(p, 0, size);
- p->size = size;
- p->type = KDBUS_POLICY_NAME;
- strcpy(p->name, name);
-
- return p;
-}
-
-static struct kdbus_policy *make_policy_access(__u64 type, __u64 bits, __u64 id)
-{
- struct kdbus_policy *p;
- __u64 size = sizeof(*p);
-
- p = malloc(size);
- if (!p)
- return NULL;
-
- memset(p, 0, size);
- p->size = size;
- p->type = KDBUS_POLICY_ACCESS;
- p->access.type = type;
- p->access.bits = bits;
- p->access.id = id;
-
- return p;
-}
-
-static void append_policy(struct kdbus_cmd_policy *cmd_policy, struct kdbus_policy *policy, __u64 max_size)
-{
- struct kdbus_policy *dst = (struct kdbus_policy *) ((char *) cmd_policy + cmd_policy->size);
-
- if (cmd_policy->size + policy->size > max_size)
- return;
-
- memcpy(dst, policy, policy->size);
- cmd_policy->size += KDBUS_ALIGN8(policy->size);
- free(policy);
-}
-
-/**
- * Registers kdbus policy for given connection.
- *
- * Policy sets rights of the name (unique or well known) on the bus. Without policy it is
- * not possible to send or receive messages. It must be set separately for unique id and
- * well known name of the connection. It is set after registering on the bus, but before
- * requesting for name. The policy is valid for the given name, not for the connection.
- *
- * Name of the policy equals name on the bus.
- *
- * @param name name of the policy = name of the connection
- * @param connection the connection
- * @param error place to store errors
- *
- * @returns #TRUE on success
- */
-static dbus_bool_t bus_register_policy_kdbus(const char* name, int fd)
-{
- struct kdbus_cmd_policy *cmd_policy;
- struct kdbus_policy *policy;
- int size = 0xffff;
-
- cmd_policy = alloca(size);
- memset(cmd_policy, 0, size);
-
- policy = (struct kdbus_policy *) cmd_policy->policies;
- cmd_policy->size = offsetof(struct kdbus_cmd_policy, policies);
-
- policy = make_policy_name(name);
- append_policy(cmd_policy, policy, size);
-
- policy = make_policy_access(KDBUS_POLICY_ACCESS_USER, KDBUS_POLICY_OWN, getuid());
- append_policy(cmd_policy, policy, size);
-
- policy = make_policy_access(KDBUS_POLICY_ACCESS_WORLD, KDBUS_POLICY_RECV, 0);
- append_policy(cmd_policy, policy, size);
-
- policy = make_policy_access(KDBUS_POLICY_ACCESS_WORLD, KDBUS_POLICY_SEND, 0);
- append_policy(cmd_policy, policy, size);
-
- if (ioctl(fd, KDBUS_CMD_EP_POLICY_SET, cmd_policy) < 0)
- {
- _dbus_verbose ("Error setting policy: %m, %d", errno);
- return FALSE;
- }
-
- _dbus_verbose("Policy %s set correctly\n", name);
- return TRUE;
-}
-
/**
* Kdbus part of dbus_bus_register.
* Shouldn't be used separately because it needs to be surrounded
}
/**
- * kdbus version of dbus_bus_request_name.
- *
- * Asks the bus to assign the given name to this connection.
- *
- * Use same flags as original dbus version with one exception below.
- * Result flag #DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER is currently
- * never returned by kdbus, instead DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
- * is returned by kdbus.
- *
- * @param connection the connection
- * @param name the name to request
- * @param flags flags
- * @param error location to store the error
- * @returns a result code, -1 if error is set
- */
-static int bus_request_name_kdbus(int fd, const char *name, const uint64_t flags)
-{
- struct kdbus_cmd_name *cmd_name;
-
- uint64_t size = sizeof(*cmd_name) + strlen(name) + 1;
- uint64_t flags_kdbus = 0;
-
- cmd_name = alloca(size);
-
- memset(cmd_name, 0, size);
- strcpy(cmd_name->name, name);
- cmd_name->size = size;
-
- if(flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT)
- flags_kdbus |= KDBUS_NAME_ALLOW_REPLACEMENT;
- if(!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE))
- flags_kdbus |= KDBUS_NAME_QUEUE;
- if(flags & DBUS_NAME_FLAG_REPLACE_EXISTING)
- flags_kdbus |= KDBUS_NAME_REPLACE_EXISTING;
-
- cmd_name->conn_flags = flags_kdbus;
-
- _dbus_verbose("Request name - flags sent: 0x%llx !!!!!!!!!\n", cmd_name->conn_flags);
-
- if (ioctl(fd, KDBUS_CMD_NAME_ACQUIRE, cmd_name))
- {
- _dbus_verbose ("error acquiring name '%s': %m, %d", name, errno);
- if(errno == EEXIST)
- return DBUS_REQUEST_NAME_REPLY_EXISTS;
- return -1;
- }
-
- _dbus_verbose("Request name - received flag: 0x%llx !!!!!!!!!\n", cmd_name->conn_flags);
-
- if(cmd_name->conn_flags & KDBUS_NAME_IN_QUEUE)
- return DBUS_REQUEST_NAME_REPLY_IN_QUEUE;
- else
- return DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
- /*todo now 1 code is never returned - DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER
- * because kdbus never returns it now
- */
-}
-
-/**
* Seeks key in rule string, and duplicates value of the key into pValue.
* If value is "org.freedesktop.DBus" it is indicated by returning -1, because it
* needs to be handled in different manner.
* @param rule textual form of match rule
* @param error location to store any errors - may be NULL
*/
-static dbus_bool_t dbus_bus_add_match_kdbus (DBusTransportSocket* transportS, const char *rule)
+dbus_bool_t add_match_kdbus (DBusTransport* transport, __u64 id, const char *rule)
{
struct kdbus_cmd_match* pCmd_match;
struct kdbus_item *pItem;
char* pName = NULL;
char* pInterface = NULL;
dbus_bool_t ret_value = FALSE;
+ DBusTransportSocket* transportS = (DBusTransportSocket*)transport;
/*parsing rule and calculating size of command*/
size = sizeof(struct kdbus_cmd_match);
if(pCmd_match == NULL)
goto out;
- pCmd_match->id = 0;
+ pCmd_match->id = id;
+ pCmd_match->cookie = id;
pCmd_match->size = size;
- pCmd_match->cookie = strtoull(dbus_bus_get_unique_name(transportS->base.connection), NULL , 10);
pItem = pCmd_match->items;
if(kernel_item == ~0) //all signals from kernel
{
pItem->type = KDBUS_MATCH_SRC_NAME;
pItem->size = KDBUS_PART_HEADER_SIZE + name_size + 1;
- strcpy(pItem->str, pName);
+ memcpy(pItem->str, pName, strlen(pName) + 1);
pItem = KDBUS_PART_NEXT(pItem);
}
_dbus_verbose("Failed adding match bus rule %s,\nerror: %d, %m\n", rule, errno);
else
{
- _dbus_verbose("Added match bus rule %s\n", rule);
+ _dbus_verbose("Added match bus rule %s for id:%llu\n", rule, (unsigned long long)id);
ret_value = TRUE;
}
* @param connection connection to the message bus
* @param error location to store any errors - may be NULL
*/
-static dbus_bool_t dbus_bus_remove_match_kdbus (DBusTransportSocket* transportS)
+dbus_bool_t remove_match_kdbus (DBusTransport* transport, __u64 id)
{
struct kdbus_cmd_match __attribute__ ((__aligned__(8))) cmd;
+ DBusTransportSocket* transportS = (DBusTransportSocket*) transport;
- cmd.cookie = strtoull(dbus_bus_get_unique_name(transportS->base.connection), NULL , 10);
- cmd.id = cmd.cookie;
+ cmd.cookie = id;
+ cmd.id = id;
cmd.size = sizeof(struct kdbus_cmd_match);
- if(ioctl(transportS->fd, KDBUS_CMD_MATCH_ADD, &cmd))
+ if(ioctl(transportS->fd, KDBUS_CMD_MATCH_REMOVE, &cmd))
{
- _dbus_verbose("Failed removing match rule; error: %d, %m\n", errno);
+ _dbus_verbose("Failed removing match rule for id: %llu; error: %d, %m\n", (unsigned long long)id, errno);
return FALSE;
}
else
*/
static int emulateOrgFreedesktopDBus(DBusTransport *transport, DBusMessage *message)
{
+#ifdef DBUS_SERVICES_IN_LIB
int inter_ret;
struct nameInfo info;
+#endif
int ret_value = -1;
if(!strcmp(dbus_message_get_member(message), "Hello"))
return -1;
if(!bus_register_kdbus(name, (DBusTransportSocket*)transport))
goto outH1;
- if(!bus_register_policy_kdbus(name, ((DBusTransportSocket*)transport)->fd))
+ if(!register_kdbus_policy(name, ((DBusTransportSocket*)transport)->fd))
goto outH1;
sender = malloc (strlen(name) + 4);
((DBusTransportSocket*)transport)->sender = sender;
if(!reply_1_data(message, DBUS_TYPE_STRING, &name, transport->connection))
- return 0; //todo why we cannot free name after sending reply?
+ return 0; //todo why we cannot free name after sending reply, shouldn't we?
else
free(sender);
outH1:
free(name);
}
+#ifdef DBUS_SERVICES_IN_LIB
else if(!strcmp(dbus_message_get_member(message), "RequestName"))
{
char* name;
if(!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT32, &flags, DBUS_TYPE_INVALID))
return -1;
- if(!bus_register_policy_kdbus(name, ((DBusTransportSocket*)transport)->fd))
+
+ if(!register_kdbus_policy(name, ((DBusTransportSocket*)transport)->fd))
return -1;
- result = bus_request_name_kdbus(((DBusTransportSocket*)transport)->fd, name, flags);
- return reply_1_data(message, DBUS_TYPE_UINT32, &result, transport->connection);
+ result = request_kdbus_name(((DBusTransportSocket*)transport)->fd, name, flags, 0);
+ if(result == -EPERM)
+ return reply_with_error(DBUS_ERROR_ACCESS_DENIED,
+ "Connection is not allowed to own the service \"%s\" due to security policies in the configuration file",
+ name, message, transport->connection);
+ else if(result < 0)
+ return reply_with_error(DBUS_ERROR_FAILED , "Name \"%s\" could not be acquired", name, message, transport->connection);
+ else
+ return reply_1_data(message, DBUS_TYPE_UINT32, &result, transport->connection);
}
else if(!strcmp(dbus_message_get_member(message), "AddMatch"))
{
if(!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &rule, DBUS_TYPE_INVALID))
return -1;
- if(!dbus_bus_add_match_kdbus((DBusTransportSocket*)transport, rule))
+ if(!add_match_kdbus(transport, 0, rule))
return -1;
return reply_ack(message,transport->connection);
}
else if(!strcmp(dbus_message_get_member(message), "RemoveMatch"))
{
- if(!dbus_bus_remove_match_kdbus((DBusTransportSocket*)transport))
+ if(!remove_match_kdbus(transport, 0))
return -1;
return reply_ack(message, transport->connection);
}
char* name = NULL;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- inter_ret = kdbus_NameQuery(name, ((DBusTransportSocket*)transport)->fd, &info);
+ inter_ret = kdbus_NameQuery(name, transport, &info);
if(inter_ret == 0) //unique id of the name
{
char unique_name[(unsigned int)(snprintf(name, 0, "%llu", ULLONG_MAX) + sizeof(":1."))];
dbus_bool_t result;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- inter_ret = kdbus_NameQuery(name, ((DBusTransportSocket*)transport)->fd, &info);
+ inter_ret = kdbus_NameQuery(name, transport, &info);
if((inter_ret == 0) || (inter_ret == -ENOENT))
{
result = (inter_ret == 0) ? TRUE : FALSE;
char* name = NULL;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- inter_ret = kdbus_NameQuery(name, ((DBusTransportSocket*)transport)->fd, &info);
+ inter_ret = kdbus_NameQuery(name, transport, &info);
if(inter_ret == 0) //name found
{
_dbus_verbose("User id:%llu\n", (unsigned long long) info.userId);
char* name = NULL;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- inter_ret = kdbus_NameQuery(name, ((DBusTransportSocket*)transport)->fd, &info);
+ inter_ret = kdbus_NameQuery(name, transport, &info);
if(inter_ret == 0) //name found
ret_value = reply_1_data(message, DBUS_TYPE_UINT32, &info.processId, transport->connection);
else if(inter_ret == -ENOENT) //name has no owner
{
pCmd = realloc(pCmd, cmd_size); //prepare memory
if(pCmd == NULL)
- return FALSE;
+ return -1;
goto again; //and try again
}
else
{
DBusMessage *reply;
- DBusMessageIter args;
+ DBusMessageIter iter, sub;
struct kdbus_cmd_name* pCmd_name;
char* pName;
if(reply == NULL)
goto out;
dbus_message_set_sender(reply, DBUS_SERVICE_DBUS);
- dbus_message_iter_init_append(reply, &args);
-
+ dbus_message_iter_init_append(reply, &iter);
+ if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub))
+ {
+ dbus_message_unref(reply);
+ goto out;
+ }
for (pCmd_name = pCmd->names; (uint8_t *)(pCmd_name) < (uint8_t *)(pCmd) + pCmd->size; pCmd_name = KDBUS_PART_NEXT(pCmd_name))
{
pName = pCmd_name->name;
- if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &pName))
+ if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &pName))
{
dbus_message_unref(reply);
goto out;
}
}
- if(add_message_to_received(reply, transport->connection))
+ if (!dbus_message_iter_close_container (&iter, &sub))
{
- free(pCmd);
- return TRUE;
+ dbus_message_unref (reply);
+ goto out;
}
+
+ if(add_message_to_received(reply, transport->connection))
+ ret_value = 0;
}
out:
if(pCmd)
free(pCmd);
- return FALSE;
+ return ret_value;
}
else if(!strcmp(dbus_message_get_member(message), "GetId"))
{
MD5_CTX md5;
DBusString binary, encoded;
- ret_value = FALSE;
path = &transport->address[11]; //start of kdbus bus path
if(stat(path, &stats) < -1)
{
outgid:
return ret_value;
}
- else if(!strcmp(dbus_message_get_member(message), "GetAdtAuditSessionData"))
+#endif
+/* else if(!strcmp(dbus_message_get_member(message), "GetAdtAuditSessionData")) //todo to be implemented if needed and possible
{
char* name = NULL;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
return reply_with_error(DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN, "Could not determine audit session data for '%s'", name, message, transport->connection);
- }
+ }*/
+#ifdef DBUS_SERVICES_IN_LIB
else if(!strcmp(dbus_message_get_member(message), "GetConnectionSELinuxSecurityContext"))
{
char* name = NULL;
dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- inter_ret = kdbus_NameQuery(name, ((DBusTransportSocket*)transport)->fd, &info);
+ inter_ret = kdbus_NameQuery(name, transport, &info);
if(inter_ret == -ENOENT) //name has no owner
return reply_with_error(DBUS_ERROR_NAME_HAS_NO_OWNER, "Could not get security context of name '%s': no such name", name, message, transport->connection);
else if(inter_ret < 0)
{
DBusMessage *reply;
- ret_value = FALSE;
reply = dbus_message_new_method_return(message);
if(reply != NULL)
{
if (!dbus_message_append_args (reply, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &info.sec_label, info.sec_label_len, DBUS_TYPE_INVALID))
dbus_message_unref(reply);
else if(add_message_to_received(reply, transport->connection))
- ret_value = TRUE;
+ ret_value = 0;
}
}
}
+#endif
else
- return reply_with_error(DBUS_ERROR_UNKNOWN_METHOD, NULL, (char*)dbus_message_get_member(message), message, transport->connection);
-/* else if(!strcmp(dbus_message_get_member(message), "ListActivatableNames")) //todo
- {
-
- }
- else if(!strcmp(dbus_message_get_member(message), "StartServiceByName"))
- {
-
- }
- else if(!strcmp(dbus_message_get_member(message), "UpdateActivationEnvironment"))
- {
-
- }
- else if(!strcmp(dbus_message_get_member(message), "ReloadConfig"))
- {
-
- }
- */
+ return 1; //send to daemon
+#ifdef DBUS_SERVICES_IN_LIB
if(info.sec_label)
free(info.sec_label);
+#endif
return ret_value;
}
_dbus_transport_ref (transport);
#ifdef DBUS_AUTHENTICATION
- if (_dbus_transport_get_is_authenticated (transport))
+ if (_dbus_transport_try_to_authenticate (transport))
#endif
needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);
#ifdef DBUS_AUTHENTICATION
_dbus_transport_ref (transport);
#ifdef DBUS_AUTHENTICATION
- if (_dbus_transport_get_is_authenticated (transport))
+ if (_dbus_transport_try_to_authenticate (transport))
#endif
need_read_watch =
(_dbus_counter_get_size_value (transport->live_messages) < transport->max_live_messages_size) &&
DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
DBusString *buffer;
int bytes_read;
+ int *fds, n_fds;
*oom = FALSE;
_dbus_auth_get_buffer (transport->auth, &buffer);
- bytes_read = kdbus_read_message(socket_transport, buffer);
+ bytes_read = kdbus_read_message(socket_transport, buffer, fds, &n_fds);
_dbus_auth_return_buffer (transport->auth, buffer,
bytes_read > 0 ? bytes_read : 0);
}
}
+static int kdbus_send_auth (DBusTransport *transport, const DBusString *buffer)
+{
+ int len;
+ int bytes_written = -1;
+ struct kdbus_msg *msg;
+ struct kdbus_item *item;
+
+ len = _dbus_string_get_length (buffer);
+// data = _dbus_string_get_const_data_len (buffer, 0, len);
+
+ msg = kdbus_init_msg(NULL, 1, 0, FALSE, 0, (DBusTransportSocket*)transport);
+ item = msg->items;
+ MSG_ITEM_BUILD_VEC(_dbus_string_get_const_data_len (buffer, 0, len), len);
+
+ again:
+ if(ioctl(((DBusTransportSocket*)transport)->fd, KDBUS_CMD_MSG_SEND, msg))
+ {
+ if(errno == EINTR)
+ goto again;
+ _dbus_verbose ("Error writing auth: %d, %m\n", errno);
+ }
+ else
+ bytes_written = len;
+
+ return bytes_written;
+}
+
/* Return value is whether we successfully wrote any bytes */
static dbus_bool_t
write_data_from_auth (DBusTransport *transport)
{
- DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
+// DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
int bytes_written;
const DBusString *buffer;
&buffer))
return FALSE;
- bytes_written = _dbus_write_socket (socket_transport->fd,
- buffer,
- 0, _dbus_string_get_length (buffer));
+ bytes_written = kdbus_send_auth (transport, buffer);
if (bytes_written > 0)
{
oom = FALSE;
- orig_auth_state = _dbus_transport_get_is_authenticated (transport);
+ orig_auth_state = _dbus_transport_try_to_authenticate (transport);
/* This is essential to avoid the check_write_watch() at the end,
* we don't want to add a write watch in do_iteration before
_dbus_transport_ref (transport);
- while (!_dbus_transport_get_is_authenticated (transport) &&
+ while (!_dbus_transport_try_to_authenticate (transport) &&
_dbus_transport_get_is_connected (transport))
{
if (!exchange_credentials (transport, do_reading, do_writing))
out:
if (auth_completed)
- *auth_completed = (orig_auth_state != _dbus_transport_get_is_authenticated (transport));
+ *auth_completed = (orig_auth_state != _dbus_transport_try_to_authenticate (transport));
check_read_watch (transport);
check_write_watch (transport);
#ifdef DBUS_AUTHENTICATION
/* No messages without authentication! */
- if (!_dbus_transport_get_is_authenticated (transport))
+ if (!_dbus_transport_try_to_authenticate (transport))
{
_dbus_verbose ("Not authenticated, not writing anything\n");
return TRUE;
message = _dbus_connection_get_message_to_send (transport->connection);
_dbus_assert (message != NULL);
- dbus_message_unlock(message);
- dbus_message_set_sender(message, socket_transport->sender);
- dbus_message_lock (message);
+ if(dbus_message_get_sender(message) == NULL) //needed for daemon
+ {
+ dbus_message_unlock(message);
+ dbus_message_set_sender(message, socket_transport->sender);
+ dbus_message_lock (message);
+ }
_dbus_message_get_network_data (message, &header, &body);
total_bytes_to_write = _dbus_string_get_length(header) + _dbus_string_get_length(body);
pDestination = dbus_message_get_destination(message);
#ifdef DBUS_AUTHENTICATION
/* No messages without authentication! */
- if (!_dbus_transport_get_is_authenticated (transport))
+ if (!_dbus_transport_try_to_authenticate (transport))
return TRUE;
#endif
{
DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;
- dbus_connection_set_is_authenticated(transport->connection); //todo remove when authentication will work
+ dbus_connection_set_is_authenticated(transport->connection); //now we don't have authentication in kdbus
_dbus_watch_set_handler (socket_transport->write_watch,
_dbus_connection_handle_watch,
return TRUE;
}
-/**
+/** original dbus copy-pasted
* @todo We need to have a way to wake up the select sleep if
* a new iteration request comes in with a flag (read/write) that
* we're not currently serving. Otherwise a call that just reads
poll_fd.fd = socket_transport->fd;
poll_fd.events = 0;
- if (_dbus_transport_peek_is_authenticated (transport))
+ if (_dbus_transport_try_to_authenticate (transport))
{
/* This is kind of a hack; if we have stuff to write, then try
* to avoid the poll. This is probably about a 5% speedup on an