jitterbug/wire.c

568 lines
19 KiB
C
Raw Normal View History

#include <string.h>
#include <stdio.h>
#include "try.h"
#include "wire.h"
2023-01-16 02:20:53 +02:00
#include "log.h"
2022-12-26 20:28:56 +02:00
bool wire_align(wire_context_t *c, uint32_t alignment)
{
if ((c->byte_cursor % alignment) == 0) {
return true;
}
uint32_t new_cursor = c->byte_cursor + alignment - (c->byte_cursor % alignment);
if (new_cursor >= c->data_len || new_cursor < c->byte_cursor) {
return false;
}
c->byte_cursor = new_cursor;
return true;
}
bool wire_write_align(wire_context_t *c, uint32_t alignment)
{
if ((c->byte_cursor % alignment) == 0) {
return true;
}
uint32_t new_cursor = c->byte_cursor + alignment - (c->byte_cursor % alignment);
if (new_cursor >= c->data_len || new_cursor < c->byte_cursor) {
return false;
}
while (c->byte_cursor < new_cursor) {
c->data[c->byte_cursor] = '\0';
c->byte_cursor++;
}
return true;
}
// SPEC: https://dbus.freedesktop.org/doc/dbus-specification.html#id-1.4.6
_WIRE_DEF_BYTE_TYPE(i8, int8_t)
_WIRE_DEF_BYTE_TYPE(u8, uint8_t)
_WIRE_DEF_TYPE(i16, int16_t, 2)
_WIRE_DEF_TYPE(u16, uint16_t, 2)
_WIRE_DEF_TYPE(i32, int32_t, 4)
_WIRE_DEF_TYPE(u32, uint32_t, 4)
_WIRE_DEF_TYPE(boolean, uint32_t, 4)
2022-12-26 21:13:09 +02:00
char *wire_get_string_impl(wire_context_t *c, bool as_signature)
{
2022-12-26 21:13:09 +02:00
uint32_t len = 0;
if (as_signature) {
len = *(uint8_t*)TRYPTR_NIL(wire_get_u8(c));
} else {
len = *(uint32_t*)TRYPTR_NIL(wire_get_u32(c));
}
uint32_t new_cursor = c->byte_cursor + len + 1; /* + 1 because of the extra null termination that strings have */
if (new_cursor >= c->data_len) {
return NULL;
}
2022-12-26 23:10:22 +02:00
// strings always end with a null byte
if (c->data[c->byte_cursor + len] != '\0') {
return NULL;
}
char *str = (char *)&c->data[c->byte_cursor];
2022-12-26 23:10:22 +02:00
if (strlen(str) != len) {
return NULL;
}
c->byte_cursor = new_cursor;
return str;
}
2022-12-26 21:13:09 +02:00
char *wire_set_string_impl(wire_context_t *c, const char *str, bool as_signature)
{
uint32_t len = strlen(str);
2022-12-26 21:13:09 +02:00
if (as_signature) {
TRYPTR_NIL(wire_set_u8(c, len));
} else {
TRYPTR_NIL(wire_set_u32(c, len));
}
uint32_t new_cursor = c->byte_cursor + len + 1; /* + 1 because of the extra null termination that strings have */
if (new_cursor >= c->data_len) {
return NULL;
}
// TODO?
char *dest = (char*)&c->data[c->byte_cursor];
memcpy(dest, str, len + 1);
c->byte_cursor = new_cursor;
return dest;
}
char *wire_get_string_check(wire_context_t *c, int min_length, int max_length) {
char *str = TRYPTR_NIL(wire_get_string_impl(c, false));
int length = strlen(str);
if (length < min_length || length > max_length) return NULL;
return str;
}
int wire_parse_message(wire_context_t *c, wire_message_t *msg)
{
// SPEC: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messages
2022-12-25 20:54:10 +02:00
msg->endianness = *(uint8_t*)TRYPTR(wire_get_u8(c));
2022-12-26 20:31:12 +02:00
if (msg->endianness == 'B') {
// we only support little endian
return -1;
}
2022-12-25 20:54:10 +02:00
msg->type = *(uint8_t*)TRYPTR(wire_get_u8(c));
msg->flags = *(uint8_t*)TRYPTR(wire_get_u8(c));
msg->protocol_version = *(uint8_t*)TRYPTR(wire_get_u8(c));
msg->body_length = *(uint32_t*)TRYPTR(wire_get_u32(c));
msg->serial = *(uint32_t*)TRYPTR(wire_get_u32(c));
msg->header_fields_length = *(uint32_t*)TRYPTR(wire_get_u32(c));
size_t header_fields_end = c->byte_cursor + msg->header_fields_length;
2023-01-16 02:20:53 +02:00
VERBOSE("start parse message: type=%d, no_reply_expected=%d\n", msg->type, msg->flags & DBUS_FLAG_NO_REPLY_EXPECTED);
2022-12-26 18:05:12 +02:00
while (c->byte_cursor < header_fields_end) {
2022-12-25 20:54:10 +02:00
uint8_t field_code = *(uint8_t*)TRYPTR(wire_get_u8(c));
2022-12-26 21:13:09 +02:00
TRYPTR(wire_get_signature(c));
switch (field_code) {
2022-12-23 23:58:18 +02:00
case DBUS_HEADER_FIELD_PATH: /* through */
case DBUS_HEADER_FIELD_INTERFACE: /* through */
case DBUS_HEADER_FIELD_MEMBER: /* through */
case DBUS_HEADER_FIELD_DESTINATION: {
2022-12-26 21:13:09 +02:00
char *str = TRYPTR(wire_get_string(c));
2023-01-16 02:20:53 +02:00
VERBOSE("field: %s\n", str);
2022-12-23 23:58:18 +02:00
msg->fields[field_code].t.str = str;
} break;
case DBUS_HEADER_FIELD_SIGNATURE: {
2022-12-26 21:13:09 +02:00
char *str = TRYPTR(wire_get_signature(c));
2023-01-16 02:20:53 +02:00
VERBOSE("field: %s\n", str);
2022-12-23 23:58:18 +02:00
msg->fields[field_code].t.str = str;
} break;
case DBUS_HEADER_FIELD_REPLY_SERIAL: {
2022-12-25 20:54:10 +02:00
uint32_t u = *(uint32_t*)TRYPTR(wire_get_u32(c));
2023-01-16 02:20:53 +02:00
VERBOSE("field: %d\n", u);
2022-12-23 23:58:18 +02:00
msg->fields[field_code].t.u32 = u;
} break;
default: {
printf("header: unknown field: %d\n", field_code);
return -1;
} break;
}
2022-12-23 23:58:18 +02:00
msg->fields[field_code].present = true;
// Structs are always aligned to `8`.
// SPEC: https://dbus.freedesktop.org/doc/dbus-specification.html#id-1.4.6
2022-12-25 20:54:10 +02:00
TRYPTR(wire_align(c, 8));
if (msg->header_fields_count++ > WIRE_MESSAGE_MAX_HEADER_FIELDS) {
return -1;
}
}
2023-01-16 02:20:53 +02:00
VERBOSE("end parse message\n");
2022-12-26 18:05:12 +02:00
/* header ends at 8 byte boundry */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_align(c, 8));
return 0;
}
int wire_compose_signal(wire_context_t *c, wire_message_t *out_msg, const char *signature, const char *member, uint32_t **out_body_length)
{
out_msg->endianness = 'l';
TRYPTR(wire_set_u8(c, 'l')); /* endianness */
out_msg->type = DBUS_MESSAGE_SIGNAL;
TRYPTR(wire_set_u8(c, DBUS_MESSAGE_SIGNAL)); /* type */
out_msg->flags = 0 | DBUS_FLAG_NO_REPLY_EXPECTED;
TRYPTR(wire_set_u8(c, out_msg->flags)); /* flags */
out_msg->protocol_version = DBUS_PROTOCOL_VERSION;
TRYPTR(wire_set_u8(c, DBUS_PROTOCOL_VERSION)); /* protocol_version */
uint32_t *body_length = TRYPTR(wire_set_u32(c, 0)); /* body length */
TRYPTR(wire_set_u32(c, 1)); /* serial */
uint32_t *header_fields_length = TRYPTR(wire_set_u32(c, 0)); /* header_fields_length */
uint32_t header_fields_start = c->byte_cursor;
/* header fields */
{
/* SENDER */
{
out_msg->fields[DBUS_HEADER_FIELD_SENDER].t.str = "org.freedesktop.DBus";
out_msg->fields[DBUS_HEADER_FIELD_SENDER].present = true;
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SENDER));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "s"));
/* string */
TRYPTR(wire_set_string(c, "org.freedesktop.DBus"));
// need to align to 8 byte boundry after each array element?
TRYPTR(wire_write_align(c, 8));
}
/* INTERFACE */
{
out_msg->fields[DBUS_HEADER_FIELD_INTERFACE].t.str = "org.freedesktop.DBus";
out_msg->fields[DBUS_HEADER_FIELD_INTERFACE].present = true;
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_INTERFACE));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "s"));
/* string */
TRYPTR(wire_set_string(c, "org.freedesktop.DBus"));
// need to align to 8 byte boundry after each array element?
TRYPTR(wire_write_align(c, 8));
}
/* PATH */
{
out_msg->fields[DBUS_HEADER_FIELD_PATH].t.str = "/org/freedesktop/DBus";
out_msg->fields[DBUS_HEADER_FIELD_PATH].present = true;
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_PATH));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "o"));
/* string */
TRYPTR(wire_set_string(c, "/org/freedesktop/DBus"));
// need to align to 8 byte boundry after each array element?
TRYPTR(wire_write_align(c, 8));
}
/* MEMBER */
{
out_msg->fields[DBUS_HEADER_FIELD_MEMBER].t.str = (char*)member;
out_msg->fields[DBUS_HEADER_FIELD_MEMBER].present = true;
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_MEMBER));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "s"));
/* string */
TRYPTR(wire_set_string(c, member));
// need to align to 8 byte boundry after each array element?
TRYPTR(wire_write_align(c, 8));
}
/* SIGNATURE */
{
out_msg->fields[DBUS_HEADER_FIELD_SIGNATURE].t.str = (char*)signature;
out_msg->fields[DBUS_HEADER_FIELD_SIGNATURE].present = true;
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SIGNATURE));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "g"));
/* signature */
TRYPTR(wire_set_signature(c, signature));
}
}
*header_fields_length = c->byte_cursor - header_fields_start;
// header ends on an 8 byte alignment
TRYPTR(wire_write_align(c, 8));
if (out_body_length) {
*out_body_length = body_length;
}
return 0;
}
int wire_compose_reply(wire_context_t *c, wire_message_t *msg, const char *signature, uint32_t **out_body_length)
{
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, msg->endianness)); /* endianness */
TRYPTR(wire_set_u8(c, DBUS_MESSAGE_METHOD_RETURN)); /* type */
2023-01-03 17:20:02 +02:00
TRYPTR(wire_set_u8(c, 0 | DBUS_FLAG_NO_REPLY_EXPECTED)); /* flags */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_PROTOCOL_VERSION)); /* protocol_version */
uint32_t *body_length = TRYPTR(wire_set_u32(c, 0)); /* body length */
TRYPTR(wire_set_u32(c, msg->serial+1)); /* serial */
uint32_t *header_fields_length = TRYPTR(wire_set_u32(c, 0)); /* header_fields_length */
uint32_t header_fields_start = c->byte_cursor;
/* header fields */
{
2023-01-03 19:06:44 +02:00
/* SENDER */
{
/* byte (field code) */
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SENDER));
/* variant */
/* signature */
TRYPTR(wire_set_signature(c, "s"));
/* string */
TRYPTR(wire_set_string(c, "org.freedesktop.DBus"));
// need to align to 8 byte boundry after each array element?
TRYPTR(wire_write_align(c, 8));
}
/* SIGNATURE */
{
/* byte (field code) */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SIGNATURE));
/* variant */
/* signature */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_signature(c, "g"));
/* signature */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_signature(c, signature));
// need to align to 8 byte boundry after each array element?
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
}
/* REPLY_SERIAL */
{
/* byte (field code) */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_REPLY_SERIAL));
/* variant */
/* signature */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_signature(c, "u"));
/* reply serial */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u32(c, msg->serial));
}
}
*header_fields_length = c->byte_cursor - header_fields_start;
// header ends on an 8 byte alignment
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
if (out_body_length) {
*out_body_length = body_length;
}
return 0;
}
int wire_compose_error(wire_context_t *c, wire_message_t *msg, const char *error_name)
{
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, msg->endianness)); /* endianness */
TRYPTR(wire_set_u8(c, DBUS_MESSAGE_ERROR)); /* type */
TRYPTR(wire_set_u8(c, 0)); /* flags */
TRYPTR(wire_set_u8(c, DBUS_PROTOCOL_VERSION)); /* protocol_version */
TRYPTR(wire_set_u32(c, 0)); /* body length */
TRYPTR(wire_set_u32(c, msg->serial+1)); /* serial */
uint32_t *header_fields_length = TRYPTR(wire_set_u32(c, 0)); /* header_fields_length */
uint32_t header_fields_start = c->byte_cursor;
/* header fields */
{
/* ERROR_NAME */
{
/* byte (field code) */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_ERROR_NAME));
/* variant */
/* signature */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_signature(c, "s"));
/* string */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_string(c, error_name));
// need to align to 8 byte boundry after each array element?
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
}
/* REPLY_SERIAL */
{
/* byte (field code) */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_REPLY_SERIAL));
/* variant */
/* signature */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_signature(c, "u"));
/* reply serial */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u32(c, msg->serial));
}
}
*header_fields_length = c->byte_cursor - header_fields_start;
// header ends on an 8 byte alignment
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
return 0;
}
2022-12-23 23:58:18 +02:00
int wire_compose_unicast_reply(wire_context_t *c, wire_context_t *msg_c, wire_message_t *msg, char *sender_unique_name)
{
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, msg->endianness)); /* endianness */
TRYPTR(wire_set_u8(c, msg->type)); /* type */
2023-01-03 17:20:02 +02:00
TRYPTR(wire_set_u8(c, msg->flags)); /* flags */
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_PROTOCOL_VERSION)); /* protocol_version */
TRYPTR(wire_set_u32(c, msg->body_length)); /* body length */
TRYPTR(wire_set_u32(c, msg->serial)); /* serial */
uint32_t *header_fields_length = TRYPTR(wire_set_u32(c, 0)); /* header_fields_length */
2022-12-23 23:58:18 +02:00
uint32_t header_fields_start = c->byte_cursor;
switch (msg->type) {
case DBUS_MESSAGE_METHOD_CALL: {
// these fields are required for DBUS_MESSAGE_METHOD_CALL, so we must (hackily) check for their presence
// interface is not strictly required by the spec, however we require it here anyways
wire_message_field_t *path_field = &msg->fields[DBUS_HEADER_FIELD_PATH];
wire_message_field_t *interface_field = &msg->fields[DBUS_HEADER_FIELD_INTERFACE];
wire_message_field_t *member_field = &msg->fields[DBUS_HEADER_FIELD_MEMBER];
wire_message_field_t *signature_field = &msg->fields[DBUS_HEADER_FIELD_SIGNATURE];
if (!path_field->present || !interface_field->present || !interface_field->present) {
return -1;
}
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_PATH));
TRYPTR(wire_set_signature(c, "o"));
TRYPTR(wire_set_string(c, path_field->t.str));
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_INTERFACE));
TRYPTR(wire_set_signature(c, "s"));
TRYPTR(wire_set_string(c, interface_field->t.str));
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_MEMBER));
TRYPTR(wire_set_signature(c, "s"));
TRYPTR(wire_set_string(c, member_field->t.str));
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
if (signature_field->present) {
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SIGNATURE));
TRYPTR(wire_set_signature(c, "g"));
TRYPTR(wire_set_signature(c, signature_field->t.str));
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
}
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SENDER));
TRYPTR(wire_set_signature(c, "s"));
TRYPTR(wire_set_string(c, sender_unique_name));
2022-12-23 23:58:18 +02:00
// last element, don't align
} break;
case DBUS_MESSAGE_METHOD_RETURN: {
wire_message_field_t *reply_serial_field = &msg->fields[DBUS_HEADER_FIELD_REPLY_SERIAL];
if (!reply_serial_field->present) {
return -1;
}
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_REPLY_SERIAL));
TRYPTR(wire_set_signature(c, "u"));
TRYPTR(wire_set_u32(c, reply_serial_field->t.u32));
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
wire_message_field_t *signature_field = &msg->fields[DBUS_HEADER_FIELD_SIGNATURE];
if (signature_field->present) {
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SIGNATURE));
TRYPTR(wire_set_signature(c, "g"));
2023-01-03 19:06:44 +02:00
TRYPTR(wire_set_signature(c, signature_field->t.str));
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
}
2022-12-25 20:54:10 +02:00
TRYPTR(wire_set_u8(c, DBUS_HEADER_FIELD_SENDER));
TRYPTR(wire_set_signature(c, "s"));
TRYPTR(wire_set_string(c, sender_unique_name));
2022-12-23 23:58:18 +02:00
// last element, don't align
} break;
default: {
return -1;
} break;
}
*header_fields_length = c->byte_cursor - header_fields_start;
// header ends on an 8 byte alignment
2022-12-25 20:54:10 +02:00
TRYPTR(wire_write_align(c, 8));
2022-12-23 23:58:18 +02:00
2023-01-03 19:06:44 +02:00
if (c->byte_cursor + msg->body_length >= c->data_len || msg_c->byte_cursor + msg->body_length >= msg_c->data_len) {
2022-12-23 23:58:18 +02:00
return -1;
}
memcpy(&c->data[c->byte_cursor], &msg_c->data[msg_c->byte_cursor], msg->body_length);
c->byte_cursor += msg->body_length;
2023-01-11 18:44:38 +02:00
msg_c->byte_cursor += msg->body_length;
2022-12-23 23:58:18 +02:00
return 0;
}
2022-12-29 20:10:36 +02:00
int wire_collect_strings(wire_context_t *c, wire_message_t *msg, wire_message_body_string_t *strings, int strings_count)
{
if (!msg->fields[DBUS_HEADER_FIELD_SIGNATURE].present) {
return -1;
}
char *sig = msg->fields[DBUS_HEADER_FIELD_SIGNATURE].t.str;
int stri = 0;
int sigi = 0;
uint32_t body_cursor = c->byte_cursor;
while (*sig) {
switch (*sig) {
case 'y': {
TRYPTR(wire_get_u8(c));
} break;
case 'b': {
TRYPTR(wire_get_u32(c));
} break;
case 'n': {
TRYPTR(wire_get_i16(c));
} break;
case 'q': {
TRYPTR(wire_get_u16(c));
} break;
case 'i': {
TRYPTR(wire_get_i32(c));
} break;
case 'u': {
TRYPTR(wire_get_u32(c));
} break;
case 'o': /* through */
case 's': {
char *s = TRYPTR(wire_get_string(c));
if (sigi >= strings_count) {
return -1;
}
strings[sigi].index = sigi;
strings[sigi].str = s;
} break;
case 'g': {
char *s = TRYPTR(wire_get_signature(c));
if (sigi >= strings_count) {
return -1;
}
strings[sigi].index = sigi;
strings[sigi].str = s;
} break;
case 'a': {
uint32_t array_size = *(uint32_t*)TRYPTR(wire_get_u32(c));
uint32_t new_cursor = c->byte_cursor + array_size;
if (new_cursor >= c->data_len) {
return -1;
}
c->byte_cursor = new_cursor;
} break;
default: {
return -1;
}
}
sigi++;
sig++;
}
c->byte_cursor = body_cursor;
return stri;
}