libinotifytools: inotifytools/inotifytools.h File Reference

libinotifytools

Classes | Functions
inotifytools.h File Reference

inotifytools library public interface. More...

Go to the source code of this file.

## Classes
struct | nstring
| This structure holds string that can contain any character including NULL. More...

## Functions
void | inotifytools_cleanup ()
const char * | inotifytools_dirname_from_event (struct inotify_event *event, size_t *dirnamelen)
char * | inotifytools_dirpath_from_event (struct inotify_event *event)
int | inotifytools_error ()
char * | inotifytools_event_to_str (int events)
char * | inotifytools_event_to_str_sep (int events, char sep)
const char * | inotifytools_filename_from_event (struct inotify_event *event, char const **eventname, size_t *dirnamelen)
const char * | inotifytools_filename_from_watch (struct watch *w)
const char * | inotifytools_filename_from_wd (int wd)
int | inotifytools_fprintf (FILE *file, struct inotify_event *event, char *fmt)
int | inotifytools_get_max_queued_events ()
int | inotifytools_get_max_user_instances ()
int | inotifytools_get_max_user_watches ()
int | inotifytools_get_num_watches ()
int | inotifytools_ignore_events_by_inverted_regex (char const *pattern, int flags)
int | inotifytools_ignore_events_by_regex (char const *pattern, int flags)
int | inotifytools_init (int fanotify, int watch_filesystem, int verbose)
struct inotify_event * | inotifytools_next_event (long int timeout)
struct inotify_event * | inotifytools_next_events (long int timeout, int num_events)
int | inotifytools_printf (struct inotify_event *event, char *fmt)
int | inotifytools_remove_watch_by_filename (char const *filename)
int | inotifytools_remove_watch_by_wd (int wd)
void | inotifytools_replace_filename (char const *oldname, char const *newname)
void | inotifytools_set_filename_by_filename (char const *oldname, char const *newname)
void | inotifytools_set_filename_by_wd (int wd, char const *filename)
void | inotifytools_set_printf_timefmt (char *fmt)
int | inotifytools_snprintf (struct nstring *out, int size, struct inotify_event *event, char *fmt)
int | inotifytools_sprintf (struct nstring *out, struct inotify_event *event, char *fmt)
int | inotifytools_str_to_event (char const *event)
int | inotifytools_str_to_event_sep (char const *event, char sep)
int | inotifytools_watch_file (char const *filename, int events)
int | inotifytools_watch_files (char const *filenames[], int events)
int | inotifytools_watch_recursively (char const *path, int events)
int | inotifytools_watch_recursively_with_exclude (char const *path, int events, char const **exclude_list)
int | inotifytools_wd_from_filename (char const *filename)

## Detailed Description

inotifytools library public interface.

Author
  Rohan McGovern, <rohan.nosp@m.@mcg.nosp@m.overn.nosp@m..id..nosp@m.au>

This library provides a thin layer on top of the basic inotify interface. The primary use is to easily set up watches on files, potentially many files at once, and read events without having to deal with low-level I/O. There are also several utility functions for inotify-related string formatting.

To use this library, you must `#include` the following headers accordingly:

- `<inotifytools/inotifytools.h>` - to use any functions declared in this file.
- `<inotifytools/inotify.h>` - to have the `inotify_event` type defined and the numeric IN_* event constants defined. If `<sys/inotify.h>` was present on your system at compile time, this header simply includes that. Otherwise it includes `<inotifytools/inotify-nosys.h>`.

# Example

This very simple program recursively watches the entire directory tree under its working directory for events, then prints them out with a timestamp.

#include <stdio.h>
#include <string.h>
#include <inotifytools/inotifytools.h>
#include <inotifytools/inotify.h>
/*
* libinotifytools example program.
* Compile with gcc -linotifytools example.c
*/
int main() {
// initialize and watch the entire directory tree from the current working
// directory downwards for all events
if ( !inotifytools_initialize()
|| !inotifytools_watch_recursively( ".", IN_ALL_EVENTS ) ) {
fprintf(stderr, "%s\n", strerror( inotifytools_error() ) );
return -1;
}
// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt( "%T" );
// Output all events as "<timestamp> <path> <events>"
struct inotify_event * event = inotifytools_next_event( -1 );
while ( event ) {
inotifytools_printf( event, "%T %w%f %e\n" );
event = inotifytools_next_event( -1 );
}
}
inotifytools.h
inotifytools library public interface.
inotifytools_error
int inotifytools_error()
Definition: inotifytools.c:1829
inotifytools_watch_recursively
int inotifytools_watch_recursively(char const *path, int events)
Definition: inotifytools.c:1682
inotifytools_next_event
struct inotify_event * inotifytools_next_event(long int timeout)
Definition: inotifytools.c:1368
inotifytools_printf
int inotifytools_printf(struct inotify_event *event, char *fmt)
Definition: inotifytools.c:1905
inotifytools_set_printf_timefmt
void inotifytools_set_printf_timefmt(char *fmt)
Definition: inotifytools.c:2207

