aboutsummaryrefslogtreecommitdiffstats
path: root/bus.texinfo
diff options
context:
space:
mode:
authorMattias Andrée <maandree@kth.se>2017-12-11 23:13:37 +0100
committerMattias Andrée <maandree@kth.se>2017-12-11 23:13:37 +0100
commite35ba8684be9951fa2129503477ccd5ed6e4e5fc (patch)
tree756292d5a18ad6011a9311fdea8159f474385b65 /bus.texinfo
parenttypo (diff)
downloadbus-e35ba8684be9951fa2129503477ccd5ed6e4e5fc.tar.gz
bus-e35ba8684be9951fa2129503477ccd5ed6e4e5fc.tar.bz2
bus-e35ba8684be9951fa2129503477ccd5ed6e4e5fc.tar.xz
Simplify, do not install examples or info manual, and change license3.1.7
Signed-off-by: Mattias Andrée <maandree@kth.se>
Diffstat (limited to 'bus.texinfo')
-rw-r--r--bus.texinfo2079
1 files changed, 2079 insertions, 0 deletions
diff --git a/bus.texinfo b/bus.texinfo
new file mode 100644
index 0000000..be50cea
--- /dev/null
+++ b/bus.texinfo
@@ -0,0 +1,2079 @@
+\input texinfo @c -*-texinfo-*-
+
+@c %**start of header
+@setfilename bus.info
+@settitle bus
+@afourpaper
+@documentencoding UTF-8
+@documentlanguage en
+@finalout
+@c %**end of header
+
+
+@dircategory Interprorcess Communication
+@direntry
+* bus: (bus). A simple daemonless system for broadcasting messages locally
+@end direntry
+
+
+@copying
+Copyright @copyright{} 2015 Mattias Andrée
+
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.3 or
+any later version published by the Free Software Foundation; with no
+Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
+Texts. A copy of the license is included in the section entitled
+``GNU Free Documentation License''.
+@end quotation
+@end copying
+
+@ifnottex
+@node Top
+@top bus -- A simple daemonless system for broadcasting messages locally
+@insertcopying
+@end ifnottex
+
+@titlepage
+@title bus
+@subtitle A simple daemonless system for broadcasting messages locally
+@author by Mattias Andrée (maandree)
+
+@page
+@vskip 0pt plus 1filll
+@insertcopying
+@page
+@end titlepage
+
+@contents
+
+
+@iftex
+@macro xrm{}
+@rm{}
+@end macro
+@macro xtt{}
+@tt{}
+@end macro
+@end iftex
+
+@ifnottex
+@macro xrm{}
+@end macro
+@macro xtt{}
+@end macro
+@end ifnottex
+
+@menu
+* Overview:: Brief overview of @command{bus}.
+* Standard:: How to use @command{bus} properly.
+* Invoking:: Executing @command{bus}.
+* Interface:: Using @command{libbus}.
+* Protocol:: How communication over @command{bus} works internally.
+* Rationale:: Why @command{bus}?
+* Examples:: Usecase examples and API-demonstration.
+* GNU Free Documentation License:: Copying and sharing this manual.
+
+@detailmenu
+ --- The Detailed Node Listing ---
+
+Invoking
+
+* bus create:: Create a bus.
+* bus remove:: Remove a bus.
+* bus listen:: Listen for new message on a bus.
+* bus wait:: Listen for one new message only on a bus.
+* bus broadcast:: Broadcast a message on a bus.
+* bus chmod:: Change permissions on a bus.
+* bus chown:: Change ownership of a bus.
+* bus chgrp:: Change group ownership of a bus.
+
+Examples
+
+* Audio-volume control::
+* Telephony and music::
+* Timed::
+* Nonblocking::
+* Daemon-dependencies::
+
+@end detailmenu
+@end menu
+
+
+
+@node Overview
+@chapter Overview
+
+@command{bus} is a stupid-simple, thrilless, daemonless interprocess
+communication system for broadcasting messages. It is a lightweight
+alternative to a two-phase interprocess flexible barrier.
+
+@command{bus} uses a System V semaphore array and System V shared
+memory. Buses are named; the key of the semaphore array and the
+shared memory is stored in a regular file.
+
+The shared memory used by @command{bus} is always 2048 bytes.
+Additionally all messages should be encoded in UTF-8 and not contain
+any NULL characters, except they @emph{must} always end with a NULL
+byte. Furthermore messages should be prefixed with the process
+identifer of the process whence the message originated, followed
+by a space. If the process is ephemeral@footnote{The process exits
+after the broadcast, or shortly thereafter.}, 0 should be used
+instead of the process identifier.
+
+Communication over @command{bus} is synchronous. The broadcast call
+does not return until all listeners have received (and copied) the
+message. A malfunctioning program can lock the bus.
+
+This software package contains a C library and a command line
+utility. The package python-bus provides a Python 3 module.
+
+
+
+@node Standard
+@chapter Standard
+
+The command @command{bus create} can be used to create new buses. By
+convention, buses should be stored in @file{$XDG_RUNTIME_DIR/bus},
+this is what @command{bus create} does if no pathname is given. The
+pathname of the bus should be tracked using @env{BUS_X}, where @env{X}
+is replaced with either:
+
+@table @env
+@item GENERIC
+For the bus used in generic cases. That is all but the cases
+of the buses listed below.
+@item AUDIO
+For the bus used in with the audio subsystem is involved.
+@item VIDEO
+For the bus used in with the video subsystem is involved.
+@item INPUT
+For the bus used in with the input subsystem is involved.
+@item FILES
+For the bus used in with the storage subsystem is involved.
+@end table
+
+This list may be extended in the future. Therefore, and for
+other conventions, project-private buses should be tracked
+using @env{X_BUS}, where @env{X} is the project name.
+
+Messages broadcasted on a bus cannot be longer than 2047 bytes,
+excluding NUL termination. Message should be encoded in UTF-8,
+and most not contain the NUL character.
+
+Broadcasted message should start with the process ID whence
+the message originated, followed by a single regular space.
+If the process is ephemeral@footnote{The process exits after
+the broadcast, or shortly thereafter.}, 0 should be used instead
+of the process identifier.
+
+
+
+@node Invoking
+@chapter Invoking
+
+@command{bus} includes the following commands:
+
+@table @command
+@item create
+Create a bus.
+See @ref{bus create} for more information.
+@item remove
+Remove a bus.
+See @ref{bus remove} for more information.
+@item listen
+Listen for new message on a bus.
+See @ref{bus listen} for more information.
+@item wait
+Listen for one new message only on a bus.
+See @ref{bus wait} for more information.
+@item broadcast
+Broadcast a message on a bus.
+See @ref{bus broadcast} for more information.
+@item chmod
+Change permissions on a bus.
+See @ref{bus chmod} for more information.
+@item chown
+Change ownership of a bus.
+See @ref{bus chown} for more information.
+@item chgrp
+Change group ownership of a bus.
+See @ref{bus chgrp} for more information.
+@end table
+
+Upon successful completion, these commands exit with the value
+0. On failure, they exit with the value 1. If the command is
+not recognised the exit value is 2.
+
+@menu
+* bus create:: Create a bus.
+* bus remove:: Remove a bus.
+* bus listen:: Listen for new message on a bus.
+* bus wait:: Listen for one new message only on a bus.
+* bus broadcast:: Broadcast a message on a bus.
+* bus chmod:: Change permissions on a bus.
+* bus chown:: Change ownership of a bus.
+* bus chgrp:: Change group ownership of a bus.
+@end menu
+
+
+
+@node bus create
+@section @command{bus create}
+
+The syntax for invocation of @command{bus create} is
+@example
+bus create [-x] [--] [@var{PATHNAME}]
+@end example
+
+The command creates a bus and stores the key to it in the
+file @var{PATHNAME}. If @var{PATHNAME} is omitted, a
+random pathname in @file{$XDG_RUNTIME_DIR/bus} will be
+used and printed to stdout.
+
+If @option{-x} is used, the command will fail if
+the file @var{PATHNAME} already exists.
+
+
+
+
+@node bus remove
+@section @command{bus remove}
+
+The syntax for invocation of @command{bus remove} is
+@example
+bus remove [--] @var{PATHNAME}
+@end example
+
+The command removes the bus whose key is stored in
+the file @var{PATHNAME}. The file holding the
+key is also unlinked.
+
+
+
+@node bus listen
+@section @command{bus listen}
+
+The syntax for invocation of @command{bus command} is
+@example
+bus listen [--] @var{PATHNAME} @var{COMMAND}
+@end example
+
+The command listens for new messages on the bus whose
+key is stored in the file @var{PATHNAME}. Once a message
+is received, @var{COMMAND} will be spawned with the
+environment variable @env{msg} (lowercased) set to the
+received message. @sc{POSIX} shell syntax applies to
+@var{COMMAND}.
+
+
+@node bus wait
+@section @command{bus wait}
+
+The syntax for invocation of @command{bus wait} is
+@example
+bus wait [--] @var{PATHNAME} @var{COMMAND}
+@end example
+
+The command listens for a new message on the bus whose
+key is stored in the file @var{PATHNAME}. Once a message
+is received, the process will stop listening for more
+messages and @var{COMMAND} will be spawned with the
+environment variable @env{msg} (lowercased) set to the
+received message. @sc{POSIX} shell syntax applies to
+@var{COMMAND}.
+
+
+
+@node bus broadcast
+@section @command{bus broadcast}
+
+The syntax for invocation of @command{bus broadcast} is
+@example
+bus broadcast [-n] [--] @var{PATHNAME} @var{MESSAGE}
+@end example
+
+The command broadcasts the message @var{MESSAGE} on the
+bus whose key is stored in the file @var{PATHNAME}.
+
+
+
+@node bus chmod
+@section @command{bus chmod}
+
+The syntax for invocation of @command{bus chmod} is
+@example
+bus chmod [--] @var{PERMISSIONS} @var{PATHNAME}
+@end example
+
+This command changes who have access to the bus whose key
+is stored in the file @var{PATHNAME}. In the permissions,
+the owner, the group, and others (not in tgroup) are
+represented by the symbols @code{u}@footnote{@code{u}
+stands for `user'.}, @code{g}, and @code{o}, respectively.
+The permissions string is imagined to have always be
+prefixed with an @code{=}. This symbols means that all user
+classes list after it, and only those classes, as permission
+to use the bus. Similarly the symbols @code{+} and @code{-}
+can be used to grant and revoke access, respectively. The
+symbols @code{=}, @code{+}, and @code{-} can be mixed, and
+are interpreted from left to right. Alternatively the
+permissions string can be a octal number, where the owner
+is represented by any bit in 700 (100, 200, or 400, or any
+combination thereof), the group is represented by any bit
+in 70, and others (not in the group) is represented by any
+bit in 7.
+
+The current permission of the bus can be retrieved by
+running @command{stat} over the file @var{PATHNAME}.
+
+
+
+@node bus chown
+@section @command{bus chown}
+
+The syntax for invocation of @command{bus chown} is
+@example
+bus chown [--] @var{OWNER}[:@var{GROUP}] @var{PATHNAME}
+@end example
+
+This command changes the owner, that owns the bus whose
+key is stored in the file @var{PATHNAME}, to the specified
+owner. The owner can be specified either with a numerical
+user identifier or with a user name. If a group is
+specified, the bus's owner-group will be set to that group,
+otherwise the group will remain unchanged (not changed
+to the group of the new owner.) The group can be specified
+either with a numerical group identifier or with a group
+name.
+
+The current ownership of the bus can be retrieved by
+running @command{stat} over the file @var{PATHNAME}.
+
+
+
+@node bus chgrp
+@section @command{bus chgrp}
+
+The syntax for invocation of @command{bus chgrp} is
+@example
+bus chgrp [--] @var{GROUP} @var{PATHNAME}
+@end example
+
+This command changes the group, that owns the bus whose
+key is stored in the file @var{PATHNAME}, to the specified
+group. The group can be specified either with a numerical
+group identifier or with a group name.
+
+The current ownership of the bus can be retrieved by
+running @command{stat} over the file @var{PATHNAME}.
+
+
+
+@node Interface
+@chapter Interface
+
+To use @command{libbus} in your C program, include the
+header file @file{<bus.h>} and link with the flag
+@option{-lbus}.
+
+With exception to @code{bus_poll} and @code{bus_poll_timed},
+all functions return @code{0} upon successful completion,
+and @code{-1} in case of failure. @code{bus_poll} and
+@code{bus_poll_timed} return @code{NULL} on failure.
+On failure on all functions set @code{errno} to indicate
+what went wrong.
+
+@file{<bus.h>} defines the following functions:
+
+@table @code
+@item int bus_create(const char *file, int flags, char **out_file)
+This function creates a bus with the asscoiated pathname
+specifed by the value of the parameter @code{file}. If
+@code{file} is @code{NULL} a random pathname is selected.
+This pathname adheres to the convention set forth by
+in @ref{Standard}.
+
+If @code{file} is not @code{NULL} the function fails if the
+file already exists if @code{flags} contains @code{BUS_EXCL}.
+Otherwise if @code{file} is not @code{NULL}, the function
+does nothing if the file already exists.
+
+If @code{flags} contains @code{BUS_INTR}, the function fails
+if it is interrupted.
+
+Unless @code{out_file} is NULL, the pathname of the bus
+should be stored in a new char array stored in @code{*out_file}.
+The caller must free the allocated stored in @code{*out_file}.
+
+If the processes cannot allocate enough memory to perform
+the action, the function sets @code{errno} to @code{ENOMEM}
+and fails. It may also fail and set @code{errno} to any of
+the errors specified for the system calls @code{open} and
+@code{write}.
+
+@item int bus_unlink(const char *file)
+This function removes the bus assoicated with the pathname
+stored in the parameter @code{file}. The function also
+unlinks the file.
+
+The function may set @code{errno} to any of the following
+values and fail for the specified reasons:
+@table @code
+@item EINVAL
+The bus does not exist.
+@item EACCES
+Operation permission is denied to the calling process.
+@item EPERM
+The user does not have permission to remove the bus.
+@end table
+@noindent
+It may also fail and set @code{errno} to any of the errors
+specified for the system calls @code{unlink} and @code{open},
+and the functions @code{semget} and @code{shmget}.
+
+@item int bus_open(bus_t *bus, const char *file, int flags)
+This function acquires resources required for the process
+to use the bus associated with the filename stored in the
+parameter @code{file}. The function also stores the resources
+in @code{bus} for use by other @command{bus} functions.
+
+Values for @code{flags} are constructed by a bitwise
+inclusive @sc{or} of flags from the following list.
+@table @code
+@item BUS_RDONLY
+The process will only be using the bus for receiving messages.
+@item BUS_WRONLY
+The process will only be using the bus for sending messages.
+@item BUS_RDWR
+The process will use the bus for both receiving and sending
+messages.
+@end table
+
+The function may set @code{errno} to any of the following
+values and fail for the specified reasons:
+@table @code
+@item ENOMEM
+The process cannot allocate enough memory to perform the
+action.
+@item EACCES
+Operation permission is denied to the calling process.
+@item EINVAL
+The described bus does not exist.
+@end table
+@noindent
+It may also fail and set @code{errno} to any of the errors
+specified for the system call @code{open}.
+
+@item int bus_close(bus_t *bus)
+This function disposes of resources allocated to the
+process, as referenced in the parameter @code{bus}.
+
+The function fails and sets @code{errno} to @code{EINVAL}
+if the bus does not exist.
+
+@item int bus_write(const bus_t *bus, const char *message, int flags)
+This function broadcasts a message on the bus whose
+information is stored in the parameter @code{bus}. The
+message read by the function is stored in the parameter
+@code{message}. It may not exceeed 2048 bytes, including
+NUL termination.
+
+The function shall fail, and set @code{errno} to
+@code{EAGAIN}, if the call would suspend the process and
+@code{flags} contains @code{BUS_NOWAIT}.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the function @code{semop}.
+
+@item int bus_write_timed(const bus_t *bus, const char *message, const struct timespec *timeout, clockid_t clockid)
+This function behaves like @code{bus_write}, except if it
+is not able to write the message within the specified time,
+it will fail and set @code{errno} to @code{EAGAIN}. The
+time is specified as an absolute time using the parameter
+@code{timeout}. The behaviour is unspecified if @code{timeout}
+is @code{NULL}. @code{timeout} is measured with the clock whose
+identifier is specified by the parameter @code{clockid}. This
+clock must be a predicitable clock@footnote{There are probably
+other, undocumented, seemingly arbitrary restrictions too.}.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the functions @code{semop} and
+@code{clock_gettime}.
+
+@item int bus_read(const bus_t *bus, int (*callback)(const char *message, void *user_data), void *user_data)
+This function waits for new message to be sent on the bus
+specified in the @code{bus} parameter, as provieded by a
+previous call to the function @code{bus_open}. Once a
+message is received, the parameter-function @code{callback}
+is invoked. The parameter @code{message} in @code{callback}
+is the received message, and @code{user_data} in
+@code{callback} should be @code{user_data} from @code{bus_read}.
+However, once the function [@code{bus_read}] has ensured
+that it will receive any message sent on the bus, it shall
+invoke the parameter-function @code{callback} with
+@code{message} set to @code{NULL}, to notify the process that
+it can perform any action that requires that it is listening
+on the bus.
+
+After @code{callback} returns, @code{message} may be override.
+Therefore @code{callback} should copy message and start a new
+thread that uses the copy of @code{message}. @code{callback}
+shall return @code{-1} on failure, @code{0} if the function
+[@code{bus_read}] should stop listening, or @code{1} if
+the function should continue listening.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the function @code{semop}.
+
+@item int bus_read_timed(const bus_t *bus, int (*callback)(const char *message, void *user_data), void *user_data, const struct timespec *timeout, clockid_t clockid)
+This function behaves like @code{bus_read}, except it will
+automatically fail and set @code{errno} to @code{EAGAIN} when
+the specified time has passed. The time is specified as an
+absolute time using the parameter @code{timeout}. The
+behaviour is unspecified if @code{timeout} is @code{NULL}.
+@code{timeout} is measured with the clock whose identifier
+is specified by the parameter @code{clockid}. This clock
+must be a predicitable clock@footnote{There are probably
+other, undocumented, seemingly arbitrary restrictions too.}.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the functions @code{semop} and
+@code{clock_gettime}.
+
+@item int bus_poll_start(bus_t *bus)
+@itemx int bus_poll_stop(const bus_t *bus)
+@itemx const char *bus_poll(bus_t *bus, int flags)
+@itemx const char *bus_poll_timed(bus_t *bus, const struct timespec *timeout, clockid_t clockid)
+The function @code{bus_poll} waits for a message to be
+broadcasted on the bus, and return the message it receives.
+The function fails if @code{flags} contains @code{BUS_NOWAIT}
+and there is not already a message waiting on the bus.
+Received messages shall be copied and parsed, and acted
+upon, in a separate thread, and the function @code{bus_poll}
+or the function @code{bus_poll_stop} called again as soon
+as possible.
+
+The funcion @code{bus_poll_start} must be called before
+@code{bus_poll} is called for the first time. When the
+process is done listening on the bus, it must call the
+function @code{bus_poll_stop}.
+
+The function @code{bus_poll_timed} behaves like the function
+@code{bus_poll}, except if it is not able to read a message
+within the specified time, it will fail and set @code{errno}
+to @code{EAGAIN}. The time is specified as an absolute time
+using the parameter @code{timeout}. The behaviour is
+unspecified if @code{timeout} is @code{NULL}. @code{timeout}
+is measured with the clock whose identifier is specified by
+the parameter @code{clockid}. This clock must be a predicitable
+clock@footnote{There are probably other, undocumented,
+seemingly arbitrary restrictions too.}.
+
+Upon successful completion, the functions @code{bus_poll} and
+@code{bus_poll_timed} returns the received message.
+
+These functions may fail and set @code{errno} to any of the
+errors specified for the function @code{semop}. The function
+@code{bus_poll_timed} may also set @code{errno} to any of
+the errors specified for @code{clock_gettime}.
+
+@item int bus_chown(const char *file, uid_t owner, gid_t group)
+This function changes the owner and the group of the bus,
+associated with the file whose pathname is stored in the
+parameter @code{file}, to the owner and group specified by
+the parameters @code{owner} and @code{group}, respectively.
+
+The current ownership of a bus can be retrieved by calling
+@code{stat} over the pathname of the bus.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the functions @code{bus_open},
+@code{chown}, @code{semget}, @code{shmget}, and @code{shmctl}
+as well as any errors specified for the commands
+@code{IPC_STAT} and @code{IPC_SET} for the function
+@code{semctl}.
+
+@item int bus_chmod(const char *file, mode_t mode)
+This function gives access to the bus associated with the
+file whose pathname is stored in the parameter @code{file}
+according to the following rules:
+
+@itemize @bullet{}
+@item
+If @code{mode} contains any of the bits @code{S_IRWXU}
+contains, the owner should be given full access to the
+bus. Otherwise the owner should have no access.
+@item
+If @code{mode} contains any of the bits @code{S_IRWXG}
+contains, the group should be given read and write
+access to the bus. Otherwise the group should have no
+access.
+@item
+If @code{mode} contains any of the bits @code{S_IRWXO}
+contains, users that are neither the owner nor member
+of the group should be given read and write access to
+the bus. Otherwise they should have no access.
+@end itemize
+
+The current permissions of a bus can be retrieved by calling
+@code{stat} over the pathname of the bus.
+
+The function may fail and set @code{errno} to any of the
+errors specified for the functions @code{bus_open},
+@code{chmode}, @code{semget}, @code{shmget}, and @code{shmctl}
+as well as any errors specified for the commands
+@code{IPC_STAT} and @code{IPC_SET} for the function
+@code{semctl}.
+@end table
+
+There is not reason for poking around in @code{bus_t}
+(@code{struct bus}). It should be considered opaque.
+You can read the documentation in @file{<bus.h>} if
+you want to know what is in it.
+
+
+
+
+@node Protocol
+@chapter Protocol
+
+@command{bus} is built upon following three procedures.
+
+@noindent
+@code{create}
+@example
+@w{@xrm{}Select a filename.@xtt{}}
+
+@w{@xrm{}Create XSI semaphore array @{@code{S} = 0, @code{W} = 0, @code{X} = 1, @code{Q} = 0, @code{N} = 0@}@xtt{}}
+@w{@xrm{}with random key. Store the semaphore array's key in decimal form@xtt{}}
+@w{@xrm{}on the first line in the selected file.@xtt{}}
+
+@w{@xrm{}Create XSI shared memory, with an allocation of 2048 bytes, with@xtt{}}
+@w{@xrm{}a random key. Store the shared memory's key in decimal form on@xtt{}}
+@w{@xrm{}the second line in the selected file.@xtt{}}
+@end example
+
+@noindent
+@code{broadcast}
+@example
+with P(X):
+ Z(W)
+ @w{@xrm{}Write NUL-terminate message to shared memory@xtt{}}
+ with V(N): -- (1)
+ Q := 0
+ Z(S)
+
+-- (1) @w{@xrm{}may be omitted if semaphores are known that@xtt{}}
+ @w{P()@xrm{}, @xtt{}Z()@xrm{}, @xtt{}V()@xrm{} cannot create a race condition@xtt{}}
+ @w{@xrm{}with a processes running @xtt{}Z()@xrm{}.@xtt{}}
+@end example
+
+@noindent
+@code{listen}
+@example
+with V(S):
+ forever:
+ V(Q)
+ Z(Q)
+ @w{@xrm{}Read NUL-terminated message from shared memory@xtt{}}
+ if breaking:
+ break
+ with V(W):
+ with P(S):
+ Z(S)
+ Z(N)
+@end example
+
+@noindent
+@code{V(a)} means that semaphore a is released.@*
+@code{P(a)} means that semaphore a is acquired.@*
+@code{Z(a)} means that the process waits for semaphore a to become 0.@*
+@code{with P(a)} that @code{P(a)} is done before the entering the scope,
+and @code{V(a)} is done when exiting the scope. It also means that
+these actions [@code{P(a)} and @code{V(a)}] are undone when the process
+exits, or if the call fails.@*
+@code{with V(a)} is to @code{V(a)} as @code{with P(a)} is to @code{P(a)}.
+
+
+
+@node Rationale
+@chapter Rationale
+
+We need an interprocess communication system similar
+to message queues. But we need broadcasting rather than
+anycasting, so we have a fast, simple and daemonless
+system for announcing events to any processes that
+might be interested.
+
+
+
+@node Examples
+@chapter Examples
+
+This chapter contains usecase examples and
+API-demonstrations. You will find that they are (on
+a standard installation) installed on your system.
+
+@menu
+* Audio-volume control::
+* Telephony and music::
+* Timed::
+* Nonblocking::
+* Daemon-dependencies::
+@end menu
+
+
+
+
+@node Audio-volume control
+@section Audio-volume control
+
+Assume you have program that display the audio volume.
+This program checks every second third if the volume
+have changed.
+
+Also assume that you use @command{amixer} to change the
+volume, most often by using keybindings via @command{xbindkeys}.
+
+To reduce the delay, you want to send a signal to the
+monitor program that the volume have changed. For this
+more primitive IPC is sufficient, but lets assume there
+are other programs interested in this information too.
+
+To accomplish this, you create a wrapper for @command{amixer}
+that broadcasts updates on a bus. This wrapper is
+installed as @command{~/.local/bin/amixer}, and
+@command{~/.local/bin/} is included in @env{$PATH}
+before @command{/usr/bin}.
+@*
+
+@noindent
+Before starting run @command{./init}, this code is
+should be run from your profile file if you want to
+implement this on your system. After running
+@command{./init}, you can start one or more listeners
+by running @command{./alsa-monitor}.
+
+To change the volume run
+@code{./amixer -c 0 -- set Master 5%+} or similar.
+
+When you are done run @command{./cleanup}.
+
+
+@subsubheading @file{./amixer}
+@example
+#!/bin/sh
+/usr/bin/amixer "$@@"
+for arg in "$@@"; do
+ if [ "$@{arg@}" = "set" ] || \
+ [ "$@{arg@}" = "sset" ] || \
+ [ "$@{arg@}" = "cset" ]; then
+ exec bus broadcast "/tmp/example-bus" '0 volume-changed *'
+ fi
+done
+@end example
+
+
+@subsubheading @file{./cleanup}
+@example
+#!/bin/sh
+exec bus remove "/tmp/example-bus"
+@end example
+
+
+@subsubheading @file{./init}
+@example
+#!/bin/sh
+bus create "/tmp/example-bus"
+
+# @w{@xrm{}The following code is more suitable in the real world,@xtt{}}
+# @w{@xrm{}if used, the other files should use @xtt{}"$@{BUS_AUDIO@}"}
+# @w{@xrm{}instead of @xtt{}"/tmp/example-bus"@xrm{}.@xtt{}}
+#
+# export BUS_AUDIO="$@{XDG_RUNTIME_DIR@}/bus/audio"
+# if [ ! -f "$@{BUS_AUDIO@}" ]; then
+# bus create "$@{BUS_AUDIO@}"
+# fi
+@end example
+
+
+@subsubheading @file{./monitor}
+@example
+#!/bin/sh
+if [ $# = 1 ]; then
+ if [ "$(echo "$@{1@}" | cut -d ' ' -f 2)" = "volume-changed" ]; then
+ printf '\e[H\e[2J'
+ amixer get Master
+ fi
+ exit 0
+fi
+
+exec 2>/dev/null
+
+printf '\e[?1049h\e[H\e[2J'
+trap -- "printf '\e[?1049l'" SIGINT
+bus listen "/tmp/example-bus" \'"$@{0/\'/\'\\\'\'@}"\'' "$@{msg@}"'
+@end example
+
+
+
+@node Telephony and music
+@section Telephony and music
+
+Assume you have a music player and a telephony program.
+You might like it if the music player pauses whenever
+you make or receive a call. You may also like it, if
+the music resumed when the call ended.
+
+In this example we will assume you the have @command{mocp}
+(@command{moc} package) running. And we will use the shell to
+simulate a telephony program.
+@*
+
+@noindent
+First of, run make to build this example. Before
+starting run @command{./init}. And when you are
+done run @command{./cleanup}.
+
+In one terminal run @command{./monitor}. This program
+will pause @command{mocp} when you make or receive a call,
+it will also resume @command{mocp} when all calls have
+ended if it did pause @command{mocp}.
+
+Then start any positive number of terminals.
+We will pretend that each of them are telephony
+programs. To make or receive a call, run
+@command{./receive-or-make-call}, when you want to
+end the pretend call, run @command{./end-call} from
+the terminal (or more accurately, from the same
+process.)
+
+
+@subsubheading @file{./Makefile}
+@example
+COMMANDS = init cleanup monitor end-call receive-or-make-call
+
+all: $@{COMMANDS@}
+%: %.c
+ $@{CC@} -Wall -Wextra -pedantic -std=c99 -lbus -o $@@ $<
+clean:
+ -rm $@{COMMANDS@}
+
+.PHONY: all clean
+@end example
+
+
+@subsubheading @file{./cleanup.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_unlink("/tmp/example-bus") && (perror("cleanup"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./end-call.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char message[BUS_MEMORY_SIZE];
+
+int main()
+@{
+ bus_t bus;
+ sprintf(message, "%ji unforce-pause", (intmax_t)getppid());
+ /* @w{@xrm{}Yes, PPID; in this example we pretend the shell is the telephony process.@xtt{}} */
+ t (bus_open(&bus, "/tmp/example-bus", BUS_WRONLY));
+ t (bus_write(&bus, message, 0));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("end-call");
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./init.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_create("/tmp/example-bus", 0, NULL) && (perror("init"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./monitor.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static size_t pauser_count = 0;
+static size_t pausers_size = 0;
+static char* pausers = NULL;
+
+static int is_moc_playing(void)
+@{
+ return !WEXITSTATUS(system("env LANG=C mocp -i 2>/dev/null |"
+ "grep 'State: PLAY' >/dev/null"));
+@}
+
+/* @w{@xrm{}In a proper implementation, message whould be copyied, and then@xtt{}}
+ * @w{@xrm{}a new thread would be created that parsed the copy. But that is@xtt{}}
+ * @w{@xrm{}too much for an example, especially since it would also require@xtt{}}
+ * @w{@xrm{}a mutex to make sure two threads do not modify data at the same@xtt{}}
+ * @w{@xrm{}time, causing chaos.@xtt{}} */
+static int callback(const char *message, void *user_data)
+@{
+ char *msg = NULL;
+ size_t len = 0;
+ if (message == 0)
+ return 1;
+ while ((len < 2047) && message[len])
+ len++;
+ msg = malloc((len + 1) * sizeof(char));
+ t (msg == NULL);
+ memcpy(msg, message, len * sizeof(char));
+ msg[len] = 0;
+ /* @w{@xrm{}BEGIN run as in a separate thread@xtt{}} */
+ if (pauser_count || is_moc_playing()) @{
+ char *begin = strchr(msg, ' ');
+ ssize_t pid;
+ int requests_pause;
+ if (begin == NULL)
+ goto done;
+ *begin++ = 0;
+ pid = (ssize_t)atoll(msg);
+ if (pid < 1) /* @w{@xrm{}We need a real PID, too bad there is@xtt{}}
+ * @w{@xrm{}no convient way to detect if it dies.@xtt{}} */
+ goto done;
+ if ((strstr(begin, "force-pause ") == begin) ||
+ !strcmp(begin, "force-pause"))
+ requests_pause = 1;
+ else if ((strstr(begin, "unforce-pause ") == begin) ||
+ !strcmp(begin, "unforce-pause"))
+ requests_pause = 0;
+ else
+ goto done;
+ if ((size_t)pid >= pausers_size) @{
+ pausers = realloc(pausers, (size_t)(pid + 1) * sizeof(char));
+ t (pausers == NULL); /* @w{@xrm{}Let's ignore the memory leak.@xtt{}} */
+ memset(pausers + pausers_size, 0,
+ ((size_t)(pid + 1) - pausers_size) * sizeof(char));
+ pausers_size = (size_t)(pid + 1);
+ @}
+ if (pausers[pid] ^ requests_pause) @{
+ pauser_count += requests_pause ? 1 : -1;
+ pausers[pid] = requests_pause;
+ if (pauser_count == (size_t)requests_pause)
+ system(requests_pause ? "mocp -P" : "mocp -U");
+ @}
+ @}
+ /* @w{@xrm{}END run as in a separate thread@xtt{}} */
+ goto done;
+ (void) user_data;
+
+fail:
+ perror("monitor");
+ return -1;
+
+done:
+ free(msg);
+ return 1;
+@}
+
+int main()
+@{
+ bus_t bus;
+ t (bus_open(&bus, "/tmp/example-bus", BUS_RDONLY));
+ t (bus_read(&bus, callback, NULL));
+ bus_close(&bus);
+ free(pausers);
+ return 0;
+
+fail:
+ perror("monitor");
+ bus_close(&bus);
+ free(pausers);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./receive-or-make-call.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char message[BUS_MEMORY_SIZE];
+
+int main()
+@{
+ bus_t bus;
+ sprintf(message, "%ji force-pause", (intmax_t)getppid());
+ /* @w{@xrm{}Yes, PPID; in this example we pretend the shell is the telephony process.@xtt{}} */
+ t (bus_open(&bus, "/tmp/example-bus", BUS_WRONLY));
+ t (bus_write(&bus, message, 0));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("receive-or-make-call");
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+
+@node Timed
+@section Timed
+
+This example shows how to use timed operations.
+
+First of, run make to build this example.
+
+To start the example run @command{./init}. When you are
+done run @command{./cleanup}.
+
+Running instances of @command{./poll} will wait for new
+messages continuously, but with one second timeouts.
+
+@command{./slow-poll} works like @command{./poll}, except
+it will sleep for one second every time it receives
+a message.
+
+Running instances of @command{./read} will read for ten
+seconds and then time out.
+
+@command{./poll}, @command{./read}, and @command{./slow-poll}
+will stop if the message "stop" is broadcasted.
+
+@command{./write} will wait for atmost a tenth of a
+seconds before failing. This means that if two instances
+of @command{./write} is started at the same time one of
+them will fail if @command{./slow-poll} is running.
+
+@command{./poll}, @command{./read}, @command{./init} and
+@command{./cleanup} are run without any additional
+arguments. @command{./write} is run with the message
+as the second argument.
+
+
+@subsubheading @file{./Makefile}
+@example
+COMMANDS = init cleanup write poll read slow-poll
+
+all: $@{COMMANDS@}
+%: %.c
+ $@{CC@} -Wall -Wextra -pedantic -std=c99 -lbus -o $@@ $<
+clean:
+ -rm $@{COMMANDS@}
+
+.PHONY: all clean
+@end example
+
+
+@subsubheading @file{./cleanup.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_unlink("/tmp/example-bus") && (perror("cleanup"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./init.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_create("/tmp/example-bus", 0, NULL) && (perror("init"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./poll.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define t(stmt) if (stmt) goto fail
+
+int main()
+@{
+ bus_t bus;
+ const char *message;
+ long long tick = 0;
+ struct timespec timeout;
+ t (bus_open(&bus, "/tmp/example-bus", BUS_RDONLY));
+ t (bus_poll_start(&bus));
+ for (;;) @{
+ t (clock_gettime(CLOCK_MONOTONIC, &timeout));
+ timeout.tv_sec += 1;
+ message = bus_poll_timed(&bus, &timeout, CLOCK_MONOTONIC);
+ if (message == NULL) @{
+ t (errno != EAGAIN);
+ printf("waiting... %lli\n", ++tick);
+ continue;
+ @}
+ tick = 0;
+ message = strchr(message, ' ') + 1;
+ if (!strcmp(message, "stop"))
+ break;
+ printf("\033[01m%s\033[21m\n", message);
+ @}
+ t (bus_poll_stop(&bus));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("poll");
+ bus_poll_stop(&bus);
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./read.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static int callback(const char *message, void *user_data)
+@{
+ (void) user_data;
+
+ if (message == NULL)
+ return 1;
+
+ message = strchr(message, ' ') + 1;
+ if (!strcmp(message, "stop"))
+ return 0;
+ printf("%s\n", message);
+ return 1;
+@}
+
+int main()
+@{
+ bus_t bus;
+ struct timespec timeout;
+ t (bus_open(&bus, "/tmp/example-bus", BUS_RDONLY));
+ t (clock_gettime(CLOCK_MONOTONIC, &timeout));
+ timeout.tv_sec += 10;
+ t (bus_read_timed(&bus, callback, NULL, &timeout, CLOCK_MONOTONIC));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("poll");
+ bus_poll_stop(&bus);
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./slow-poll.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define t(stmt) if (stmt) goto fail
+
+int main()
+@{
+ bus_t bus;
+ const char *message;
+ long long tick = 0;
+ struct timespec timeout;
+ t (bus_open(&bus, "/tmp/example-bus", BUS_RDONLY));
+ t (bus_poll_start(&bus));
+ for (;;) @{
+ t (clock_gettime(CLOCK_MONOTONIC, &timeout));
+ timeout.tv_sec += 1;
+ message = bus_poll_timed(&bus, &timeout, CLOCK_MONOTONIC);
+ if (message == NULL) @{
+ t (errno != EAGAIN);
+ printf("waiting... %lli\n", ++tick);
+ continue;
+ @}
+ tick = 0;
+ message = strchr(message, ' ') + 1;
+ if (!strcmp(message, "stop"))
+ break;
+ printf("\033[01m%s\033[21m\n", message);
+ sleep(1);
+ @}
+ t (bus_poll_stop(&bus));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("poll");
+ bus_poll_stop(&bus);
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./write.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char message[BUS_MEMORY_SIZE];
+
+int main(int argc, char *argv[])
+@{
+ bus_t bus;
+ struct timespec timeout;
+ if (argc < 2) @{
+ fprintf(stderr, "%s: USAGE: %s message\n", argv[0], argv[0]);
+ return 2;
+ @}
+ sprintf(message, "0 %s", argv[1]);
+ t (bus_open(&bus, "/tmp/example-bus", BUS_WRONLY));
+ t (clock_gettime(CLOCK_MONOTONIC, &timeout));
+ timeout.tv_nsec += 100000000L;
+ t (bus_write_timed(&bus, message, &timeout, CLOCK_MONOTONIC));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("write");
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+
+@node Nonblocking
+@section Nonblocking
+
+This example shows how to use bus_poll instead of bus_read,
+and how to do non-blocking polling and non-blocking writing.
+
+First of, run make to build this example.
+
+To start the example run @command{./init}. When you are done
+run @command{./cleanup}.
+
+Running instances of @command{./poll} will check every second
+if there is a new inbound message. Between these checks
+@command{./write} will wait for all @command{./poll}:s to
+receive the message. This means that @command{./write} blocks
+while @command{./poll} sleeps. If two or more instances of
+@command{./write} is started at approximately the same time,
+only one will continue to write a message on the bus, the
+others will fail.
+
+@command{./poll} will stop if the message ``stop'' is
+broadcasted.
+
+@command{./poll}, @command{./init} and @command{./cleanup}
+are run without any additional arguments. @command{./write}
+is run with the message as the second argument.
+
+
+@subsubheading @file{./Makefile}
+@example
+COMMANDS = init cleanup write poll
+
+all: $@{COMMANDS@}
+%: %.c
+ $@{CC@} -Wall -Wextra -pedantic -std=c99 -lbus -o $@@ $<
+clean:
+ -rm $@{COMMANDS@}
+
+.PHONY: all clean
+@end example
+
+
+@subsubheading @file{./cleanup.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_unlink("/tmp/example-bus") && (perror("cleanup"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./init.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+
+int main()
+@{
+ return bus_create("/tmp/example-bus", 0, NULL) && (perror("init"), 1);
+@}
+@end example
+
+
+@subsubheading @file{./poll.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define t(stmt) if (stmt) goto fail
+
+int main()
+@{
+ bus_t bus;
+ const char *message;
+ long long tick = 0;
+ t (bus_open(&bus, "/tmp/example-bus", BUS_RDONLY));
+ t (bus_poll_start(&bus));
+ for (;;) @{
+ message = bus_poll(&bus, BUS_NOWAIT);
+ if (message == NULL) @{
+ t (errno != EAGAIN);
+ printf("waiting... %lli\n", ++tick);
+ sleep(1);
+ continue;
+ @}
+ tick = 0;
+ message = strchr(message, ' ') + 1;
+ if (!strcmp(message, "stop"))
+ break;
+ printf("\033[01m%s\033[21m\n", message);
+ @}
+ t (bus_poll_stop(&bus));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("poll");
+ bus_poll_stop(&bus);
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./write.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char message[BUS_MEMORY_SIZE];
+
+int main(int argc, char *argv[])
+@{
+ bus_t bus;
+ if (argc < 2) @{
+ fprintf(stderr, "%s: USAGE: %s message\n", argv[0], argv[0]);
+ return 2;
+ @}
+ sprintf(message, "0 %s", argv[1]);
+ t (bus_open(&bus, "/tmp/example-bus", BUS_WRONLY));
+ t (bus_write(&bus, message, BUS_NOWAIT));
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("write");
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+
+@node Daemon-dependencies
+@section Daemon-dependencies
+
+This example shows how bus can be used in an init system
+to provide ``aggressivly'' parallel startup of daemons.
+
+First of, run make to build this example.
+
+To start the example run @command{./init}. It will print in
+red export-statement you may want to run i other terminals.
+You will need to select at least one daemon, for example
+you can run @code{./init d-ntp}. The available pretend
+daemons are: @command{d-network}, @command{d-ntp}, and
+@command{d-ssh}.
+
+When you are done run @command{./cleanup} with @env{BUS_INIT}
+exported with the value printed by @command{./init}.
+
+
+@subsubheading @file{./Makefile}
+@example
+COMMANDS = announce await-ready await-started cleanup \
+ init require start-daemon test-daemon
+
+all: $@{COMMANDS@}
+%: %.c
+ $@{CC@} -Wall -Wextra -pedantic -std=c99 -lbus -o $@@ $<
+clean:
+ -rm $@{COMMANDS@}
+ -rm -r run
+
+.PHONY: all clean
+@end example
+
+
+@subsubheading @file{./announce.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char arg[4098];
+
+int main(int argc, char *argv[])
+@{
+ bus_t bus;
+ if (argc < 3)
+ return fprintf(stderr, "USAGE: %s state daemon", *argv), 2;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_WRONLY));
+ sprintf(arg, "%ji %s %s", (intmax_t)getppid(), argv[1], argv[2]);
+ t (bus_write(&bus, arg, 0));
+ t (bus_close(&bus));
+ return 0;
+
+fail:
+ perror("announce");
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./await-ready.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char arg[4098];
+static int argc;
+static char **argv;
+static int remaining = 0;
+static char *started = NULL;
+static char msg[BUS_MEMORY_SIZE];
+
+static void announce_wait(pid_t pid)
+@{
+ bus_t bus;
+ int i;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_WRONLY));
+ for (i = 1; i < argc; i++) @{
+ if (!started[i]) @{
+ sprintf(arg, "%ji awaiting-ready %s", (intmax_t)pid, argv[i]);
+ t (bus_write(&bus, arg, 0));
+ @}
+ @}
+ t (bus_close(&bus));
+ return;
+
+fail:
+ perror("await-ready");
+@}
+
+static int callback(const char *message, void *user_data)
+@{
+ int i;
+ char *arg2;
+ char *arg3;
+ pid_t pid;
+ pid_t ppid;
+
+ if (!message) @{
+ ppid = getppid();
+ pid = fork();
+ if (pid == 0) @{
+ if (fork() == 0)
+ announce_wait(ppid);
+ exit(0);
+ @} else @{
+ (void) waitpid(pid, NULL, 0);
+ /* @w{@xrm{}Let's pretend everything will go swimmingly.@xtt{}} */
+ @}
+ return 1;
+ @}
+
+ strncpy(msg, message, BUS_MEMORY_SIZE - 1);
+ msg[BUS_MEMORY_SIZE - 1] = 0;
+
+ arg2 = strchr(msg, ' ');
+ if (!arg2)
+ return 1;
+ arg3 = strchr(++arg2, ' ');
+ if (!arg3)
+ return 1;
+ *arg3++ = 0;
+
+ if (strcmp(arg2, "ready"))
+ return 1;
+
+ for (i = 1; i < argc; i++)
+ if (!started[i] && !strcmp(argv[i], arg3))
+ started[i] = 1, remaining--;
+
+ return !!remaining;
+ (void) user_data;
+@}
+
+int main(int argc_, char *argv_[])
+@{
+ bus_t bus;
+ int i;
+
+ argc = argc_;
+ argv = argv_;
+
+ if (argc < 2)
+ return fprintf(stderr, "USAGE: %s daemon...", *argv), 2;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_RDONLY));
+ started = calloc(argc, sizeof(char));
+ t (started == NULL);
+
+ started[0] = 1;
+ for (i = 1; i < argc; i++) @{
+ sprintf(arg, "grep '^%s$'"
+ " <\"$@{XDG_RUNTIME_DIR@}/ready-daemons\""
+ " >/dev/null",
+ argv[i]);
+ if (!WEXITSTATUS(system(arg)))
+ started[i] = 1;
+ else
+ remaining++;
+ @}
+
+ if (remaining)
+ bus_read(&bus, callback, NULL);
+
+ bus_close(&bus);
+ free(started);
+ return 0;
+
+fail:
+ perror("await-ready");
+ bus_close(&bus);
+ free(started);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./await-started.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char arg[4098];
+static int argc;
+static char **argv;
+static int remaining = 0;
+static char *started = NULL;
+static char msg[BUS_MEMORY_SIZE];
+
+static void announce_wait(pid_t pid)
+@{
+ bus_t bus;
+ int i;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_WRONLY));
+ for (i = 1; i < argc; i++) @{
+ if (!started[i]) @{
+ sprintf(arg, "%ji awaiting-started %s", (intmax_t)pid, argv[i]);
+ t (bus_write(&bus, arg, 0));
+ @}
+ @}
+ t (bus_close(&bus));
+ return;
+
+fail:
+ perror("await-started");
+@}
+
+static int callback(const char *message, void *user_data)
+@{
+ int i;
+ char *arg2;
+ char *arg3;
+ pid_t pid;
+ pid_t ppid;
+
+ if (!message) @{
+ ppid = getppid();
+ pid = fork();
+ if (pid == 0) @{
+ if (fork() == 0)
+ announce_wait(ppid);
+ exit(0);
+ @} else @{
+ (void) waitpid(pid, NULL, 0);
+ /* @w{@xrm{}Let's pretend everything will go swimmingly.@xtt{}} */
+ @}
+ return 1;
+ @}
+
+ strncpy(msg, message, BUS_MEMORY_SIZE - 1);
+ msg[BUS_MEMORY_SIZE - 1] = 0;
+
+ arg2 = strchr(msg, ' ');
+ if (!arg2)
+ return 1;
+ arg3 = strchr(++arg2, ' ');
+ if (!arg3)
+ return 1;
+ *arg3++ = 0;
+
+ if (strcmp(arg2, "started") && strcmp(arg2, "ready"))
+ return 1;
+
+ for (i = 1; i < argc; i++)
+ if (!started[i] && !strcmp(argv[i], arg3))
+ started[i] = 1, remaining--;
+
+ return !!remaining;
+ (void) user_data;
+@}
+
+int main(int argc_, char *argv_[])
+@{
+ bus_t bus;
+ int i;
+
+ argc = argc_;
+ argv = argv_;
+
+ if (argc < 2)
+ return fprintf(stderr, "USAGE: %s daemon...", *argv), 2;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_RDONLY));
+ started = calloc(argc, sizeof(char));
+ t (started == NULL);
+
+ started[0] = 1;
+ for (i = 1; i < argc; i++) @{
+ sprintf(arg, "grep '^%s$'"
+ " <\"$@{XDG_RUNTIME_DIR@}/started-daemons\""
+ " >/dev/null",
+ argv[i]);
+ if (!WEXITSTATUS(system(arg))) @{
+ started[i] = 1;
+ @} else @{
+ sprintf(arg, "grep '^%s$'"
+ " <\"$@{XDG_RUNTIME_DIR@}/ready-daemons\""
+ " >/dev/null",
+ argv[i]);
+ if (!WEXITSTATUS(system(arg)))
+ started[i] = 1;
+ else
+ remaining++;
+ @}
+ @}
+
+ if (remaining)
+ bus_read(&bus, callback, NULL);
+
+ bus_close(&bus);
+ free(started);
+ return 0;
+
+fail:
+ perror("await-started");
+ bus_close(&bus);
+ free(started);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./cleanup.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define t(stmt) if (stmt) goto fail
+
+int main()
+@{
+ char *bus_address = getenv("BUS_INIT");
+ if (!bus_address || !*bus_address) @{
+ fprintf(stderr, "$BUS_INIT has not been set, its export statement "
+ "should have been printed in bold red by ./init\n");
+ return 1;
+ @}
+ t (bus_unlink(bus_address));
+ return 0;
+
+fail:
+ perror("cleanup");
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./d-network}
+@example
+#!/bin/sh
+PATH=.:$PATH
+d=d-network
+
+echo $d: starting
+sleep 2
+echo $d: ready
+announce ready $d
+@end example
+
+
+@subsubheading @file{./d-ntp}
+@example
+#!/bin/sh
+PATH=.:$PATH
+d=d-ntp
+
+require d-network
+echo $d: started
+announce started $d
+await-ready d-network
+echo $d: ready
+announce ready $d
+@end example
+
+
+@subsubheading @file{./d-ssh}
+@example
+#!/bin/sh
+PATH=.:$PATH
+d=d-ssh
+
+require d-network
+echo $d: starting
+sleep 1
+echo $d: started
+announce started $d
+sleep 1
+echo $d: ready
+announce ready $d
+@end example
+
+
+@subsubheading @file{./init.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#define t(stmt) if (stmt) goto fail
+#define _2(...) __VA_ARGS__, __VA_ARGS__
+
+static char msg[BUS_MEMORY_SIZE];
+static int argc;
+static char **argv;
+static char arg[4098];
+
+static void start_daemons()
+@{
+ int i;
+ for (i = 1; i < argc; i++)
+ if (fork() == 0)
+ execl("./start-daemon", "./start-daemon", argv[i], NULL);
+@}
+
+static int callback(const char *message, void *user_data)
+@{
+ pid_t pid;
+ char *arg2;
+ char *arg3;
+ if (!message) @{
+ pid = fork();
+ t (pid == -1);
+ if (pid == 0) @{
+ if (fork() == 0) @{
+ start_daemons();
+ @}
+ exit(0);
+ @} else @{
+ (void) waitpid(pid, NULL, 0);
+ /* @w{@xrm{}Let's pretend everything will go swimmingly.@xtt{}} */
+ @}
+ return 1;
+ @}
+
+ strncpy(msg, message, BUS_MEMORY_SIZE - 1);
+ msg[BUS_MEMORY_SIZE - 1] = 0;
+
+ pid = fork();
+ t (pid == -1);
+
+ if (pid == 0) @{
+ if (fork() == 0) @{
+ arg2 = strchr(msg, ' ');
+ if (arg2 == NULL)
+ exit(0);
+ arg3 = strchr(++arg2, ' ');
+ if (arg3 == NULL)
+ exit(0);
+ *arg3++ = 0;
+ if (!strcmp(arg2, "require")) @{
+ execl(_2("./start-daemon"), arg3, NULL);
+ @} else if (!strcmp(arg2, "awaiting-started")) @{
+ execl(_2("./test-daemon"), arg3, "started", NULL);
+ @} else if (!strcmp(arg2, "awaiting-ready") ||
+ !strcmp(arg2, "awaiting")) @{
+ execl(_2("./test-daemon"), arg3, "ready", NULL);
+ @} else if (!strcmp(arg2, "started")) @{
+ sprintf(arg,
+ "grep '^%s\\$' < \"%s\" >/dev/null || echo %s >> \"%s\"",
+ _2(arg3, "$@{XDG_RUNTIME_DIR@}/started-daemons"));
+ execlp(_2("sh"), "-c", arg, NULL);
+ @} else if (!strcmp(arg2, "ready")) @{
+ sprintf(arg,
+ "grep '^%s\\$' < \"%s\" >/dev/null || echo %s >> \"%s\"",
+ _2(arg3, "$@{XDG_RUNTIME_DIR@}/ready-daemons"));
+ execlp(_2("sh"), "-c", arg, NULL);
+ @}
+ @}
+ exit(0);
+ @} else @{
+ (void) waitpid(pid, NULL, 0);
+ /* @w{@xrm{}Let's pretend everything will go swimmingly.@xtt{}} */
+ @}
+
+ return 1;
+ (void) user_data;
+
+fail:
+ perror("init");
+ return -1;
+@}
+
+int main(int argc_, char *argv_[])
+@{
+ char *bus_address = NULL;
+ bus_t bus;
+ argv = argv_;
+ argc = argc_;
+ if (argc < 2) @{
+ fprintf(stderr, "USAGE: %s daemon...\n", *argv);
+ return 1;
+ @}
+ t (setenv("XDG_RUNTIME_DIR", "./run", 1));
+ /* @w{@xrm{}Real init systems with not have the period.@xtt{}} */
+ system("mkdir -p -- \"$@{XDG_RUNTIME_DIR@}\"");
+ system("truncate -s 0 -- \"$@{XDG_RUNTIME_DIR@}/started-daemons\"");
+ system("truncate -s 0 -- \"$@{XDG_RUNTIME_DIR@}/ready-daemons\"");
+ t (bus_create(NULL, 1, &bus_address));
+ fprintf(stderr, "\033[00;01;31mexport BUS_INIT=%s\033[00m\n",
+ bus_address);
+ fprintf(stderr, "\033[00;31mexport XDG_RUNTIME_DIR=./run\033[00m\n");
+ t (setenv("BUS_INIT", bus_address, 1));
+ t (bus_open(&bus, bus_address, BUS_RDONLY));
+ t (bus_read(&bus, callback, NULL));
+ bus_close(&bus);
+ free(bus_address);
+ return 0;
+
+fail:
+ perror("init");
+ bus_close(&bus);
+ free(bus_address);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./require.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char arg[4098];
+
+int main(int argc, char *argv[])
+@{
+ bus_t bus;
+ int i;
+ if (argc < 2)
+ return fprintf(stderr, "USAGE: %s daemon...", *argv), 2;
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_WRONLY));
+
+ for (i = 1; i < argc; i++) @{
+ sprintf(arg, "grep '^%s$' <\"%s\" >/dev/null",
+ argv[i], "$@{XDG_RUNTIME_DIR@}/started-daemons");
+ if (WEXITSTATUS(system(arg))) @{
+ sprintf(arg, "%ji require %s", (intmax_t)getppid(), argv[i]);
+ t (bus_write(&bus, arg, 0));
+ @}
+ @}
+
+ bus_close(&bus);
+ return 0;
+
+fail:
+ perror("require");
+ bus_close(&bus);
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./start-daemon.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static char arg[4098];
+
+int main(int argc, char *argv[])
+@{
+ if (argc != 2) @{
+ fprintf(stderr, "This program should be called from ./init\n");
+ return 2;
+ @}
+
+ sprintf(arg, "grep '^%s$' <\"%s\" >/dev/null",
+ argv[1], "$@{XDG_RUNTIME_DIR@}/started-daemons");
+ if (!WEXITSTATUS(system(arg)))
+ return 0;
+ sprintf(arg, "grep '^%s$' <\"%s\" >/dev/null",
+ argv[1], "$@{XDG_RUNTIME_DIR@}/ready-daemons");
+ if (!WEXITSTATUS(system(arg)))
+ return 0;
+
+ sprintf(arg, "./%s", argv[1]);
+ execlp(arg, arg, NULL);
+ perror("start-daemon");
+ return 1;
+@}
+@end example
+
+
+@subsubheading @file{./test-daemon.c}
+@example
+#include <bus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define t(stmt) if (stmt) goto fail
+
+static char arg[4098];
+
+int main(int argc, char *argv[])
+@{
+ bus_t bus;
+ if (argc != 3) @{
+ fprintf(stderr, "This program should be called from ./init\n");
+ return 2;
+ @}
+
+retry:
+ sprintf(arg, "grep '^%s$'"
+ " <\"$@{XDG_RUNTIME_DIR@}/%s-daemons\""
+ " >/dev/null",
+ argv[1], argv[2]);
+ if (!WEXITSTATUS(system(arg))) @{
+ t (bus_open(&bus, getenv("BUS_INIT"), BUS_WRONLY));
+ sprintf(arg, "0 %s %s", argv[2], argv[1]);
+ t (bus_write(&bus, arg, 0));
+ bus_close(&bus);
+ @} else if (!strcmp(argv[2], "started")) @{
+ argv[2] = "ready";
+ goto retry;
+ @}
+ return 0;
+
+fail:
+ perror("test-daemon");
+ return 1;
+@}
+@end example
+
+
+
+@node GNU Free Documentation License
+@appendix GNU Free Documentation License
+@include fdl.texinfo
+
+@bye
+