D-Bus
Süreçlerarası İletişim

# Kurulum
apt install dbus libdbus-1-dev

# D-Bus daemon durumu
systemctl status dbus

# System bus socket
ls -la /run/dbus/system_bus_socket
# srw-rw-rw- 1 root messagebus 0 ... /run/dbus/system_bus_socket

# Session bus adresi (desktop ortamında)
echo $DBUS_SESSION_BUS_ADDRESS
# unix:path=/run/user/1000/bus

# systemd — root manager nesnesi
/org/freedesktop/systemd1

# Belirli bir unit nesnesi
/org/freedesktop/systemd1/unit/ssh_2eservice

# NetworkManager — aktif bağlantı
/org/freedesktop/NetworkManager/ActiveConnection/1

# BlueZ — Bluetooth adapter
/org/bluez/hci0

# BlueZ — bağlı cihaz
/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF

# System bus üzerindeki tüm servisler
busctl list

# Çıktı (kısaltılmış):
# NAME                              PID PROCESS         USER
# :1.1                                1 systemd         root
# :1.2                              423 NetworkManager  root
# org.freedesktop.NetworkManager   423 NetworkManager  root
# org.freedesktop.systemd1           1 systemd         root
# org.bluez                        512 bluetoothd      root

# Servis ağaç yapısı
busctl tree org.freedesktop.systemd1

# Belirli nesnenin introspection
busctl introspect org.freedesktop.systemd1 /org/freedesktop/systemd1

# NetworkManager root nesnesini incele
gdbus introspect --system \
  --dest org.freedesktop.NetworkManager \
  --object-path /

# Çıktı (XML fragment):
# <node>
#   <interface name="org.freedesktop.NetworkManager">
#     <method name="GetDevices">
#       <arg type="ao" name="devices" direction="out"/>
#     </method>
#     <signal name="StateChanged">
#       <arg type="u" name="state"/>
#     </signal>
#     <property name="State" type="u" access="read"/>
#   </interface>
# </node>

# Tüm nesneleri recursive listele
gdbus introspect --system \
  --dest org.freedesktop.NetworkManager \
  --object-path / \
  --recurse

# NetworkManager sürümünü sorgula
gdbus call --system \
  --dest org.freedesktop.NetworkManager \
  --object-path /org/freedesktop/NetworkManager \
  --method org.freedesktop.DBus.Properties.Get \
  "org.freedesktop.NetworkManager" "Version"
# (<'1.44.2'>,)

# systemd ListUnits çağrısı
gdbus call --system \
  --dest org.freedesktop.systemd1 \
  --object-path /org/freedesktop/systemd1 \
  --method org.freedesktop.systemd1.Manager.ListUnits

# NetworkManager'dan tüm sinyalleri izle
gdbus monitor --system \
  --dest org.freedesktop.NetworkManager

# Çıktı:
# /org/freedesktop/NetworkManager: org.freedesktop.NetworkManager.StateChanged (uint32 70,)
# /org/freedesktop/NetworkManager/ActiveConnection/1: \
#   org.freedesktop.DBus.Properties.PropertiesChanged ...

# Tüm system bus sinyalleri (çok verbose)
gdbus monitor --system

# busctl call: tür signature sonra argümanlar
busctl call org.freedesktop.hostname1 \
  /org/freedesktop/hostname1 \
  org.freedesktop.hostname1 \
  GetHostname

# Property okuma
busctl get-property org.freedesktop.hostname1 \
  /org/freedesktop/hostname1 \
  org.freedesktop.hostname1 \
  Hostname

# Gerçek zamanlı signal izleme
busctl monitor org.freedesktop.NetworkManager

# JSON formatında çıktı (scripting için kullanışlı)
busctl --json=short get-property \
  org.freedesktop.systemd1 \
  /org/freedesktop/systemd1 \
  org.freedesktop.systemd1.Manager \
  Version

from gi.repository import Gio, GLib

# System bus bağlantısı (senkron)
bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
print(f"Bağlantı UUID: {bus.get_guid()}")

