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