static int PmonInit(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
usec_t time = 0;
sd_bus_message_read(m, "t", &time);
int id = 0;
if (openSlots == 0) {
return sd_bus_reply_method_return(m, "u", -1);
}
uint64_t usec = 0;
sd_event_now(event, CLOCK_MONOTONIC, &usec);
usec += time;
if (clients[lastAllocatedId] == NULL) {
id = lastAllocatedId;
sd_event_add_time(event, &clients[lastAllocatedId], CLOCK_MONOTONIC, usec, 1000,
Timeout, (void *)sd_bus_message_get_sender(m));
lastAllocatedId += 1;
openSlots -= 1;
clientTimeout[id] = time;
return sd_bus_reply_method_return(m, "u", id);
}
id = freeIds[lastFreedSlot];
sd_event_add_time(event, &clients[freeIds[lastFreedSlot]], CLOCK_MONOTONIC, usec, 1000,
Timeout, (void *)sd_bus_message_get_sender(m));
lastFreedSlot -= 1;
openSlots -= 1;
clientTimeout[id] = time;
return sd_bus_reply_method_return(m, "u", id);
}
static void server(sd_bus *b, size_t *result) {
int r;
for (;;) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
r = sd_bus_process(b, &m);
assert_se(r >= 0);
if (r == 0)
assert_se(sd_bus_wait(b, (usec_t) -1) >= 0);
if (!m)
continue;
if (sd_bus_message_is_method_call(m, "benchmark.server", "Ping"))
assert_se(sd_bus_reply_method_return(b, m, NULL) >= 0);
else if (sd_bus_message_is_method_call(m, "benchmark.server", "Work")) {
const void *p;
size_t sz;
/* Make sure the mmap is mapped */
assert_se(sd_bus_message_read_array(m, 'y', &p, &sz) > 0);
assert_se(sd_bus_reply_method_return(b, m, NULL) >= 0);
} else if (sd_bus_message_is_method_call(m, "benchmark.server", "Exit")) {
uint64_t res;
assert_se(sd_bus_message_read(m, "t", &res) > 0);
*result = res;
return;
} else
assert_not_reached("Unknown method");
}
}
static int generate_signals(sd_bus_message *m, void *userdata, sd_bus_error
*ret_error) {
uint64_t num_signals, payload_size;
uint64_t i = 0;
double c_time;
int r;
struct timeval ts;
char *pl = NULL;
/* Read the parameters */
r = sd_bus_message_read(m, "tt", &num_signals, &payload_size);
if (r < 0) {
fprintf(stderr, "Failed to parse parameters: %s\n", strerror(-r));
return r;
}
printf("SpamSignal: %"PRIu64", %"PRIu64 "\n", num_signals,
payload_size);
pl = (char*) malloc(payload_size + 1);
_rs(pl, payload_size);
for (i = 0; i < num_signals; i++) {
c_time = time_time();
r = sd_bus_emit_signal(bus, OBJ, INT,
"Spam", "dts", c_time, payload_size, pl);
if (r < 0) {
fprintf(stderr, "Failed to emit signal: %s\n", strerror(-r));
free(pl);
return sd_bus_reply_method_return(m, "t", i);
}
}
free(pl);
return sd_bus_reply_method_return(m, "t", num_signals);
}
static int something_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
struct context *c = userdata;
const char *s;
char *n = NULL;
int r;
r = sd_bus_message_read(m, "s", &s);
assert_se(r > 0);
n = strjoin("<<<", s, ">>>", NULL);
assert_se(n);
free(c->something);
c->something = n;
log_info("AlterSomething() called, got %s, returning %s", s, n);
/* This should fail, since the return type doesn't match */
assert_se(sd_bus_reply_method_return(m, "u", 4711) == -ENOMSG);
r = sd_bus_reply_method_return(m, "s", n);
assert_se(r >= 0);
return 1;
}
static int method_set_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
Context *c = userdata;
const char *name;
int interactive;
char *h;
int r;
assert(m);
assert(c);
r = sd_bus_message_read(m, "sb", &name, &interactive);
if (r < 0)
return r;
if (isempty(name))
name = c->data[PROP_STATIC_HOSTNAME];
if (isempty(name))
name = "localhost";
if (!hostname_is_valid(name, false))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname '%s'", name);
if (streq_ptr(name, c->data[PROP_HOSTNAME]))
return sd_bus_reply_method_return(m, NULL);
r = bus_verify_polkit_async(
m,
CAP_SYS_ADMIN,
"org.freedesktop.hostname1.set-hostname",
NULL,
interactive,
UID_INVALID,
&c->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
h = strdup(name);
if (!h)
return -ENOMEM;
free(c->data[PROP_HOSTNAME]);
c->data[PROP_HOSTNAME] = h;
r = context_update_kernel_hostname(c);
if (r < 0) {
log_error_errno(r, "Failed to set host name: %m");
return sd_bus_error_set_errnof(error, r, "Failed to set hostname: %s", strerror(-r));
}
log_info("Changed host name to '%s'", strna(c->data[PROP_HOSTNAME]));
(void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m), "/org/freedesktop/hostname1", "org.freedesktop.hostname1", "Hostname", NULL);
return sd_bus_reply_method_return(m, NULL);
}
int bus_scope_method_abandon(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Scope *s = userdata;
int r;
assert(message);
assert(s);
r = mac_selinux_unit_access_check(UNIT(s), message, "stop", error);
if (r < 0)
return r;
r = bus_verify_manage_units_async(UNIT(s)->manager, message, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
r = scope_abandon(s);
if (r == -ESTALE)
return sd_bus_error_setf(error, BUS_ERROR_SCOPE_NOT_RUNNING, "Scope %s is not running, cannot abandon.", UNIT(s)->id);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
int bus_job_method_cancel(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Job *j = userdata;
int r;
assert(message);
assert(j);
r = mac_selinux_unit_access_check(j->unit, message, "stop", error);
if (r < 0)
return r;
/* Access is granted to the job owner */
if (!sd_bus_track_contains(j->clients, sd_bus_message_get_sender(message))) {
/* And for everybody else consult PolicyKit */
r = bus_verify_manage_units_async(j->unit->manager, message, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
}
job_finish_and_invalidate(j, JOB_CANCELED, true);
return sd_bus_reply_method_return(message, NULL);
}
static int method_echo(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
char *str;
const char *intf = sd_bus_message_get_interface(m),
*path = sd_bus_message_get_path(m);
sd_bus *bus = sd_bus_message_get_bus(m);
char response[512] = {0};
int r;
/* Read the parameters */
r = sd_bus_message_read(m, "s", &str);
if (r < 0) {
fprintf(stderr, "Failed to parse parameters: %s\n", strerror(-r));
return r;
}
r = sd_bus_emit_signal(bus, path, intf, "MethodInvoked", "ss",
"Echo method was invoked", path);
if (r < 0) {
fprintf(stderr, "Failed to emit signal: %s\n", strerror(-r));
return r;
}
strncat(response, path, 128);
strcat(response, " says ");
strncat(response, str, 128);
/* Reply with the response */
return sd_bus_reply_method_return(m, "s", &response);
}
int bus_image_method_remove(
sd_bus_message *message,
void *userdata,
sd_bus_error *error) {
Image *image = userdata;
Manager *m = image->userdata;
int r;
assert(message);
assert(image);
r = bus_verify_polkit_async(
message,
CAP_SYS_ADMIN,
"org.freedesktop.machine1.manage-images",
false,
UID_INVALID,
&m->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = image_remove(image);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
int bus_machine_method_kill(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Machine *m = userdata;
const char *swho;
int32_t signo;
KillWho who;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "si", &swho, &signo);
if (r < 0)
return r;
if (isempty(swho))
who = KILL_ALL;
else {
who = kill_who_from_string(swho);
if (who < 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
}
if (signo <= 0 || signo >= _NSIG)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
r = machine_kill(m, who, signo);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int operation_done(sd_event_source *s, const siginfo_t *si, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
Operation *o = userdata;
int r;
assert(o);
assert(si);
log_debug("Operating " PID_FMT " is now complete with code=%s status=%i",
o->pid,
sigchld_code_to_string(si->si_code), si->si_status);
o->pid = 0;
if (si->si_code != CLD_EXITED) {
r = sd_bus_error_setf(&error, SD_BUS_ERROR_FAILED, "Child died abnormally.");
goto fail;
}
if (si->si_status == EXIT_SUCCESS)
r = 0;
else if (read(o->errno_fd, &r, sizeof(r)) != sizeof(r)) { /* Try to acquire error code for failed operation */
r = sd_bus_error_setf(&error, SD_BUS_ERROR_FAILED, "Child failed.");
goto fail;
}
if (o->done) {
/* A completion routine is set for this operation, call it. */
r = o->done(o, r, &error);
if (r < 0) {
if (!sd_bus_error_is_set(&error))
sd_bus_error_set_errno(&error, r);
goto fail;
}
} else {
/* The default operation when done is to simply return an error on failure or an empty success
* message on success. */
if (r < 0) {
sd_bus_error_set_errno(&error, r);
goto fail;
}
r = sd_bus_reply_method_return(o->message, NULL);
if (r < 0)
log_error_errno(r, "Failed to reply to message: %m");
}
operation_free(o);
return 0;
fail:
r = sd_bus_reply_method_error(o->message, &error);
if (r < 0)
log_error_errno(r, "Failed to reply to message: %m");
operation_free(o);
return 0;
}
int bus_machine_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Machine *m = userdata;
int r;
assert(message);
assert(m);
r = bus_verify_polkit_async(
message,
CAP_KILL,
"org.freedesktop.machine1.manage-machines",
NULL,
false,
UID_INVALID,
&m->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = machine_stop(m);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int driver_remove_match(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
struct bus_match_component *components = NULL;
_cleanup_free_ char *normalized = NULL;
Context *context = userdata;
unsigned n_components = 0;
Client *c = NULL;
Match *m = NULL;
char *arg0;
uint64_t id;
int r;
assert(bus);
assert(message);
assert(context);
r = sd_bus_message_read(message, "s", &arg0);
if (r < 0)
return r;
r = bus_kernel_parse_unique_name(message->sender, &id);
if (r < 0)
return r;
c = hashmap_get(context->clients, &id);
if (!c)
return sd_bus_error_setf(error, SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "You have not registered any matches.");
r = bus_match_parse(arg0, &components, &n_components);
if (r < 0) {
r = sd_bus_error_setf(error, SD_BUS_ERROR_MATCH_RULE_INVALID, "Match rule \"%s\" is not valid", arg0);
goto finish;
}
normalized = bus_match_to_string(components, n_components);
if (!normalized) {
r = -ENOMEM;
goto finish;
}
m = hashmap_get(c->matches, normalized);
if (!m) {
r = sd_bus_error_setf(error, SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "Match rule \"%s\" not found.", normalized);
goto finish;
}
bus_remove_match_internal_kernel(bus, id, m->cookie);
match_free(m);
r = sd_bus_reply_method_return(message, NULL);
finish:
bus_match_parse_free(components, n_components);
if (c->n_matches <= 0)
client_free(c);
return r;
}
static int DevicePath(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
int cmd = DBUSGETPATH;
write(fd, &cmd, sizeof(int));
read(fd, path, sizeof(path));
return sd_bus_reply_method_return(m, "s", path);
}
static int GetTimeoutDbus(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
int cmd = DBUSGETIMOUT;
write(fd, &cmd, sizeof(long));
read(fd, &timeout, sizeof(long));
return sd_bus_reply_method_return(m, "x", timeout);
}
static int Identity(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
int cmd = DBUSGETNAME;
write(fd, &cmd, sizeof(int));
read(fd, identity, sizeof(identity));
return sd_bus_reply_method_return(m, "s", identity);
}
static void dbus_req_reply(struct dbus_req *dreq, uint8_t type, const char *first, const char *second)
{
int rc;
rc = sd_bus_reply_method_return(dreq->message,
"yssu", type, first, second, (uint32_t)dreq->context.flags);
if (rc < 0)
ERROR("sending the reply failed");
}
static int Version(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
int cmd = DBUSVERSION;
write(fd, &cmd, sizeof(long));
read(fd, &version, sizeof(long));
return sd_bus_reply_method_return(m, "x", version);
}
static int emit_object_removed(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
int r;
assert_se(sd_bus_emit_object_removed(bus, m->path) >= 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
return 1;
}
static int emit_object_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
int r;
assert_se(sd_bus_emit_object_removed(sd_bus_message_get_bus(m), "/value/a/x") >= 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
return 1;
}
static int emit_interfaces_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
int r;
assert_se(sd_bus_emit_interfaces_removed(sd_bus_message_get_bus(m), "/value/a/x", "org.freedesktop.systemd.ValueTest", NULL) >= 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
return 1;
}
static int notify_test2(sd_bus_message *m, void *userdata, sd_bus_error *error) {
int r;
assert_se(sd_bus_emit_properties_changed_strv(sd_bus_message_get_bus(m), m->path, "org.freedesktop.systemd.ValueTest", NULL) >= 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
return 1;
}
static int GetTimeleftDbus(sd_bus_message *m, void *userdata, sd_bus_error *retError)
{
int cmd = DBUSTIMELEFT;
long buf = 0;
write(fd, &cmd, sizeof(long));
read(fd, &buf, sizeof(long));
return sd_bus_reply_method_return(m, "x", buf);
}
static int driver_get_name_owner(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
int r;
r = get_creds(bus, m, SD_BUS_CREDS_UNIQUE_NAME, &creds, error);
if (r < 0)
return r;
return sd_bus_reply_method_return(m, "s", creds->unique_name);
}
static int driver_get_user(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
int r;
r = get_creds(bus, m, SD_BUS_CREDS_UID, &creds, error);
if (r < 0)
return r;
return sd_bus_reply_method_return(m, "u", (uint32_t) creds->uid);
}
static int notify_test(sd_bus *bus, sd_bus_message *m, void *userdata) {
int r;
assert_se(sd_bus_emit_properties_changed(bus, m->path, "org.freedesktop.systemd.ValueTest", "Value", NULL) >= 0);
r = sd_bus_reply_method_return(bus, m, NULL);
assert_se(r >= 0);
return 1;
}
static int emit_interfaces_removed(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
int r;
assert_se(sd_bus_emit_interfaces_removed(bus, m->path, "org.freedesktop.systemd.test", NULL) >= 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
return 1;
}
static int driver_get_id(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
sd_id128_t server_id;
char buf[SD_ID128_STRING_MAX];
int r;
r = sd_bus_get_server_id(bus, &server_id);
if (r < 0)
return r;
return sd_bus_reply_method_return(m, "s", sd_id128_to_string(server_id, buf));
}
static int driver_get_name_owner(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
const char *name;
int r;
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return r;
/* Here's a special exception for compatibility with dbus1:
* the bus name of the driver is owned by itself, not by a
* unique ID. */
if (streq(name, "org.freedesktop.DBus"))
return sd_bus_reply_method_return(m, "s", "org.freedesktop.DBus");
r = get_creds_by_name(bus, name, SD_BUS_CREDS_UNIQUE_NAME, &creds, error);
if (r < 0)
return r;
return sd_bus_reply_method_return(m, "s", creds->unique_name);
}
static int exit_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
struct context *c = userdata;
int r;
c->quit = true;
log_info("Exit called");
r = sd_bus_reply_method_return(m, "");
assert_se(r >= 0);
return 1;
}