# Session bus bağlantısı
session_bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)

from gi.repository import Gio, GLib

bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)

# NetworkManager proxy'si oluştur
proxy = Gio.DBusProxy.new_sync(
    bus,
    Gio.DBusProxyFlags.NONE,
    None,                                          # interface info
    "org.freedesktop.NetworkManager",              # bus name
    "/org/freedesktop/NetworkManager",             # object path
    "org.freedesktop.NetworkManager",              # interface
    None
)

# Property okuma (DBus.Properties.Get)
version = proxy.get_cached_property("Version")
print(f"NetworkManager sürümü: {version.get_string()}")

# GetDevices method çağrısı
devices = proxy.call_sync(
    "GetDevices",
    None,
    Gio.DBusCallFlags.NONE,
    -1,
    None
)
# devices: GLib.Variant("(ao)", ...) — object path dizisi
device_paths = devices.unpack()[0]
for path in device_paths:
    print(f"  Aygıt: {path}")

from gi.repository import Gio, GLib

def on_state_changed(proxy, sender, signal_name, params):
    if signal_name == "StateChanged":
        state = params.unpack()[0]
        states = {
            20: "asleep", 30: "disconnected",
            40: "disconnecting", 50: "connecting",
            60: "connected_local", 70: "connected_site",
            80: "connected_global"
        }
        print(f"NM durum: {states.get(state, state)}")

bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)

proxy = Gio.DBusProxy.new_sync(
    bus, Gio.DBusProxyFlags.NONE, None,
    "org.freedesktop.NetworkManager",
    "/org/freedesktop/NetworkManager",
    "org.freedesktop.NetworkManager",
    None
)

# g-signal: tüm sinyaller bu callback'e düşer
proxy.connect("g-signal", on_state_changed)

loop = GLib.MainLoop()
loop.run()  # Ctrl+C ile durdur

from gi.repository import Gio, GLib

def get_active_connections():
    bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)

    nm = Gio.DBusProxy.new_sync(
        bus, Gio.DBusProxyFlags.NONE, None,
        "org.freedesktop.NetworkManager",
        "/org/freedesktop/NetworkManager",
        "org.freedesktop.NetworkManager",
        None
    )

    # ActiveConnections property: object path dizisi
    active = nm.get_cached_property("ActiveConnections")
    if not active:
        print("Aktif bağlantı yok")
        return

    for path in active.unpack():
        conn_proxy = Gio.DBusProxy.new_sync(
            bus, Gio.DBusProxyFlags.NONE, None,
            "org.freedesktop.NetworkManager",
            path,
            "org.freedesktop.NetworkManager.Connection.Active",
            None
        )
        iface  = conn_proxy.get_cached_property("Id")
        state  = conn_proxy.get_cached_property("State")
        iptype = conn_proxy.get_cached_property("Type")
        print(f"  [{iptype.get_string()}] {iface.get_string()} — durum: {state.get_uint32()}")

get_active_connections()

#include <stdio.h>
#include <stdlib.h>
#include <dbus/dbus.h>

int main(void)
{
    DBusError   err;
    DBusConnection *conn;
    DBusMessage    *msg, *reply;
    char           *version = NULL;

    dbus_error_init(&err);

    /* System bus'a bağlan */
    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
    if (dbus_error_is_set(&err)) {
        fprintf(stderr, "Bağlantı hatası: %s\n", err.message);
        dbus_error_free(&err);
        return 1;
    }

    /* Method call mesajı oluştur */
    msg = dbus_message_new_method_call(
        "org.freedesktop.NetworkManager",    /* destination */
        "/org/freedesktop/NetworkManager",    /* object path */
        "org.freedesktop.DBus.Properties",   /* interface */
        "Get"                                 /* method */
    );

    /* Argümanları ekle: interface adı + property adı */
    const char *iface = "org.freedesktop.NetworkManager";
    const char *prop  = "Version";
    dbus_message_append_args(
        msg,
        DBUS_TYPE_STRING, &iface,
        DBUS_TYPE_STRING, &prop,
        DBUS_TYPE_INVALID
    );

    /* Senkron çağrı (5 saniye timeout) */
    reply = dbus_connection_send_with_reply_and_block(
        conn, msg, 5000, &err
    );
    if (!reply) {
        fprintf(stderr, "Yanıt hatası: %s\n", err.message);
        dbus_error_free(&err);
        goto cleanup;
    }

    /* Yanıttan variant içindeki string'i oku */
    DBusMessageIter iter, sub;
    dbus_message_iter_init(reply, &iter);
    if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT) {
        dbus_message_iter_recurse(&iter, &sub);
        if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
            dbus_message_iter_get_basic(&sub, &version);
            printf("NM Sürümü: %s\n", version);
        }
    }

