Main Page | File List | File Members | Related Pages

inotifytools/inotifytools.h File Reference

inotifytools library public interface. More...

Go to the source code of this file.

Functions

void inotifytools_cleanup ()
int inotifytools_error ()
char * inotifytools_filename_from_wd (int wd)
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_get_stat_by_filename (char const *filename, int event)
int inotifytools_get_stat_by_wd (int wd, int event)
int inotifytools_get_stat_total (int event)
int inotifytools_ignore_events_by_regex (char const *pattern, int flags)
int inotifytools_initialize ()
void inotifytools_initialize_stats ()
inotify_event * inotifytools_next_event (int timeout)
inotify_event * inotifytools_next_events (int timeout, int num_events)
int inotifytools_remove_watch_by_filename (char const *filename)
int inotifytools_remove_watch_by_wd (int wd)
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_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@mcgovern.id.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:

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 );
        }
}

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:

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:

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

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

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 326 of file inotifytools.c.

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 1588 of file inotifytools.c.

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 763 of file inotifytools.c.

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 1953 of file inotifytools.c.

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 1968 of file inotifytools.c.

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 1983 of file inotifytools.c.

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 1614 of file inotifytools.c.

int inotifytools_get_stat_by_filename char const *  filename,
int  event
 

Get statistics by a particular filename.

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

Parameters:
filename name of file to get stats for.
event a single inotify event to get statistics for, or 0 for event total. See section Events.
Returns:
the number of times the event specified by event has occurred on the file specified by filename since stats collection was enabled, or -1 if the file is not being watched or event is invalid.
Note:
The filename specified must always be the original name used to establish the watch.

Definition at line 1572 of file inotifytools.c.

int inotifytools_get_stat_by_wd int  wd,
int  event
 

Get statistics by a particular watch descriptor.

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

Parameters:
wd watch descriptor to get stats for.
event a single inotify event to get statistics for, or 0 for event total. See section Events.
Returns:
the number of times the event specified by event has occurred on the watch descriptor specified by wd since stats collection was enabled, or -1 if event or wd are invalid.

Definition at line 1495 of file inotifytools.c.

int inotifytools_get_stat_total int  event  ) 
 

Get statistics aggregated across all watches.

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

Parameters:
event a single inotify event to get statistics for, or 0 for event total. See section Events.
Returns:
the number of times the event specified by event has occurred over all watches since stats collection was enabled, or -1 if event is not a valid event.

Definition at line 1518 of file inotifytools.c.

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 2000 of file inotifytools.c.

int inotifytools_initialize  ) 
 

Initialise inotify.

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 281 of file inotifytools.c.

void inotifytools_initialize_stats  ) 
 

Initialize or reset statistics.

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

When this function is called, all subsequent events will be tallied. Statistics can then be obtained via the inotifytools_get_stat_* functions.

After the first call, subsequent calls to this function will reset the event tallies to 0.

Definition at line 418 of file inotifytools.c.

struct inotify_event* inotifytools_next_event 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 0, 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 1038 of file inotifytools.c.

struct inotify_event* inotifytools_next_events 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 0, 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 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 1092 of file inotifytools.c.

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 930 of file inotifytools.c.

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 907 of file inotifytools.c.

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 827 of file inotifytools.c.

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 805 of file inotifytools.c.

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 1941 of file inotifytools.c.

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 953 of file inotifytools.c.

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 975 of file inotifytools.c.

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 1246 of file inotifytools.c.

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 1282 of file inotifytools.c.

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 784 of file inotifytools.c.


Generated on Thu Mar 27 18:37:39 2008 for libinotifytools by  doxygen 1.3.9.1