# Events

Note
  This section comes almost verbatim from the inotify(7) man page.

Warning
  The information here applies to inotify in Linux 2.6.17. Older versions of Linux may not support all the events described here.

The following numeric events can be specified to functions in inotifytools, and may be present in events returned through inotifytools:

- `IN_ACCESS` - File was accessed (read) *
- `IN_ATTRIB` - Metadata changed (permissions, timestamps, extended attributes, etc.) *
- `IN_CLOSE_WRITE` - File opened for writing was closed *
- `IN_CLOSE_NOWRITE` - File not opened for writing was closed *
- `IN_CREATE` - File/directory created in watched directory *
- `IN_DELETE` - File/directory deleted from watched directory *
- `IN_DELETE_SELF` - Watched file/directory was itself deleted
- `IN_MODIFY` - File was modified *
- `IN_MOVE_SELF` - Watched file/directory was itself moved
- `IN_MOVED_FROM` - File moved out of watched directory *
- `IN_MOVED_TO` - File moved into watched directory *
- `IN_OPEN` - File was opened *

When monitoring a directory, the events marked with an asterisk * above can occur for files in the directory, in which case the name field in the returned inotify_event structure identifies the name of the file within the directory.

The IN_ALL_EVENTS macro is defined as a bit mask of all of the above events.

Two additional convenience macros are IN_MOVE, which equates to IN_MOVED_FROM|IN_MOVED_TO, and IN_CLOSE which equates to IN_CLOSE_WRITE|IN_CLOSE_NOWRITE.

The following bitmasks can also be provided when creating a new watch:

- `IN_DONT_FOLLOW` - Don't dereference pathname if it is a symbolic link
- `IN_MASK_ADD` - Add (OR) events to watch mask for this pathname if it already exists (instead of replacing mask)
- `IN_ONESHOT` - Monitor pathname for one event, then remove from watch list
- `IN_ONLYDIR` - Only watch pathname if it is a directory

The following bitmasks may occur in events generated by a watch:

- `IN_IGNORED` - Watch was removed explicitly (inotifytools_remove_watch_*) or automatically (file was deleted, or file system was unmounted)
- `IN_ISDIR` - Subject of this event is a directory
- `IN_Q_OVERFLOW` - Event queue overflowed (wd is -1 for this event)
- `IN_UNMOUNT` - File system containing watched object was unmounted

# TODO list

Todo:
  Improve wd/filename mapping. Currently there is no explicit code for handling different filenames mapping to the same inode (and hence, wd). gamin's approach sounds good: let the user watch an inode using several different filenames, and when an event occurs on the inode, generate an event for each filename.

Definition in file inotifytools.h.

## Function Documentation

## ◆ inotifytools_cleanup()

void inotifytools_cleanup | ( |  | ) |

Close inotify and free the memory used by inotifytools.

If you call this function, you must call inotifytools_initialize() again before any other functions can be used.

Definition at line 368 of file inotifytools.c.

## ◆ inotifytools_dirname_from_event()

const char * inotifytools_dirname_from_event | ( | struct inotify_event * | event,
|  | size_t * | dirnamelen
| ) |  |

Get the directory path used to establish a watch.

Returns the filename recorded for event->wd and the dirname prefix length.

The caller should NOT free() the returned string.

Definition at line 896 of file inotifytools.c.

References inotifytools_filename_from_wd().

Referenced by inotifytools_filename_from_event().

## ◆ inotifytools_dirpath_from_event()

char * inotifytools_dirpath_from_event | ( | struct inotify_event * | event | ) |

Get the directory path from an event.

Returns the filename recorded for event->wd or NULL. For an event on non-directory also returns NULL.

The caller is responsible to free() the returned string.

Definition at line 951 of file inotifytools.c.

References inotifytools_filename_from_wd().

## ◆ inotifytools_error()

int inotifytools_error | ( |  | ) |

Get the last error which occurred.

When a function fails, call this to find out why. The returned value is a typical errno value, the meaning of which depends on context. For example, if inotifytools_watch_file() fails because you attempt to watch a file which doesn't exist, this function will return ENOENT.

Returns
  an error code.