cleanup:
    if (reply) dbus_message_unref(reply);
    dbus_message_unref(msg);
    /* dbus_connection_unref(conn) — paylaşılan bağlantı, unref etme */
    return 0;
}

gcc dbus1_call.c -o dbus1_call \
    $(pkg-config --cflags --libs dbus-1)

# Cross-compile (ARM)
arm-linux-gnueabihf-gcc dbus1_call.c -o dbus1_call \
    $(pkg-config --cflags --libs dbus-1)

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

int main(void)
{
    sd_bus *bus  = NULL;
    sd_bus_error error = SD_BUS_ERROR_NULL;
    sd_bus_message *reply = NULL;
    const char *version;
    int rc;

    /* System bus'a bağlan */
    rc = sd_bus_open_system(&bus);
    if (rc < 0) {
        fprintf(stderr, "Bağlantı hatası: %s\n", strerror(-rc));
        return 1;
    }

    /* Property oku — tek satırda! */
    rc = sd_bus_get_property(
        bus,
        "org.freedesktop.NetworkManager",    /* destination  */
        "/org/freedesktop/NetworkManager",    /* object path  */
        "org.freedesktop.NetworkManager",    /* interface    */
        "Version",                            /* property     */
        &error,
        &reply,
        "s"                                   /* type sig     */
    );
    if (rc < 0) {
        fprintf(stderr, "Property hatası: %s\n", error.message);
        goto out;
    }

    sd_bus_message_read(reply, "s", &version);
    printf("NM sürümü: %s\n", version);

out:
    sd_bus_error_free(&error);
    sd_bus_message_unref(reply);
    sd_bus_unref(bus);
    return rc < 0 ? 1 : 0;
}

/* systemd servisini yeniden başlat */
int restart_service(sd_bus *bus, const char *unit)
{
    sd_bus_error error  = SD_BUS_ERROR_NULL;
    sd_bus_message *reply = NULL;
    int rc;

    rc = sd_bus_call_method(
        bus,
        "org.freedesktop.systemd1",
        "/org/freedesktop/systemd1",
        "org.freedesktop.systemd1.Manager",
        "RestartUnit",
        &error,
        &reply,
        "ss",          /* iki string argüman */
        unit,           /* "ssh.service" gibi */
        "replace"      /* mode */
    );

    if (rc < 0)
        fprintf(stderr, "Hata: %s — %s\n",
                error.name, error.message);
    else {
        const char *job_path;
        sd_bus_message_read(reply, "o", &job_path);
        printf("Job: %s\n", job_path);
    }

    sd_bus_error_free(&error);
    sd_bus_message_unref(reply);
    return rc;
}

/* Signal callback */
static int on_unit_new(sd_bus_message *m, void *userdata,
                       sd_bus_error *ret_err)
{
    const char *id, *path;
    sd_bus_message_read(m, "so", &id, &path);
    printf("Yeni unit: %s — %s\n", id, path);
    return 0;
}

/* Subscribe */
sd_bus_slot *slot = NULL;
rc = sd_bus_match_signal(
    bus,
    &slot,
    "org.freedesktop.systemd1",           /* sender */
    "/org/freedesktop/systemd1",           /* path */
    "org.freedesktop.systemd1.Manager",   /* interface */
    "UnitNew",                             /* member */
    on_unit_new,
    NULL
);

