Observando as propriedades do sd-bus

Não tenho permissão para adicionar comentários, portanto, estendo a resposta de @Stewart. Para habilitar os sinais, é preciso assiná -los:

Subscribe() permite que a maioria dos sinais de barramento sejam enviados. Clientes interessados ​​em sinais precisam chamar esse método. Os sinais são enviados apenas se pelo menos um cliente invocou esse método.

Se você está se perguntando por que sd_bus_waitnunca retorna, então está perdendo algo como

sd_bus_call_method(bus,
                   "org.freedesktop.systemd1",
                   "/org/freedesktop/systemd1",
                   "org.freedesktop.systemd1.Manager",
                   "Subscribe",
                   &error,
                   NULL,
                   NULL);

A resposta é usar sd_bus_match_signal(3)para configurar um filtro para eventos.

Você ouve eventos fazendo um dos seguintes:

1. sd_bus_wait(3)bloquear até que os eventos aconteçam e sd_bus_process(3)tratá-los.
2. Conecte sd-bus-se ao sd-eventloop com sd_bus_attach_event(3)(talvez seja necessário configurar o loop sd-event também).
3. Use sd_bus_get_fd(3)e sd_bus_get_events(3)para sd_bus_get_timeout(3)conectar o sd-bus ao seu próprio loop de eventos.

Aqui está um pequeno exemplo em C de como fazer isso:

/* gcc main.c -lsystemd */

#include <systemd/sd-bus.h>
#include <stdio.h>
#include <stdlib.h>

static inline const char *strna(const char *s) {
        return s ?: "n/a";
}

int message_callback(sd_bus_message* m, void* userdata, sd_bus_error* ret_error) {
        printf("callback: path=%s interface=%s member=%s\n", 
                strna(sd_bus_message_get_path(m)), 
                strna(sd_bus_message_get_interface(m)), 
                strna(sd_bus_message_get_member(m))
        );
        return 0;
}

int main() {
        sd_bus* bus = NULL;
        sd_bus_error err = SD_BUS_ERROR_NULL;
        char* msg = NULL;
        void* userdata = NULL;

        sd_bus_default_system(&bus);

        sd_bus_match_signal(
                bus,                                             /* bus */
                NULL,                                            /* slot */
                NULL,                                            /* sender */
                "/org/freedesktop/systemd1/unit/foo_2eservice",  /* path */
                "org.freedesktop.DBus.Properties",               /* interface */
                "PropertiesChanged",                             /* member */
                NULL /*message_callback*/ ,                      /* callback */
                userdata
        );

        while( 1 ) { 
                sd_bus_wait(bus, UINT64_MAX);
                while ( sd_bus_process(bus, NULL) ) {  }

                sd_bus_get_property_string(
                        bus,                                             /* bus */
                        "org.freedesktop.systemd1",                      /* destination */
                        "/org/freedesktop/systemd1/unit/foo_2eservice", /* path */
                        "org.freedesktop.systemd1.Unit",                 /* interface */
                        "ActiveState",                                   /* member */
                        &err, 
                        &msg);

                printf("New state: %s\n", msg);
                free(msg);

        }

        sd_bus_error_free(&err);
        sd_bus_message_unref(ret);
        sd_bus_unref(bus);
        return 0;
}

Eu comentei os mecanismos de retorno de chamada.

Observe que você recebe uma mensagem para uma alteração em qualquer uma das propriedades da unidade. Portanto, se você fizer algo como systemctl stop, poderá esperar várias mensagens.