adhocify/adhocify.c

/*
 * Copyright (c) 2014-2017 Albert S. <adhocify@quitesimple.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#define  _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <libgen.h>
#include <inttypes.h>
#include <time.h>
#include <stdbool.h>
#include <stdarg.h>
#include <errno.h>
#include <fnmatch.h>
#include <getopt.h>
#include <ftw.h>
#include <linux/limits.h>
#define BUF_SIZE (sizeof(struct inotify_event) + NAME_MAX + 1) * 1024
#define STREQ(s1,s2) ( strcmp(s1,s2) == 0 )
#define SCRIPT_PLACE_SPECIFIER "{}" //TODO: think of a better name...
struct watchlistentry
{
	int ifd;
	char *path;
	bool isdir;
	struct watchlistentry *next;
};
size_t max_watches = 0;
size_t watchlistentries = 0;
struct watchlistentry *watchlist_head = NULL;
struct watchlistentry **watchlist = &watchlist_head;



struct ignorelist
{
	char *ignore;
	struct ignorelist *next;
};

struct ignorelist *ignorelist_head = NULL;
struct ignorelist **ignorelist_current = &ignorelist_head;


/* Write once globals. Set from process_arguments*/
bool silent = false;
bool noenv = false;
bool fromstdin = false;
bool forkbombcheck = true;
bool daemonize  = false;
bool exit_with_child = false;
int exitcode = 0;

uint32_t mask = 0;
char *prog = NULL;
char *path_logfile = NULL;
char **script_arguments = NULL; //options to be passed to script we are calling 
size_t n_script_arguments = 0;

void *xmalloc(size_t size)
{
	void *m = malloc(size);
	if(m == NULL) 
	{
		perror("malloc"); 
		exit(EXIT_FAILURE);
	}
	return m;
}

char *xstrdup(const char *s)
{
	char *tmp = strdup(s);
	if(tmp == NULL)
	{
		perror("strdup");
		exit(EXIT_FAILURE);
	}
	return tmp;
}

char *xrealpath(const char *path, char *resolved_path)
{
	char *tmp = realpath(path, resolved_path);
	if(tmp == NULL)
	{
		perror("realpath");
		exit(EXIT_FAILURE);
	}
	return tmp;
}


char *ndirname(const char *path)
{
	if(path == NULL)
	{
		return xstrdup("."); 
	}
	char *c = strdupa(path);
	return xstrdup(dirname(c));
}

char *find_ifd_path(int ifd)
{
	for(struct watchlistentry *lkp = watchlist_head; lkp != NULL; lkp = lkp->next)
	{	
		if(lkp->ifd == ifd) 
		{
			return lkp->path;
		}
	}
	return NULL;
}

bool is_ignored(const char *filename)
{
	for(struct ignorelist *l = ignorelist_head; l != NULL; l = l->next)
	{
		if(fnmatch(l->ignore, filename, 0) == 0)
		{
			return true;
		}
	}
	return false;
}

bool path_is_directory(const char *path)
{
	struct stat sb;
	int r = stat(path, &sb);
	if(r == -1)
	{
		perror("stat");
		return false;
	}
	return S_ISDIR(sb.st_mode);
}

static inline bool file_exists(const char *path)
{
	return access(path, F_OK) == 0; 
}


void add_to_ignore_list(const char *str)
{
	*ignorelist_current = xmalloc(sizeof(struct ignorelist));
	(*ignorelist_current)->ignore = xstrdup(str);

	ignorelist_current = &(*ignorelist_current)->next; 
}



void logwrite(const char *format, ...)
{
	if(silent)
	{
		return;
	}
	va_list args;
	va_start(args, format);
	vfprintf(stdout, format, args);
	fflush(stdout);
	va_end(args);
}

void logerror(const char *format, ...)
{
	va_list args;
	va_start(args, format);
	char *prefix = "Error: "; 
	char *tmp = alloca(strlen(format) + strlen(prefix) + 1);
	strcpy(tmp, prefix);
	strcat(tmp, format);
	vfprintf(stderr, tmp, args);
	fflush(stderr);
	va_end(args);

}

void watchqueue_add_path(const char *pathname)
{
	*watchlist = xmalloc(sizeof(struct watchlistentry));
	struct watchlistentry *e = *watchlist;
	char *path = xrealpath(pathname, NULL);
	e->ifd = 0;
	e->path = path;
	e->isdir = path_is_directory(pathname);
	e->next = NULL;
	watchlist= &e->next;
	++watchlistentries;
}

static int recursive_walker_callback(const char *path, const struct stat *sb,
                          int typeflag, struct FTW *ftwbuf)
                         