Definition at line 1829 of file inotifytools.c.

## ◆ inotifytools_event_to_str()

char * inotifytools_event_to_str | ( | int | events | ) |

Convert event from integer form to string form (as in inotify.h).

The returned string is from static storage; subsequent calls to this function or inotifytools_event_to_str_sep() will overwrite it. Don't free() it and make a copy if you want to keep it.

Parameters

  events | OR'd event(s) in integer form as defined in inotify.h. See section Events.

Returns
  comma-separated string representing the event(s), in no particular order

# Example

int eventnum == IN_MODIFY | IN_CLOSE | IN_CREATE;
char * eventstr = inotifytools_event_to_str( eventnum );
printf( "%s\n", eventstr );
// outputs something like MODIFY,CLOSE,CREATE but order not guaranteed.
inotifytools_event_to_str
char * inotifytools_event_to_str(int events)
Definition: inotifytools.c:628

Definition at line 628 of file inotifytools.c.

References inotifytools_event_to_str_sep().

## ◆ inotifytools_event_to_str_sep()

char * inotifytools_event_to_str_sep | ( | int | events,
|  | char | sep
| ) |  |

Convert event from integer form to string form (as in inotify.h).

The returned string is from static storage; subsequent calls to this function or inotifytools_event_to_str() will overwrite it. Don't free() it and make a copy if you want to keep it.

Parameters

  events | OR'd event(s) in integer form as defined in inotify.h
  sep | character used to separate events

Returns
  sep separated string representing the event(s), in no particular order. If the integer is not made of OR'ed inotify events, the string returned will be a hexadecimal representation of the integer.

# Example

int eventnum == IN_MODIFY | IN_CLOSE | IN_CREATE;
char * eventstr = inotifytools_event_to_str_sep( eventnum, '-' );
printf( "%s\n", eventstr );
// outputs something like MODIFY-CLOSE-CREATE but order not guaranteed.
inotifytools_event_to_str_sep
char * inotifytools_event_to_str_sep(int events, char sep)
Definition: inotifytools.c:656

Definition at line 656 of file inotifytools.c.

Referenced by inotifytools_event_to_str().

## ◆ inotifytools_filename_from_event()

const char * inotifytools_filename_from_event | ( | struct inotify_event * | event,
|  | char const ** | eventname,
|  | size_t * | dirnamelen
| ) |  |

Get the watched path and filename from an event.

Returns the filename either recorded for event->wd or from event->name and the watched filename for event->wd.

The caller should NOT free() the returned strings.

Definition at line 925 of file inotifytools.c.

References inotifytools_dirname_from_event().

## ◆ inotifytools_filename_from_watch()

const char * inotifytools_filename_from_watch | ( | watch * | w | ) |

Get the filename from a watch.

If not stored in watch, resolve filename from fid + name and return static filename string.

Definition at line 848 of file inotifytools.c.

Referenced by inotifytools_filename_from_wd().

## ◆ inotifytools_filename_from_wd()

const char * inotifytools_filename_from_wd | ( | int | wd | ) |

Get the filename used to establish a watch.

inotifytools_initialize() must be called before this function can be used.

Parameters

  wd | watch descriptor.

Returns
  filename associated with watch descriptor wd, or NULL if wd is not associated with any filename.

Note
  This always returns the filename which was used to establish a watch. This means the filename may be a relative path. If this isn't desired, then always use absolute paths when watching files. Also, this is not necessarily the filename which might have been used to cause an event on the file, since inotify is inode based and there can be many filenames mapping to a single inode. Finally, if a file is moved or renamed while being watched, the filename returned will still be the original name.

Definition at line 877 of file inotifytools.c.

References inotifytools_filename_from_watch().

Referenced by inotifytools_dirname_from_event(), and inotifytools_dirpath_from_event().

## ◆ inotifytools_fprintf()

int inotifytools_fprintf | ( | FILE * | file,
|  | struct inotify_event * | event,
|  | char * | fmt
| ) |  |

Print a string to a file using an inotify_event and a printf-like syntax. The string written will only ever be up to 4096 characters in length.

Parameters

  file | file to print to
  event | the event to use to construct a string.
  fmt | the format string used to construct a string.

Returns
  number of characters written, or -1 if an error occurs.

# Format string syntax

The following tokens will be replaced with the specified string:

