int main(int argc, char *argv[]) { _cleanup_bus_message_unref_ sd_bus_message *m = NULL; int r, boolean; const char *x, *y, *z, *a, *b, *c, *d; uint8_t u, v; void *buffer = NULL; size_t sz; char *h; const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array; r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &m); assert_se(r >= 0); r = sd_bus_message_append(m, "s", "a string"); assert_se(r >= 0); r = sd_bus_message_append(m, "s", NULL); assert_se(r < 0); r = sd_bus_message_append(m, "as", 2, "string #1", "string #2"); assert_se(r >= 0); r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after"); assert_se(r >= 0); r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo"); assert_se(r >= 0); r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3"); assert_se(r >= 0); r = sd_bus_message_open_container(m, 'a', "s"); assert_se(r >= 0); r = sd_bus_message_append_basic(m, 's', "foobar"); assert_se(r >= 0); r = sd_bus_message_append_basic(m, 's', "waldo"); assert_se(r >= 0); r = sd_bus_message_close_container(m); assert_se(r >= 0); r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array)); assert_se(r >= 0); r = bus_message_seal(m, 4711); assert_se(r >= 0); bus_message_dump(m); r = bus_message_get_blob(m, &buffer, &sz); assert_se(r >= 0); h = hexmem(buffer, sz); assert_se(h); log_info("message size = %lu, contents =\n%s", (unsigned long) sz, h); free(h); #ifdef HAVE_GLIB { GDBusMessage *g; char *p; #if !defined(GLIB_VERSION_2_36) g_type_init(); #endif g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL); p = g_dbus_message_print(g, 0); log_info("%s", p); g_free(p); g_object_unref(g); } #endif { DBusMessage *w; DBusError error; dbus_error_init(&error); w = dbus_message_demarshal(buffer, sz, &error); if (!w) { log_error("%s", error.message); } else dbus_message_unref(w); } m = sd_bus_message_unref(m); r = bus_message_from_malloc(buffer, sz, NULL, 0, NULL, NULL, &m); assert_se(r >= 0); bus_message_dump(m); assert_se(sd_bus_message_rewind(m, true) >= 0); r = sd_bus_message_read(m, "sas", &x, 2, &y, &z); assert_se(r > 0); assert_se(streq(x, "a string")); assert_se(streq(y, "string #1")); assert_se(streq(z, "string #2")); r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d); assert_se(r > 0); assert_se(streq(x, "foobar")); assert_se(streq(y, "foo")); assert_se(streq(z, "bar")); assert_se(streq(a, "waldo")); assert_se(streq(b, "piep")); assert_se(streq(c, "pap")); assert_se(streq(d, "after")); r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y); assert_se(r > 0); assert_se(u == 3); assert_se(streq(x, "foo")); assert_se(v == 5); assert_se(streq(y, "waldo")); r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d); assert_se(r > 0); assert_se(boolean); assert_se(streq(x, "aaa")); assert_se(streq(y, "1")); assert_se(streq(a, "bbb")); assert_se(streq(b, "2")); assert_se(streq(c, "ccc")); assert_se(streq(d, "3")); r = sd_bus_message_read(m, "as", 2, &x, &y); assert_se(r > 0); assert_se(streq(x, "foobar")); assert_se(streq(y, "waldo")); r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz); assert_se(r > 0); assert_se(sz == sizeof(integer_array)); assert_se(memcmp(integer_array, return_array, sz) == 0); r = sd_bus_message_peek_type(m, NULL, NULL); assert_se(r == 0); return 0; }
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; }
static void* client2(void*p) { _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL; _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL; _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; bool quit = false; const char *mid; int r; 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_message_new_method_call( bus, &m, "org.freedesktop.systemd.test", "/foo/bar/waldo/piep", "org.object.test", "Foobar"); if (r < 0) { log_error_errno(r, "Failed to allocate method call: %m"); goto finish; } r = sd_bus_send(bus, m, NULL); if (r < 0) { log_error("Failed to issue method call: %s", bus_error_message(&error, -r)); goto finish; } m = sd_bus_message_unref(m); r = sd_bus_message_new_signal( bus, &m, "/foobar", "foo.bar", "Notify"); if (r < 0) { log_error_errno(r, "Failed to allocate signal: %m"); goto finish; } r = sd_bus_send(bus, m, NULL); if (r < 0) { log_error("Failed to issue signal: %s", bus_error_message(&error, -r)); goto finish; } m = sd_bus_message_unref(m); r = sd_bus_message_new_method_call( bus, &m, "org.freedesktop.systemd.test", "/", "org.freedesktop.DBus.Peer", "GetMachineId"); if (r < 0) { log_error_errno(r, "Failed to allocate method call: %m"); goto finish; } r = sd_bus_call(bus, m, 0, &error, &reply); if (r < 0) { log_error("Failed to issue method call: %s", bus_error_message(&error, -r)); goto finish; } r = sd_bus_message_read(reply, "s", &mid); if (r < 0) { log_error_errno(r, "Failed to parse machine ID: %m"); goto finish; } log_info("Machine ID is %s.", mid); m = sd_bus_message_unref(m); r = sd_bus_message_new_method_call( bus, &m, "org.freedesktop.systemd.test", "/", "org.freedesktop.systemd.test", "Slow"); if (r < 0) { log_error_errno(r, "Failed to allocate method call: %m"); goto finish; } reply = sd_bus_message_unref(reply); r = sd_bus_call(bus, m, 200 * USEC_PER_MSEC, &error, &reply); if (r < 0) log_info("Failed to issue method call: %s", bus_error_message(&error, -r)); else log_info("Slow call succeed."); m = sd_bus_message_unref(m); r = sd_bus_message_new_method_call( bus, &m, "org.freedesktop.systemd.test", "/", "org.freedesktop.systemd.test", "Slow"); if (r < 0) { log_error_errno(r, "Failed to allocate method call: %m"); goto finish; } r = sd_bus_call_async(bus, NULL, m, quit_callback, &quit, 200 * USEC_PER_MSEC); if (r < 0) { log_info("Failed to issue method call: %s", bus_error_message(&error, -r)); goto finish; } while (!quit) { r = sd_bus_process(bus, NULL); if (r < 0) { log_error_errno(r, "Failed to process requests: %m"); goto finish; } if (r == 0) { r = sd_bus_wait(bus, (uint64_t) -1); if (r < 0) { log_error_errno(r, "Failed to wait: %m"); goto finish; } } } r = 0; finish: if (bus) { _cleanup_(sd_bus_message_unrefp) sd_bus_message *q; r = sd_bus_message_new_method_call( bus, &q, "org.freedesktop.systemd.test", "/", "org.freedesktop.systemd.test", "ExitClient2"); if (r < 0) { log_error_errno(r, "Failed to allocate method call: %m"); goto finish; } (void) sd_bus_send(bus, q, NULL); } return INT_TO_PTR(r); }
int main(int argc, char *argv[]) { _cleanup_free_ char *name = NULL, *bus_name = NULL, *address = NULL; uint8_t *p; sd_bus *a, *b; int r, bus_ref; sd_bus_message *m; int f; uint64_t sz; uint32_t u32; size_t i, l; char *s; _cleanup_close_ int sfd = -1; 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_address(a, address); assert_se(r >= 0); r = sd_bus_set_address(b, address); assert_se(r >= 0); r = sd_bus_start(a); assert_se(r >= 0); r = sd_bus_start(b); assert_se(r >= 0); r = sd_bus_message_new_method_call(b, &m, ":1.1", "/a/path", "an.inter.face", "AMethod"); assert_se(r >= 0); r = sd_bus_message_open_container(m, 'r', "aysay"); assert_se(r >= 0); r = sd_bus_message_append_array_space(m, 'y', FIRST_ARRAY, (void**) &p); assert_se(r >= 0); p[0] = '<'; memset(p+1, 'L', FIRST_ARRAY-2); p[FIRST_ARRAY-1] = '>'; f = memfd_new_and_map(NULL, STRING_SIZE, (void**) &s); assert_se(f >= 0); s[0] = '<'; for (i = 1; i < STRING_SIZE-2; i++) s[i] = '0' + (i % 10); s[STRING_SIZE-2] = '>'; s[STRING_SIZE-1] = 0; munmap(s, STRING_SIZE); r = memfd_get_size(f, &sz); assert_se(r >= 0); assert_se(sz == STRING_SIZE); r = sd_bus_message_append_string_memfd(m, f, 0, (uint64_t) -1); assert_se(r >= 0); close(f); f = memfd_new_and_map(NULL, SECOND_ARRAY, (void**) &p); assert_se(f >= 0); p[0] = '<'; memset(p+1, 'P', SECOND_ARRAY-2); p[SECOND_ARRAY-1] = '>'; munmap(p, SECOND_ARRAY); r = memfd_get_size(f, &sz); assert_se(r >= 0); assert_se(sz == SECOND_ARRAY); r = sd_bus_message_append_array_memfd(m, 'y', f, 0, (uint64_t) -1); assert_se(r >= 0); close(f); r = sd_bus_message_close_container(m); assert_se(r >= 0); r = sd_bus_message_append(m, "u", 4711); assert_se(r >= 0); assert_se((sfd = memfd_new_and_map(NULL, 6, (void**) &p)) >= 0); memcpy(p, "abcd\0", 6); munmap(p, 6); assert_se(sd_bus_message_append_string_memfd(m, sfd, 1, 4) >= 0); r = bus_message_seal(m, 55, 99*USEC_PER_SEC); assert_se(r >= 0); bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER); r = sd_bus_send(b, m, NULL); assert_se(r >= 0); sd_bus_message_unref(m); r = sd_bus_process(a, &m); assert_se(r > 0); bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER); sd_bus_message_rewind(m, true); r = sd_bus_message_enter_container(m, 'r', "aysay"); assert_se(r > 0); r = sd_bus_message_read_array(m, 'y', (const void**) &p, &l); assert_se(r > 0); assert_se(l == FIRST_ARRAY); assert_se(p[0] == '<'); for (i = 1; i < l-1; i++) assert_se(p[i] == 'L'); assert_se(p[l-1] == '>'); r = sd_bus_message_read(m, "s", &s); assert_se(r > 0); assert_se(s[0] == '<'); for (i = 1; i < STRING_SIZE-2; i++) assert_se(s[i] == (char) ('0' + (i % 10))); assert_se(s[STRING_SIZE-2] == '>'); assert_se(s[STRING_SIZE-1] == 0); r = sd_bus_message_read_array(m, 'y', (const void**) &p, &l); assert_se(r > 0); assert_se(l == SECOND_ARRAY); assert_se(p[0] == '<'); for (i = 1; i < l-1; i++) assert_se(p[i] == 'P'); assert_se(p[l-1] == '>'); r = sd_bus_message_exit_container(m); assert_se(r > 0); r = sd_bus_message_read(m, "u", &u32); assert_se(r > 0); assert_se(u32 == 4711); r = sd_bus_message_read(m, "s", &s); assert_se(r > 0); assert_se(streq_ptr(s, "bcd")); sd_bus_message_unref(m); sd_bus_unref(a); sd_bus_unref(b); return 0; }
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; }
//------------------------------------------------------------------------ // 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; }
//------------------- // 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); } }
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, true); 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, true); 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, true); 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, true); 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, true); 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; }
//------------------------------------------------------------------------ // Takes FRU data, invokes Parser for each fru record area and updates // Inventory //------------------------------------------------------------------------ int ipmi_update_inventory(fru_area_vec_t & area_vec) { // Generic error reporter 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; // Response from sd bus calls 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) { // Start fresh on each. sd_bus_error_free(&bus_error); sd_bus_message_unref(response); sd_bus_message_unref(fru_dict); // Constructor to allow further initializations and customization. rc = sd_bus_message_new_method_call((iter)->get_bus_type(), &fru_dict, (iter)->get_bus_name(), (iter)->get_obj_path(), (iter)->get_intf_name(), "update"); if(rc < 0) { fprintf(stderr,"ERROR: creating a update method call for bus_name:[%s]\n", (iter)->get_bus_name()); 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)->get_type(), (void *)(iter)->get_data(), (iter)->get_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((iter)->get_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, (iter)->get_fruid()); break; } else if((iter)->is_bmc_fru()) { // For FRUs that are accessible by HostBoot, host boot does all of // these. printf("SUCCESS: Updated:[%s_%d] successfully. Setting Valid bit\n", (iter)->get_name(), (iter)->get_fruid()); (iter)->set_valid(true); } else { printf("SUCCESS: Updated:[%s_%d] successfully\n", (iter)->get_name(), (iter)->get_fruid()); } } // 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); return rc; }
///----------------------------------------------------- // 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; }
ipmi_ret_t ipmi_sen_get_sensor_reading(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) { sensor_data_t *reqptr = (sensor_data_t*)request; ipmi_ret_t rc = IPMI_CC_SENSOR_INVALID; uint8_t type; sensorreadingresp_t *resp = (sensorreadingresp_t*) response; int r; dbus_interface_t a; sd_bus *bus = ipmid_get_sd_bus_connection(); sd_bus_message *reply = NULL; int reading = 0; printf("IPMI GET_SENSOR_READING [0x%02x]\n",reqptr->sennum); r = find_openbmc_path("SENSOR", reqptr->sennum, &a); if (r < 0) { fprintf(stderr, "Failed to find Sensor 0x%02x\n", reqptr->sennum); return IPMI_CC_SENSOR_INVALID; } type = find_sensor(reqptr->sennum); fprintf(stderr, "Bus: %s, Path: %s, Interface: %s\n", a.bus, a.path, a.interface); *data_len=0; switch(type) { case 0xC3: case 0xC2: r = sd_bus_get_property(bus,a.bus, a.path, a.interface, "value", NULL, &reply, "i"); if (r < 0) { fprintf(stderr, "Failed to call sd_bus_get_property:%d, %s\n", r, strerror(-r)); fprintf(stderr, "Bus: %s, Path: %s, Interface: %s\n", a.bus, a.path, a.interface); break; } r = sd_bus_message_read(reply, "i", &reading); if (r < 0) { fprintf(stderr, "Failed to read sensor: %s\n", strerror(-r)); break; } printf("Contents of a 0x%02x is 0x%02x\n", type, reading); rc = IPMI_CC_OK; *data_len=sizeof(sensorreadingresp_t); resp->value = (uint8_t)reading; resp->operation = 0; resp->indication[0] = 0; resp->indication[1] = 0; break; default: *data_len=0; rc = IPMI_CC_SENSOR_INVALID; break; } reply = sd_bus_message_unref(reply); return rc; }
ipmi_ret_t ipmi_app_set_watchdog(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) { const char *busname = "org.openbmc.watchdog.Host"; const char *objname = "/org/openbmc/watchdog/host0"; const char *iface = "org.openbmc.Watchdog"; sd_bus_message *reply = NULL, *m = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; int r = 0; set_wd_data_t *reqptr = (set_wd_data_t*) request; uint16_t timer = 0; uint32_t timer_ms = 0; // Status code. ipmi_ret_t rc = IPMI_CC_OK; *data_len = 0; // Get number of 100ms intervals timer = (((uint16_t)reqptr->ms) << 8) + reqptr->ls; // Get timer value in ms timer_ms = timer * 100; printf("WATCHDOG SET Timer:[0x%X] 100ms intervals\n",timer); // Set watchdog timer r = sd_bus_message_new_method_call(bus,&m,busname,objname,iface,"set"); if (r < 0) { fprintf(stderr, "Failed to add the set method object: %s\n", strerror(-r)); return -1; } r = sd_bus_message_append(m, "i", timer_ms); if (r < 0) { fprintf(stderr, "Failed to add timer value: %s\n", strerror(-r)); return -1; } r = sd_bus_call(bus, m, 0, &error, &reply); if (r < 0) { fprintf(stderr, "Failed to call the set method: %s\n", strerror(-r)); return -1; } // Stop the current watchdog if any r = sd_bus_message_new_method_call(bus,&m,busname,objname,iface,"stop"); if (r < 0) { fprintf(stderr, "Failed to add the start method object: %s\n", strerror(-r)); return -1; } r = sd_bus_call(bus, m, 0, &error, &reply); if (r < 0) { fprintf(stderr, "Failed to call the start method: %s\n", strerror(-r)); return -1; } // Start the watchdog if requested if (reqptr->t_use & 0x40) { r = sd_bus_message_new_method_call(bus,&m,busname,objname,iface,"start"); if (r < 0) { fprintf(stderr, "Failed to add the start method object: %s\n", strerror(-r)); return -1; } r = sd_bus_call(bus, m, 0, &error, &reply); if (r < 0) { fprintf(stderr, "Failed to call the start method: %s\n", strerror(-r)); return -1; } } sd_bus_error_free(&error); sd_bus_message_unref(m); return rc; }
ipmi_ret_t ipmi_app_get_device_guid(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) { const char *busname = "org.openbmc.control.Chassis"; const char *objname = "/org/openbmc/control/chassis0"; const char *iface = "org.freedesktop.DBus.Properties"; const char *chassis_iface = "org.openbmc.control.Chassis"; sd_bus_message *reply = NULL, *m = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; int r = 0; char *uuid = NULL; // Status code. ipmi_ret_t rc = IPMI_CC_OK; *data_len = 0; printf("IPMI GET DEVICE GUID\n"); // Call Get properties method with the interface and property name r = sd_bus_message_new_method_call(bus,&m,busname,objname,iface,"Get"); if (r < 0) { fprintf(stderr, "Failed to add the Get method object: %s\n", strerror(-r)); return IPMI_CC_UNSPECIFIED_ERROR; } r = sd_bus_message_append(m, "ss", chassis_iface, "uuid"); if (r < 0) { fprintf(stderr, "Failed to append arguments: %s\n", strerror(-r)); return -1; } r = sd_bus_call(bus, m, 0, &error, &reply); if (r < 0) { fprintf(stderr, "Failed to call the Get method: %s\n", strerror(-r)); return IPMI_CC_UNSPECIFIED_ERROR; } r = sd_bus_message_read(reply, "v", "s", &uuid); if (r < 0) { fprintf(stderr, "Failed to get a response: %s", strerror(-r)); return IPMI_CC_RESPONSE_ERROR; } if (uuid == NULL) { fprintf(stderr, "Failed to get a valid response: %s", strerror(-r)); return IPMI_CC_RESPONSE_ERROR; } // UUID is in RFC4122 format. Ex: 61a39523-78f2-11e5-9862-e6402cfc3223 // Per IPMI Spec 2.0 need to convert to 16 hex bytes and reverse the byte order // Ex: 0x2332fc2c40e66298e511f2782395a361 const int resp_size = 16; // Response is 16 hex bytes per IPMI Spec uint8_t resp_uuid[resp_size]; // Array to hold the formatted response int resp_loc = resp_size-1; // Point resp end of array to save in reverse order int i = 0; char *tokptr = NULL; // Traverse the UUID char* id_octet = strtok_r(uuid, "-", &tokptr); // Get the UUID octects separated by dash if (id_octet == NULL) { // Error fprintf(stderr, "Unexpected UUID format: %s", uuid); return IPMI_CC_RESPONSE_ERROR; } while (id_octet != NULL) { // Calculate the octet string size since it varies // Divide it by 2 for the array size since 1 byte is built from 2 chars int tmp_size = strlen(id_octet)/2; for(i = 0; i < tmp_size; i++) { char tmp_array[3] = {0}; // Holder of the 2 chars that will become a byte strncpy(tmp_array, id_octet, 2); // 2 chars at a time int resp_byte = strtoul(tmp_array, NULL, 16); // Convert to hex byte memcpy((void*)&resp_uuid[resp_loc], &resp_byte, 1); // Copy end to first resp_loc--; id_octet+=2; // Finished with the 2 chars, advance } id_octet=strtok_r(NULL, "-", &tokptr); // Get next octet } // Data length *data_len = resp_size; // Pack the actual response memcpy(response, &resp_uuid, *data_len); sd_bus_error_free(&error); sd_bus_message_unref(m); return rc; }
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; }
//------------------------------------------------------------------- // 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); } }
int main(int argc, char *argv[]) { _cleanup_free_ char *bus_name = NULL, *address = NULL; uint8_t *p; sd_bus *a, *b; int r, bus_ref; sd_bus_message *m; sd_memfd *f; uint64_t sz; uint32_t u32; size_t i, l; char *s; log_set_max_level(LOG_DEBUG); bus_ref = bus_kernel_create("deine-mutter", &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_address(a, address); assert_se(r >= 0); r = sd_bus_set_address(b, address); assert_se(r >= 0); r = sd_bus_start(a); assert_se(r >= 0); r = sd_bus_start(b); assert_se(r >= 0); r = sd_bus_message_new_method_call(b, ":1.1", "/a/path", "an.inter.face", "AMethod", &m); assert_se(r >= 0); r = sd_bus_message_open_container(m, 'r', "aysay"); assert_se(r >= 0); r = sd_bus_message_append_array_space(m, 'y', FIRST_ARRAY, (void**) &p); assert_se(r >= 0); memset(p, 'L', FIRST_ARRAY); r = sd_memfd_new_and_map(&f, STRING_SIZE, (void**) &s); assert_se(r >= 0); for (i = 0; i < STRING_SIZE-1; i++) s[i] = '0' + (i % 10); s[STRING_SIZE-1] = 0; munmap(s, STRING_SIZE); r = sd_memfd_get_size(f, &sz); assert_se(r >= 0); assert_se(sz == STRING_SIZE); r = sd_bus_message_append_string_memfd(m, f); assert_se(r >= 0); sd_memfd_free(f); r = sd_memfd_new_and_map(&f, SECOND_ARRAY, (void**) &p); assert_se(r >= 0); memset(p, 'P', SECOND_ARRAY); munmap(p, SECOND_ARRAY); r = sd_memfd_get_size(f, &sz); assert_se(r >= 0); assert_se(sz == SECOND_ARRAY); r = sd_bus_message_append_array_memfd(m, 'y', f); assert_se(r >= 0); sd_memfd_free(f); r = sd_bus_message_close_container(m); assert_se(r >= 0); r = sd_bus_message_append(m, "u", 4711); assert_se(r >= 0); r = bus_message_seal(m, 55); assert_se(r >= 0); bus_message_dump(m, stdout, true); r = sd_bus_send(b, m, NULL); assert_se(r >= 0); sd_bus_message_unref(m); r = sd_bus_process(a, &m); assert_se(r > 0); bus_message_dump(m, stdout, true); sd_bus_message_rewind(m, true); r = sd_bus_message_enter_container(m, 'r', "aysay"); assert_se(r > 0); r = sd_bus_message_read_array(m, 'y', (const void**) &p, &l); assert_se(r > 0); assert_se(l == FIRST_ARRAY); for (i = 0; i < l; i++) assert_se(p[i] == 'L'); r = sd_bus_message_read(m, "s", &s); assert_se(r > 0); for (i = 0; i < STRING_SIZE-1; i++) assert_se(s[i] == (char) ('0' + (i % 10))); assert_se(s[STRING_SIZE-1] == 0); r = sd_bus_message_read_array(m, 'y', (const void**) &p, &l); assert_se(r > 0); assert_se(l == SECOND_ARRAY); for (i = 0; i < l; i++) assert_se(p[i] == 'P'); r = sd_bus_message_exit_container(m); assert_se(r > 0); r = sd_bus_message_read(m, "u", &u32); assert_se(r > 0); assert_se(u32 == 4711); sd_bus_message_unref(m); sd_bus_unref(a); sd_bus_unref(b); return 0; }
int main(int argc, char *argv[]) { _cleanup_close_ int bus_ref = -1; _cleanup_free_ char *bus_name = NULL, *address = NULL; _cleanup_bus_message_unref_ sd_bus_message *m = NULL; const char *ua = NULL, *ub = NULL, *the_string = NULL; sd_bus *a, *b; int r, pipe_fds[2]; bus_ref = bus_kernel_create("deine-mutter", &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_address(a, address); assert_se(r >= 0); r = sd_bus_set_address(b, address); assert_se(r >= 0); r = sd_bus_start(a); assert_se(r >= 0); r = sd_bus_start(b); assert_se(r >= 0); r = sd_bus_get_unique_name(a, &ua); assert_se(r >= 0); printf("unique a: %s\n", ua); r = sd_bus_get_unique_name(b, &ub); assert_se(r >= 0); printf("unique b: %s\n", ub); { //FIXME: struct kdbus_cmd_match cmd_match; cmd_match.size = sizeof(cmd_match); cmd_match.src_id = KDBUS_MATCH_SRC_ID_ANY; r = ioctl(sd_bus_get_fd(a), KDBUS_CMD_MATCH_ADD, &cmd_match); assert_se(r >= 0); r = ioctl(sd_bus_get_fd(b), KDBUS_CMD_MATCH_ADD, &cmd_match); 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_process(b, &m); assert_se(r > 0); assert_se(m); bus_message_dump(m); 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, "net.x0pointer.foobar", "/a/path", "an.inter.face", "AMethod", &m); assert_se(r >= 0); assert_se(pipe2(pipe_fds, O_CLOEXEC) >= 0); assert_se(write(pipe_fds[1], "x", 1) == 1); close_nointr_nofail(pipe_fds[1]); pipe_fds[1] = -1; r = sd_bus_message_append(m, "h", pipe_fds[0]); assert_se(r >= 0); close_nointr_nofail(pipe_fds[0]); pipe_fds[0] = -1; 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); 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); sd_bus_unref(a); sd_bus_unref(b); return 0; }
int main(int argc, char *argv[]) { _cleanup_close_ int bus_ref = -1; _cleanup_free_ char *bus_name = NULL, *address = NULL; _cleanup_bus_message_unref_ sd_bus_message *m = NULL; const char *ua = NULL, *ub = NULL, *the_string = NULL; sd_bus *a, *b; int r, pipe_fds[2]; log_set_max_level(LOG_DEBUG); bus_ref = bus_kernel_create("deine-mutter", &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_address(a, address); assert_se(r >= 0); r = sd_bus_set_address(b, address); assert_se(r >= 0); assert_se(sd_bus_negotiate_attach_comm(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_exe(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_cmdline(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_cgroup(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_caps(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_selinux_context(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_audit(a, 1) >= 0); assert_se(sd_bus_negotiate_attach_comm(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_exe(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_cmdline(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_cgroup(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_caps(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_selinux_context(b, 1) >= 0); assert_se(sd_bus_negotiate_attach_audit(b, 1) >= 0); r = sd_bus_start(a); assert_se(r >= 0); r = sd_bus_start(b); assert_se(r >= 0); r = sd_bus_get_unique_name(a, &ua); assert_se(r >= 0); printf("unique a: %s\n", ua); r = sd_bus_get_unique_name(b, &ub); assert_se(r >= 0); printf("unique b: %s\n", ub); r = sd_bus_add_match(b, "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_process(b, &m); assert_se(r > 0); assert_se(m); bus_message_dump(m); 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, "net.x0pointer.foobar", "/a/path", "an.inter.face", "AMethod", &m); assert_se(r >= 0); assert_se(pipe2(pipe_fds, O_CLOEXEC) >= 0); assert_se(write(pipe_fds[1], "x", 1) == 1); close_nointr_nofail(pipe_fds[1]); pipe_fds[1] = -1; r = sd_bus_message_append(m, "h", pipe_fds[0]); assert_se(r >= 0); close_nointr_nofail(pipe_fds[0]); pipe_fds[0] = -1; 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); 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); sd_bus_unref(a); sd_bus_unref(b); return 0; }
static void test_marshal(void) { _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *n = NULL; _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL; _cleanup_free_ void *blob; size_t sz; int r; r = sd_bus_open_system(&bus); if (r < 0) exit(EXIT_TEST_SKIP); bus->message_version = 2; /* dirty hack to enable gvariant */ assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName") >= 0); assert_cc(sizeof(struct bus_header) == 16); assert_se(sd_bus_message_append(m, "a(usv)", 3, 4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111, 4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6, 4713, "third-string-parameter", "(uu)", 1, 2) >= 0); assert_se(bus_message_seal(m, 4711, 0) >= 0); #ifdef HAVE_GLIB { GVariant *v; char *t; #if !defined(GLIB_VERSION_2_36) g_type_init(); #endif v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuta{tv})"), m->header, sizeof(struct bus_header) + m->fields_size, false, NULL, NULL); assert_se(g_variant_is_normal_form(v)); t = g_variant_print(v, TRUE); printf("%s\n", t); g_free(t); g_variant_unref(v); v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, m->user_body_size, false, NULL, NULL); assert_se(g_variant_is_normal_form(v)); t = g_variant_print(v, TRUE); printf("%s\n", t); g_free(t); g_variant_unref(v); } #endif assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0); assert_se(bus_message_get_blob(m, &blob, &sz) >= 0); #ifdef HAVE_GLIB { GVariant *v; char *t; v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuta{tv}v)"), blob, sz, false, NULL, NULL); assert_se(g_variant_is_normal_form(v)); t = g_variant_print(v, TRUE); printf("%s\n", t); g_free(t); g_variant_unref(v); } #endif assert_se(bus_message_from_malloc(bus, blob, sz, NULL, 0, NULL, &n) >= 0); blob = NULL; assert_se(bus_message_dump(n, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0); m = sd_bus_message_unref(m); assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0); assert_se(sd_bus_message_append(m, "as", 0) >= 0); assert_se(bus_message_seal(m, 4712, 0) >= 0); assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0); }
int x11_read_data(Context *c, sd_bus_message *m) { _cleanup_fclose_ FILE *f = NULL; bool in_section = false; struct stat st; usec_t t; int r; /* Do not try to re-read the file within single bus operation. */ if (m) { if (m == c->x11_cache) return 0; sd_bus_message_unref(c->x11_cache); c->x11_cache = sd_bus_message_ref(m); } if (stat("/etc/X11/xorg.conf.d/00-keyboard.conf", &st) < 0) { if (errno != ENOENT) return -errno; c->x11_mtime = USEC_INFINITY; context_free_x11(c); return 0; } /* If mtime is not changed, then we do not need to re-read */ t = timespec_load(&st.st_mtim); if (c->x11_mtime != USEC_INFINITY && t == c->x11_mtime) return 0; c->x11_mtime = t; context_free_x11(c); f = fopen("/etc/X11/xorg.conf.d/00-keyboard.conf", "re"); if (!f) return -errno; for (;;) { _cleanup_free_ char *line = NULL; char *l; r = read_line(f, LONG_LINE_MAX, &line); if (r < 0) return r; if (r == 0) break; l = strstrip(line); if (IN_SET(l[0], 0, '#')) continue; if (in_section && first_word(l, "Option")) { _cleanup_strv_free_ char **a = NULL; r = strv_split_extract(&a, l, WHITESPACE, EXTRACT_QUOTES); if (r < 0) return r; if (strv_length(a) == 3) { char **p = NULL; if (streq(a[1], "XkbLayout")) p = &c->x11_layout; else if (streq(a[1], "XkbModel")) p = &c->x11_model; else if (streq(a[1], "XkbVariant")) p = &c->x11_variant; else if (streq(a[1], "XkbOptions")) p = &c->x11_options; if (p) { free_and_replace(*p, a[2]); } } } else if (!in_section && first_word(l, "Section")) { _cleanup_strv_free_ char **a = NULL; r = strv_split_extract(&a, l, WHITESPACE, EXTRACT_QUOTES); if (r < 0) return -ENOMEM; if (strv_length(a) == 2 && streq(a[1], "InputClass")) in_section = true; } else if (in_section && first_word(l, "EndSection")) in_section = false; } return 0; }
int main(int argc, char *argv[]) { _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *copy = NULL; int r, boolean; const char *x, *x2, *y, *z, *a, *b, *c, *d, *a_signature; uint8_t u, v; void *buffer = NULL; size_t sz; char *h; const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array; char *s; _cleanup_free_ char *first = NULL, *second = NULL, *third = NULL; _cleanup_fclose_ FILE *ms = NULL; size_t first_size = 0, second_size = 0, third_size = 0; _cleanup_bus_unref_ sd_bus *bus = NULL; double dbl; uint64_t u64; r = sd_bus_default_system(&bus); if (r < 0) return EXIT_TEST_SKIP; r = sd_bus_message_new_method_call(bus, &m, "foobar.waldo", "/", "foobar.waldo", "Piep"); assert_se(r >= 0); r = sd_bus_message_append(m, ""); assert_se(r >= 0); r = sd_bus_message_append(m, "s", "a string"); assert_se(r >= 0); r = sd_bus_message_append(m, "s", NULL); assert_se(r >= 0); r = sd_bus_message_append(m, "asg", 2, "string #1", "string #2", "sba(tt)ss"); assert_se(r >= 0); r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after"); assert_se(r >= 0); r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo"); assert_se(r >= 0); r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3"); assert_se(r >= 0); r = sd_bus_message_open_container(m, 'a', "s"); assert_se(r >= 0); r = sd_bus_message_append_basic(m, 's', "foobar"); assert_se(r >= 0); r = sd_bus_message_append_basic(m, 's', "waldo"); assert_se(r >= 0); r = sd_bus_message_close_container(m); assert_se(r >= 0); r = sd_bus_message_append_string_space(m, 5, &s); assert_se(r >= 0); strcpy(s, "hallo"); r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array)); assert_se(r >= 0); r = sd_bus_message_append_array(m, 'u', NULL, 0); assert_se(r >= 0); r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/"); assert_se(r >= 0); r = bus_message_seal(m, 4711, 0); assert_se(r >= 0); bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER); ms = open_memstream(&first, &first_size); bus_message_dump(m, ms, 0); fflush(ms); assert_se(!ferror(ms)); r = bus_message_get_blob(m, &buffer, &sz); assert_se(r >= 0); h = hexmem(buffer, sz); assert_se(h); log_info("message size = %zu, contents =\n%s", sz, h); free(h); #ifdef HAVE_GLIB { GDBusMessage *g; char *p; #if !defined(GLIB_VERSION_2_36) g_type_init(); #endif g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL); p = g_dbus_message_print(g, 0); log_info("%s", p); g_free(p); g_object_unref(g); } #endif #ifdef HAVE_DBUS { DBusMessage *w; DBusError error; dbus_error_init(&error); w = dbus_message_demarshal(buffer, sz, &error); if (!w) log_error("%s", error.message); else dbus_message_unref(w); } #endif m = sd_bus_message_unref(m); r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, &m); assert_se(r >= 0); bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER); fclose(ms); ms = open_memstream(&second, &second_size); bus_message_dump(m, ms, 0); fflush(ms); assert_se(!ferror(ms)); assert_se(first_size == second_size); assert_se(memcmp(first, second, first_size) == 0); assert_se(sd_bus_message_rewind(m, true) >= 0); r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature); assert_se(r > 0); assert_se(streq(x, "a string")); assert_se(streq(x2, "")); assert_se(streq(y, "string #1")); assert_se(streq(z, "string #2")); assert_se(streq(a_signature, "sba(tt)ss")); r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d); assert_se(r > 0); assert_se(streq(x, "foobar")); assert_se(streq(y, "foo")); assert_se(streq(z, "bar")); assert_se(streq(a, "waldo")); assert_se(streq(b, "piep")); assert_se(streq(c, "pap")); assert_se(streq(d, "after")); r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y); assert_se(r > 0); assert_se(u == 3); assert_se(streq(x, "foo")); assert_se(v == 5); assert_se(streq(y, "waldo")); r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d); assert_se(r > 0); assert_se(boolean); assert_se(streq(x, "aaa")); assert_se(streq(y, "1")); assert_se(streq(a, "bbb")); assert_se(streq(b, "2")); assert_se(streq(c, "ccc")); assert_se(streq(d, "3")); assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0); r = sd_bus_message_read(m, "as", 2, &x, &y); assert_se(r > 0); assert_se(streq(x, "foobar")); assert_se(streq(y, "waldo")); r = sd_bus_message_read_basic(m, 's', &s); assert_se(r > 0); assert_se(streq(s, "hallo")); r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz); assert_se(r > 0); assert_se(sz == sizeof(integer_array)); assert_se(memcmp(integer_array, return_array, sz) == 0); r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz); assert_se(r > 0); assert_se(sz == 0); r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y); assert_se(r > 0); assert_se(streq(x, "foo")); assert_se(u64 == 815ULL); assert_se(fabs(dbl - 47.0) < 0.1); assert_se(streq(y, "/")); r = sd_bus_message_peek_type(m, NULL, NULL); assert_se(r == 0); r = sd_bus_message_new_method_call(bus, ©, "foobar.waldo", "/", "foobar.waldo", "Piep"); assert_se(r >= 0); r = sd_bus_message_rewind(m, true); assert_se(r >= 0); r = sd_bus_message_copy(copy, m, true); assert_se(r >= 0); r = bus_message_seal(copy, 4712, 0); assert_se(r >= 0); fclose(ms); ms = open_memstream(&third, &third_size); bus_message_dump(copy, ms, 0); fflush(ms); assert_se(!ferror(ms)); printf("<%.*s>\n", (int) first_size, first); printf("<%.*s>\n", (int) third_size, third); assert_se(first_size == third_size); assert_se(memcmp(first, third, third_size) == 0); r = sd_bus_message_rewind(m, true); assert_se(r >= 0); assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0); r = sd_bus_message_skip(m, "ssasg"); assert_se(r > 0); assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0); r = sd_bus_message_skip(m, "sass"); assert_se(r >= 0); assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0); r = sd_bus_message_skip(m, "a{yv}"); assert_se(r >= 0); assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0); r = sd_bus_message_read(m, "b", &boolean); assert_se(r > 0); assert_se(boolean); r = sd_bus_message_enter_container(m, 0, NULL); assert_se(r > 0); r = sd_bus_message_read(m, "(ss)", &x, &y); assert_se(r > 0); r = sd_bus_message_read(m, "(ss)", &a, &b); assert_se(r > 0); r = sd_bus_message_read(m, "(ss)", &c, &d); assert_se(r > 0); r = sd_bus_message_read(m, "(ss)", &x, &y); assert_se(r == 0); r = sd_bus_message_exit_container(m); assert_se(r >= 0); assert_se(streq(x, "aaa")); assert_se(streq(y, "1")); assert_se(streq(a, "bbb")); assert_se(streq(b, "2")); assert_se(streq(c, "ccc")); assert_se(streq(d, "3")); test_bus_label_escape(); test_bus_path_encode(); test_bus_path_encode_unique(); return 0; }