Ubus IPC

import { connect } from 'ubus';

const ubus = connect();
const result = ubus.call("session", "get", { key: "value" });

import * as ubus from 'ubus';

const ctx = ubus.connect();

const ubus = require("ubus");

// Connect to ubus and call a method
const conn = ubus.connect();
if (conn) {
    const result = conn.call("network.interface", "status", {});
    printf("Interface status: %.J\n", result);
    conn.disconnect();
}

const ubus = require("ubus");

// Typical pattern: async call with callback
const conn = ubus.connect();

conn.defer("some.object", "some_method", {}, (rc, result) => {
    if (rc == 0) {
        printf("Result: %.J\n", result);
    }
});

const ubus = require("ubus");

// Keep connection alive to prevent GC
const ubus_conn = ubus.connect();

function handle_request(request) {
    ubus_conn.defer("some.object", "some_method", {}, (rc, data) => {
        request.reply({ result: data });
    });
}

const ubus = require("ubus");

const conn = ubus.connect();
const obj = conn.publish("my.service", {
    "hello": (req, msg) => {
        req.reply({ message: "Hello from " + msg.name });
    }
});

const ubus = require("ubus");

const conn = ubus.connect();

// Register as event listener
const listener = conn.listener("my.event.*", (pattern, data) => {
    printf("Received event: %s %.J\n", pattern, data);
});

// Send an event
conn.event("my.event.test", { data: "test payload" });

Classes

ubus.channel

Represents a channel connection to the ubus bus.

Channels provide bidirectional communication between two ubus objects through file descriptors. They are created via open_channel() or from an incoming request via new_channel().

Channels are useful for:

• Establishing dedicated communication paths between specific objects
• Streaming data or multiple requests over a single connection
• File descriptor passing between processes

ubus.connection

Represents a connection to the ubus bus.

A connection is established via connect() and serves as the primary interface for all ubus operations. Through a connection, you can:

• Discover and invoke methods on remote objects (list(), call())
• Publish your own objects to the bus (publish())
• Subscribe to notifications from other objects (subscriber())
• Register event listeners for pattern-based events (listener())
• Send broadcast events to other listeners (event())

The connection uses the broker pattern, routing all communication through ubusd. It supports both synchronous (call) and asynchronous (defer) method invocations.

ubus.deferred

Represents a deferred ubus request.

A deferred request is created when invoking a method asynchronously using defer() or defer(). Instead of blocking and waiting for the result, the operation returns immediately with a deferred object that can be used to:

• Check if the request has completed (completed())
• Wait synchronously for completion (await())
• Abort the pending request if no longer needed (abort())

This pattern is useful for:

• Non-blocking operations in event-driven applications
• Timeout handling and request cancellation
• Concurrent execution of multiple ubus method calls

ubus.listener

Represents an event listener for pattern-based events.

A listener is registered via listener() to receive events matching a specific pattern. Listeners are part of the event broadcast communication scheme, where events are sent to all registered listeners with matching event patterns.

Event patterns support wildcards (e.g., `system.*`, `network.interface.*`) allowing flexible event routing and subscription.

ubus.notify

Represents an asynchronous notification request.

A notify object is created when sending a notification to subscribers via notify(). It allows tracking the delivery status of the notification and provides the ability to abort if needed.

Notifications are delivered to all subscribers of an object in the subscribe/notify communication scheme. The notify object provides non-blocking status checking and cancellation capabilities.

ubus.object

Represents a ubus object published on the bus.

A published object is a service registered with ubusd that provides methods for other processes to call. Objects are created via publish() and can:

• Expose multiple methods for remote invocation
• Receive notifications from subscribers (subscribed(), notify())
• Be removed from the bus when no longer needed (remove())

Objects are identified by their path (e.g., system, network.interface) and can be discovered by other processes using list().

ubus.request

Represents a deferred ubus method call context.

A request object is created when a published object method is invoked asynchronously. It provides the server-side interface for handling incoming method calls and sending responses.

The request context allows the method handler to:

• Send a successful reply with data (reply())
• Report an error condition (error())
• Defer completion for asynchronous processing (defer())
• Exchange file descriptors with the caller (get_fd(), set_fd())
• Establish channel-based communication (new_channel())

This is used internally by the ubus module when a published object's method is called by a client.

ubus.subscriber

Represents a subscriber to an object's notifications.

A subscriber is registered via subscriber() to receive notifications from a specific object. Subscribers are part of the subscribe/notify communication scheme, where the target object can send notifications that are delivered to all registered subscribers.

When a subscriber is registered, the target object receives a notification about the new subscription. Similarly, when a subscriber is removed, the target object is notified of the unsubscription.

Methods

connect(socketopt, timeoutopt) → {connection}nullable

Source

• lib/ubus.c, line 898

error(numericopt) → {string|number}

Source

• lib/ubus.c, line 617

guard(handleropt) → {function|boolean}

Source

• lib/ubus.c, line 3758

open_channel(fd, cb, disconnect_cbopt, timeoutopt) → {channel}nullable

Source

• lib/ubus.c, line 3695

Type Definitions

Ubus status codes

Source

• lib/ubus.c, line 3896

Ubus system object IDs

Source

• lib/ubus.c, line 3939