- `%w` - This will be replaced with the name of the Watched file on which an event occurred.
- `%c` - This will be replaced with the cookie of the Watched file on which an event occurred.
- `%f` - When an event occurs within a directory, this will be replaced with the name of the File which caused the event to occur. Otherwise, this will be replaced with an empty string.
- `%e` - Replaced with the Event(s) which occurred, comma-separated.
- `%Xe` - Replaced with the Event(s) which occurred, separated by whichever character is in the place of ‘X’.
- `%T` - Replaced by the current Time in the format specified by the string previously passed to inotifytools_set_printf_timefmt(), or replaced with an empty string if that function has never been called.
- `%0` - Replaced with the 'NUL' character
- `%n` - Replaced with the 'Line Feed' character

# Example

// suppose this is the only file watched.
inotifytools_watch_file( "mydir/", IN_CLOSE );
// wait until an event occurs
struct inotify_event * event = inotifytools_next_event( -1 );
inotifytools_fprintf(stderr, event, "in %w, file %f had event(s): %.e\n");
// suppose the file 'myfile' in mydir was read from and closed. Then,
// this prints to standard error something like:
// "in mydir/, file myfile had event(s): CLOSE_NOWRITE.CLOSE.ISDIR\n"
inotifytools_fprintf
int inotifytools_fprintf(FILE *file, struct inotify_event *event, char *fmt)
Definition: inotifytools.c:1954
inotifytools_watch_file
int inotifytools_watch_file(char const *filename, int events)
Definition: inotifytools.c:1177

Definition at line 1954 of file inotifytools.c.

References nstring::buf, inotifytools_sprintf(), and nstring::len.

Referenced by inotifytools_printf().

## ◆ inotifytools_get_max_queued_events()

int inotifytools_get_max_queued_events | ( |  | ) |

Get the event queue size.

This setting can also be read or modified by accessing the file /proc/sys/fs/inotify/max_queued_events.

Returns
  the maximum number of events which will be queued in the kernel.

Definition at line 2219 of file inotifytools.c.

## ◆ inotifytools_get_max_user_instances()

int inotifytools_get_max_user_instances | ( |  | ) |

Get the maximum number of user instances of inotify.

This setting can also be read or modified by accessing the file /proc/sys/fs/inotify/max_user_instances.

Returns
  the maximum number of inotify file descriptors a single user can obtain.

Definition at line 2234 of file inotifytools.c.

## ◆ inotifytools_get_max_user_watches()

int inotifytools_get_max_user_watches | ( |  | ) |

Get the maximum number of user watches.

This setting can also be read or modified by accessing the file /proc/sys/fs/inotify/max_user_watches.

Returns
  the maximum number of inotify watches a single user can obtain per inotify instance.

Definition at line 2249 of file inotifytools.c.

## ◆ inotifytools_get_num_watches()

int inotifytools_get_num_watches | ( |  | ) |

Get the number of watches set up through libinotifytools.

Returns
  number of watches set up by inotifytools_watch_file(), inotifytools_watch_files() and inotifytools_watch_recursively().

Definition at line 1855 of file inotifytools.c.

## ◆ inotifytools_ignore_events_by_inverted_regex()

int inotifytools_ignore_events_by_inverted_regex | ( | char const * | pattern,
|  | int | flags
| ) |  |

Ignore inotify events NOT matching a particular regular expression.

pattern is a regular expression and flags is a bitwise combination of POSIX regular expression flags.

On future calls to inotifytools_next_events() or inotifytools_next_event(), the regular expression is executed on the filename of files on which events occur. If the regular expression matches, the matched event will be ignored.

Definition at line 2318 of file inotifytools.c.

## ◆ inotifytools_ignore_events_by_regex()

int inotifytools_ignore_events_by_regex | ( | char const * | pattern,
|  | int | flags
| ) |  |

Ignore inotify events matching a particular regular expression.

pattern is a regular expression and flags is a bitwise combination of POSIX regular expression flags.

On future calls to inotifytools_next_events() or inotifytools_next_event(), the regular expression is executed on the filename of files on which events occur. If the regular expression matches, the matched event will be ignored.

Definition at line 2303 of file inotifytools.c.

## ◆ inotifytools_init()

int inotifytools_init | ( | int | fanotify,
|  | int | watch_filesystem,
|  | int | verbose
| ) |  |

Initialise inotify. With @fanotify non-zero, initialize fanotify filesystem watch.

You must call this function before using any function which adds or removes watches or attempts to access any information about watches.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error().

Definition at line 301 of file inotifytools.c.

## ◆ inotifytools_next_event()

struct inotify_event * inotifytools_next_event | ( | long int | timeout | ) |

Get the next inotify event to occur.

inotifytools_initialize() must be called before this function can be used.

Parameters

  timeout | maximum amount of time, in seconds, to wait for an event. If timeout is non-negative, the function is non-blocking. If timeout is negative, the function will block until an event occurs.