/* Event loop */
while (1) {
    rc = sd_bus_process(bus, NULL);
    if (rc < 0) break;
    if (rc > 0) continue; /* daha işlenecek mesaj var */
    sd_bus_wait(bus, UINT64_MAX); /* yeni mesaj bekle */
}

CFLAGS  := $(shell pkg-config --cflags libsystemd)
LDFLAGS := $(shell pkg-config --libs   libsystemd)

sdbus_call: sdbus_call.c
	$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)

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

#define SERVICE  "com.example.TempSensor"
#define PATH     "/com/example/TempSensor"
#define IFACE    "com.example.TempSensor"

static int32_t g_temperature = 230; /* °C × 10 */
static sd_bus *g_bus = NULL;

/* GetTemperature method handler */
static int method_get_temperature(sd_bus_message *m, void *ud,
                                   sd_bus_error *err)
{
    printf("GetTemperature çağrıldı\n");
    return sd_bus_reply_method_return(m, "i", g_temperature);
}

/* SetTemperature method handler */
static int method_set_temperature(sd_bus_message *m, void *ud,
                                   sd_bus_error *err)
{
    int32_t new_temp;
    int rc = sd_bus_message_read(m, "i", &new_temp);
    if (rc < 0)
        return rc;

    if (new_temp < -400 || new_temp > 1500) {
        return sd_bus_error_setf(err,
            SD_BUS_ERROR_INVALID_ARGS,
            "Sıcaklık aralık dışı: %d", new_temp);
    }

    g_temperature = new_temp;

    /* TemperatureChanged sinyali yayınla */
    sd_bus_emit_signal(g_bus, PATH, IFACE,
                       "TemperatureChanged", "i", g_temperature);

    return sd_bus_reply_method_return(m, "");
}

/* Property getter */
static int prop_get_temperature(sd_bus *bus, const char *path,
    const char *interface, const char *property,
    sd_bus_message *reply, void *ud, sd_bus_error *err)
{
    return sd_bus_message_append(reply, "i", g_temperature);
}

/* Vtable — servisin tüm API tanımı */
static const sd_bus_vtable sensor_vtable[] = {
    SD_BUS_VTABLE_START(0),

    SD_BUS_METHOD("GetTemperature", "", "i",
                  method_get_temperature, SD_BUS_VTABLE_UNPRIVILEGED),

    SD_BUS_METHOD("SetTemperature", "i", "",
                  method_set_temperature, SD_BUS_VTABLE_UNPRIVILEGED),

    SD_BUS_PROPERTY("Temperature", "i", prop_get_temperature,
                    0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),

    SD_BUS_SIGNAL("TemperatureChanged", "i", 0),

    SD_BUS_VTABLE_END
};

int main(void)
{
    sd_bus_slot *slot = NULL;
    int rc;

    rc = sd_bus_open_system(&g_bus);
    if (rc < 0) { fprintf(stderr, "Bus: %s\n", strerror(-rc)); return 1; }

    /* Nesneyi vtable ile yayınla */
    rc = sd_bus_add_object_vtable(g_bus, &slot, PATH, IFACE,
                                   sensor_vtable, NULL);
    if (rc < 0) { fprintf(stderr, "Vtable: %s\n", strerror(-rc)); goto out; }

    /* Well-known isim talep et */
    rc = sd_bus_request_name(g_bus, SERVICE, 0);
    if (rc < 0) { fprintf(stderr, "Name: %s\n", strerror(-rc)); goto out; }

    printf("Servis hazır: %s\n", SERVICE);

    /* Event loop */
    while (1) {
        rc = sd_bus_process(g_bus, NULL);
        if (rc < 0) break;
        if (rc > 0) continue;
        sd_bus_wait(g_bus, UINT64_MAX);
    }

out:
    sd_bus_slot_unref(slot);
    sd_bus_unref(g_bus);
    return rc < 0 ? 1 : 0;
}