{
	if(watchlistentries == max_watches)
	{
		fprintf(stderr, "Error: Max number of watches reached\n");
		return -1;
	}
	if(typeflag == FTW_D)
	{
		watchqueue_add_path(path);
	}
	return 0;
}
void watchqueue_add_recursive(const char *pathname)
{
		FILE *fp = fopen("/proc/sys/fs/inotify/max_user_watches", "r");
		if(fp == NULL)
		{
			fprintf(stderr, "error opening max_user_watches file\n");
			exit(EXIT_FAILURE);
		}
	
		if(fscanf(fp, "%zu", &max_watches) < 1)
		{
			fprintf(stderr, "error processing max_user_watches file\n");
			exit(EXIT_FAILURE);
		}
		fclose(fp);
		
		int walker = nftw(pathname, &recursive_walker_callback, 10, FTW_PHYS);
		if(walker == -1)
		{
			fprintf(stderr, "nftw failed\n");
			exit(EXIT_FAILURE);
		}
}



void create_watches(int fd, uint32_t mask)
{
	for(struct watchlistentry *lkp = watchlist_head; lkp != NULL; lkp = lkp->next)
	{
		int ret = inotify_add_watch(fd, lkp->path, mask);
		if(ret == -1) 
		{
			perror("inotify_add_watch"); 
			exit(EXIT_FAILURE); 
		}

		lkp->ifd = ret;
	}	
}

