Added command execution support
This commit is contained in:
parent
4e25735cd9
commit
77f6db18a5
2
Makefile
2
Makefile
@ -8,7 +8,7 @@ DEBUG_CFLAGS = -Wall -Wextra -Werror -pedantic-errors -fstack-protector-strong \
|
|||||||
-Wwrite-strings -std=c99 -g
|
-Wwrite-strings -std=c99 -g
|
||||||
CFLAGS = -Wall -Wextra -Werror -pedantic-errors -Wwrite-strings -std=c99 -O3
|
CFLAGS = -Wall -Wextra -Werror -pedantic-errors -Wwrite-strings -std=c99 -O3
|
||||||
|
|
||||||
BUILD_FLAGS = -DVERSION=\"0.0.1\"
|
BUILD_FLAGS = -DVERSION=\"0.0.2\"
|
||||||
|
|
||||||
build: $(TARGET)
|
build: $(TARGET)
|
||||||
debug: $(DEBUG_TARGET)
|
debug: $(DEBUG_TARGET)
|
||||||
|
66
README.md
66
README.md
@ -2,8 +2,11 @@
|
|||||||
|
|
||||||
**Wolf** is a configurable file watchdog for Linux platform written in C. **Wolf** monitors
|
**Wolf** is a configurable file watchdog for Linux platform written in C. **Wolf** monitors
|
||||||
a set of files or directories and prints out a log event each time the watched resources changes. The watchdog
|
a set of files or directories and prints out a log event each time the watched resources changes. The watchdog
|
||||||
can be configured to watch for any kind of event, that includes file creation and deletion, file moving, I/O and
|
can be configured to monitor any kind of event, that includes file creation and deletion, file moving, I/O and
|
||||||
permission changing. **Wolf** relies on the `inotify(7)` system call, therefore it is only compatible with Linux-based systems.
|
permission changes. Additionally, **Wolf** can execute an user-defined command every time a watchdog detects a
|
||||||
|
change, thus allowing you to easily build complex pipelines without the need to employ any additional tool.
|
||||||
|
|
||||||
|
**Wolf** relies on the `inotify(7)` system call, therefore it is only compatible with Linux-based systems.
|
||||||
|
|
||||||
## Building
|
## Building
|
||||||
The single source file(`wolf.c`) of the watchdog can be compiled using any C99 compiler. To build it, issue the following command:
|
The single source file(`wolf.c`) of the watchdog can be compiled using any C99 compiler. To build it, issue the following command:
|
||||||
@ -98,16 +101,57 @@ R '/home/marco/wolf' (dir)
|
|||||||
P '/home/marco/wolf/a.out' (file)
|
P '/home/marco/wolf/a.out' (file)
|
||||||
W '/home/marco/wolf/a.out' (file)
|
W '/home/marco/wolf/a.out' (file)
|
||||||
```
|
```
|
||||||
|
Additionally, if you want to execute a custom command every time a watchdog detects a change, you can do so by
|
||||||
|
using the `-e,--exec` option. For instance, suppose that you have a Python file(`foo.py`) with the following content:
|
||||||
|
|
||||||
## Caveats
|
```py
|
||||||
**Wolf** relies on the Linux `inotify(7)` system call to implement the file tracking mechanism. Before using this
|
def square(x):
|
||||||
tool you should be aware of the following idiosyncrasies related to the way this system interface works:
|
return x ** 2
|
||||||
|
|
||||||
1. `inotify` is **NOT** recursive. Meaning that you cannot monitor subdirectories of a watched directory;
|
print(f"10^2 = {square(10)}")
|
||||||
2. `inotify` can only work within files for which you already have reading and writing permissions;
|
```
|
||||||
3. `inotify` removes deleted files from the `inotify_add_watch(2)`, meaning that a watchdog is automatically
|
|
||||||
removed from a deleted file. To add it again, the program have to be restarted;
|
and you want to continously evaluate it as soon as you save it to the disk. To do this, you can use **Wolf** as described
|
||||||
4. `inotify` is quite verbose by design. For instance if you try to write to a **non-empty** watched file
|
below:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
$> ./wolf -w --exec 'python foo.py'
|
||||||
|
```
|
||||||
|
|
||||||
|
Each time a write event is detected by the watchdog, the supplied command will be issued, causing the program
|
||||||
|
to be automatically evaluated, that is:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
$> ./wolf -w --exec 'python foo.py'
|
||||||
|
[2024-08-20 16:24:43] W 'foo.py' (file)
|
||||||
|
10^2 = 100
|
||||||
|
[2024-08-20 16:24:55] W 'foo.py' (file)
|
||||||
|
10^2 = 100
|
||||||
|
5^2 = 25
|
||||||
|
[2024-08-20 16:25:10] W 'foo.py' (file)
|
||||||
|
10^2 = 100
|
||||||
|
5^2 = 25
|
||||||
|
4^2 = 16
|
||||||
|
```
|
||||||
|
|
||||||
|
Be sure to read the _caveats_ section to learn more about the concurrent aspects of this feature and how **Wolf**
|
||||||
|
spawns a new process.
|
||||||
|
|
||||||
|
## Technical details
|
||||||
|
Below there is a brief list of the things you should be aware of when using **Wolf**.
|
||||||
|
|
||||||
|
- `inotify` is **NOT** recursive. Meaning that you cannot monitor subdirectories of a watched directory;
|
||||||
|
- `inotify` can only work within files for which you already have reading and writing permissions;
|
||||||
|
- The `-e,--exec` option works by spawning a child process using the `fork(2)` system call; thus, the command is being executed
|
||||||
|
in a new process;
|
||||||
|
- The `-e,--exec` option is a **NON-BLOCKING** feature, meaning that the parent process will continue to log new changes while the
|
||||||
|
child process execute the supplied command; therefore the parent process will **NOT** wait for the child(s) process to terminate;
|
||||||
|
- Since the parent process does not await for the child process to complete it will also not handle its return code, thus the exit
|
||||||
|
status of any supplied command is ignored.
|
||||||
|
- Any `SIGCHLD` signal generated by a child process is ignored, therefore the process reaping of any child is delegated to the kernel;
|
||||||
|
- `inotify` removes deleted files from the `inotify_add_watch(2)`, meaning that, after a file is being deleted, the watchdog associated with it
|
||||||
|
is automatically removed as well. To add it again, the program has to be restarted;
|
||||||
|
- `inotify` is quite verbose by design. For instance if you try to write to a **non-empty** watched file
|
||||||
using the `echo(1)` command along with a _redirection_(i.e., `echo 'hello world' > foo`), the watchdog will
|
using the `echo(1)` command along with a _redirection_(i.e., `echo 'hello world' > foo`), the watchdog will
|
||||||
log two events:
|
log two events:
|
||||||
|
|
||||||
@ -136,7 +180,7 @@ exit_group(0) = ?
|
|||||||
+++ exited with 0 +++
|
+++ exited with 0 +++
|
||||||
```
|
```
|
||||||
|
|
||||||
Since `inotify(1)` intercepts both, **wolf** will also log twice the same operation.
|
Since `inotify(1)` intercepts both, **wolf** will also log the same operation twice.
|
||||||
|
|
||||||
## License
|
## License
|
||||||
[GPLv3](https://choosealicense.com/licenses/gpl-3.0/)
|
[GPLv3](https://choosealicense.com/licenses/gpl-3.0/)
|
||||||
|
110
wolf.c
110
wolf.c
@ -1,3 +1,5 @@
|
|||||||
|
#define _GNU_SOURCE
|
||||||
|
|
||||||
#ifndef __linux__
|
#ifndef __linux__
|
||||||
#error "Unsupported platform"
|
#error "Unsupported platform"
|
||||||
#endif
|
#endif
|
||||||
@ -11,6 +13,8 @@
|
|||||||
#include <poll.h>
|
#include <poll.h>
|
||||||
#include <time.h>
|
#include <time.h>
|
||||||
#include <sys/inotify.h>
|
#include <sys/inotify.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/wait.h>
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <signal.h>
|
#include <signal.h>
|
||||||
|
|
||||||
@ -32,8 +36,10 @@ typedef enum {
|
|||||||
|
|
||||||
typedef enum { false, true } bool;
|
typedef enum { false, true } bool;
|
||||||
|
|
||||||
static void handle_inotify_events(int fd, const int *wd, int wd_len, char **watched_files, const bool is_timestamp_enabled);
|
static void handle_inotify_events(int fd, const int *wd, int wd_len, char **watched_files, const bool is_timestamp_enabled, const char *watchdog_cmd);
|
||||||
static void get_timestamp(uint8_t *timestamp, const ssize_t timestamp_len);
|
static void get_timestamp(uint8_t *timestamp, const ssize_t timestamp_len);
|
||||||
|
static void exec_command(const char *cmd);
|
||||||
|
static uint8_t **tokenize_command(const char *cmd);
|
||||||
|
|
||||||
volatile sig_atomic_t stop_signal = 0;
|
volatile sig_atomic_t stop_signal = 0;
|
||||||
void sigint_handler() {
|
void sigint_handler() {
|
||||||
@ -51,6 +57,7 @@ void helper(const char *name) {
|
|||||||
"-w, --write | Add a watchdog for writing events\n"
|
"-w, --write | Add a watchdog for writing events\n"
|
||||||
"-p, --permission | Add a watchdog for permissions changes\n"
|
"-p, --permission | Add a watchdog for permissions changes\n"
|
||||||
"-f, --full | Enable all the previous options\n"
|
"-f, --full | Enable all the previous options\n"
|
||||||
|
"-e, --exec | Execute a command when a watchdog detects a change\n"
|
||||||
"--no-timestamp | Disable timestamp from watchdog output\n"
|
"--no-timestamp | Disable timestamp from watchdog output\n"
|
||||||
"-v, --version | Show program version\n"
|
"-v, --version | Show program version\n"
|
||||||
"-h, --help | Show this helper\n\n"
|
"-h, --help | Show this helper\n\n"
|
||||||
@ -68,7 +75,8 @@ void version() {
|
|||||||
|
|
||||||
int main(int argc, char **argv) {
|
int main(int argc, char **argv) {
|
||||||
int opt, opt_idx = 0;
|
int opt, opt_idx = 0;
|
||||||
const char *short_opts = "cdmrwpfvh";
|
const char *short_opts = "cdmrwpfvhe:";
|
||||||
|
char *watchdog_cmd = NULL;
|
||||||
uint32_t mask = 0;
|
uint32_t mask = 0;
|
||||||
bool is_timestamp_enabled = true;
|
bool is_timestamp_enabled = true;
|
||||||
struct option long_opts[] = {
|
struct option long_opts[] = {
|
||||||
@ -79,6 +87,7 @@ int main(int argc, char **argv) {
|
|||||||
{"write", no_argument, NULL, 'w'},
|
{"write", no_argument, NULL, 'w'},
|
||||||
{"permission", no_argument, NULL, 'p'},
|
{"permission", no_argument, NULL, 'p'},
|
||||||
{"full", no_argument, NULL, 'f'},
|
{"full", no_argument, NULL, 'f'},
|
||||||
|
{"exec", required_argument, NULL, 'e'},
|
||||||
{"no-timestamp", no_argument, NULL, 0 },
|
{"no-timestamp", no_argument, NULL, 0 },
|
||||||
{"version", no_argument, NULL, 'v'},
|
{"version", no_argument, NULL, 'v'},
|
||||||
{"help", no_argument, NULL, 'h'},
|
{"help", no_argument, NULL, 'h'},
|
||||||
@ -96,6 +105,7 @@ int main(int argc, char **argv) {
|
|||||||
case 'p': mask |= IN_ATTRIB; break;
|
case 'p': mask |= IN_ATTRIB; break;
|
||||||
case 'f': mask = IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_MOVED_FROM |
|
case 'f': mask = IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_MOVED_FROM |
|
||||||
IN_ACCESS | IN_MODIFY | IN_ATTRIB; break;
|
IN_ACCESS | IN_MODIFY | IN_ATTRIB; break;
|
||||||
|
case 'e': watchdog_cmd = optarg; break;
|
||||||
case 0:
|
case 0:
|
||||||
if(!strcmp(long_opts[opt_idx].name, "no-timestamp")) {
|
if(!strcmp(long_opts[opt_idx].name, "no-timestamp")) {
|
||||||
is_timestamp_enabled = false;
|
is_timestamp_enabled = false;
|
||||||
@ -171,7 +181,9 @@ int main(int argc, char **argv) {
|
|||||||
if(poll_num > 0) {
|
if(poll_num > 0) {
|
||||||
// Inotify events are available
|
// Inotify events are available
|
||||||
if(fds->revents & POLLIN) {
|
if(fds->revents & POLLIN) {
|
||||||
handle_inotify_events(fd, wd, number_of_files, (argv + optind), is_timestamp_enabled);
|
handle_inotify_events(fd, wd, number_of_files, (argv + optind), is_timestamp_enabled, watchdog_cmd);
|
||||||
|
|
||||||
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -183,7 +195,7 @@ int main(int argc, char **argv) {
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void handle_inotify_events(int fd, const int *wd, int wd_len, char **watched_files, const bool is_timestamp_enabled) {
|
static void handle_inotify_events(int fd, const int *wd, int wd_len, char **watched_files, const bool is_timestamp_enabled, const char *watchdog_cmd) {
|
||||||
// Align inotify reading buffer to inotify_event struct
|
// Align inotify reading buffer to inotify_event struct
|
||||||
char inotify_read_buf[4096]
|
char inotify_read_buf[4096]
|
||||||
__attribute__((aligned((__alignof__(struct inotify_event)))));
|
__attribute__((aligned((__alignof__(struct inotify_event)))));
|
||||||
@ -270,6 +282,11 @@ static void handle_inotify_events(int fd, const int *wd, int wd_len, char **watc
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
// If user supplied a command, execute it
|
||||||
|
if(watchdog_cmd != NULL) {
|
||||||
|
exec_command(watchdog_cmd);
|
||||||
|
}
|
||||||
|
|
||||||
free(file_name);
|
free(file_name);
|
||||||
}
|
}
|
||||||
memset(inotify_read_buf, 0, sizeof(inotify_read_buf));
|
memset(inotify_read_buf, 0, sizeof(inotify_read_buf));
|
||||||
@ -281,3 +298,88 @@ static void get_timestamp(uint8_t *timestamp, const ssize_t timestamp_len) {
|
|||||||
struct tm *timeinfo = localtime(&now);
|
struct tm *timeinfo = localtime(&now);
|
||||||
strftime((char*)timestamp, timestamp_len, "%Y-%m-%d %H:%M:%S", timeinfo);
|
strftime((char*)timestamp, timestamp_len, "%Y-%m-%d %H:%M:%S", timeinfo);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void exec_command(const char *cmd) {
|
||||||
|
// Ignore SIGCHLD signals.
|
||||||
|
// This allows us to avoid blocking the parent process until the child completes
|
||||||
|
// its execution; furthermore, it allows us to prevent the creation of zombie processes
|
||||||
|
// by delegating the cleanup process to the kernel. By doing so, we lose the ability
|
||||||
|
// to check the return status of the child process.
|
||||||
|
signal(SIGCHLD, SIG_IGN);
|
||||||
|
|
||||||
|
// Execute command in a new process
|
||||||
|
pid_t pid = fork();
|
||||||
|
|
||||||
|
if(pid == -1) {
|
||||||
|
perror("fork");
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
} else if(pid == 0) { // Child process
|
||||||
|
// Tokenize command
|
||||||
|
uint8_t **argv = tokenize_command(cmd);
|
||||||
|
|
||||||
|
// Replace memory of child process with new program
|
||||||
|
execvp((char*)argv[0], (char**)argv);
|
||||||
|
|
||||||
|
// If execvp returns, it means it has failed
|
||||||
|
switch(errno) {
|
||||||
|
case ENOENT: puts("Cannot execute command: no such file or directory"); break;
|
||||||
|
case EACCES: puts("Cannot execute command: permission denied"); break;
|
||||||
|
default: puts("Cannot execute command"); break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Free allocated resources
|
||||||
|
for (int i = 0; argv[i] != NULL; i++) {
|
||||||
|
free(argv[i]);
|
||||||
|
}
|
||||||
|
free(argv);
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static uint8_t **tokenize_command(const char *cmd) {
|
||||||
|
// Duplicate command
|
||||||
|
char *cmd_dup = strdup(cmd);
|
||||||
|
if(cmd_dup == NULL) {
|
||||||
|
perror("strdup");
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Count number of arguments
|
||||||
|
size_t argc = 0;
|
||||||
|
char *token = strtok(cmd_dup, " ");
|
||||||
|
while(token != NULL) {
|
||||||
|
argc++;
|
||||||
|
token = strtok(NULL, " ");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Allocate enough memory for arguments(and null terminator)
|
||||||
|
uint8_t **argv = malloc((argc + 1) * sizeof(uint8_t*));
|
||||||
|
if(argv == NULL) {
|
||||||
|
perror("malloc");
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reset command string and tokenize again
|
||||||
|
strcpy(cmd_dup, cmd);
|
||||||
|
size_t idx = 0;
|
||||||
|
token = strtok(cmd_dup, " ");
|
||||||
|
while(token != NULL) {
|
||||||
|
argv[idx] = (uint8_t*)strdup(token);
|
||||||
|
if(argv[idx] == NULL) {
|
||||||
|
perror("strdup");
|
||||||
|
while(idx > 0) { free(argv[--idx]); }
|
||||||
|
free(argv);
|
||||||
|
free(cmd_dup);
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
idx++;
|
||||||
|
token = strtok(NULL, " ");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Null-terminate the string
|
||||||
|
argv[idx] = NULL;
|
||||||
|
// Clear temporary resources
|
||||||
|
free(cmd_dup);
|
||||||
|
|
||||||
|
return argv;
|
||||||
|
}
|
||||||
|
Loading…
Reference in New Issue
Block a user