# Servisi arka planda başlat (policy dosyası gerekli, bkz. bölüm 07)
sudo ./temp_sensor_service &

# GetTemperature çağrısı
busctl call com.example.TempSensor \
  /com/example/TempSensor \
  com.example.TempSensor \
  GetTemperature
# i 230

# SetTemperature çağrısı
busctl call com.example.TempSensor \
  /com/example/TempSensor \
  com.example.TempSensor \
  SetTemperature i 280

# Property okuma
busctl get-property com.example.TempSensor \
  /com/example/TempSensor \
  com.example.TempSensor \
  Temperature
# i 280

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE busconfig PUBLIC
 "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
 "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">

<busconfig>
  <!-- Servis sahibi: yalnızca root çalıştırabilir -->
  <policy user="root">
    <allow own="com.example.TempSensor"/>
    <allow send_destination="com.example.TempSensor"/>
    <allow receive_sender="com.example.TempSensor"/>
  </policy>

  <!-- Varsayılan: tüm kullanıcılar GetTemperature çağırabilir -->
  <policy context="default">
    <allow send_destination="com.example.TempSensor"
           send_interface="com.example.TempSensor"
           send_member="GetTemperature"/>
    <allow receive_sender="com.example.TempSensor"/>
  </policy>

  <!-- operator grubu: SetTemperature de çağırabilir -->
  <policy group="operator">
    <allow send_destination="com.example.TempSensor"
           send_interface="com.example.TempSensor"
           send_member="SetTemperature"/>
  </policy>
</busconfig>

# Policy dosyasını kopyala
sudo cp com.example.TempSensor.conf /etc/dbus-1/system.d/
sudo chmod 644 /etc/dbus-1/system.d/com.example.TempSensor.conf

# dbus-daemon'ı yeniden yükle (servis yeniden başlatılmaz)
sudo systemctl reload dbus

# Policy hata logları
journalctl -u dbus --since "1 min ago"

[D-BUS Service]
Name=com.example.TempSensor
Exec=/usr/bin/temp-sensor-service
User=root
SystemdService=com.example.TempSensor.service

[Unit]
Description=Temperature Sensor D-Bus Service
After=dbus.service

[Service]
Type=dbus
BusName=com.example.TempSensor
ExecStart=/usr/bin/temp-sensor-service
User=root
Restart=on-failure

[Install]
WantedBy=multi-user.target

# dbus-broker kurulumu (Debian/Ubuntu)
apt install dbus-broker

# dbus.service'i dbus-broker ile değiştir
systemctl enable --now dbus-broker.service
systemctl disable dbus.service

# Çalışma kontrolü
systemctl status dbus-broker.service
busctl list # Hâlâ aynı çıktı

# BlueZ nesne ağacını gör
busctl tree org.bluez

# Çıktı:
# └─ /org/bluez
#    └─ /org/bluez/hci0
#       ├─ /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF
#       │  ├─ /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001
#       │  │  ├─ /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001/char0002
#       │  │  └─ /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001/char0004

# Adapter interface'ini incele
busctl introspect org.bluez /org/bluez/hci0 \
  org.bluez.Adapter1

import time
from gi.repository import Gio, GLib

BLUEZ_SERVICE   = "org.bluez"
ADAPTER_PATH    = "/org/bluez/hci0"
ADAPTER_IFACE   = "org.bluez.Adapter1"
OBJ_MGR_IFACE   = "org.freedesktop.DBus.ObjectManager"

def get_adapter(bus):
    return Gio.DBusProxy.new_sync(
        bus, Gio.DBusProxyFlags.NONE, None,
        BLUEZ_SERVICE, ADAPTER_PATH, ADAPTER_IFACE, None
    )