Returns
  pointer to an inotify event, or NULL if function timed out before an event occurred. The event is located in static storage and it may be overwritten in subsequent calls; do not call free() on it, and make a copy if you want to keep it.

Note
  Your program should call this function or inotifytools_next_events() frequently; between calls to this function, inotify events will be queued in the kernel, and eventually the queue will overflow and you will miss some events.
  If the function inotifytools_ignore_events_by_regex() has been called with a non-NULL parameter, this function will not return on events which match the regular expression passed to that function. However, the timeout period begins again each time a matching event occurs.

Definition at line 1368 of file inotifytools.c.

References inotifytools_next_events().

## ◆ inotifytools_next_events()

struct inotify_event * inotifytools_next_events | ( | long int | timeout,
|  | int | num_events
| ) |  |

Get the next inotify events to occur.

inotifytools_initialize() must be called before this function can be used.

Parameters

  timeout | maximum amount of time, in seconds, to wait for an event. If timeout is non-negative, the function is non-blocking. If timeout is negative, the function will block until an event occurs.
  num_events | approximate number of inotify events to wait for until this function returns. Use this for buffering reads to inotify if you expect to receive large amounts of events. You are NOT guaranteed that this number of events will actually be read; instead, you are guaranteed that the number of bytes read from inotify is num_events * sizeof(struct inotify_event). Obviously the larger this number is, the greater the latency between when an event occurs and when you'll know about it. May not be larger than 4096.

Returns
  pointer to an inotify event, or NULL if function timed out before an event occurred or num_events < 1. The event is located in static storage and it may be overwritten in subsequent calls; do not call free() on it, and make a copy if you want to keep it. When num_events is greater than 1, this will return a pointer to the first event only, and you MUST call this function again to get pointers to subsequent events; don't try to add to the pointer to find the next events or you will run into trouble.

Note
  You may actually get different events with different values of num_events. This is because inotify does some in-kernel filtering of duplicate events, meaning some duplicate events will not be reported if num_events > 1. For some purposes this is fine, but for others (such as gathering accurate statistics on numbers of event occurrences) you must call this function with num_events = 1, or simply use inotifytools_next_event().
  Your program should call this function frequently; between calls to this function, inotify events will be queued in the kernel, and eventually the queue will overflow and you will miss some events.
  If the function inotifytools_ignore_events_by_regex() has been called with a non-NULL parameter, this function will not return on events which match the regular expression passed to that function. However, the timeout period begins again each time a matching event occurs.

Definition at line 1425 of file inotifytools.c.

Referenced by inotifytools_next_event().

## ◆ inotifytools_printf()

int inotifytools_printf | ( | struct inotify_event * | event,
|  | char * | fmt
| ) |  |

Print a string to standard out using an inotify_event and a printf-like syntax. The string written will only ever be up to 4096 characters in length.

Parameters

  event | the event to use to construct a string.
  fmt | the format string used to construct a string.

Returns
  number of characters written, or -1 if an error occurs.

# Format string syntax

The following tokens will be replaced with the specified string:

- `%w` - This will be replaced with the name of the Watched file on which an event occurred.
- `%c` - This will be replaced with the cookie of the Watched file on which an event occurred.
- `%f` - When an event occurs within a directory, this will be replaced with the name of the File which caused the event to occur. Otherwise, this will be replaced with an empty string.
- `%e` - Replaced with the Event(s) which occurred, comma-separated.
- `%Xe` - Replaced with the Event(s) which occurred, separated by whichever character is in the place of ‘X’.
- `%T` - Replaced by the current Time in the format specified by the string previously passed to inotifytools_set_printf_timefmt(), or replaced with an empty string if that function has never been called.
- `%0` - Replaced with the 'NUL' character
- `%n` - Replaced with the 'Line Feed' character

# Example

// suppose this is the only file watched.
inotifytools_watch_file( "mydir/", IN_CLOSE );
// wait until an event occurs
struct inotify_event * event = inotifytools_next_event( -1 );
inotifytools_printf(stderr, event, "in %w, file %f had event(s): %.e\n");
// suppose the file 'myfile' in mydir was read from and closed. Then,
// this prints to standard out something like:
// "in mydir/, file myfile had event(s): CLOSE_NOWRITE.CLOSE.ISDIR\n"

Definition at line 1905 of file inotifytools.c.

References inotifytools_fprintf().

## ◆ inotifytools_remove_watch_by_filename()

int inotifytools_remove_watch_by_filename | ( | char const * | filename | ) |

Remove a watch on a file specified by filename.