bool redirect_stdout(const char *outfile)
{
	int fd = open(outfile, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
	if(fd == -1)
	{
		perror("open");
		return false;
	}

	if(dup2(fd, 1) == -1 || dup2(fd, 2) == -1)
	{
		perror("dup2");
		return false;
	}

	return true;
}


bool run_prog(const char *eventfile,  uint32_t eventmask)
{
	pid_t pid = fork();
	if(pid == 0)
	{
		if(path_logfile)
		{
			if(! redirect_stdout(path_logfile))
			{
				return false;	
			}
		}

	
		if(! noenv)
		{
			char envvar[30];
			snprintf(envvar, sizeof(envvar), "adhocifyevent=%"PRIu32, eventmask); 
			putenv(envvar);
		}
		
		//This can be thrown away, if in create_script_args we create pointer to the pointer pointing to the SCRIPT_PLACE_SPECIFIER string. 
		//Then all what we have to do here is to set the pointer to eventfile. However, we can have multiple of those, probably not worth it as we shouldn't have tons of arguments
		for(unsigned int i = 0; i < n_script_arguments; i++)
		{
			char *argument = script_arguments[i];
			if(argument && STREQ(argument, SCRIPT_PLACE_SPECIFIER))
				script_arguments[i] = eventfile;
		}
		
		execv(prog, script_arguments);
		perror("execv");
		return false;
	}
	if(pid == -1)
	{
		perror("fork");
		return false;
	}	

	return true;

}

uint32_t nameToMask(const char *name)
{ 
	if(STREQ(name, "IN_CLOSE_WRITE"))
		return IN_CLOSE_WRITE;
	else if(STREQ(name, "IN_OPEN"))
		return IN_OPEN;
	else if(STREQ(name, "IN_MODIFY"))
		return IN_MODIFY;
	else if(STREQ(name, "IN_DELETE"))
		return IN_DELETE;
	else if(STREQ(name, "IN_ATTRIB"))
		return IN_ATTRIB;
	else if(STREQ(name, "IN_CLOSE_NOWRITE"))
		return IN_CLOSE_NOWRITE;
	else if(STREQ(name, "IN_MOVED_FROM"))
		return IN_MOVED_FROM;
	else if(STREQ(name, "IN_MOVED_TO"))
		return IN_MOVED_TO;
	else if(STREQ(name, "IN_CREATE"))
		return IN_CREATE;
	else if(STREQ(name, "IN_DELETE_SELF"))
		return IN_DELETE_SELF;
	else if(STREQ(name, "IN_MOVE_SELF"))
		return IN_MOVE_SELF;
	else if(STREQ(name, "IN_ALL_EVENTS"))
		return IN_ALL_EVENTS;
	else if(STREQ(name, "IN_CLOSE"))
		return IN_CLOSE;
	else if(STREQ(name, "IN_MOVE"))
		return IN_MOVE;
	else
		return 0;

}

void check_forkbomb(const char *path_logfile, const char *path_prog)
{
	char *dir_log = ndirname(path_logfile);
	char *dir_prog = ndirname(path_prog);	

	struct watchlistentry *lkp = watchlist_head;
	while(lkp)
	{
		if(lkp->isdir)
		{

			char *dir_lkpPath = lkp->path;
			if( STREQ(dir_lkpPath, dir_log)	|| STREQ(dir_lkpPath, dir_prog) )
			{
				logerror("Don't place your logfiles or script in a directory you are watching for events. Pass -b to bypass this check.\n");
				exit(EXIT_FAILURE);
			}
		}

		lkp = lkp->next;
	}

	free(dir_log);
	free(dir_prog);
}

void queue_watches_from_stdin()
{
	char *line = NULL;
	size_t n = 0; 
	ssize_t r;
	while((r = getline(&line, &n, stdin)) != -1)
	{
		if(line[r-1] == '\n') 
			line[r-1] = 0;
		watchqueue_add_path(line);
	}
}

char *get_eventfile_abspath(struct inotify_event *event)
{
	char *wdpath = find_ifd_path(event->wd);
	if(wdpath == NULL)
	{
		return NULL;
	}
	size_t nameLen = strlen(event->name);
	char *abspath = xmalloc((strlen(wdpath) + nameLen + 2) * sizeof(char));
	strcpy(abspath, wdpath);
	if(nameLen > 0) 
	{
		strcat(abspath, "/");
		strcat(abspath, event->name);
	}

	return abspath;
}


void handle_event(struct inotify_event *event)
{
	if(event->mask & mask) 
	{	
		char *eventfile_abspath = get_eventfile_abspath(event);
		if(eventfile_abspath == NULL)
		{
			logerror("Could not get absolute path for event. Watch descriptor %i\n", event->wd);
			exit(EXIT_FAILURE);
		}
		
		if(is_ignored(eventfile_abspath)) 
		{
			free(eventfile_abspath);
			return;
		}
		logwrite("Starting execution of child %s\n", prog);
		bool r = run_prog(eventfile_abspath, event->mask);
		if(!r) 
		{
			logerror("Execution of child %s failed\n", prog);
			exit(EXIT_FAILURE);
		}
		
		fflush(stdout);
		fflush(stderr);
		
		free (eventfile_abspath);
	}
}

static inline char *get_cwd()
{
	return getcwd(NULL,0); 
}

void print_usage()
{
	printf("adhocify [OPTIONS] script [arguments for script]\n");
	
	printf("--daemon, -d\t\t\tdaemonize\n");
	printf("--path, -w\t\t\tpath -- adds the specified path to the watchlist\n");
	printf("--recursive, -r\t\t\tpath -- adds the specified path to the watchlist recursively (all subdirectories too. Do not use for large structures!)\n");
	printf("--logfile, -o\t\t\tlogfile -- output goes here\n");
	printf("--mask, -m\t\t\tmaskval -- inotify mask value. Can be specified multiple times, will be ORed.\n");
	printf("--no-env, -a\t\t\tif specified, the inotify event which occured won't be passed to the script as an environment variable.\n");
	printf("--silent, -q\t\t\tsilent\n");
	printf("--stdin, -s\t\t\tRead the paths which must be added to the watchlist from stdin. Each path in a seperate line\n");
	printf("--no-forkbomb-check, -b\t\tDisable fork bomb detection\n");
	printf("--ignore, -i\t\t\tpattern -- Ignore events on files for which the pattern matches\n"); 
	printf("--exit-with-child, -e\t\tExit when the script exits. You can also specify a return code (e. g. -e 1 = exit on error)\n");
	printf("\n\nIf your script should know the file the event occured on, use {} when you specify the script arguments (like xargs)\n");
}

static struct option long_options[] = 
{
  { "daemon", no_argument, 0, 'd' },
  { "logfile", required_argument, 0, 'o' },
  { "mask", required_argument, 0, 'm' },
  { "path", required_argument, 0, 'w' },
  { "no-env", no_argument, 0, 'a' },
  { "stdin", no_argument, 0, 's' },
  { "no-forkbomb-check", no_argument, 0, 'b' },
  { "ignore", required_argument, 0, 'i' },  
  { "silent", no_argument, 0, 'q' },
  { "help", no_argument, 0, 'h' },
  { "exit-with-child", optional_argument, 0, 'e' }
};

//fills global n_script_arguments and script_arguments var
void fill_script_arguments(size_t n_args, char *args[])
{
		n_script_arguments = n_args + 2; //2 = argv0 and terminating NULL
		
		char **arguments = xmalloc( n_script_arguments * sizeof(char *) ); 
		
		const char *argv0 = memrchr(prog, '/', strlen(prog));
		argv0 = ( argv0 == NULL ) ? prog : argv0+1;
		arguments[0] = argv0;
		
		const int begin_offset = 1;
		for(unsigned int i = 0; i < n_args; i++)
		{
			char *argument = args[i];
			arguments[i+begin_offset] = strdup(argument); 
		}
		arguments[n_args+begin_offset] = NULL;
		
		script_arguments = arguments;
}


void parse_options(int argc, char **argv)
{
	char *watchpath = NULL;
	int option;
    int option_index;
    uint32_t optmask = 0; 
	while((option = getopt_long(argc, argv, "absdo:w:r:m:l:i:e::", long_options, &option_index)) != -1)
	{
		switch(option)
		{
			case 'd':
				daemonize = true;
				break;
			case 'o':
				path_logfile = optarg;
				break;
			case 'm':
				optmask = nameToMask(optarg);
				if(optmask == 0) { 
					logerror("Not supported inotify event: %s\n", optmask); 
					exit(EXIT_FAILURE); 
				}
				mask |= optmask;
				break;
			case 'w':
				watchpath = optarg;
				watchqueue_add_path(watchpath);
				break;
			case 'r':
				watchpath = optarg;
				watchqueue_add_recursive(watchpath);
				break;
			case 'a':
				noenv=true;
				break;
			case 's':
				fromstdin=true;
				break;
			case 'b':
				forkbombcheck=false;
				break;
			case 'i':
				add_to_ignore_list(optarg);
				break;
			case 'q':
				silent=true;
				break;
			case 'h':
				print_usage();
				exit(EXIT_SUCCESS);
			case 'e':
				exit_with_child = true;
				if(optarg)
				{
					exitcode = atoi(optarg);
					
				}
				break;
		}	
	}
	
	if(optind == argc) 
	{ 
		print_usage();
		logerror("missing prog/script path\n");
		exit(EXIT_FAILURE); 
	}
	
	prog = argv[optind++];
	
	if(optind <= argc)
	{
		fill_script_arguments(argc - optind, &argv[optind]);
	}
}

void process_options()
{
	if(fromstdin)
	{
		queue_watches_from_stdin();
	}
	if(daemonize)
	{
		if(daemon(0,0) == -1)
		{
			perror("daemon");
			exit(EXIT_FAILURE);
		}
	}
	
	if(watchlist_head == NULL)
	{
		watchqueue_add_path(get_cwd());
	}

	if(mask == 0)
	{
		mask |= IN_CLOSE_WRITE;
	}	
	
	if(! file_exists(prog))
	{
		fprintf(stderr, "File %s does not exist\n", prog);
		exit(EXIT_FAILURE);
	}
	
	if(path_logfile)
	{
		path_logfile = xrealpath(path_logfile, NULL);
	}

	if(forkbombcheck)
	{
		char *path_prog = xrealpath(prog, NULL);
		check_forkbomb(path_logfile, path_prog);
	}
}

void start_monitoring(int ifd)
{
	while(1) 
	{
			int len;
			int offset =0;
			char buf[BUF_SIZE];
			len = read(ifd, buf, BUF_SIZE);
			if(len == -1) 
			{
				if(errno == EINTR) 
					continue;
				perror("read");
				exit(EXIT_FAILURE);
			}

			while(offset < len)
			{

				struct inotify_event *event = (struct inotify_event *)&buf[offset];
				handle_event(event);
				offset+=sizeof(struct inotify_event) + event->len;
			}
	}              
}

void child_handler(int signum, siginfo_t *info, void *context)
{
	if(signum != SIGCHLD)
	{
		return;
	}	
	
	int status;
	pid_t p = waitpid(-1, &status, WNOHANG);
	if(p == -1)
	{
		logerror("waitpid failed when handling child exit\n");
		exit(EXIT_FAILURE);
	}
	if(exit_with_child)
	{
		if(status == exitcode)
		{
			logwrite("child exited with specified exit code, exiting too");
			exit(exitcode);
		}
	}

}
void set_signals()
{
	struct sigaction action;
	action.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
	action.sa_sigaction = &child_handler;
	if(sigaction(SIGCHLD, &action, NULL) == -1)
	{
		logerror("Error when setting up the signal handler\n");
		exit(EXIT_FAILURE);
	}
}


int main(int argc, char **argv)
{
	if(argc < 2) 
	{ 
		print_usage();
		exit(EXIT_FAILURE);
	}

	//signal(SIGCHLD, SIG_IGN);
	set_signals();
	
	
	parse_options(argc, argv);
	process_options();
	
	int ifd = inotify_init();
	if(ifd == -1)
	{
		perror("inotify_init");
		exit(EXIT_FAILURE);
	}
	create_watches(ifd, mask);
	start_monitoring(ifd);
}