def on_interfaces_added(conn, sender, path, iface, signal, params, userdata):
    obj_path, ifaces = params.unpack()
    if "org.bluez.Device1" in ifaces:
        dev = ifaces["org.bluez.Device1"]
        name    = dev.get("Name", "?")
        addr    = dev.get("Address", "?")
        rssi    = dev.get("RSSI", "?")
        print(f"  Yeni cihaz: {name} [{addr}] RSSI={rssi}")

def scan_bluetooth(duration_sec=10):
    bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
    adapter = get_adapter(bus)

    # InterfacesAdded sinyaline subscribe ol
    bus.signal_subscribe(
        BLUEZ_SERVICE,
        OBJ_MGR_IFACE,
        "InterfacesAdded",
        None,
        None,
        Gio.DBusSignalFlags.NONE,
        on_interfaces_added,
        None
    )

    # Taramayı başlat
    adapter.call_sync("StartDiscovery", None,
                      Gio.DBusCallFlags.NONE, -1, None)
    print(f"Tarama başladı ({duration_sec}s)...")

    loop = GLib.MainLoop()
    GLib.timeout_add_seconds(duration_sec, loop.quit)
    loop.run()

    # Taramayı durdur
    adapter.call_sync("StopDiscovery", None,
                      Gio.DBusCallFlags.NONE, -1, None)
    print("Tarama tamamlandı.")

if __name__ == "__main__":
    scan_bluetooth()

from gi.repository import Gio, GLib

BLUEZ_SERVICE  = "org.bluez"
GATT_CHAR_IFACE = "org.bluez.GattCharacteristic1"

def read_characteristic(char_path):
    """GATT characteristic değerini oku (Raw bytes döner)."""
    bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
    char_proxy = Gio.DBusProxy.new_sync(
        bus, Gio.DBusProxyFlags.NONE, None,
        BLUEZ_SERVICE, char_path, GATT_CHAR_IFACE, None
    )

    # ReadValue metodunu çağır (options: boş dict)
    result = char_proxy.call_sync(
        "ReadValue",
        GLib.Variant("(a{sv})", [{}]),
        Gio.DBusCallFlags.NONE,
        -1,
        None
    )
    raw_bytes = bytes(result.unpack()[0])
    print(f"Raw: {raw_bytes.hex()}")
    return raw_bytes

def notify_characteristic(char_path):
    """GATT notification'ları dinle."""
    bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
    char_proxy = Gio.DBusProxy.new_sync(
        bus, Gio.DBusProxyFlags.NONE, None,
        BLUEZ_SERVICE, char_path, GATT_CHAR_IFACE, None
    )

    def on_prop_changed(proxy, changed_props, invalidated):
        props = changed_props.unpack()
        if "Value" in props:
            val = bytes(props["Value"])
            print(f"Notification: {val.hex()}")

    char_proxy.connect("g-properties-changed", on_prop_changed)
    char_proxy.call_sync("StartNotify", None,
                         Gio.DBusCallFlags.NONE, -1, None)

    loop = GLib.MainLoop()
    loop.run()

# Kullanım örneği — BLE sıcaklık sensörü (UUID 2A6E)
# char_path = "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service0001/char0002"
# read_characteristic(char_path)

from gi.repository import Gio

def list_bluez_objects():
    bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
    obj_mgr = Gio.DBusProxy.new_sync(
        bus, Gio.DBusProxyFlags.NONE, None,
        "org.bluez", "/",
        "org.freedesktop.DBus.ObjectManager", None
    )

    result = obj_mgr.call_sync("GetManagedObjects", None,
                                Gio.DBusCallFlags.NONE, -1, None)
    objects = result.unpack()[0]

    for path, ifaces in objects.items():
        if "org.bluez.Device1" in ifaces:
            dev = ifaces["org.bluez.Device1"]
            print(f"{path}")
            print(f"  Name:    {dev.get('Name', 'N/A')}")
            print(f"  Address: {dev.get('Address', 'N/A')}")
            print(f"  Paired:  {dev.get('Paired', False)}")
            print(f"  Connected: {dev.get('Connected', False)}")

list_bluez_objects()