Parameters

  filename | Name of file on which watch should be removed.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error().

Note
  The filename specified must always be the original name used to establish the watch.

Definition at line 1152 of file inotifytools.c.

## ◆ inotifytools_remove_watch_by_wd()

int inotifytools_remove_watch_by_wd | ( | int | wd | ) |

Remove a watch on a file specified by watch descriptor.

inotifytools_initialize() must be called before this function can be used.

Parameters

  wd | Watch descriptor of watch to be removed.

Returns
  1 on success, 0 on failure. If the given watch doesn't exist, returns 1. On failure, the error can be obtained from inotifytools_error().

Definition at line 1127 of file inotifytools.c.

## ◆ inotifytools_replace_filename()

void inotifytools_replace_filename | ( | char const * | oldname,
|  | char const * | newname
| ) |  |

Replace a certain filename prefix on all watches.

This function should be used to update filenames for an entire directory tree when a directory is known to have been moved or renamed. At the moment, libinotifytools does not automatically handle this situation.

inotifytools_initialize() must be called before this function can be used.

Parameters

  oldname | Current filename prefix.
  newname | New filename prefix.

# Example

// if /home/user1/original_dir is moved to /home/user2/new_dir, then to
// update all watches:
inotifytools_replace_filename( "/home/user1/original_dir",
"/home/user2/new_dir" );
inotifytools_replace_filename
void inotifytools_replace_filename(char const *oldname, char const *newname)
Definition: inotifytools.c:1057

Definition at line 1057 of file inotifytools.c.

## ◆ inotifytools_set_filename_by_filename()

void inotifytools_set_filename_by_filename | ( | char const * | oldname,
|  | char const * | newname
| ) |  |

Set the filename for one or more watches with a particular existing filename.

This function should be used to update a filename when a file is known to have been moved or renamed. At the moment, libinotifytools does not automatically handle this situation.

inotifytools_initialize() must be called before this function can be used.

Parameters

  oldname | Current filename.
  newname | New filename.

Definition at line 1027 of file inotifytools.c.

## ◆ inotifytools_set_filename_by_wd()

void inotifytools_set_filename_by_wd | ( | int | wd,
|  | char const * | filename
| ) |  |

Set the filename for a particular watch descriptor.

This function should be used to update a filename when a file is known to have been moved or renamed. At the moment, libinotifytools does not automatically handle this situation.

inotifytools_initialize() must be called before this function can be used.

Parameters

  wd | Watch descriptor.
  filename | New filename.

Definition at line 1005 of file inotifytools.c.

## ◆ inotifytools_set_printf_timefmt()

void inotifytools_set_printf_timefmt | ( | char * | fmt | ) |

Set time format for printf functions.

Parameters

  fmt | A format string valid for use with strftime, or NULL. If NULL, time substitutions will no longer be made in printf functions. Note that this format string is not validated at all; using an incorrect format string will cause the printf functions to give incorrect results.

Definition at line 2207 of file inotifytools.c.

## ◆ inotifytools_snprintf()

int inotifytools_snprintf | ( | struct nstring * | out,
|  | int | size,
|  | struct inotify_event * | event,
|  | char * | fmt
| ) |  |

Construct a string using an inotify_event and a printf-like syntax. The string can only ever be up to 4096 characters in length.

Parameters

  out | location in which to store nstring.
  size | maximum amount of characters to write.
  event | the event to use to construct a nstring.
  fmt | the format string used to construct a nstring.

Returns
  number of characters written, or -1 if an error occurs.

# Format string syntax

The following tokens will be replaced with the specified string:

- `%w` - This will be replaced with the name of the Watched file on which an event occurred.
- `%c` - This will be replaced with cookie of the Watched file on which an event occurred.
- `%f` - When an event occurs within a directory, this will be replaced with the name of the File which caused the event to occur. Otherwise, this will be replaced with an empty string.
- `%e` - Replaced with the Event(s) which occurred, comma-separated.
- `%Xe` - Replaced with the Event(s) which occurred, separated by whichever character is in the place of ‘X’.
- `%T` - Replaced by the current Time in the format specified by the string previously passed to inotifytools_set_printf_timefmt(), or replaced with an empty string if that function has never been called.
- `%0` - Replaced with the 'NUL' character
- `%n` - Replaced with the 'Line Feed' character

# Example

