int terminate_machine(
sd_bus *bus,
const char *machine_name) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
r = sd_bus_call_method(
bus,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"TerminateMachine",
&error,
NULL,
"s",
machine_name);
if (r < 0)
log_debug("Failed to terminate machine: %s", bus_error_message(&error, r));
return 0;
}
//------------------------------------------------------------------------
// Takes FRU data, invokes Parser for each fru record area and updates
// Inventory
//------------------------------------------------------------------------
int ipmi_update_inventory(const uint8_t fruid, const uint8_t *fru_data,
fru_area_vec_t & area_vec)
{
// Now, use this fru dictionary object and connect with FRU Inventory Dbus
// and update the data for this FRU ID.
int rc = 0;
// Dictionary object to hold Name:Value pair
sd_bus_message *fru_dict = NULL;
// SD Bus error report mechanism.
sd_bus_error bus_error = SD_BUS_ERROR_NULL;
// Gets a hook onto either a SYSTEM or SESSION bus
sd_bus *bus_type = ipmid_get_sd_bus_connection();
// Req message contains the specifics about which method etc that we want to
// access on which bus, object
sd_bus_message *response = NULL;
// For each FRU area, extract the needed data , get it parsed and update
// the Inventory.
for(auto& iter : area_vec)
{
uint8_t area_type = (iter).type;
uint8_t area_data[(iter).len];
memset(area_data, 0x0, sizeof(area_data));
// Grab area specific data
memmove(area_data, (iter).offset, (iter).len);
// Need this to get respective DBUS objects
const char *area_name = NULL;
if(area_type == IPMI_FRU_AREA_CHASSIS_INFO)
{
area_name = "CHASSIS_";
}
else if(area_type == IPMI_FRU_AREA_BOARD_INFO)
{
area_name = "BOARD_";
}
else if(area_type == IPMI_FRU_AREA_PRODUCT_INFO)
{
area_name = "PRODUCT_";
}
else
{
fprintf(stderr, "ERROR: Invalid Area type :[%d]",area_type);
break;
}
// What we need is BOARD_1, PRODUCT_1, CHASSIS_1 etc..
char fru_area_name[16] = {0};
sprintf(fru_area_name,"%s%d",area_name, fruid);
#ifdef __IPMI_DEBUG__
printf("Updating Inventory with :[%s]\n",fru_area_name);
#endif
// Each area needs a clean set.
sd_bus_error_free(&bus_error);
sd_bus_message_unref(response);
sd_bus_message_unref(fru_dict);
// We want to call a method "getObjectFromId" on System Bus that is
// made available over OpenBmc system services.
rc = sd_bus_call_method(bus_type, // On the System Bus
bus_name, // Service to contact
object_name, // Object path
intf_name, // Interface name
"getObjectFromId", // Method to be called
&bus_error, // object to return error
&response, // Response message on success
"ss", // input message (string,byte)
"FRU_STR", // First argument to getObjectFromId
fru_area_name); // Second Argument
if(rc < 0)
{
fprintf(stderr, "Failed to issue method call: %s\n", bus_error.message);
break;
}
// Method getObjectFromId returns 3 parameters and all are strings, namely
// bus_name , object_path and interface name for accessing that particular
// FRU over Inventory SDBUS manager. 'sss' here mentions that format.
char *inv_bus_name, *inv_obj_path, *inv_intf_name;
rc = sd_bus_message_read(response, "(sss)", &inv_bus_name, &inv_obj_path, &inv_intf_name);
if(rc < 0)
{
fprintf(stderr, "Failed to parse response message:[%s]\n", strerror(-rc));
break;
}
#ifdef __IPMI_DEBUG__
printf("fru_area=[%s], inv_bus_name=[%s], inv_obj_path=[%s],inv_intf_name=[%s]\n",
fru_area_name, inv_bus_name, inv_obj_path, inv_intf_name);
#endif
// Constructor to allow further initializations and customization.
rc = sd_bus_message_new_method_call(bus_type,
&fru_dict,
inv_bus_name,
inv_obj_path,
inv_intf_name,
"update");
if(rc < 0)
{
fprintf(stderr,"ERROR: creating a update method call\n");
break;
}
// A Dictionary ({}) having (string, variant)
rc = sd_bus_message_open_container(fru_dict, 'a', "{sv}");
if(rc < 0)
{
fprintf(stderr,"ERROR:[%d] creating a dict container:\n",errno);
break;
}
// Fill the container with information
rc = parse_fru_area((iter).type, (void *)area_data, (iter).len, fru_dict);
if(rc < 0)
{
fprintf(stderr,"ERROR parsing FRU records\n");
break;
}
sd_bus_message_close_container(fru_dict);
// Now, Make the actual call to update the FRU inventory database with the
// dictionary given by FRU Parser. There is no response message expected for
// this.
rc = sd_bus_call(bus_type, // On the System Bus
fru_dict, // With the Name:value dictionary array
0, //
&bus_error, // Object to return error.
&response); // Response message if any.
if(rc < 0)
{
fprintf(stderr, "ERROR:[%s] updating FRU inventory for ID:[0x%X]\n",
bus_error.message, fruid);
}
else
{
printf("SUCCESS: Updated:[%s] successfully\n",fru_area_name);
}
} // END walking the vector of areas and updating
sd_bus_error_free(&bus_error);
sd_bus_message_unref(response);
sd_bus_message_unref(fru_dict);
sd_bus_unref(bus_type);
return rc;
}
int bus_print_all_properties(sd_bus *bus, const char *dest, const char *path, char **filter, bool all) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
assert(path);
r = sd_bus_call_method(bus,
dest,
path,
"org.freedesktop.DBus.Properties",
"GetAll",
&error,
&reply,
"s", "");
if (r < 0)
return r;
r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
if (r < 0)
return r;
while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
const char *name;
const char *contents;
r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &name);
if (r < 0)
return r;
if (!filter || strv_find(filter, name)) {
r = sd_bus_message_peek_type(reply, NULL, &contents);
if (r < 0)
return r;
r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
if (r < 0)
return r;
r = bus_print_property(name, reply, all);
if (r < 0)
return r;
if (r == 0) {
if (all)
printf("%s=[unprintable]\n", name);
/* skip what we didn't read */
r = sd_bus_message_skip(reply, contents);
if (r < 0)
return r;
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return r;
} else {
r = sd_bus_message_skip(reply, "v");
if (r < 0)
return r;
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return r;
}
if (r < 0)
return r;
r = sd_bus_message_exit_container(reply);
if (r < 0)
return r;
return 0;
}
static int client(struct context *c) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_unref_ sd_bus *bus = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
const char *s;
int r;
assert_se(sd_bus_new(&bus) >= 0);
assert_se(sd_bus_set_fd(bus, c->fds[1], c->fds[1]) >= 0);
assert_se(sd_bus_start(bus) >= 0);
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "NoOperation", &error, NULL, NULL);
assert_se(r >= 0);
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AlterSomething", &error, &reply, "s", "hallo");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
assert_se(streq(s, "<<<hallo>>>"));
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Doesntexist", &error, &reply, "");
assert_se(r < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_METHOD));
sd_bus_error_free(&error);
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AlterSomething", &error, &reply, "as", 1, "hallo");
assert_se(r < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS));
sd_bus_error_free(&error);
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, &reply, "s");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
assert_se(streq(s, "<<<hallo>>>"));
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, "s", "test");
assert_se(r >= 0);
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Something", &error, &reply, "s");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
assert_se(streq(s, "test"));
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AutomaticIntegerProperty", &error, "u", 815);
assert_se(r >= 0);
assert_se(c->automatic_integer_property == 815);
r = sd_bus_set_property(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "AutomaticStringProperty", &error, "s", "Du Dödel, Du!");
assert_se(r >= 0);
assert_se(streq(c->automatic_string_property, "Du Dödel, Du!"));
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
fputs(s, stdout);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_get_property(bus, "org.freedesktop.systemd.test", "/value/xuzz", "org.freedesktop.systemd.ValueTest", "Value", &error, &reply, "s");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
log_info("read %s", s);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
fputs(s, stdout);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
fputs(s, stdout);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");
assert_se(r >= 0);
r = sd_bus_message_read(reply, "s", &s);
assert_se(r >= 0);
fputs(s, stdout);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", "");
assert_se(r >= 0);
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", "org.freedesktop.systemd.ValueTest2");
assert_se(r < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_INTERFACE));
sd_bus_error_free(&error);
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", &error, &reply, "");
assert_se(r < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_METHOD));
sd_bus_error_free(&error);
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects", &error, &reply, "");
assert_se(r >= 0);
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.systemd.ValueTest", "NotifyTest", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.Properties", "PropertiesChanged"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/value/a", "org.freedesktop.systemd.ValueTest", "NotifyTest2", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.Properties", "PropertiesChanged"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitInterfacesAdded", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitInterfacesRemoved", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitObjectAdded", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "EmitObjectRemoved", &error, NULL, "");
assert_se(r >= 0);
r = sd_bus_process(bus, &reply);
assert_se(r > 0);
assert_se(sd_bus_message_is_signal(reply, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved"));
bus_message_dump(reply, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
sd_bus_message_unref(reply);
reply = NULL;
r = sd_bus_call_method(bus, "org.freedesktop.systemd.test", "/foo", "org.freedesktop.systemd.test", "Exit", &error, NULL, "");
assert_se(r >= 0);
sd_bus_flush(bus);
return 0;
}
int register_machine(
sd_bus *bus,
const char *machine_name,
pid_t pid,
const char *directory,
sd_id128_t uuid,
int local_ifindex,
const char *slice,
CustomMount *mounts,
unsigned n_mounts,
int kill_signal,
char **properties,
bool keep_unit,
const char *service) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
if (keep_unit) {
r = sd_bus_call_method(
bus,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"RegisterMachineWithNetwork",
&error,
NULL,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
service,
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
} else {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = sd_bus_message_new_method_call(
bus,
&m,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"CreateMachineWithNetwork");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(
m,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
service,
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return bus_log_create_error(r);
if (!isempty(slice)) {
r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
if (r < 0)
return bus_log_create_error(r);
}
r = append_controller_property(bus, m);
if (r < 0)
return r;
r = append_machine_properties(
m,
mounts,
n_mounts,
kill_signal,
properties);
if (r < 0)
return r;
r = bus_append_unit_property_assignment_many(m, UNIT_SERVICE, properties);
if (r < 0)
return r;
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, NULL);
}
if (r < 0) {
log_error("Failed to register machine: %s", bus_error_message(&error, r));
return r;
}
return 0;
}
static void client_chart(Type type, const char *address, const char *server_name, int fd) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *x = NULL;
size_t csize;
sd_bus *b;
int r;
r = sd_bus_new(&b);
assert_se(r >= 0);
if (type == TYPE_DIRECT) {
r = sd_bus_set_fd(b, fd, fd);
assert_se(r >= 0);
} else {
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
r = sd_bus_set_bus_client(b, true);
assert_se(r >= 0);
}
r = sd_bus_start(b);
assert_se(r >= 0);
r = sd_bus_call_method(b, server_name, "/", "benchmark.server", "Ping", NULL, NULL, NULL);
assert_se(r >= 0);
switch (type) {
case TYPE_KDBUS:
printf("SIZE\tCOPY\tMEMFD\n");
break;
case TYPE_LEGACY:
printf("SIZE\tLEGACY\n");
break;
case TYPE_DIRECT:
printf("SIZE\tDIRECT\n");
break;
}
for (csize = 1; csize <= MAX_SIZE; csize *= 2) {
usec_t t;
unsigned n_copying, n_memfd;
printf("%zu\t", csize);
if (type == TYPE_KDBUS) {
b->use_memfd = 0;
t = now(CLOCK_MONOTONIC);
for (n_copying = 0;; n_copying++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\t", (unsigned) ((n_copying * USEC_PER_SEC) / arg_loop_usec));
b->use_memfd = -1;
}
t = now(CLOCK_MONOTONIC);
for (n_memfd = 0;; n_memfd++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
}
b->use_memfd = 1;
assert_se(sd_bus_message_new_method_call(b, &x, server_name, "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
sd_bus_unref(b);
}
// Helper Function to get IP Address/NetMask/Gateway from Network Manager or Cache
// based on Set-In-Progress State
ipmi_ret_t getNetworkData(uint8_t lan_param, uint8_t * data)
{
sd_bus *bus = ipmid_get_sd_bus_connection();
sd_bus_message *reply = NULL;
sd_bus_error error = SD_BUS_ERROR_NULL;
int family;
unsigned char prefixlen;
char* ipaddr = NULL;
unsigned long mask = 0xFFFFFFFF;
char* gateway = NULL;
int r = 0;
ipmi_ret_t rc = IPMI_CC_OK;
r = sd_bus_call_method(bus, app, obj, ifc, "GetAddress4", &error,
&reply, "s", nwinterface);
if(r < 0)
{
fprintf(stderr, "Failed to call Get Method: %s\n", strerror(-r));
rc = IPMI_CC_UNSPECIFIED_ERROR;
goto cleanup;
}
r = sd_bus_message_read(reply, "iyss", &family, &prefixlen, &ipaddr, &gateway);
if(r < 0)
{
fprintf(stderr, "Failed to get a response: %s\n", strerror(-rc));
rc = IPMI_CC_RESPONSE_ERROR;
goto cleanup;
}
printf("N/W data from HW %s:%d:%s:%s\n", family==AF_INET?"IPv4":"IPv6", prefixlen, ipaddr,gateway);
printf("N/W data from Cache: %s:%s:%s\n", new_ipaddr, new_netmask, new_gateway);
if(lan_param == LAN_PARM_IP)
{
if(lan_set_in_progress == SET_COMPLETE)
{
std::string ipaddrstr(ipaddr);
inet_pton(AF_INET, ipaddrstr.c_str(),(void *)data);
}
else if(lan_set_in_progress == SET_IN_PROGRESS)
{
inet_pton(AF_INET, new_ipaddr, (void *)data);
}
}
else if(lan_param == LAN_PARM_SUBNET)
{
if(lan_set_in_progress == SET_COMPLETE)
{
mask = htonl(mask<<(32-prefixlen));
memcpy(data, &mask, 4);
}
else if(lan_set_in_progress == SET_IN_PROGRESS)
{
inet_pton(AF_INET, new_netmask, (void *)data);
}
}
else if(lan_param == LAN_PARM_GATEWAY)
{
if(lan_set_in_progress == SET_COMPLETE)
{
std::string gatewaystr(gateway);
inet_pton(AF_INET, gatewaystr.c_str(), (void *)data);
}
else if(lan_set_in_progress == SET_IN_PROGRESS)
{
inet_pton(AF_INET, new_gateway,(void *)data);
}
}
else
{
rc = IPMI_CC_PARM_OUT_OF_RANGE;
}
cleanup:
sd_bus_error_free(&error);
reply = sd_bus_message_unref(reply);
return rc;
}
ipmi_ret_t ipmi_transport_set_lan(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
ipmi_request_t request, ipmi_response_t response,
ipmi_data_len_t data_len, ipmi_context_t context)
{
ipmi_ret_t rc = IPMI_CC_OK;
*data_len = 0;
sd_bus *bus = ipmid_get_sd_bus_connection();
sd_bus_message *reply = NULL;
sd_bus_error error = SD_BUS_ERROR_NULL;
int r = 0;
printf("IPMI SET_LAN\n");
set_lan_t *reqptr = (set_lan_t*) request;
// TODO Use dbus interface once available. For now use cmd line.
// TODO Add the rest of the parameters like setting auth type
// TODO Add error handling
if (reqptr->parameter == LAN_PARM_IP)
{
snprintf(new_ipaddr, INET_ADDRSTRLEN, "%d.%d.%d.%d",
reqptr->data[0], reqptr->data[1], reqptr->data[2], reqptr->data[3]);
}
else if (reqptr->parameter == LAN_PARM_MAC)
{
char mac[SIZE_MAC];
snprintf(mac, SIZE_MAC, "%02x:%02x:%02x:%02x:%02x:%02x",
reqptr->data[0],
reqptr->data[1],
reqptr->data[2],
reqptr->data[3],
reqptr->data[4],
reqptr->data[5]);
r = sd_bus_call_method(bus, app, obj, ifc, "SetHwAddress", &error,
&reply, "ss", nwinterface, mac);
if(r < 0)
{
fprintf(stderr, "Failed to call the method: %s\n", strerror(-r));
rc = IPMI_CC_UNSPECIFIED_ERROR;
}
}
else if (reqptr->parameter == LAN_PARM_SUBNET)
{
snprintf(new_netmask, INET_ADDRSTRLEN, "%d.%d.%d.%d",
reqptr->data[0], reqptr->data[1], reqptr->data[2], reqptr->data[3]);
}
else if (reqptr->parameter == LAN_PARM_GATEWAY)
{
snprintf(new_gateway, INET_ADDRSTRLEN, "%d.%d.%d.%d",
reqptr->data[0], reqptr->data[1], reqptr->data[2], reqptr->data[3]);
}
else if (reqptr->parameter == LAN_PARM_INPROGRESS)
{
if(reqptr->data[0] == SET_COMPLETE) // Set Complete
{
lan_set_in_progress = SET_COMPLETE;
// Apply the IP settings once IP Address, Netmask and Gateway is set
if (!strcmp(new_ipaddr, "") || !strcmp (new_netmask, "") || !strcmp (new_gateway, ""))
{
printf("ERROR: Incomplete LAN Parameters\n");
}
else
{
r = sd_bus_call_method(bus, // On the System Bus
app, // Service to contact
obj, // Object path
ifc, // Interface name
"SetAddress4", // Method to be called
&error, // object to return error
&reply, // Response message on success
"ssss", // input message (Interface, IP Address, Netmask, Gateway)
nwinterface, // eth0
new_ipaddr,
new_netmask,
new_gateway);
if(r < 0)
{
fprintf(stderr, "Failed to set network data %s:%s:%s %s\n", new_ipaddr, new_netmask, new_gateway, error.message);
rc = IPMI_CC_UNSPECIFIED_ERROR;
}
memset(new_ipaddr, 0, INET_ADDRSTRLEN);
memset(new_netmask, 0, INET_ADDRSTRLEN);
memset(new_gateway, 0, INET_ADDRSTRLEN);
}
}
else if(reqptr->data[0] == SET_IN_PROGRESS) // Set In Progress
{
lan_set_in_progress = SET_IN_PROGRESS;
}
}
else
{
fprintf(stderr, "Unsupported parameter 0x%x\n", reqptr->parameter);
rc = IPMI_CC_PARM_NOT_SUPPORTED;
}
sd_bus_error_free(&error);
reply = sd_bus_message_unref(reply);
return rc;
}
int bus_verify_polkit(
sd_bus *bus,
sd_bus_message *m,
const char *action,
bool interactive,
bool *_challenge,
sd_bus_error *e) {
const char *sender;
uid_t uid;
int r;
assert(bus);
assert(m);
assert(action);
sender = sd_bus_message_get_sender(m);
if (!sender)
return -EBADMSG;
r = sd_bus_get_owner_uid(bus, sender, &uid);
if (r < 0)
return r;
if (uid == 0)
return 1;
#ifdef ENABLE_POLKIT
else {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
unsigned authorized = false, challenge = false;
r = sd_bus_call_method(
bus,
"org.freedesktop.PolicyKit1",
"/org/freedesktop/PolicyKit1/Authority",
"org.freedesktop.PolicyKit1.Authority",
"CheckAuthorization",
e,
&reply,
"(sa{sv})sa{ss}us",
"system-bus-name", 1, "name", "s", sender,
action,
0,
interactive ? 1 : 0,
"");
if (r < 0) {
/* Treat no PK available as access denied */
if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN)) {
sd_bus_error_free(e);
return -EACCES;
}
return r;
}
r = sd_bus_message_read(reply, "(bb)", &authorized, &challenge);
if (r < 0)
return r;
if (authorized)
return 1;
if (_challenge) {
*_challenge = challenge;
return 0;
}
}
#endif
return -EACCES;
}
//-------------------------------------------------------------------
// Gets called by PowerOff handler when a Soft Power off is requested
//-------------------------------------------------------------------
static int soft_power_off(sd_bus_message *m, void *userdata, sd_bus_error *ret_error)
{
int64_t bt_resp = -1;
int rc = 0;
char *bus_name = NULL;
// Steps to be taken when we get this.
// 1: Send a SMS_ATN to the Host
// 2: Host receives it and sends a GetMsgFlags IPMI command
// 3: IPMID app handler will respond to that with a MSgFlag with bit:0x2
// set indicating we have a message for Host
// 4: Host sends a GetMsgBuffer command and app handler will respond to
// that with a OEM-SEL with certain fields packed indicating to the
// host that it do a shutdown of the partitions.
// 5: Host does the partition shutdown and calls Chassis Power off command
// 6: App handler handles the command by making a call to ChassisManager
// Dbus
// Now the job is to send the SMS_ATTN.
// Req message contains the specifics about which method etc that we want to
// access on which bus, object
sd_bus_message *response = NULL;
// Error return mechanism
sd_bus_error bus_error = SD_BUS_ERROR_NULL;
// Gets a hook onto either a SYSTEM or SESSION bus
sd_bus *bus = ipmid_get_sd_bus_connection();
rc = mapper_get_service(bus, object_name, &bus_name);
if (rc < 0) {
fprintf(stderr, "Failed to get %s bus name: %s\n",
object_name, strerror(-rc));
goto finish;
}
rc = sd_bus_call_method(bus, // In the System Bus
bus_name, // Service to contact
object_name, // Object path
intf_name, // Interface name
"setAttention", // Method to be called
&bus_error, // object to return error
&response, // Response buffer if any
NULL); // No input arguments
if(rc < 0)
{
fprintf(stderr,"ERROR initiating Power Off:[%s]\n",bus_error.message);
goto finish;
}
// See if we were able to successfully raise SMS_ATN
rc = sd_bus_message_read(response, "x", &bt_resp);
if (rc < 0)
{
fprintf(stderr, "Failed to get a rc from BT for SMS_ATN: %s\n", strerror(-rc));
goto finish;
}
finish:
sd_bus_error_free(&bus_error);
response = sd_bus_message_unref(response);
free(bus_name);
if(rc < 0)
{
return sd_bus_reply_method_return(m, "x", rc);
}
else
{
return sd_bus_reply_method_return(m, "x", bt_resp);
}
}
//-------------------
// Destructor
//-------------------
ipmi_fru::~ipmi_fru()
{
sd_bus_error bus_error = SD_BUS_ERROR_NULL;
sd_bus_message *response = NULL;
int rc = 0;
if(iv_data != NULL)
{
delete [] iv_data;
iv_data = NULL;
}
// If we have not been successful in doing some updates and we are a BMC
// fru, then need to set the fault bits.
bool valid_dbus = !(iv_bus_name.empty()) &&
!(iv_obj_path.empty()) &&
!(iv_intf_name.empty());
// Based on bmc_fru, success in updating the FRU inventory we need to set
// some special bits.
if(iv_bmc_fru && valid_dbus)
{
// Set the Fault bit if we did not successfully process the fru
const char *fault_bit = iv_valid ? "False" : "True";
rc = sd_bus_call_method(iv_bus_type, // On the System Bus
iv_bus_name.c_str(), // Service to contact
iv_obj_path.c_str(), // Object path
iv_intf_name.c_str(), // Interface name
"setFault", // Method to be called
&bus_error, // object to return error
&response, // Response message on success
"s", // input message (string)
fault_bit); // First argument to setFault
if(rc <0)
{
fprintf(stderr,"Failed to set Fault bit, value:[%s] for fruid:[%d], path:[%s]\n",
fault_bit, iv_fruid, iv_obj_path.c_str());
}
else
{
printf("Fault bit set to :[%s] for fruid:[%d], Path:[%s]\n",
fault_bit, iv_fruid,iv_obj_path.c_str());
}
sd_bus_error_free(&bus_error);
sd_bus_message_unref(response);
// Set the Present bits
const char *present_bit = iv_present ? "True" : "False";
rc = sd_bus_call_method(iv_bus_type, // On the System Bus
iv_bus_name.c_str(), // Service to contact
iv_obj_path.c_str(), // Object path
iv_intf_name.c_str(), // Interface name
"setPresent", // Method to be called
&bus_error, // object to return error
&response, // Response message on success
"s", // input message (string)
present_bit); // First argument to setPresent
if(rc < 0)
{
fprintf(stderr,"Failed to set Present bit for fruid:[%d], path:[%s]\n",
iv_fruid, iv_obj_path.c_str());
}
else
{
printf("Present bit set to :[%s] for fruid:[%d], Path[%s]:\n",
present_bit, iv_fruid, iv_obj_path.c_str());
}
sd_bus_error_free(&bus_error);
sd_bus_message_unref(response);
}
}
///-----------------------------------------------------
// Get the fru area names defined in BMC for a given @fruid.
//----------------------------------------------------
int get_defined_fru_area(sd_bus *bus_type, const uint8_t fruid,
std::vector<std::string> &defined_fru_area)
{
// Need this to get respective DBUS objects
sd_bus_error bus_error = SD_BUS_ERROR_NULL;
sd_bus_message *response = NULL;
int rc = 0;
char *areas = NULL;
#ifdef __IPMI_DEBUG__
printf("Getting fru areas defined in Skeleton for :[%d]\n", fruid);
#endif
// We want to call a method "getFRUArea" on System Bus that is
// made available over OpenBmc system services.
rc = sd_bus_call_method(bus_type, // On the System Bus
sys_bus_name, // Service to contact
sys_object_name, // Object path
sys_intf_name, // Interface name
"getFRUArea", // Method to be called
&bus_error, // object to return error
&response, // Response message on success
"y", // input message (integer)
fruid); // Argument
if(rc < 0)
{
fprintf(stderr, "Failed to get fru area for fruid:[%d] to dbus: [%s]\n",
fruid, bus_error.message);
}
else
{
// if several fru area names are defined, the names are combined to
// a string seperated by ','
rc = sd_bus_message_read(response, "s", &areas);
if(rc < 0)
{
fprintf(stderr, "Failed to parse response message from getFRUArea:[%s]\n",
strerror(-rc));
}
else
{
#ifdef __IPMI_DEBUG__
printf("get defined fru area: id: %d, areas: %s\n", fruid, areas);
#endif
std::string area_name;
std::stringstream ss(areas);
// fru area names string is seperated by ',', parse it into tokens
while (std::getline(ss, area_name, ','))
{
if (!area_name.empty())
defined_fru_area.emplace_back(area_name);
}
}
}
sd_bus_error_free(&bus_error);
sd_bus_message_unref(response);
return rc;
}
static int start_transient_service(
sd_bus *bus,
char **argv,
int *retval) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
_cleanup_free_ char *service = NULL, *pty_path = NULL;
_cleanup_close_ int master = -1;
int r;
assert(bus);
assert(argv);
assert(retval);
if (arg_pty) {
if (arg_transport == BUS_TRANSPORT_LOCAL) {
master = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NDELAY);
if (master < 0)
return log_error_errno(errno, "Failed to acquire pseudo tty: %m");
r = ptsname_malloc(master, &pty_path);
if (r < 0)
return log_error_errno(r, "Failed to determine tty name: %m");
if (unlockpt(master) < 0)
return log_error_errno(errno, "Failed to unlock tty: %m");
} else if (arg_transport == BUS_TRANSPORT_MACHINE) {
_cleanup_(sd_bus_unrefp) sd_bus *system_bus = NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *pty_reply = NULL;
const char *s;
r = sd_bus_default_system(&system_bus);
if (r < 0)
return log_error_errno(r, "Failed to connect to system bus: %m");
r = sd_bus_call_method(system_bus,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"OpenMachinePTY",
&error,
&pty_reply,
"s", arg_host);
if (r < 0) {
log_error("Failed to get machine PTY: %s", bus_error_message(&error, -r));
return r;
}
r = sd_bus_message_read(pty_reply, "hs", &master, &s);
if (r < 0)
return bus_log_parse_error(r);
master = fcntl(master, F_DUPFD_CLOEXEC, 3);
if (master < 0)
return log_error_errno(errno, "Failed to duplicate master fd: %m");
pty_path = strdup(s);
if (!pty_path)
return log_oom();
} else
assert_not_reached("Can't allocate tty via ssh");
}
if (!arg_no_block) {
r = bus_wait_for_jobs_new(bus, &w);
if (r < 0)
return log_error_errno(r, "Could not watch jobs: %m");
}
if (arg_unit) {
r = unit_name_mangle_with_suffix(arg_unit, UNIT_NAME_NOGLOB, ".service", &service);
if (r < 0)
return log_error_errno(r, "Failed to mangle unit name: %m");
} else {
r = make_unit_name(bus, UNIT_SERVICE, &service);
if (r < 0)
return r;
}
r = sd_bus_message_new_method_call(
bus,
&m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartTransientUnit");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
if (r < 0)
return bus_log_create_error(r);
/* Name and mode */
r = sd_bus_message_append(m, "ss", service, "fail");
if (r < 0)
return bus_log_create_error(r);
/* Properties */
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return bus_log_create_error(r);
r = transient_service_set_properties(m, argv, pty_path);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
/* Auxiliary units */
r = sd_bus_message_append(m, "a(sa(sv))", 0);
if (r < 0)
return bus_log_create_error(r);
polkit_agent_open_if_enabled();
r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0)
return log_error_errno(r, "Failed to start transient service unit: %s", bus_error_message(&error, r));
if (w) {
const char *object;
r = sd_bus_message_read(reply, "o", &object);
if (r < 0)
return bus_log_parse_error(r);
r = bus_wait_for_jobs_one(w, object, arg_quiet);
if (r < 0)
return r;
}
if (!arg_quiet)
log_info("Running as unit: %s", service);
if (arg_wait || master >= 0) {
_cleanup_(run_context_free) RunContext c = {};
c.bus = sd_bus_ref(bus);
r = sd_event_default(&c.event);
if (r < 0)
return log_error_errno(r, "Failed to get event loop: %m");
if (master >= 0) {
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGWINCH, SIGTERM, SIGINT, -1) >= 0);
(void) sd_event_add_signal(c.event, NULL, SIGINT, NULL, NULL);
(void) sd_event_add_signal(c.event, NULL, SIGTERM, NULL, NULL);
if (!arg_quiet)
log_info("Press ^] three times within 1s to disconnect TTY.");
r = pty_forward_new(c.event, master, PTY_FORWARD_IGNORE_INITIAL_VHANGUP, &c.forward);
if (r < 0)
return log_error_errno(r, "Failed to create PTY forwarder: %m");
pty_forward_set_handler(c.forward, pty_forward_handler, &c);
}
if (arg_wait) {
_cleanup_free_ char *path = NULL;
const char *mt;
path = unit_dbus_path_from_name(service);
if (!path)
return log_oom();
mt = strjoina("type='signal',"
"sender='org.freedesktop.systemd1',"
"path='", path, "',"
"interface='org.freedesktop.DBus.Properties',"
"member='PropertiesChanged'");
r = sd_bus_add_match(bus, &c.match, mt, on_properties_changed, &c);
if (r < 0)
return log_error_errno(r, "Failed to add properties changed signal.");
r = sd_bus_attach_event(bus, c.event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop.");
}
r = sd_event_loop(c.event);
if (r < 0)
return log_error_errno(r, "Failed to run event loop: %m");
if (c.forward) {
char last_char = 0;
r = pty_forward_get_last_char(c.forward, &last_char);
if (r >= 0 && !arg_quiet && last_char != '\n')
fputc('\n', stdout);
}
if (!arg_quiet) {
if (!isempty(c.result))
log_info("Finished with result: %s", strna(c.result));
if (c.exit_code == CLD_EXITED)
log_info("Main processes terminated with: code=%s/status=%i", sigchld_code_to_string(c.exit_code), c.exit_status);
else if (c.exit_code > 0)
log_info("Main processes terminated with: code=%s/status=%s", sigchld_code_to_string(c.exit_code), signal_to_string(c.exit_status));
if (c.inactive_enter_usec > 0 && c.inactive_enter_usec != USEC_INFINITY &&
c.inactive_exit_usec > 0 && c.inactive_exit_usec != USEC_INFINITY &&
c.inactive_enter_usec > c.inactive_exit_usec) {
char ts[FORMAT_TIMESPAN_MAX];
log_info("Service runtime: %s", format_timespan(ts, sizeof(ts), c.inactive_enter_usec - c.inactive_exit_usec, USEC_PER_MSEC));
}
if (c.cpu_usage_nsec > 0 && c.cpu_usage_nsec != NSEC_INFINITY) {
char ts[FORMAT_TIMESPAN_MAX];
log_info("CPU time consumed: %s", format_timespan(ts, sizeof(ts), (c.cpu_usage_nsec + NSEC_PER_USEC - 1) / NSEC_PER_USEC, USEC_PER_MSEC));
}
}
/* Try to propagate the service's return value */
if (c.result && STR_IN_SET(c.result, "success", "exit-code") && c.exit_code == CLD_EXITED)
*retval = c.exit_status;
else
*retval = EXIT_FAILURE;
}
return 0;
}
/*
* First of all, creates a transaction;
* then reads the newly created bus path,
* adds a match to the bus to wait until installation is really finished before notifying the user.
* finally, calls InstallFiles method, and processes the bus while finished == 0.
*/
void *install_package(void *str) {
sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus_message *mess = NULL;
sd_bus *install_bus = NULL;
const char *path;
int r, inhibit_fd = -1, finished = 0;
r = sd_bus_open_system(&install_bus);
if (r < 0) {
print_and_warn(strerror(-r), ERR_LINE);
goto finish;
}
INFO("calling CreateTransaction on bus.");
r = sd_bus_call_method(install_bus,
"org.freedesktop.PackageKit",
"/org/freedesktop/PackageKit",
"org.freedesktop.PackageKit",
"CreateTransaction",
&error,
&mess,
NULL);
if (r < 0) {
print_and_warn(error.message, ERR_LINE);
goto finish;
}
if (config.inhibit) {
inhibit_fd = inhibit_suspend("Package installation...");
}
sd_bus_message_read(mess, "o", &path);
r = sd_bus_add_match(install_bus, NULL, "type='signal',interface='org.freedesktop.PackageKit.Transaction',member='Finished'", match_callback, &finished);
if (r < 0) {
print_and_warn(strerror(-r), ERR_LINE);
goto finish;
}
sd_bus_flush(install_bus);
INFO("calling InstallFiles on bus.");
r = sd_bus_call_method(install_bus,
"org.freedesktop.PackageKit",
path,
"org.freedesktop.PackageKit.Transaction",
"InstallFiles",
&error,
NULL,
"tas",
0,
1,
(char *)str);
if (r < 0) {
print_and_warn(error.message, ERR_LINE);
goto finish;
}
while (!finished) {
r = sd_bus_process(install_bus, NULL);
if (r > 0) {
continue;
}
r = sd_bus_wait(install_bus, (uint64_t) -1);
if (r < 0) {
break;
}
}
finish:
stop_inhibition(inhibit_fd);
close_bus(&error, mess, install_bus);
pthread_detach(pthread_self());
pthread_exit(NULL);
}
enum nss_status _nss_systemd_getgrgid_r(
gid_t gid,
struct group *gr,
char *buffer, size_t buflen,
int *errnop) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
const char *translated;
size_t l;
int r;
BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
if (!gid_is_valid(gid)) {
r = -EINVAL;
goto fail;
}
if (gid <= SYSTEM_GID_MAX)
goto not_found;
if (getenv_bool("SYSTEMD_NSS_DYNAMIC_BYPASS") > 0)
goto not_found;
r = sd_bus_open_system(&bus);
if (r < 0)
goto fail;
r = sd_bus_call_method(bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"LookupDynamicUserByUID",
&error,
&reply,
"u",
(uint32_t) gid);
if (r < 0) {
if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_DYNAMIC_USER))
goto not_found;
goto fail;
}
r = sd_bus_message_read(reply, "s", &translated);
if (r < 0)
goto fail;
l = sizeof(char*) + strlen(translated) + 1;
if (buflen < l) {
*errnop = ENOMEM;
return NSS_STATUS_TRYAGAIN;
}
memzero(buffer, sizeof(char*));
strcpy(buffer + sizeof(char*), translated);
gr->gr_name = buffer + sizeof(char*);
gr->gr_gid = gid;
gr->gr_passwd = (char*) "*"; /* locked */
gr->gr_mem = (char**) buffer;
*errnop = 0;
return NSS_STATUS_SUCCESS;
not_found:
*errnop = 0;
return NSS_STATUS_NOTFOUND;
fail:
*errnop = -r;
return NSS_STATUS_UNAVAIL;
}
enum nss_status _nss_systemd_getpwnam_r(
const char *name,
struct passwd *pwd,
char *buffer, size_t buflen,
int *errnop) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
uint32_t translated;
size_t l;
int r;
BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
assert(name);
assert(pwd);
/* Make sure that we don't go in circles when allocating a dynamic UID by checking our own database */
if (getenv_bool("SYSTEMD_NSS_DYNAMIC_BYPASS") > 0)
goto not_found;
r = sd_bus_open_system(&bus);
if (r < 0)
goto fail;
r = sd_bus_call_method(bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"LookupDynamicUserByName",
&error,
&reply,
"s",
name);
if (r < 0) {
if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_DYNAMIC_USER))
goto not_found;
goto fail;
}
r = sd_bus_message_read(reply, "u", &translated);
if (r < 0)
goto fail;
l = strlen(name);
if (buflen < l+1) {
*errnop = ENOMEM;
return NSS_STATUS_TRYAGAIN;
}
memcpy(buffer, name, l+1);
pwd->pw_name = buffer;
pwd->pw_uid = (uid_t) translated;
pwd->pw_gid = (uid_t) translated;
pwd->pw_gecos = (char*) "Dynamic User";
pwd->pw_passwd = (char*) "*"; /* locked */
pwd->pw_dir = (char*) "/";
pwd->pw_shell = (char*) "/sbin/nologin";
*errnop = 0;
return NSS_STATUS_SUCCESS;
not_found:
*errnop = 0;
return NSS_STATUS_NOTFOUND;
fail:
*errnop = -r;
return NSS_STATUS_UNAVAIL;
}
static int acquire_time_data(sd_bus *bus, struct unit_times **out) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r, c = 0;
struct unit_times *unit_times = NULL;
size_t size = 0;
UnitInfo u;
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"ListUnits",
&error, &reply,
NULL);
if (r < 0) {
log_error("Failed to list units: %s", bus_error_message(&error, -r));
goto fail;
}
r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
if (r < 0) {
bus_log_parse_error(r);
goto fail;
}
while ((r = bus_parse_unit_info(reply, &u)) > 0) {
struct unit_times *t;
if (!GREEDY_REALLOC(unit_times, size, c+1)) {
r = log_oom();
goto fail;
}
t = unit_times+c;
t->name = NULL;
assert_cc(sizeof(usec_t) == sizeof(uint64_t));
if (bus_get_uint64_property(bus, u.unit_path,
"org.freedesktop.systemd1.Unit",
"InactiveExitTimestampMonotonic",
&t->activating) < 0 ||
bus_get_uint64_property(bus, u.unit_path,
"org.freedesktop.systemd1.Unit",
"ActiveEnterTimestampMonotonic",
&t->activated) < 0 ||
bus_get_uint64_property(bus, u.unit_path,
"org.freedesktop.systemd1.Unit",
"ActiveExitTimestampMonotonic",
&t->deactivating) < 0 ||
bus_get_uint64_property(bus, u.unit_path,
"org.freedesktop.systemd1.Unit",
"InactiveEnterTimestampMonotonic",
&t->deactivated) < 0) {
r = -EIO;
goto fail;
}
if (t->activated >= t->activating)
t->time = t->activated - t->activating;
else if (t->deactivated >= t->activating)
t->time = t->deactivated - t->activating;
else
t->time = 0;
if (t->activating == 0)
continue;
t->name = strdup(u.id);
if (t->name == NULL) {
r = log_oom();
goto fail;
}
c++;
}
if (r < 0) {
bus_log_parse_error(r);
goto fail;
}
*out = unit_times;
return c;
fail:
free_unit_times(unit_times, (unsigned) c);
return r;
}
ipmi_ret_t ipmi_transport_get_lan(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
ipmi_request_t request, ipmi_response_t response,
ipmi_data_len_t data_len, ipmi_context_t context)
{
ipmi_ret_t rc = IPMI_CC_OK;
*data_len = 0;
sd_bus *bus = ipmid_get_sd_bus_connection();
sd_bus_message *reply = NULL;
sd_bus_error error = SD_BUS_ERROR_NULL;
int r = 0;
const uint8_t current_revision = 0x11; // Current rev per IPMI Spec 2.0
int i = 0;
printf("IPMI GET_LAN\n");
get_lan_t *reqptr = (get_lan_t*) request;
if (reqptr->rev_channel & 0x80) // Revision is bit 7
{
// Only current revision was requested
*data_len = sizeof(current_revision);
memcpy(response, ¤t_revision, *data_len);
return IPMI_CC_OK;
}
// TODO Use dbus interface once available. For now use ip cmd.
// TODO Add the rest of the parameters, like gateway
if (reqptr->parameter == LAN_PARM_INPROGRESS)
{
uint8_t buf[] = {current_revision, lan_set_in_progress};
*data_len = sizeof(buf);
memcpy(response, &buf, *data_len);
}
else if (reqptr->parameter == LAN_PARM_AUTHSUPPORT)
{
uint8_t buf[] = {current_revision,0x04};
*data_len = sizeof(buf);
memcpy(response, &buf, *data_len);
}
else if (reqptr->parameter == LAN_PARM_AUTHENABLES)
{
uint8_t buf[] = {current_revision,0x04,0x04,0x04,0x04,0x04};
*data_len = sizeof(buf);
memcpy(response, &buf, *data_len);
}
else if ((reqptr->parameter == LAN_PARM_IP) || (reqptr->parameter == LAN_PARM_SUBNET) || (reqptr->parameter == LAN_PARM_GATEWAY))
{
uint8_t buf[5];
*data_len = sizeof(current_revision);
memcpy(buf, ¤t_revision, *data_len);
if(getNetworkData(reqptr->parameter, &buf[1]) == IPMI_CC_OK)
{
*data_len = sizeof(buf);
memcpy(response, &buf, *data_len);
}
else
{
rc = IPMI_CC_UNSPECIFIED_ERROR;
}
}
else if (reqptr->parameter == LAN_PARM_MAC)
{
//string to parse: link/ether xx:xx:xx:xx:xx:xx
uint8_t buf[7];
char *eaddr1 = NULL;
r = sd_bus_call_method(bus, app, obj, ifc, "GetHwAddress", &error,
&reply, "s", nwinterface);
if(r < 0)
{
fprintf(stderr, "Failed to call Get Method: %s\n", strerror(-r));
rc = IPMI_CC_UNSPECIFIED_ERROR;
goto cleanup;
}
r = sd_bus_message_read(reply, "s", &eaddr1);
if (r < 0)
{
fprintf(stderr, "Failed to get a response: %s", strerror(-r));
rc = IPMI_CC_UNSPECIFIED_ERROR;
goto cleanup;
}
if (eaddr1 == NULL)
{
fprintf(stderr, "Failed to get a valid response: %s", strerror(-r));
rc = IPMI_CC_UNSPECIFIED_ERROR;
goto cleanup;
}
memcpy((void*)&buf[0], ¤t_revision, 1);
char *tokptr = NULL;
char* digit = strtok_r(eaddr1, ":", &tokptr);
if (digit == NULL)
{
fprintf(stderr, "Unexpected MAC format: %s", eaddr1);
rc = IPMI_CC_RESPONSE_ERROR;
goto cleanup;
}
i=0;
while (digit != NULL)
{
int resp_byte = strtoul(digit, NULL, 16);
memcpy((void*)&buf[i+1], &resp_byte, 1);
i++;
digit = strtok_r(NULL, ":", &tokptr);
}
*data_len = sizeof(buf);
memcpy(response, &buf, *data_len);
}
else
{
fprintf(stderr, "Unsupported parameter 0x%x\n", reqptr->parameter);
rc = IPMI_CC_PARM_NOT_SUPPORTED;
}
cleanup:
sd_bus_error_free(&error);
reply = sd_bus_message_unref(reply);
return rc;
}
int dbus_get_property(const char *name, char **buf)
{
sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus_message *m = NULL;
sd_bus *bus = NULL;
char *temp_buf = NULL;
char *connection = NULL;
int r;
r = object_mapper_get_connection(&connection, settings_object_name);
if (r < 0) {
fprintf(stderr, "Failed to get connection, return value: %d.\n", r);
goto finish;
}
printf("connection: %s\n", connection);
// Get the system bus where most system services are provided.
bus = ipmid_get_sd_bus_connection();
/*
* Bus, service, object path, interface and method are provided to call
* the method.
* Signatures and input arguments are provided by the arguments at the
* end.
*/
r = sd_bus_call_method(bus,
connection, /* service to contact */
settings_object_name, /* object path */
settings_intf_name, /* interface name */
"Get", /* method name */
&error, /* object to return error in */
&m, /* return message on success */
"ss", /* input signature */
host_intf_name, /* first argument */
name); /* second argument */
if (r < 0) {
fprintf(stderr, "Failed to issue method call: %s\n", error.message);
goto finish;
}
/*
* The output should be parsed exactly the same as the output formatting
* specified.
*/
r = sd_bus_message_read(m, "v", "s", &temp_buf);
if (r < 0) {
fprintf(stderr, "Failed to parse response message: %s\n", strerror(-r));
goto finish;
}
asprintf(buf, "%s", temp_buf);
/* *buf = (char*) malloc(strlen(temp_buf));
if (*buf) {
strcpy(*buf, temp_buf);
}
*/
printf("IPMID boot option property get: {%s}.\n", (char *) temp_buf);
finish:
sd_bus_error_free(&error);
sd_bus_message_unref(m);
free(connection);
return r;
}
int register_machine(
const char *machine_name,
pid_t pid,
const char *directory,
sd_id128_t uuid,
int local_ifindex,
const char *slice,
CustomMount *mounts,
unsigned n_mounts,
int kill_signal,
char **properties,
bool keep_unit) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
int r;
r = sd_bus_default_system(&bus);
if (r < 0)
return log_error_errno(r, "Failed to open system bus: %m");
if (keep_unit) {
r = sd_bus_call_method(
bus,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"RegisterMachineWithNetwork",
&error,
NULL,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
"nspawn",
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
} else {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
char **i;
unsigned j;
r = sd_bus_message_new_method_call(
bus,
&m,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
"org.freedesktop.machine1.Manager",
"CreateMachineWithNetwork");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(
m,
"sayssusai",
machine_name,
SD_BUS_MESSAGE_APPEND_ID128(uuid),
"nspawn",
"container",
(uint32_t) pid,
strempty(directory),
local_ifindex > 0 ? 1 : 0, local_ifindex);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return bus_log_create_error(r);
if (!isempty(slice)) {
r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_append(m, "(sv)", "DevicePolicy", "s", "strict");
if (r < 0)
return bus_log_create_error(r);
/* If you make changes here, also make sure to update
* [email protected], to keep the device
* policies in sync regardless if we are run with or
* without the --keep-unit switch. */
r = sd_bus_message_append(m, "(sv)", "DeviceAllow", "a(ss)", 9,
/* Allow the container to
* access and create the API
* device nodes, so that
* PrivateDevices= in the
* container can work
* fine */
"/dev/null", "rwm",
"/dev/zero", "rwm",
"/dev/full", "rwm",
"/dev/random", "rwm",
"/dev/urandom", "rwm",
"/dev/tty", "rwm",
"/dev/net/tun", "rwm",
/* Allow the container
* access to ptys. However,
* do not permit the
* container to ever create
* these device nodes. */
"/dev/pts/ptmx", "rw",
"char-pts", "rw");
if (r < 0)
return bus_log_create_error(r);
for (j = 0; j < n_mounts; j++) {
CustomMount *cm = mounts + j;
if (cm->type != CUSTOM_MOUNT_BIND)
continue;
r = is_device_node(cm->source);
if (r < 0)
return log_error_errno(r, "Failed to stat %s: %m", cm->source);
if (r) {
r = sd_bus_message_append(m, "(sv)", "DeviceAllow", "a(ss)", 1,
cm->source, cm->read_only ? "r" : "rw");
if (r < 0)
return log_error_errno(r, "Failed to append message arguments: %m");
}
}
if (kill_signal != 0) {
r = sd_bus_message_append(m, "(sv)", "KillSignal", "i", kill_signal);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "(sv)", "KillMode", "s", "mixed");
if (r < 0)
return bus_log_create_error(r);
}
STRV_FOREACH(i, properties) {
r = sd_bus_message_open_container(m, 'r', "sv");
if (r < 0)
return bus_log_create_error(r);
r = bus_append_unit_property_assignment(m, *i);
if (r < 0)
return r;
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, NULL);
}
int object_mapper_get_connection(char **buf, const char *obj_path)
{
sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus_message *m = NULL;
sd_bus *bus = NULL;
char *temp_buf = NULL, *intf = NULL;
size_t buf_size = 0;
int r;
// Get the system bus where most system services are provided.
bus = ipmid_get_sd_bus_connection();
/*
* Bus, service, object path, interface and method are provided to call
* the method.
* Signatures and input arguments are provided by the arguments at the
* end.
*/
r = sd_bus_call_method(bus,
objmapper_service_name, /* service to contact */
objmapper_object_name, /* object path */
objmapper_intf_name, /* interface name */
"GetObject", /* method name */
&error, /* object to return error in */
&m, /* return message on success */
"s", /* input signature */
obj_path /* first argument */
);
if (r < 0) {
fprintf(stderr, "Failed to issue method call: %s\n", error.message);
goto finish;
}
// Get the key, aka, the connection name
sd_bus_message_read(m, "a{sas}", 1, &temp_buf, 1, &intf);
/*
* TODO: check the return code. Currently for no reason the message
* parsing of object mapper is always complaining about
* "Device or resource busy", but the result seems OK for now. Need
* further checks.
* TODO: The following code is preserved in the comments so that it can be
* resumed after the problem aforementioned is resolved.
*r = sd_bus_message_read(m, "a{sas}", 1, &temp_buf, 1, &intf);
*if (r < 0) {
* fprintf(stderr, "Failed to parse response message: %s\n", strerror(-r));
* goto finish;
*}
*/
buf_size = strlen(temp_buf) + 1;
printf("IPMID connection name: %s\n", temp_buf);
*buf = (char *)malloc(buf_size);
if (*buf == NULL) {
fprintf(stderr, "Malloc failed for get_sys_boot_options");
r = -1;
goto finish;
}
memcpy(*buf, temp_buf, buf_size);
finish:
sd_bus_error_free(&error);
sd_bus_message_unref(m);
return r;
}
static void client_bisect(const char *address, const char *server_name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *x = NULL;
size_t lsize, rsize, csize;
sd_bus *b;
int r;
r = sd_bus_new(&b);
assert_se(r >= 0);
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
r = sd_bus_start(b);
assert_se(r >= 0);
r = sd_bus_call_method(b, server_name, "/", "benchmark.server", "Ping", NULL, NULL, NULL);
assert_se(r >= 0);
lsize = 1;
rsize = MAX_SIZE;
printf("SIZE\tCOPY\tMEMFD\n");
for (;;) {
usec_t t;
unsigned n_copying, n_memfd;
csize = (lsize + rsize) / 2;
if (csize <= lsize)
break;
if (csize <= 0)
break;
printf("%zu\t", csize);
b->use_memfd = 0;
t = now(CLOCK_MONOTONIC);
for (n_copying = 0;; n_copying++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\t", (unsigned) ((n_copying * USEC_PER_SEC) / arg_loop_usec));
b->use_memfd = -1;
t = now(CLOCK_MONOTONIC);
for (n_memfd = 0;; n_memfd++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
if (n_copying == n_memfd)
break;
if (n_copying > n_memfd)
lsize = csize;
else
rsize = csize;
}
b->use_memfd = 1;
assert_se(sd_bus_message_new_method_call(b, &x, server_name, "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
sd_bus_unref(b);
}
int bus_map_all_properties(sd_bus *bus,
const char *destination,
const char *path,
const struct bus_properties_map *map,
void *userdata) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(bus);
assert(destination);
assert(path);
assert(map);
r = sd_bus_call_method( bus,
destination,
path,
"org.freedesktop.DBus.Properties",
"GetAll",
&error,
&m,
"s", "");
if (r < 0)
return r;
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
if (r < 0)
return r;
while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
const struct bus_properties_map *prop;
const char *member;
const char *contents;
void *v;
unsigned i;
r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
if (r < 0)
return r;
for (i = 0, prop = NULL; map[i].member; i++)
if (streq(map[i].member, member)) {
prop = &map[i];
break;
}
if (prop) {
r = sd_bus_message_peek_type(m, NULL, &contents);
if (r < 0)
return r;
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
if (r < 0)
return r;
v = (uint8_t *)userdata + prop->offset;
if (map[i].set)
r = prop->set(bus, member, m, &error, v);
else
r = map_basic(bus, member, m, &error, v);
r = sd_bus_message_exit_container(m);
if (r < 0)
return r;
} else {
r = sd_bus_message_skip(m, "v");
if (r < 0)
return r;
}
r = sd_bus_message_exit_container(m);
if (r < 0)
return r;
}
return r;
}
static void* client1(void*p) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
const char *hello;
int r;
_cleanup_close_pair_ int pp[2] = { -1, -1 };
char x;
r = sd_bus_open_user(&bus);
if (r < 0) {
log_error_errno(r, "Failed to connect to user bus: %m");
goto finish;
}
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
"LowerCase",
&error,
&reply,
"s",
"HELLO");
if (r < 0) {
log_error_errno(r, "Failed to issue method call: %m");
goto finish;
}
r = sd_bus_message_read(reply, "s", &hello);
if (r < 0) {
log_error_errno(r, "Failed to get string: %m");
goto finish;
}
assert_se(streq(hello, "hello"));
if (pipe2(pp, O_CLOEXEC|O_NONBLOCK) < 0) {
log_error_errno(errno, "Failed to allocate pipe: %m");
r = -errno;
goto finish;
}
log_info("Sending fd=%d", pp[1]);
r = sd_bus_call_method(
bus,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
"FileDescriptor",
&error,
NULL,
"h",
pp[1]);
if (r < 0) {
log_error_errno(r, "Failed to issue method call: %m");
goto finish;
}
errno = 0;
if (read(pp[0], &x, 1) <= 0) {
log_error("Failed to read from pipe: %s", errno ? strerror(errno) : "early read");
goto finish;
}
r = 0;
finish:
if (bus) {
_cleanup_bus_message_unref_ sd_bus_message *q;
r = sd_bus_message_new_method_call(
bus,
&q,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
"ExitClient1");
if (r < 0)
log_error_errno(r, "Failed to allocate method call: %m");
else
sd_bus_send(bus, q, NULL);
}
return INT_TO_PTR(r);
}
static int list_images(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = sd_bus_call_method(
bus,
"org.freedesktop.portable1",
"/org/freedesktop/portable1",
"org.freedesktop.portable1.Manager",
"ListImages",
&error,
&reply,
NULL);
if (r < 0)
return log_error_errno(r, "Failed to list images: %s", bus_error_message(&error, r));
table = table_new("name", "type", "ro", "crtime", "mtime", "usage", "state");
if (!table)
return log_oom();
r = sd_bus_message_enter_container(reply, 'a', "(ssbtttso)");
if (r < 0)
return bus_log_parse_error(r);
for (;;) {
const char *name, *type, *state;
uint64_t crtime, mtime, usage;
TableCell *cell;
bool ro_bool;
int ro_int;
r = sd_bus_message_read(reply, "(ssbtttso)", &name, &type, &ro_int, &crtime, &mtime, &usage, &state, NULL);
if (r < 0)
return bus_log_parse_error(r);
if (r == 0)
break;
r = table_add_many(table,
TABLE_STRING, name,
TABLE_STRING, type);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
ro_bool = ro_int;
r = table_add_cell(table, &cell, TABLE_BOOLEAN, &ro_bool);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
if (ro_bool) {
r = table_set_color(table, cell, ansi_highlight_red());
if (r < 0)
return log_error_errno(r, "Failed to set table cell color: %m");
}
r = table_add_many(table,
TABLE_TIMESTAMP, crtime,
TABLE_TIMESTAMP, mtime,
TABLE_SIZE, usage);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
r = table_add_cell(table, &cell, TABLE_STRING, state);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
if (!streq(state, "detached")) {
r = table_set_color(table, cell, ansi_highlight_green());
if (r < 0)
return log_error_errno(r, "Failed to set table cell color: %m");
}
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return bus_log_parse_error(r);
if (table_get_rows(table) > 1) {
r = table_set_sort(table, (size_t) 0, (size_t) -1);
if (r < 0)
return log_error_errno(r, "Failed to sort table: %m");
table_set_header(table, arg_legend);
r = table_print(table, NULL);
if (r < 0)
return log_error_errno(r, "Failed to show table: %m");
}
if (arg_legend) {
if (table_get_rows(table) > 1)
printf("\n%zu images listed.\n", table_get_rows(table) - 1);
else
printf("No images.\n");
}
return 0;
}
int bus_verify_polkit(
sd_bus_message *call,
int capability,
const char *action,
bool interactive,
bool *_challenge,
sd_bus_error *e) {
int r;
assert(call);
assert(action);
r = sd_bus_query_sender_privilege(call, capability);
if (r < 0)
return r;
else if (r > 0)
return 1;
#ifdef ENABLE_POLKIT
else {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
int authorized = false, challenge = false;
const char *sender;
sender = sd_bus_message_get_sender(call);
if (!sender)
return -EBADMSG;
r = sd_bus_call_method(
call->bus,
"org.freedesktop.PolicyKit1",
"/org/freedesktop/PolicyKit1/Authority",
"org.freedesktop.PolicyKit1.Authority",
"CheckAuthorization",
e,
&reply,
"(sa{sv})sa{ss}us",
"system-bus-name", 1, "name", "s", sender,
action,
0,
interactive ? 1 : 0,
"");
if (r < 0) {
/* Treat no PK available as access denied */
if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN)) {
sd_bus_error_free(e);
return -EACCES;
}
return r;
}
r = sd_bus_message_enter_container(reply, 'r', "bba{ss}");
if (r < 0)
return r;
r = sd_bus_message_read(reply, "bb", &authorized, &challenge);
if (r < 0)
return r;
if (authorized)
return 1;
if (_challenge) {
*_challenge = challenge;
return 0;
}
}
#endif
return -EACCES;
}
int main(int argc, char *argv[]) {
_cleanup_close_ int bus_ref = -1;
_cleanup_free_ char *name = NULL, *bus_name = NULL, *address = NULL, *bname = NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char *ua = NULL, *ub = NULL, *the_string = NULL;
sd_bus *a, *b;
int r, pipe_fds[2];
const char *nn;
log_set_max_level(LOG_DEBUG);
assert_se(asprintf(&name, "deine-mutter-%u", (unsigned) getpid()) >= 0);
bus_ref = bus_kernel_create_bus(name, false, &bus_name);
if (bus_ref == -ENOENT)
return EXIT_TEST_SKIP;
assert_se(bus_ref >= 0);
address = strappend("kernel:path=", bus_name);
assert_se(address);
r = sd_bus_new(&a);
assert_se(r >= 0);
r = sd_bus_new(&b);
assert_se(r >= 0);
r = sd_bus_set_description(a, "a");
assert_se(r >= 0);
r = sd_bus_set_address(a, address);
assert_se(r >= 0);
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
assert_se(sd_bus_negotiate_timestamp(a, 1) >= 0);
assert_se(sd_bus_negotiate_creds(a, true, _SD_BUS_CREDS_ALL) >= 0);
assert_se(sd_bus_negotiate_timestamp(b, 0) >= 0);
assert_se(sd_bus_negotiate_creds(b, true, 0) >= 0);
r = sd_bus_start(a);
assert_se(r >= 0);
r = sd_bus_start(b);
assert_se(r >= 0);
assert_se(sd_bus_negotiate_timestamp(b, 1) >= 0);
assert_se(sd_bus_negotiate_creds(b, true, _SD_BUS_CREDS_ALL) >= 0);
r = sd_bus_get_unique_name(a, &ua);
assert_se(r >= 0);
printf("unique a: %s\n", ua);
r = sd_bus_get_description(a, &nn);
assert_se(r >= 0);
printf("name of a: %s\n", nn);
r = sd_bus_get_unique_name(b, &ub);
assert_se(r >= 0);
printf("unique b: %s\n", ub);
r = sd_bus_get_description(b, &nn);
assert_se(r >= 0);
printf("name of b: %s\n", nn);
assert_se(bus_kernel_get_bus_name(b, &bname) >= 0);
assert_se(endswith(bname, name));
r = sd_bus_call_method(a, "this.doesnt.exist", "/foo", "meh.mah", "muh", &error, NULL, "s", "yayayay");
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_SERVICE_UNKNOWN));
assert_se(r == -EHOSTUNREACH);
r = sd_bus_add_match(b, NULL, "interface='waldo.com',member='Piep'", NULL, NULL);
assert_se(r >= 0);
r = sd_bus_emit_signal(a, "/foo/bar/waldo", "waldo.com", "Piep", "sss", "I am a string", "/this/is/a/path", "and.this.a.domain.name");
assert_se(r >= 0);
r = sd_bus_try_close(b);
assert_se(r == -EBUSY);
r = sd_bus_process_priority(b, -10, &m);
assert_se(r == 0);
r = sd_bus_process(b, &m);
assert_se(r > 0);
assert_se(m);
bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
assert_se(sd_bus_message_rewind(m, true) >= 0);
r = sd_bus_message_read(m, "s", &the_string);
assert_se(r >= 0);
assert_se(streq(the_string, "I am a string"));
sd_bus_message_unref(m);
m = NULL;
r = sd_bus_request_name(a, "net.x0pointer.foobar", 0);
assert_se(r >= 0);
r = sd_bus_message_new_method_call(b, &m, "net.x0pointer.foobar", "/a/path", "an.inter.face", "AMethod");
assert_se(r >= 0);
assert_se(pipe2(pipe_fds, O_CLOEXEC) >= 0);
assert_se(write(pipe_fds[1], "x", 1) == 1);
pipe_fds[1] = safe_close(pipe_fds[1]);
r = sd_bus_message_append(m, "h", pipe_fds[0]);
assert_se(r >= 0);
pipe_fds[0] = safe_close(pipe_fds[0]);
r = sd_bus_send(b, m, NULL);
assert_se(r >= 0);
for (;;) {
sd_bus_message_unref(m);
m = NULL;
r = sd_bus_process(a, &m);
assert_se(r > 0);
assert_se(m);
bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
assert_se(sd_bus_message_rewind(m, true) >= 0);
if (sd_bus_message_is_method_call(m, "an.inter.face", "AMethod")) {
int fd;
char x;
r = sd_bus_message_read(m, "h", &fd);
assert_se(r >= 0);
assert_se(read(fd, &x, 1) == 1);
assert_se(x == 'x');
break;
}
}
r = sd_bus_release_name(a, "net.x0pointer.foobar");
assert_se(r >= 0);
r = sd_bus_release_name(a, "net.x0pointer.foobar");
assert_se(r == -ESRCH);
r = sd_bus_try_close(a);
assert_se(r >= 0);
sd_bus_unref(a);
sd_bus_unref(b);
return 0;
}
static int manager_connect_bus(Manager *m) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(m);
assert(!m->bus);
r = sd_bus_default_system(&m->bus);
if (r < 0)
return log_error_errno(r, "Failed to connect to system bus: %m");
r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/machine1", "org.freedesktop.machine1.Manager", manager_vtable, m);
if (r < 0)
return log_error_errno(r, "Failed to add manager object vtable: %m");
r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/machine", "org.freedesktop.machine1.Machine", machine_vtable, machine_object_find, m);
if (r < 0)
return log_error_errno(r, "Failed to add machine object vtable: %m");
r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/machine", machine_node_enumerator, m);
if (r < 0)
return log_error_errno(r, "Failed to add machine enumerator: %m");
r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/image", "org.freedesktop.machine1.Image", image_vtable, image_object_find, m);
if (r < 0)
return log_error_errno(r, "Failed to add image object vtable: %m");
r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/image", image_node_enumerator, m);
if (r < 0)
return log_error_errno(r, "Failed to add image enumerator: %m");
r = sd_bus_add_match(m->bus,
NULL,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='JobRemoved',"
"path='/org/freedesktop/systemd1'",
match_job_removed,
m);
if (r < 0)
return log_error_errno(r, "Failed to add match for JobRemoved: %m");
r = sd_bus_add_match(m->bus,
NULL,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='UnitRemoved',"
"path='/org/freedesktop/systemd1'",
match_unit_removed,
m);
if (r < 0)
return log_error_errno(r, "Failed to add match for UnitRemoved: %m");
r = sd_bus_add_match(m->bus,
NULL,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.DBus.Properties',"
"member='PropertiesChanged',"
"arg0='org.freedesktop.systemd1.Unit'",
match_properties_changed,
m);
if (r < 0)
return log_error_errno(r, "Failed to add match for PropertiesChanged: %m");
r = sd_bus_add_match(m->bus,
NULL,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='Reloading',"
"path='/org/freedesktop/systemd1'",
match_reloading,
m);
if (r < 0)
return log_error_errno(r, "Failed to add match for Reloading: %m");
r = sd_bus_call_method(
m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"Subscribe",
&error,
NULL, NULL);
if (r < 0) {
log_error("Failed to enable subscription: %s", bus_error_message(&error, r));
return r;
}
r = sd_bus_request_name(m->bus, "org.freedesktop.machine1", 0);
if (r < 0)
return log_error_errno(r, "Failed to register name: %m");
r = sd_bus_attach_event(m->bus, m->event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
return 0;
}
enum nss_status _nss_systemd_getpwuid_r(
uid_t uid,
struct passwd *pwd,
char *buffer, size_t buflen,
int *errnop) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
const char *translated;
size_t l;
int r;
BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
if (!uid_is_valid(uid)) {
r = -EINVAL;
goto fail;
}
if (uid <= SYSTEM_UID_MAX)
goto not_found;
if (getenv_bool("SYSTEMD_NSS_DYNAMIC_BYPASS") > 0)
goto not_found;
r = sd_bus_open_system(&bus);
if (r < 0)
goto fail;
r = sd_bus_call_method(bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"LookupDynamicUserByUID",
&error,
&reply,
"u",
(uint32_t) uid);
if (r < 0) {
if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_DYNAMIC_USER))
goto not_found;
goto fail;
}
r = sd_bus_message_read(reply, "s", &translated);
if (r < 0)
goto fail;
l = strlen(translated) + 1;
if (buflen < l) {
*errnop = ENOMEM;
return NSS_STATUS_TRYAGAIN;
}
memcpy(buffer, translated, l);
pwd->pw_name = buffer;
pwd->pw_uid = uid;
pwd->pw_gid = uid;
pwd->pw_gecos = (char*) "Dynamic User";
pwd->pw_passwd = (char*) "*"; /* locked */
pwd->pw_dir = (char*) "/";
pwd->pw_shell = (char*) "/sbin/nologin";
*errnop = 0;
return NSS_STATUS_SUCCESS;
not_found:
*errnop = 0;
return NSS_STATUS_NOTFOUND;
fail:
*errnop = -r;
return NSS_STATUS_UNAVAIL;
}
