Busybus ALPHA (development in progress)

What is it?

  Busybus is a lightweight, simple and portable message bus and IPC system
  for embedded, Linux-based systems. The main objective is to create an
  intuitive, easy-to-use and small message bus using binary data marshalling
  without any external dependencies other than a standard Unix-like C library
  (glibc, eglibc or uClibc). It shall work out-of-the-box - ie. server daemon
  bbusd will be fully functional without any kind of configuration files - just
  simple command line options will suffice.

Why busybus?

  Having D-Bus on small flash-based embedded systems is often overkill. Other
  than that there are no many alternatives. There is ubus, but it's
  integrated with OpenWRT, there's abus, but it uses JSON for serialization
  and there's embus, but it doesn't seem to be actively developed and it
  doesn't offer much functionality either.

Is it ready?

  Not yet - right now I'm working on an initial alpha version of this program,
  which will act basically as a working proof of concept. Once a working
  version is ready I will try and get some attention on various mailing lists
  and open-source focused websites.

Compilation and installation:

  This will probably change, but for now it's a simple 'make all' in order to
  build the libbbus.so library and all the binaries. Additionally there's
  the 'make test' command, that will run the test suite located in the test/
  directory. For more info just type 'make help'.

  There's no installation procedure for now - just make sure your loader can
  locate libbbus.so and put the binaries where you like.

  It is already possible to view partial documentation - just run 'make doc' to
  generate html, TeX etc. output from doxygen comments in the API header file.

How easy is it?

  Here's an example of a simple user session - a program connects to the server
  and calls a method (error checking has been left out).

    bbus_client_connection* conn;
    bbus_object* arg;
    bbus_object* ret;
    char* retstr;

    conn = bbus_connect();
    arg = bbus_obj_build("s", "Hello world!");
    ret = bbus_callmethod(conn, "bbus.bbusd.echo", ret);
    bbus_obj_parse(obj, "s", &retstr);
    printf("%s\n", retstr);
    bbus_closeconn(conn);
    bbus_obj_free(ret);
    bbus_obj_free(arg);

  Example echo method implementation on the service provider side:

    static bbus_object* echo(const char* UNUSED method, bbus_object* arg)
    {
            char* str;

            bbus_obj_parse(arg, "s", &str);
            return bbus_obj_build("s", str);
    }

    struct bbus_method method = {
            .name = "echo",
            .argdscr = "s",
            .retdscr = "s",
            .func = echo
    };

    bbus_service_connection* conn;
    struct bbus_timeval tv;

    tv.sec = 0;
    tv.usec = 500000;
    conn = bbus_srvc_connect("some_provider");
    bbus_srvc_regmethod(conn, &method);
    while (bbus_srvc_listencalls(conn, &tv) >= 0);
    bbus_srvc_closeconn(conn);

  Functions used by bbusd are a bit more complex, but user programs don't
  even need to look at them.

Questions and suggestions => Bartosz Golaszewski <bartekgola@gmail.com>