// suppose this is the only file watched.
inotifytools_watch_file( "mydir/", IN_CLOSE );
// wait until an event occurs
struct inotify_event * event = inotifytools_next_event( -1 );
struct nstring mynstring;
inotifytools_snprintf( mynstring, MAX_STRLEN, event,
"in %w, file %f had event(s): %.e\n" );
fwrite( mynstring.buf, sizeof(char), mynstring.len, stdout );
// suppose the file 'myfile' in mydir was written to and closed. Then,
// this prints something like:
// "in mydir/, file myfile had event(s): CLOSE_WRITE.CLOSE.ISDIR\n"
inotifytools_snprintf
int inotifytools_snprintf(struct nstring *out, int size, struct inotify_event *event, char *fmt)
Definition: inotifytools.c:2069
nstring
This structure holds string that can contain any character including NULL.
Definition: inotifytools.h:25

Definition at line 2069 of file inotifytools.c.

Referenced by inotifytools_sprintf().

## ◆ inotifytools_sprintf()

int inotifytools_sprintf | ( | struct nstring * | out,
|  | struct inotify_event * | event,
|  | char * | fmt
| ) |  |

Construct a string using an inotify_event and a printf-like syntax. The string can only ever be up to 4096 characters in length.

This function will keep writing until it reaches 4096 characters. If your allocated array is not large enough to hold the entire string, your program may crash. inotifytools_snprintf() is safer and you should use it where possible.

Parameters

  out | location in which to store nstring.
  event | the event to use to construct a nstring.
  fmt | the format string used to construct a nstring.

Returns
  number of characters written, or -1 if an error occurs.

# Format string syntax

The following tokens will be replaced with the specified string:

- `%w` - This will be replaced with the name of the Watched file on which an event occurred.
- `%c` - This will be replaced with the cookie of the Watched file on which an event occurred.
- `%f` - When an event occurs within a directory, this will be replaced with the name of the File which caused the event to occur. Otherwise, this will be replaced with an empty string.
- `%e` - Replaced with the Event(s) which occurred, comma-separated.
- `%Xe` - Replaced with the Event(s) which occurred, separated by whichever character is in the place of ‘X’.
- `%T` - Replaced by the current Time in the format specified by the string previously passed to inotifytools_set_printf_timefmt(), or replaced with an empty string if that function has never been called.
- `%0` - Replaced with the 'NUL' character
- `%n` - Replaced with the 'Line Feed' character

# Example

// suppose this is the only file watched.
inotifytools_watch_file( "mydir/", IN_CLOSE );
// wait until an event occurs
struct inotify_event * event = inotifytools_next_event( -1 );
nstring mynstring;
inotifytools_sprintf(mynstring, event, "in %w, file %f had event(s): %.e\n");
fwrite( mynstring.buf, sizeof(char), mynstring.len, stdout );
// suppose the file 'myfile' in mydir was written to and closed. Then,
// this prints something like:
// "in mydir/, file myfile had event(s): CLOSE_WRITE.CLOSE.ISDIR\n"
inotifytools_sprintf
int inotifytools_sprintf(struct nstring *out, struct inotify_event *event, char *fmt)
Definition: inotifytools.c:2014
nstring::len
unsigned int len
Definition: inotifytools.h:27
nstring::buf
char buf[MAX_STRLEN]
Definition: inotifytools.h:26

Definition at line 2014 of file inotifytools.c.

References inotifytools_snprintf().

Referenced by inotifytools_fprintf().

## ◆ inotifytools_str_to_event()

int inotifytools_str_to_event | ( | char const * | event | ) |

Convert comma-separated events from string form to integer form (as in inotify.h).

Parameters

  event | a sequence of events in string form as defined in inotify.h without leading IN_ prefix (e.g., MODIFY, ATTRIB), comma-separated. Case insensitive. Can be a single event. Can be empty or NULL. See section Events.

Returns
  integer representing the mask specified by event, or 0 if any string in event is empty or NULL, or -1 if any string in event does not match any event.

# Example

char * eventstr = "MODIFY,CLOSE,CREATE";
int eventnum = inotifytools_str_to_event( eventstr );
if ( eventnum == IN_MODIFY | IN_CLOSE | IN_CREATE ) {
printf( "This code always gets executed!\n" );
}
inotifytools_str_to_event
int inotifytools_str_to_event(char const *event)
Definition: inotifytools.c:541

Definition at line 541 of file inotifytools.c.

References inotifytools_str_to_event_sep().

## ◆ inotifytools_str_to_event_sep()

int inotifytools_str_to_event_sep | ( | char const * | event,
|  | char | sep
| ) |  |

Convert character separated events from string form to integer form (as in inotify.h).

Parameters

  event | a sequence of events in string form as defined in inotify.h without leading IN_ prefix (e.g., MODIFY, ATTRIB), separated by the sep character. Case insensitive. Can be a single event. Can be empty or NULL. See section Events.
  sep | Character used to separate events. sep must not be a character in a-z, A-Z, or _.

