SD_BUS_MESSAGE_NEW_METHOD_CALL(3)

📦
version 261.3 · 18 versions
, in ubuntu stonking

✨ NAME ✨

okay so bestie, this page is sd_bus_message_new_method_call(3) and it's all about sd_bus_message_new_method_call, sd_bus_message_new_method_return — literally just Create a method call message. that's the whole vibe 💅

🌈 SYNOPSIS 🌈

#include <systemd/sd-bus.h>

int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m,
                                   const char *destination,
                                   const char *path,
                                   const char *interface,
                                   const char *member);

int sd_bus_message_new_method_return(sd_bus_message *call,
                                     sd_bus_message **m);

💖 DESCRIPTION 💖

so the sd_bus_message_new_method_call() function creates a shiny new bus message object that encapsulates a D-Bus method call, and hands it back to you in the m output parameter. the call will be made on the destination destination, path path, on the interface interface, member member. slay, that's the whole thing 🎀

real quick, because terminology is giving entrance exam energy:

  • the destination is a dot-separated name that identifies a service connected to the bus.
  • the path is a slash-separated identifier of an object within the destination that resembles a file system path. the meaning of this path is defined by the destination — nobody else gets a vote, iykyk.
  • the interface is a dot-separated name that resembles a Java interface name that identifies a group of methods and signals supported by the object identified by path.
  • methods and signals are collectively called members, and they're identified by a simple name composed of ASCII letters, numbers, and underscores.

for an in-depth explanation, go read the D-Bus Tutorial[1] — it's the assigned reading, bestie, no skipping 📚

the destination parameter may be NULL. the interface parameter may be NULL, if the destination has only a single member with the given name and there is no ambiguity if the interface name is omitted. so like, only when it's genuinely unambiguous, okay? don't be out here guessing 🙈

heads up: this is a low level interface. see sd_bus_call_method(3) for a more convenient way of calling D-Bus methods. the convenient way exists, you don't have to raw-dog this one 💀

the sd_bus_message_new_method_return() function creates a new bus message object that is a reply to the method call call and returns it in the m output parameter. the call parameter must be a method call message. the sender of call is used as the destination. cute, right? it just knows 🫶

🎀 RETURN VALUE 🎀

on success, these functions return a non-negative integer. on failure, they return a negative errno-style error code. no in-between, no "it's complicated", just vibes and integers ✨

😭 Errors 😭

returned errors may indicate the following problems:

  • -EINVAL — several possible crimes here:
    • the output parameter m is NULL.
    • the destination parameter is non-null and is not a valid D-Bus service name ("org.somewhere.Something"), the path parameter is not a valid D-Bus path ("/an/object/path"), the interface parameter is non-null and is not a valid D-Bus interface name ("an.interface.name"), or the member parameter is not a valid D-Bus member ("Name"). bestie, those are the formats, please use them 😭
    • the call parameter is not a method call object.
  • -ENOTCONN — the bus parameter bus is NULL or the bus is not connected. you can't call into the void, babes 🕳️
  • -ENOMEM — memory allocation failed. the machine simply said no 💀
  • -EPERM — the call parameter is not sealed. seal it before you ship it, fr fr.
  • -EOPNOTSUPP — the call message does not have a cookie. no cookie, no dice 🍪

🦋 NOTES 🦋

functions described here are available as a shared library, which can be compiled against and linked to with the libsystemd pkg-config(1) file. standard procedure, icon behavior ✨

all functions listed here are thread-agnostic and only a single thread may operate on a given object at any given time. different threads may access the same object at different times. multiple independent objects may be used from different threads in parallel. so: share the object across time, not across simultaneous threads — them's the rules 🌸

the code described here uses getenv(3), which is declared to be not multi-thread-safe. this means that the code calling the functions described here must not call setenv(3) from a parallel thread. it is recommended to only do calls to setenv() from an early phase of the program when no other threads have been started. like, do your env setup before the party starts, don't be rearranging the furniture mid-rave 🪩

🍓 EXAMPLES 🍓

✨ Example 1. Make a call to a D-Bus method that takes a single parameter ✨

/* SPDX-License-Identifier: MIT-0 */

/* This is equivalent to:
 * busctl call org.freedesktop.systemd1 /org/freedesktop/systemd1 \
 *       org.freedesktop.systemd1.Manager GetUnitByPID $$
 *
 * Compile with 'cc print-unit-path.c -lsystemd'
 */

#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

#include <systemd/sd-bus.h>

#define _cleanup_(f) __attribute__((cleanup(f)))
#define DESTINATION "org.freedesktop.systemd1"
#define PATH        "/org/freedesystemd1"
#define INTERFACE   "org.freedesktop.systemd1.Manager"
#define MEMBER      "GetUnitByPID"

static int log_error(int error, const char *message) {
  fprintf(stderr, "%s: %s\n", message, strerror(-error));
  return error;
}

int main(int argc, char **argv) {
  _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
  _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
  _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL, *m = NULL;
  int r;

  r = sd_bus_open_system(&bus);
  if (r < 0)
    return log_error(r, "Failed to acquire bus");

  r = sd_bus_message_new_method_call(bus, &m,
                                     DESTINATION, PATH, INTERFACE, MEMBER);
  if (r < 0)
    return log_error(r, "Failed to create bus message");

  r = sd_bus_message_append(m, "u", (unsigned) getpid());
  if (r < 0)
    return log_error(r, "Failed to append to bus message");

  r = sd_bus_call(bus, m, -1, &error, &reply);
  if (r < 0)
    return log_error(r, MEMBER " call failed");

  const char *ans;
  r = sd_bus_message_read(reply, "o", &ans);
  if (r < 0)
    return log_error(r, "Failed to read reply");

  printf("Unit path is \"%s\".\n", ans);

  return 0;
}

this defines a minimally useful program that will open a connection to the bus, create a message object, send it, wait for the reply, and finally extract and print the answer. it does error handling and proper memory management. like, it's small but it's doing everything correctly — main character energy 👑🔥

👑 HISTORY 👑

sd_bus_message_new_method_call() and sd_bus_message_new_method_return() were added in version 246. throwback era, but still iconic 💜

🌸 SEE ALSO 🌸

systemd(1), sd-bus(3), sd_bus_call(3), sd_bus_call_method(3), sd_bus_path_encode(3)

💜 NOTES 💜

  1. D-Bus Tutorial https://dbus.freedesktop.org/doc/dbus-tutorial.html#concepts

aaaand that's the page, bestie 🫶💖 this came to you from systemd 261.3, filed under SD_BUS_MESSAGE_NEW_METHOD_CALL(3) — now go create some method calls and hydrate while you're at it 🌈✨🍓

📦 where this page comes from