The ftrigr library provides an API for listeners, i.e. programs that want to subscribe to fifodirs and be instantly notified when the proper sequence of events happens.
Check the s6/ftrigr.h header for the exact function prototypes.
The src/pipe-tools/s6-ftrig-listen1.c and src/supervision/s6-svwait.c files in the s6 package, for instance, illustrate how to use the ftrigr library.
Synchronous functions take a tain_t const * (deadline) parameter and a tain_t * (stamp) parameter. Those are pointers to tain_t structures containing absolute times; the former represents a deadline (in most cases, this time will be in the future) and the latter must be an accurate enough timestamp. These structures can be filled using the tain_ primitives declared in skalibs/tai.h.
If such a synchronous function still hasn't returned when the deadline occurs, then it will immediately return a failure code and set errno to ETIMEDOUT. It is possible to pass null pointers to the function instead of pointers to tain_t structures, in which case the function will never timeout.
If a timeout occurs, the library does not guarantee proper interprocess communication later on; the application should either die, or at least close the communication channel and open a new one.
If any waiting occurred, the stamp structure is automatically updated by the called function, so it always represents an accurate enough estimation of the current time. This allows the programmer to call several such functions in a sequence without modifying the deadline and stamp parameters: then the whole sequence is bound in execution time.
This is a general safety mechanism implemented in libunixonacid: in interprocess communication, purely synchronous primitives are dangerous because they make the calling process rely on proper behaviour of the called process. Giving synchronous primitives the ability to timeout allows developers to write reliable programs even when interacting with software they have no control on.
ftrigr_start starts a session with a ftrigrd service listening on path.
ftrigr_startf starts a session with a ftrigrd process as a child (which is the simplest usage).
a is a ftrigr_t structure that must be declared in the stack and initialized to FTRIGR_ZERO. stamp must be an accurate enough timestamp.
You can have more than one session open in parallel, by declaring several distinct ftrigr_t structures and calling ftrigr_startf (or ftrigr_start) more than once. However, this is useless, since one single session can handle virtually as many concurrent fifodirs as your application needs.
ftrigr_end frees all the resources used by the session. The a structure is then reusable for another session.
ftrigr_subscribe instructs the s6-ftrigrd daemon, related to the open session represented by the a structure, to subscribe to the path fifodir, and to notify the application when it receives a series of events that matches the re regexp. options can be 0 or FTRIGR_REPEAT. If it is 0, the daemon will automatically unsubscribe from path once re has been matched by a series of events. If it is FTRIGR_REPEAT, it will remain subscribed until told otherwise.
ftrigr_subscribe() returns 0 and sets errno in case of failure, or a nonzero 16-bit number identifying the subscription in case of success.
ftrigr_subscribe should return near-instantly, but if deadline is reached, it will return 0 ETIMEDOUT. If ftrigr_subscribe returns successfully, then the s6-ftrigrd daemon is guaranteed to be listening on path, and events can be sent without the risk of a race condition.
ftrigr_wait_and() waits for all the n fifodirs whose ids are listed in list to receive an event. It returns -1 in case of error or timeout, or a non-negative integer in case of success.
ftrigr_wait_or() waits for one of the n fifodirs whose ids are listed in list to receive an event. It returns -1 in case of error or timeout; if it succeeds, the return value is the position in list, starting at 0, of the identifier that received an event; and trigger is set to the character that triggered that event, i.e. the last character of a sequence that matched the regular expression re used in the subscription.
Call this function whenever the fd checks readability: it will update a's internal structures with information from the s6-ftrigrd daemon. It returns -1 if an error occurs; in case of success, it returns the number of identifiers for which something happened.
When ftrigr_updateb returns, genalloc_s(uint16_t, &a->list) points to an array of genalloc_len(uint16_t, &a->list) 16-bit unsigned integers. Those integers are ids waiting to be passed to ftrigr_check or ftrigr_checksa. The number of ids already acknowledged is stored in a->head, so the first unacknowledged id is genalloc_s(uint16_t, &a->list)[a->head].
Checks whether an event happened to id. Use after a call to ftrigr_updateb().
If an error occurred, returns -1 and sets errno. The error number may have been transmitted from s6-ftrigrd.
If no notification happened yet, returns 0.
If something happened, writes the character that triggered the latest notification into what and returns the number of times that an event happened to this identifier since the last call to ftrigr_check().
Checks whether an event happened to id. Use after a call to ftrigr_update(), as an alternative to ftrigr_check().
If something happened, appends one character to the end of the what stralloc for every time a notification was triggered since the last call to ftrigr_check(). Each character is the one that triggered a notification. The function then returns 1.
Acknowledges reading n ids from the id list updated by ftrigr_updateb.
Acknowledges all the pending ids (i.e. clears the stored id list) then calls ftrigr_updateb().