Returns
  integer representing the mask specified by event, or 0 if any string in event is empty or NULL, or -1 if any string in event does not match any event or sep is invalid.

# Example

char * eventstr = "MODIFY:CLOSE:CREATE";
int eventnum = inotifytools_str_to_event_sep( eventstr, ':' );
if ( eventnum == IN_MODIFY | IN_CLOSE | IN_CREATE ) {
printf( "This code always gets executed!\n" );
}
inotifytools_str_to_event_sep
int inotifytools_str_to_event_sep(char const *event, char sep)
Definition: inotifytools.c:466

Definition at line 466 of file inotifytools.c.

Referenced by inotifytools_str_to_event().

## ◆ inotifytools_watch_file()

int inotifytools_watch_file | ( | char const * | filename,
|  | int | events
| ) |  |

Set up a watch on a file.

Parameters

  filename | Absolute or relative path of file to watch.
  events | bitwise ORed inotify events to watch for. See section Events.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error().

Definition at line 1177 of file inotifytools.c.

References inotifytools_watch_files().

Referenced by inotifytools_watch_recursively_with_exclude().

## ◆ inotifytools_watch_files()

int inotifytools_watch_files | ( | char const * | filenames[],
|  | int | events
| ) |  |

Set up a watch on a list of files.

inotifytools_initialize() must be called before this function can be used.

Parameters

  filenames | null-terminated array of absolute or relative paths of files to watch.
  events | bitwise OR'ed inotify events to watch for. See section Events.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error().

Definition at line 1199 of file inotifytools.c.

Referenced by inotifytools_watch_file().

## ◆ inotifytools_watch_recursively()

int inotifytools_watch_recursively | ( | char const * | path,
|  | int | events
| ) |  |

Set up recursive watches on an entire directory tree.

inotifytools_initialize() must be called before this function can be used.

Parameters

  path | path of directory or file to watch. If the path is a directory, every subdirectory will also be watched for the same events up to the maximum readable depth. If the path is a file, the file is watched exactly as if inotifytools_watch_file() were used.
  events | Inotify events to watch for. See section Events.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error(). Note that some errors on subdirectories will be ignored; for example, if you watch a directory tree which contains some directories which you do not have access to, those directories will not be watched, but this function will still return 1 if no other errors occur.

Note
  This function does not attempt to work atomically. If you use this function to watch a directory tree and files or directories are being created or removed within that directory tree, there are no guarantees as to whether or not those files will be watched.

Definition at line 1682 of file inotifytools.c.

References inotifytools_watch_recursively_with_exclude().

## ◆ inotifytools_watch_recursively_with_exclude()

int inotifytools_watch_recursively_with_exclude | ( | char const * | path,
|  | int | events,
|  | char const ** | exclude_list
| ) |  |

Set up recursive watches on an entire directory tree, optionally excluding some directories.

inotifytools_initialize() must be called before this function can be used.

Author
  UH

Parameters

  path | path of directory or file to watch. If the path is a directory, every subdirectory will also be watched for the same events up to the maximum readable depth. If the path is a file, the file is watched exactly as if inotifytools_watch_file() were used.
  exclude_list | NULL terminated path list of directories not to watch. Can be NULL if no paths are to be excluded. Directories may or may not include a trailing '/'.
  events | Inotify events to watch for. See section Events.

Returns
  1 on success, 0 on failure. On failure, the error can be obtained from inotifytools_error(). Note that some errors on subdirectories will be ignored; for example, if you watch a directory tree which contains some directories which you do not have access to, those directories will not be watched, but this function will still return 1 if no other errors occur.

Note
  This function does not attempt to work atomically. If you use this function to watch a directory tree and files or directories are being created or removed within that directory tree, there are no guarantees as to whether or not those files will be watched.

Definition at line 1718 of file inotifytools.c.

References inotifytools_watch_file(), and inotifytools_watch_recursively_with_exclude().

Referenced by inotifytools_watch_recursively(), and inotifytools_watch_recursively_with_exclude().

## ◆ inotifytools_wd_from_filename()

int inotifytools_wd_from_filename | ( | char const * | filename | ) |

Get the watch descriptor for a particular filename.

inotifytools_initialize() must be called before this function can be used.

Parameters

  filename | file name to find watch descriptor for.

Returns
  watch descriptor associated with filename, or -1 if filename is not associated with any watch descriptor.

Note
  The filename specified must always be the original name used to establish the watch.

Definition at line 982 of file inotifytools.c.