lsyncd/lsyncd.c

1968 lines
46 KiB
C
Raw Normal View History

2012-02-15 11:15:32 +00:00
/**
2010-10-19 10:20:27 +00:00
* lsyncd.c Live (Mirror) Syncing Demon
2012-02-15 19:10:50 +00:00
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2010-11-22 21:17:08 +00:00
*
2012-02-15 11:15:32 +00:00
* This is the core. It contains as minimal as possible glues
2010-10-19 10:20:27 +00:00
* to the operating system needed for lsyncd operation. All high-level
* logic is coded (when feasable) into lsyncd.lua
2012-02-15 11:15:32 +00:00
*
2012-02-15 19:10:50 +00:00
* This code assumes you have a 100 character wide display to view it (when tabstop is 4)
*
* License: GPLv2 (see COPYING) or any later version
* Authors: Axel Kittenberger <axkibe@gmail.com>
*
**/
2010-11-22 21:17:08 +00:00
2010-11-22 14:54:50 +00:00
#include "lsyncd.h"
2010-10-16 10:26:48 +00:00
#define SYSLOG_NAMES 1
2011-03-30 14:08:01 +00:00
#include <sys/select.h>
2010-10-16 18:21:01 +00:00
#include <sys/stat.h>
2010-10-19 10:12:11 +00:00
#include <sys/times.h>
2010-10-18 12:23:46 +00:00
#include <sys/types.h>
#include <sys/wait.h>
2010-10-16 18:21:01 +00:00
#include <dirent.h>
2010-10-16 10:26:48 +00:00
#include <errno.h>
2010-10-28 17:56:33 +00:00
#include <fcntl.h>
2010-10-16 18:21:01 +00:00
#include <limits.h>
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
2010-10-16 18:21:01 +00:00
#include <stdlib.h>
2010-10-14 13:52:01 +00:00
#include <stdio.h>
2010-10-16 10:26:48 +00:00
#include <string.h>
#include <strings.h>
2010-10-20 15:34:01 +00:00
#include <syslog.h>
2010-11-04 13:43:57 +00:00
#include <math.h>
2010-10-20 15:34:01 +00:00
#include <time.h>
2010-10-16 10:26:48 +00:00
#include <unistd.h>
2011-02-25 07:57:11 +00:00
#define LUA_USE_APICHECK 1
2010-10-14 13:52:01 +00:00
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
2010-10-18 17:09:59 +00:00
/**
2010-11-04 13:43:57 +00:00
* The Lua part of lsyncd if compiled into the binary.
2010-10-18 17:09:59 +00:00
*/
extern const char runner_out[];
extern size_t runner_size;
2010-10-18 17:09:59 +00:00
extern const char defaults_out[];
extern size_t defaults_size;
/**
2010-11-28 08:13:05 +00:00
* Makes sure there is one monitor.
*/
2010-11-28 08:13:05 +00:00
#ifndef LSYNCD_WITH_INOTIFY
#ifndef LSYNCD_WITH_FANOTIFY
#ifndef LSYNCD_WITH_FSEVENTS
# error "need at least one notifcation system. please rerun ./configure"
#endif
2010-11-28 08:13:05 +00:00
#endif
#endif
/**
* All monitors supported by this Lsyncd.
*/
static char *monitors[] = {
2010-11-28 08:13:05 +00:00
#ifdef LSYNCD_WITH_INOTIFY
"inotify",
#endif
2010-11-28 08:13:05 +00:00
#ifdef LSYNCD_WITH_FANOTIFY
"fanotify",
#endif
2010-11-28 08:13:05 +00:00
#ifdef LSYNCD_WITH_FSEVENTS
"fsevents",
#endif
2010-11-28 08:13:05 +00:00
NULL,
};
2010-10-27 19:34:56 +00:00
/**
* configuration parameters
*/
struct settings settings = {
2010-11-03 21:02:14 +00:00
.log_file = NULL,
.log_syslog = false,
.log_ident = NULL,
.log_facility = LOG_USER,
2011-11-21 13:31:34 +00:00
.log_level = LOG_NOTICE,
2010-11-13 21:50:21 +00:00
.nodaemon = false,
2010-10-27 19:34:56 +00:00
};
2010-10-20 15:34:01 +00:00
/**
* True when lsyncd daemonized itself.
*/
2010-10-27 19:34:56 +00:00
static bool is_daemon = false;
/**
* The config file loaded by Lsyncd.
* Global so it is retained during HUPs
*/
char * lsyncd_config_file = NULL;
2010-10-27 19:34:56 +00:00
/**
2011-08-29 09:21:40 +00:00
* False after first time Lsyncd started up.
2012-02-15 11:15:32 +00:00
*
* Thus configuration error messages are written to stdout/stderr only on
2011-08-29 09:21:40 +00:00
* first start.
*
2012-02-15 11:15:32 +00:00
* All other resets (HUP or inotify OVERFLOW) run with implictly --insist
2011-08-29 09:21:40 +00:00
* turned on and thus Lsyncd not failing on a not responding target.
2010-10-27 19:34:56 +00:00
*/
2011-08-29 09:21:40 +00:00
static bool first_time = true;
2010-10-27 19:34:56 +00:00
2010-10-16 18:21:01 +00:00
/**
* Set to TERM or HUP in signal handler, when lsyncd should end or reset ASAP.
*/
volatile sig_atomic_t hup = 0;
volatile sig_atomic_t term = 0;
2010-10-16 10:26:48 +00:00
2010-10-19 10:12:11 +00:00
/**
* The kernels clock ticks per second.
*/
2012-02-15 11:15:32 +00:00
static long clocks_per_sec;
2010-10-19 10:12:11 +00:00
2010-10-24 21:35:29 +00:00
/**
* signal handler
*/
void
2012-02-15 12:47:58 +00:00
sig_child(int sig) {
// nothing
2010-10-24 21:35:29 +00:00
}
2010-11-14 09:11:09 +00:00
/**
* signal handler
*/
void
sig_handler(int sig)
{
switch (sig) {
2012-02-15 12:47:58 +00:00
case SIGTERM: term = 1; return;
case SIGHUP: hup = 1; return;
2010-11-14 09:11:09 +00:00
}
}
2010-12-06 16:33:32 +00:00
/**
* Non glibc builds need a real tms structure for times() call
*/
#ifdef __GLIBC__
static struct tms *dummy_tms = NULL;
#else
static struct tms _dummy_tms;
static struct tms *dummy_tms = &_dummy_tms;
#endif
/**
| Returns the absolute path of path.
| This is a wrapper to various C-Library differences.
*/
char *
get_realpath(const char * rpath) {
// uses c-library to get the absolute path
#ifdef __GLIBC__
// in case of GLIBC the task is easy.
2012-02-15 15:47:04 +00:00
return realpath(rpath, NULL);
#else
# warning having to use old style realpath()
// otherwise less so and requires PATH_MAX limit.
char buf[PATH_MAX];
char *asw = realpath(rpath, buf);
if (!asw) return NULL;
return s_strdup(asw);
#endif
}
2010-11-03 14:54:33 +00:00
/*****************************************************************************
* Logging
****************************************************************************/
2010-10-17 17:13:53 +00:00
/**
2012-02-15 11:15:32 +00:00
* A logging category
2010-10-17 17:13:53 +00:00
*/
2010-11-03 14:54:33 +00:00
struct logcat {
char *name;
int priority;
};
2010-10-17 17:13:53 +00:00
/**
2010-11-03 14:54:33 +00:00
* A table of all enabled logging categories.
* Sorted by first letter to have to do less comparisons;
2010-10-17 17:13:53 +00:00
*/
2010-11-03 14:54:33 +00:00
static struct logcat *logcats[26] = {0,};
2010-10-14 13:52:01 +00:00
2010-10-19 20:14:55 +00:00
/**
2012-02-15 11:15:32 +00:00
* Returns the positive priority if category is configured to be logged or -1.
2010-10-19 20:14:55 +00:00
*/
extern int
2010-11-03 14:54:33 +00:00
check_logcat(const char *name)
2010-10-19 20:14:55 +00:00
{
2010-11-03 14:54:33 +00:00
struct logcat *lc;
if (name[0] < 'A' || name[0] > 'Z') {
2011-11-21 13:31:34 +00:00
return 99;
2010-10-19 20:14:55 +00:00
}
2010-11-03 14:54:33 +00:00
lc = logcats[name[0]-'A'];
2012-02-15 12:47:58 +00:00
if (!lc) return 99;
2010-11-03 14:54:33 +00:00
while (lc->name) {
if (!strcmp(lc->name, name)) {
return lc->priority;
}
lc++;
}
2012-02-15 12:47:58 +00:00
2011-11-21 13:31:34 +00:00
return 99;
2010-10-19 20:14:55 +00:00
}
2010-10-18 17:09:59 +00:00
/**
2010-11-03 14:54:33 +00:00
* Adds a logging category
2010-11-03 21:02:14 +00:00
* @return true if OK.
2010-10-18 17:09:59 +00:00
*/
2010-11-03 21:02:14 +00:00
static bool
2010-11-03 14:54:33 +00:00
add_logcat(const char *name, int priority)
2010-10-18 17:09:59 +00:00
{
2012-02-15 11:15:32 +00:00
struct logcat *lc;
2010-11-03 16:04:11 +00:00
if (!strcmp("all", name)) {
2011-11-21 13:31:34 +00:00
settings.log_level = 99;
2010-11-03 21:02:14 +00:00
return true;
}
if (!strcmp("scarce", name)) {
2010-12-10 13:17:01 +00:00
settings.log_level = LOG_WARNING;
2010-11-03 21:02:14 +00:00
return true;
2010-11-03 16:04:11 +00:00
}
2010-11-03 14:54:33 +00:00
2012-02-15 11:15:32 +00:00
// categories must start with a capital letter.
if (name[0] < 'A' || name[0] > 'Z') return false;
2010-11-03 14:54:33 +00:00
if (!logcats[name[0]-'A']) {
2012-02-15 11:15:32 +00:00
// an empty capital letter
2010-11-03 14:54:33 +00:00
lc = logcats[name[0]-'A'] = s_calloc(2, sizeof(struct logcat));
} else {
2012-02-15 11:15:32 +00:00
int ll = 0; // length of letter list
// counts list length
2010-11-03 14:54:33 +00:00
for(lc = logcats[name[0]-'A']; lc->name; lc++) {
ll++;
}
2012-02-15 11:15:32 +00:00
// enlarges list
logcats[name[0]-'A'] =
s_realloc(logcats[name[0]-'A'], (ll + 2) * sizeof(struct logcat));
// go to list end
2010-11-03 21:02:14 +00:00
for(lc = logcats[name[0]-'A']; lc->name; lc++) {
if (!strcmp(name, lc->name)) {
2012-02-15 11:15:32 +00:00
// already there
2010-11-03 21:02:14 +00:00
return true;
}
}
2010-11-03 14:54:33 +00:00
}
lc->name = s_strdup(name);
lc->priority = priority;
2012-02-15 11:15:32 +00:00
// terminates the list
2010-11-03 14:54:33 +00:00
lc[1].name = NULL;
2010-11-03 21:02:14 +00:00
return true;
2010-10-18 17:09:59 +00:00
}
2010-10-20 18:33:17 +00:00
/**
2012-02-15 11:15:32 +00:00
* Logs a string.
2010-11-22 14:54:50 +00:00
*
* Do not call directly, but the macro logstring() in lsyncd.h
2010-10-20 18:33:17 +00:00
*
2010-11-03 14:54:33 +00:00
* @param priorty the priority of the log message
* @param cat the category
* @param message the log message
2010-10-20 18:33:17 +00:00
*/
2012-02-15 11:15:32 +00:00
extern void
2010-11-03 14:54:33 +00:00
logstring0(int priority, const char *cat, const char *message)
2010-10-20 18:33:17 +00:00
{
2011-08-29 09:21:40 +00:00
if (first_time) {
2012-02-15 11:15:32 +00:00
// lsyncd is in intial configuration phase.
// thus just print to normal stdout/stderr.
2010-11-03 21:02:14 +00:00
if (priority >= LOG_ERR) {
fprintf(stderr, "%s: %s\n", cat, message);
2010-11-03 14:54:33 +00:00
} else {
2010-11-03 21:02:14 +00:00
printf("%s: %s\n", cat, message);
2010-10-27 19:34:56 +00:00
}
return;
}
2012-02-15 11:15:32 +00:00
// writes on console if not daemonized
2010-10-20 18:33:17 +00:00
if (!is_daemon) {
char ct[255];
2012-02-15 11:15:32 +00:00
// gets current timestamp hour:minute:second
2010-10-20 18:33:17 +00:00
time_t mtime;
time(&mtime);
strftime(ct, sizeof(ct), "%T", localtime(&mtime));
2010-11-03 14:54:33 +00:00
FILE * flog = priority <= LOG_ERR ? stderr : stdout;
fprintf(flog, "%s %s: %s\n", ct, cat, message);
2010-10-20 18:33:17 +00:00
}
2012-02-15 11:15:32 +00:00
// writes to file if configured so
2010-11-03 21:02:14 +00:00
if (settings.log_file) {
FILE * flog = fopen(settings.log_file, "a");
2012-02-15 11:15:32 +00:00
// gets current timestamp day-time-year
2010-10-20 18:33:17 +00:00
char * ct;
time_t mtime;
time(&mtime);
ct = ctime(&mtime);
2012-02-15 11:15:32 +00:00
// cuts trailing linefeed
2010-10-20 18:33:17 +00:00
ct[strlen(ct) - 1] = 0;
if (flog == NULL) {
2012-02-15 11:15:32 +00:00
fprintf(stderr, "Cannot open logfile [%s]!\n",
2010-11-03 21:02:14 +00:00
settings.log_file);
2010-10-20 18:33:17 +00:00
exit(-1); // ERRNO
}
2010-11-14 09:11:09 +00:00
fprintf(flog, "%s %s: %s\n", ct, cat, message);
2010-10-20 18:33:17 +00:00
fclose(flog);
}
2012-02-15 11:15:32 +00:00
// sends to syslog if configured so
if (settings.log_syslog) syslog(priority, "%s, %s", cat, message);
2010-10-20 18:33:17 +00:00
return;
}
2010-11-04 13:43:57 +00:00
/**
2010-11-22 14:54:50 +00:00
* Lets the core print logmessages comfortably as formated string.
2010-11-04 13:43:57 +00:00
* This uses the lua_State for it easy string buffers only.
*/
2010-11-22 14:54:50 +00:00
extern void
2012-02-15 11:15:32 +00:00
printlogf0(lua_State *L,
2010-11-04 13:43:57 +00:00
int priority,
const char *cat,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
lua_pushvfstring(L, fmt, ap);
va_end(ap);
logstring0(priority, cat, luaL_checkstring(L, -1));
lua_pop(L, 1);
return;
}
2010-11-05 18:04:29 +00:00
2010-11-03 14:54:33 +00:00
/*****************************************************************************
* Simple memory management
2010-11-22 14:54:50 +00:00
* TODO: call the garbace collector in case of out of memory.
2010-11-03 14:54:33 +00:00
****************************************************************************/
2010-11-02 21:04:01 +00:00
/**
2010-11-03 14:54:33 +00:00
* "secured" calloc.
2010-11-02 21:04:01 +00:00
*/
2010-11-22 14:54:50 +00:00
extern void *
2010-11-03 14:54:33 +00:00
s_calloc(size_t nmemb, size_t size)
{
void *r = calloc(nmemb, size);
if (r == NULL) {
logstring0(LOG_ERR, "Error", "Out of memory!");
2012-02-15 11:15:32 +00:00
exit(-1); // ERRNO
}
2010-11-03 14:54:33 +00:00
return r;
}
/**
* "secured" malloc. the deamon shall kill itself
* in case of out of memory.
*/
2010-11-22 14:54:50 +00:00
extern void *
2010-11-03 14:54:33 +00:00
s_malloc(size_t size)
{
void *r = malloc(size);
if (r == NULL) {
logstring0(LOG_ERR, "Error", "Out of memory!");
exit(-1); // ERRNO
}
return r;
}
/**
* "secured" realloc.
*/
2010-11-22 14:54:50 +00:00
extern void *
2010-11-03 14:54:33 +00:00
s_realloc(void *ptr, size_t size)
2010-11-02 21:04:01 +00:00
{
2010-11-03 14:54:33 +00:00
void *r = realloc(ptr, size);
if (r == NULL) {
logstring0(LOG_ERR, "Error", "Out of memory!");
exit(-1);
2010-11-02 21:04:01 +00:00
}
2010-11-03 14:54:33 +00:00
return r;
2010-11-02 21:04:01 +00:00
}
2010-11-03 14:54:33 +00:00
/**
* "secured" strdup.
*/
2010-11-22 14:54:50 +00:00
extern char *
2010-11-03 14:54:33 +00:00
s_strdup(const char *src)
{
char *s = strdup(src);
if (s == NULL) {
logstring0(LOG_ERR, "Error", "Out of memory!");
exit(-1); // ERRNO
}
return s;
}
2010-10-18 17:09:59 +00:00
2010-11-17 11:14:36 +00:00
/*****************************************************************************
* Pipes management
****************************************************************************/
/**
* A child process gets text piped longer than on
* write() can manage.
*/
struct pipemsg {
2012-02-15 12:47:58 +00:00
char *text; // message to send
int tlen; // length of text
int pos; // position in message
2010-11-17 11:14:36 +00:00
};
/**
2012-02-15 11:15:32 +00:00
* Called by the core whenever a pipe becomes
* writeable again
2010-11-17 11:14:36 +00:00
*/
2012-02-15 11:15:32 +00:00
static void
pipe_writey(lua_State *L, struct observance *observance)
{
int fd = observance->fd;
struct pipemsg *pm = (struct pipemsg *) observance->extra;
int len = write(fd, pm->text + pm->pos, pm->tlen - pm->pos);
pm->pos += len;
if (len < 0) {
logstring("Normal", "broken pipe.");
nonobserve_fd(fd);
} else if (pm->pos >= pm->tlen) {
2011-01-20 18:55:46 +00:00
logstring("Exec", "finished pipe.");
nonobserve_fd(fd);
}
}
/**
2012-02-15 11:15:32 +00:00
* Called when cleaning up a pipe
*/
static void
2012-02-15 11:15:32 +00:00
pipe_tidy(struct observance *observance)
{
struct pipemsg *pm = (struct pipemsg *) observance->extra;
close(observance->fd);
free(pm->text);
free(pm);
}
2010-11-17 11:14:36 +00:00
/*****************************************************************************
* helper routines.
****************************************************************************/
2010-12-01 12:19:17 +00:00
/**
* Dummy variable whos address is used as the cores index in the lua registry
* to the lua runners function table in the lua registry.
*/
static int runner;
/**
* Dummy variable whos address is used as the cores index n the lua registry
* to the lua runners error handler.
*/
static int callError;
2010-11-12 15:39:43 +00:00
/**
* Sets the close-on-exit flag for an fd
*/
2010-11-22 14:54:50 +00:00
extern void
2010-11-12 15:39:43 +00:00
close_exec_fd(int fd)
{
int flags;
flags = fcntl(fd, F_GETFD);
if (flags == -1) {
logstring("Error", "cannot get descriptor flags!");
exit(-1); // ERRNO
}
2010-11-12 15:39:43 +00:00
flags |= FD_CLOEXEC;
if (fcntl(fd, F_SETFD, flags) == -1) {
logstring("Error", "cannot set descripptor flags!");
exit(-1); // ERRNO
}
}
/**
* Sets the non-blocking flag for an fd
*/
2010-11-22 14:54:50 +00:00
extern void
2010-11-12 15:39:43 +00:00
non_block_fd(int fd)
{
int flags;
flags = fcntl(fd, F_GETFL);
2012-02-15 12:47:58 +00:00
2010-11-12 15:39:43 +00:00
if (flags == -1) {
logstring("Error", "cannot get status flags!");
exit(-1); // ERRNO
}
2012-02-15 12:47:58 +00:00
flags |= O_NONBLOCK;
2012-02-15 12:47:58 +00:00
2010-11-12 15:39:43 +00:00
if (fcntl(fd, F_SETFL, flags) == -1) {
logstring("Error", "cannot set status flags!");
exit(-1); // ERRNO
}
}
/**
2010-11-17 11:14:36 +00:00
* Writes a pid file.
2010-11-12 15:39:43 +00:00
*/
2010-11-22 14:54:50 +00:00
static void
2010-11-17 11:14:36 +00:00
write_pidfile(lua_State *L, const char *pidfile) {
FILE* f = fopen(pidfile, "w");
if (!f) {
printlogf(L, "Error", "Cannot write pidfile; '%s'", pidfile);
exit(-1); // ERRNO
}
fprintf(f, "%i\n", getpid());
2012-02-15 11:15:32 +00:00
fclose(f);
2010-11-17 11:14:36 +00:00
}
2010-11-12 15:39:43 +00:00
2010-12-01 12:19:17 +00:00
/*****************************************************************************
* Observances
****************************************************************************/
/**
* List of file descriptor watches.
*/
static struct observance * observances = NULL;
static int observances_len = 0;
static int observances_size = 0;
/**
* List of file descriptors to nonobserve.
* While working for the oberver lists, it may
* not be altered, thus nonobserve stores here the
* actions that will be delayed.
*/
static int *nonobservances = NULL;
static int nonobservances_len = 0;
static int nonobservances_size = 0;
/**
* true while the observances list is being handled.
*/
static bool observance_action = false;
/**
* Core watches a filedescriptor to become ready,
* one of read_ready or write_ready may be zero
*/
extern void
2012-02-15 11:15:32 +00:00
observe_fd(int fd,
2010-12-01 12:19:17 +00:00
void (*ready) (lua_State *, struct observance *),
void (*writey)(lua_State *, struct observance *),
void (*tidy) (struct observance *),
void *extra)
{
int pos;
2012-02-15 11:15:32 +00:00
// looks if the fd is already there as pos or
// stores the position to insert the new fd in pos
2010-12-01 12:19:17 +00:00
for(pos = 0; pos < observances_len; pos++) {
if (fd <= observances[pos].fd) {
break;
}
}
if (pos < observances_len && observances[pos].fd == fd) {
2012-02-15 11:15:32 +00:00
// just updates an existing observance
logstring("Masterloop", "updating fd observance");
2010-12-01 12:19:17 +00:00
observances[pos].ready = ready;
observances[pos].writey = writey;
observances[pos].tidy = tidy;
observances[pos].extra = extra;
return;
}
if (observance_action) {
// TODO
2012-02-15 11:15:32 +00:00
logstring("Error",
2011-01-20 18:55:46 +00:00
"internal, New observances in ready/writey handlers not yet supported");
2010-12-01 12:19:17 +00:00
exit(-1); // ERRNO
}
if (!tidy) {
2012-02-15 11:15:32 +00:00
logstring("Error",
2010-12-01 12:19:17 +00:00
"internal, tidy() in observe_fd() must not be NULL.");
exit(-1); // ERRNO
}
if (observances_len + 1 > observances_size) {
observances_size = observances_len + 1;
2012-02-15 11:15:32 +00:00
observances = s_realloc(observances,
2010-12-01 12:19:17 +00:00
observances_size * sizeof(struct observance));
}
2012-02-15 11:15:32 +00:00
memmove(observances + pos + 1, observances + pos,
2010-12-01 12:19:17 +00:00
(observances_len - pos) * (sizeof(struct observance)));
observances_len++;
observances[pos].fd = fd;
observances[pos].ready = ready;
observances[pos].writey = writey;
observances[pos].tidy = tidy;
observances[pos].extra = extra;
}
/**
* Makes the core to no longer watch a filedescriptor.
2010-12-01 12:19:17 +00:00
*/
extern void
nonobserve_fd(int fd)
{
int pos;
if (observance_action) {
2012-02-15 11:15:32 +00:00
// this function is called through a ready/writey handler
// while the core works through the observance list, thus
// it does not alter the list, but stores this actions
// on a stack
2010-12-01 12:19:17 +00:00
nonobservances_len++;
if (nonobservances_len > nonobservances_size) {
nonobservances_size = nonobservances_len;
2012-02-15 11:15:32 +00:00
nonobservances = s_realloc(nonobservances, nonobservances_size * sizeof(int));
2010-12-01 12:19:17 +00:00
}
nonobservances[nonobservances_len - 1] = fd;
return;
}
2012-02-15 11:15:32 +00:00
// looks for the fd
2010-12-01 12:19:17 +00:00
for(pos = 0; pos < observances_len; pos++) {
if (observances[pos].fd == fd) {
break;
}
}
if (pos >= observances_len) {
2012-02-15 11:15:32 +00:00
logstring("Error",
2010-12-01 12:19:17 +00:00
"internal fail, not observance file descriptor in nonobserve");
exit(-1); //ERRNO
}
2012-02-15 11:15:32 +00:00
// tidies up the observance
observances[pos].tidy(observances + pos);
// and moves the list down
memmove(observances + pos, observances + pos + 1,
2010-12-01 12:19:17 +00:00
(observances_len - pos) * (sizeof(struct observance)));
observances_len--;
}
/**
* A user observance became read-ready
*/
static void
user_obs_ready(lua_State *L, struct observance *obs)
{
int fd = obs->fd;
2012-02-15 11:15:32 +00:00
// pushes the ready table on table
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) user_obs_ready);
lua_gettable(L, LUA_REGISTRYINDEX);
2012-02-15 11:15:32 +00:00
// pushes the error handler
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) &callError);
lua_gettable(L, LUA_REGISTRYINDEX);
2012-02-15 11:15:32 +00:00
// pushed the user func
2010-12-01 12:19:17 +00:00
lua_pushnumber(L, fd);
lua_gettable(L, -3);
2012-02-15 11:15:32 +00:00
// gives the ufunc the fd
2010-12-01 12:19:17 +00:00
lua_pushnumber(L, fd);
2012-02-15 11:15:32 +00:00
// calls the user function
if (lua_pcall(L, 1, 0, -3)) exit(-1); // ERRNO
2010-12-01 12:19:17 +00:00
lua_pop(L, 2);
}
/**
* A user observance became write-ready
*/
static void
user_obs_writey(lua_State *L, struct observance *obs)
{
int fd = obs->fd;
2012-02-15 11:15:32 +00:00
// pushes the writey table on table
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) user_obs_writey);
lua_gettable(L, LUA_REGISTRYINDEX);
2012-02-15 11:15:32 +00:00
// pushes the error handler
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) &callError);
lua_gettable(L, LUA_REGISTRYINDEX);
2012-02-15 11:15:32 +00:00
// pushes the user func
2010-12-01 12:19:17 +00:00
lua_pushnumber(L, fd);
lua_gettable(L, -3);
2012-02-15 11:15:32 +00:00
// gives the user func the fd
2010-12-01 12:19:17 +00:00
lua_pushnumber(L, fd);
2012-02-15 11:15:32 +00:00
// calls the user function
if (lua_pcall(L, 1, 0, -3)) exit(-1); // ERRNO
2010-12-01 12:19:17 +00:00
lua_pop(L, 2);
}
/**
* Tidies up a user observance
* TODO - give the user a chance to do something in that case!
*/
static void
user_obs_tidy(struct observance *obs)
{
close(obs->fd);
}
2010-11-12 15:39:43 +00:00
2010-10-18 09:02:51 +00:00
/*****************************************************************************
* Library calls for lsyncd.lua
2012-02-15 11:15:32 +00:00
*
* These are as minimal as possible glues to the operating system needed for
2010-10-18 09:02:51 +00:00
* lsyncd operation.
****************************************************************************/
2010-10-17 15:24:55 +00:00
static void daemonize(lua_State *L);
2010-12-10 13:28:10 +00:00
int l_stackdump(lua_State* L);
2010-11-04 13:43:57 +00:00
2010-10-20 15:34:01 +00:00
/**
2010-10-20 18:33:17 +00:00
* Logs a message.
2010-10-20 15:34:01 +00:00
*
* @param loglevel (Lua stack) loglevel of massage
* @param string (Lua stack) the string to log
*/
2012-02-15 11:15:32 +00:00
static int
2010-10-20 15:34:01 +00:00
l_log(lua_State *L)
{
2012-02-15 11:15:32 +00:00
const char * cat; // log category
const char * message; // log message
int priority; // log priority
2010-11-03 14:54:33 +00:00
cat = luaL_checkstring(L, 1);
priority = check_logcat(cat);
/* skips filtered messages */
2012-02-15 11:15:32 +00:00
if (priority > settings.log_level) return 0;
2010-11-03 14:54:33 +00:00
2010-11-04 13:43:57 +00:00
{
// replace non string values
int i;
int top = lua_gettop(L);
2012-02-15 11:15:32 +00:00
for (i = 1; i <= top; i++) {
2010-11-04 13:43:57 +00:00
int t = lua_type(L, i);
switch (t) {
case LUA_TTABLE:
lua_pushfstring(L, "(Table: %p)", lua_topointer(L, i));
lua_replace(L, i);
break;
case LUA_TBOOLEAN:
if (lua_toboolean(L, i)) {
lua_pushstring(L, "(true)");
} else {
lua_pushstring(L, "(false)");
}
lua_replace(L, i);
break;
case LUA_TUSERDATA:
{
2012-02-15 11:15:32 +00:00
clock_t *c = (clock_t *) luaL_checkudata(L, i, "Lsyncd.jiffies");
double d = (*c);
d /= clocks_per_sec;
lua_pushfstring(L, "(Timestamp: %f)", d);
lua_replace(L, i);
}
2012-02-15 12:47:58 +00:00
break;
2010-11-20 13:22:47 +00:00
case LUA_TNIL:
lua_pushstring(L, "(nil)");
lua_replace(L, i);
break;
2010-11-04 13:43:57 +00:00
}
}
}
2012-02-15 11:15:32 +00:00
// concates if there is more than one string parameter
2010-11-02 17:07:42 +00:00
lua_concat(L, lua_gettop(L) - 1);
2010-10-20 15:34:01 +00:00
message = luaL_checkstring(L, 2);
2010-11-03 14:54:33 +00:00
logstring0(priority, cat, message);
2010-10-20 15:34:01 +00:00
return 0;
}
2010-10-19 10:12:11 +00:00
/**
2012-02-15 11:15:32 +00:00
* Returns (on Lua stack) the current kernels
2010-10-27 19:34:56 +00:00
* clock state (jiffies)
2010-10-19 10:12:11 +00:00
*/
extern int
2012-02-15 11:15:32 +00:00
l_now(lua_State *L)
2010-10-19 10:12:11 +00:00
{
clock_t *j = lua_newuserdata(L, sizeof(clock_t));
luaL_getmetatable(L, "Lsyncd.jiffies");
lua_setmetatable(L, -2);
2010-12-06 16:33:32 +00:00
*j = times(dummy_tms);
2010-10-19 10:12:11 +00:00
return 1;
}
2010-10-28 17:56:33 +00:00
2010-10-17 17:13:53 +00:00
/**
2010-10-18 09:02:51 +00:00
* Executes a subprocess. Does not wait for it to return.
2012-02-15 11:15:32 +00:00
*
2010-10-18 09:02:51 +00:00
* @param (Lua stack) Path to binary to call
* @params (Lua stack) list of string as arguments
2012-02-15 11:15:32 +00:00
* or "<" in which case the next argument is a string that will be piped
2010-11-12 14:05:10 +00:00
* on stdin. the arguments will follow that one.
2010-11-11 19:52:20 +00:00
*
2010-10-18 09:02:51 +00:00
* @return (Lua stack) the pid on success, 0 on failure.
2010-10-17 17:13:53 +00:00
*/
static int
2010-10-18 09:02:51 +00:00
l_exec(lua_State *L)
2010-10-17 17:13:53 +00:00
{
2012-02-15 11:15:32 +00:00
const char *binary = luaL_checkstring(L, 1); // the binary to call
int argc = lua_gettop(L) - 1; // number of arguments
pid_t pid; // the pid spawned
int li = 1; // the arguments position in the lua arguments
char const *pipe_text = NULL; // the pipe to text
size_t pipe_len = 0; // the pipes length
char const **argv; // the arguments
int pipefd[2]; // pipe file descriptors
int i;
// expands tables if there are any, removes nils
2012-02-15 11:15:32 +00:00
for(i = 1; i <= lua_gettop(L); i++) {
if (lua_isnil(L, i)) {
lua_remove(L, i);
i--;
argc--;
continue;
}
2012-02-15 11:15:32 +00:00
if (lua_istable(L, i)) {
int tlen;
int it;
lua_checkstack(L, lua_gettop(L) + lua_objlen(L, i) + 1);
// move table to top of stack
2012-02-15 11:15:32 +00:00
lua_pushvalue(L, i);
lua_remove(L, i);
argc--;
tlen = lua_objlen(L, -1);
for (it = 1; it <= tlen; it++) {
lua_pushinteger(L, it);
lua_gettable(L, -2);
lua_insert(L,i);
i++;
argc++;
}
2012-02-15 11:15:32 +00:00
i--;
lua_pop(L, 1);
}
}
2012-02-15 11:15:32 +00:00
2012-02-15 12:47:58 +00:00
// writes a log message, prepares the message only if actually needed.
2011-11-21 13:31:34 +00:00
if (check_logcat("Exec") <= settings.log_level) {
2011-02-24 16:55:16 +00:00
lua_checkstack(L, lua_gettop(L) + argc * 3 + 2);
2010-11-05 18:04:29 +00:00
lua_pushvalue(L, 1);
for(i = 1; i <= argc; i++) {
lua_pushstring(L, " [");
lua_pushvalue(L, i + 1);
lua_pushstring(L, "]");
}
lua_concat(L, 3 * argc + 1);
logstring0(LOG_DEBUG, "Exec", luaL_checkstring(L, -1));
lua_pop(L, 1);
}
2010-11-12 14:05:10 +00:00
if (argc >= 2 && !strcmp(luaL_checkstring(L, 2), "<")) {
2012-02-15 12:47:58 +00:00
// pipes something into stdin
if (!lua_isstring(L, 3)) {
logstring("Error", "in spawn(), expected a string after pipe '<'");
exit(-1); // ERRNO
}
pipe_text = lua_tolstring(L, 3, &pipe_len);
2011-01-20 18:55:46 +00:00
if (strlen(pipe_text) > 0) {
2012-02-15 12:47:58 +00:00
// creates the pipe
2011-01-20 18:55:46 +00:00
if (pipe(pipefd) == -1) {
logstring("Error", "cannot create a pipe!");
exit(-1); // ERRNO
}
2012-02-15 12:47:58 +00:00
// always closes the write end for child processes
2011-01-20 18:55:46 +00:00
close_exec_fd(pipefd[1]);
2012-02-15 12:47:58 +00:00
// sets the write end on non-blocking
2011-01-20 18:55:46 +00:00
non_block_fd(pipefd[1]);
} else {
pipe_text = NULL;
2010-11-12 14:05:10 +00:00
}
argc -= 2;
li += 2;
}
2012-02-15 11:15:32 +00:00
// prepares the arguments
argv = s_calloc(argc + 2, sizeof(char *));
argv[0] = binary;
for(i = 1; i <= argc; i++) {
argv[i] = luaL_checkstring(L, i + li);
2010-10-17 20:26:37 +00:00
}
2012-02-15 11:15:32 +00:00
argv[i] = NULL;
2010-10-17 20:26:37 +00:00
pid = fork();
if (pid == 0) {
2012-02-15 11:15:32 +00:00
// replaces stdin for pipes
if (pipe_text) dup2(pipefd[0], STDIN_FILENO);
// if lsyncd runs as a daemon and has a logfile it will redirect
// stdout/stderr of child processes to the logfile.
2010-11-03 21:02:14 +00:00
if (is_daemon && settings.log_file) {
if (!freopen(settings.log_file, "a", stdout)) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error", "cannot redirect stdout to '%s'.", settings.log_file);
2010-10-28 17:56:33 +00:00
}
2010-11-03 21:02:14 +00:00
if (!freopen(settings.log_file, "a", stderr)) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error", "cannot redirect stderr to '%s'.", settings.log_file);
2010-10-28 17:56:33 +00:00
}
}
2010-10-17 20:26:37 +00:00
execv(binary, (char **)argv);
2012-02-15 11:15:32 +00:00
// in a sane world execv does not return!
2010-11-03 14:54:33 +00:00
printlogf(L, "Error", "Failed executing [%s]!", binary);
2010-10-17 20:26:37 +00:00
exit(-1); // ERRNO
2010-10-17 17:13:53 +00:00
}
2010-11-12 14:05:10 +00:00
if (pipe_text) {
2010-11-12 15:39:43 +00:00
int len;
2012-02-15 11:15:32 +00:00
// first closes read-end of pipe, this is for child process only
2010-11-12 14:05:10 +00:00
close(pipefd[0]);
2012-02-15 11:15:32 +00:00
// starts filling the pipe
len = write(pipefd[1], pipe_text, pipe_len);
2010-11-12 15:39:43 +00:00
if (len < 0) {
2010-11-12 20:43:27 +00:00
logstring("Normal", "immediatly broken pipe.");
2011-01-20 18:55:46 +00:00
close(pipefd[1]);
} else if (len == pipe_len) {
2012-02-15 11:15:32 +00:00
// usual and best case, the pipe accepted all input -> close
2010-11-12 15:39:43 +00:00
close(pipefd[1]);
logstring("Exec", "one-sweeped pipe");
} else {
struct pipemsg *pm;
logstring("Exec", "adding pipe observance");
pm = s_calloc(1, sizeof(struct pipemsg));
pm->text = s_calloc(pipe_len + 1, sizeof(char*));
memcpy(pm->text, pipe_text, pipe_len + 1);
pm->tlen = pipe_len;
pm->pos = len;
observe_fd(pipefd[1], NULL, pipe_writey, pipe_tidy, pm);
2010-11-12 15:39:43 +00:00
}
2010-11-12 14:05:10 +00:00
}
2010-10-17 20:26:37 +00:00
free(argv);
2010-10-18 09:02:51 +00:00
lua_pushnumber(L, pid);
return 1;
2010-10-17 17:13:53 +00:00
}
2010-10-16 10:26:48 +00:00
/**
2010-10-16 18:21:01 +00:00
* Converts a relative directory path to an absolute.
2012-02-15 11:15:32 +00:00
*
* @param dir: a relative path to directory
* @return the absolute path of directory
2010-10-16 10:26:48 +00:00
*/
2010-10-17 15:24:55 +00:00
static int
2010-11-06 15:08:17 +00:00
l_realdir(lua_State *L)
2010-10-17 15:24:55 +00:00
{
2010-10-16 18:21:01 +00:00
luaL_Buffer b;
const char *rdir = luaL_checkstring(L, 1);
char *adir = get_realpath(rdir);
2012-02-15 11:15:32 +00:00
if (!adir) {
2010-11-03 14:54:33 +00:00
printlogf(L, "Error", "failure getting absolute path of [%s]", rdir);
2010-10-16 18:21:01 +00:00
return 0;
}
2012-02-15 12:47:58 +00:00
2010-10-16 18:21:01 +00:00
{
2012-02-15 11:15:32 +00:00
// makes sure its a directory
2010-10-16 18:21:01 +00:00
struct stat st;
if (stat(adir, &st)) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error",
2012-02-15 12:47:58 +00:00
"cannot get absolute path of dir '%s': %s", rdir, strerror(errno));
free(adir);
2010-10-28 17:56:33 +00:00
return 0;
}
2010-10-16 18:21:01 +00:00
if (!S_ISDIR(st.st_mode)) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error",
2012-02-15 12:47:58 +00:00
"cannot get absolute path of dir '%s': is not a directory", rdir);
free(adir);
2010-10-16 18:21:01 +00:00
return 0;
}
}
2012-02-15 11:15:32 +00:00
// returns absolute path with a concated '/'
2010-10-16 18:21:01 +00:00
luaL_buffinit(L, &b);
luaL_addstring(&b, adir);
2010-10-16 18:21:01 +00:00
luaL_addchar(&b, '/');
luaL_pushresult(&b);
free(adir);
2010-10-16 18:21:01 +00:00
return 1;
}
2010-10-17 15:24:55 +00:00
/**
* Dumps the LUA stack. For debugging purposes.
*/
2010-12-10 13:28:10 +00:00
int
2010-10-18 10:26:15 +00:00
l_stackdump(lua_State* L)
2010-10-17 15:24:55 +00:00
{
int i;
2010-10-18 10:26:15 +00:00
int top = lua_gettop(L);
2010-11-03 14:54:33 +00:00
printlogf(L, "Debug", "total in stack %d",top);
2012-02-15 11:15:32 +00:00
for (i = 1; i <= top; i++) {
2010-10-18 10:26:15 +00:00
int t = lua_type(L, i);
2010-10-17 15:24:55 +00:00
switch (t) {
2010-10-20 15:34:01 +00:00
case LUA_TSTRING:
2012-02-15 11:15:32 +00:00
printlogf(L, "Debug", "%d string: '%s'", i, lua_tostring(L, i));
2010-10-20 15:34:01 +00:00
break;
case LUA_TBOOLEAN:
2012-02-15 11:15:32 +00:00
printlogf(L, "Debug", "%d boolean %s", i, lua_toboolean(L, i) ? "true" : "false");
2010-10-20 15:34:01 +00:00
break;
2012-02-15 11:15:32 +00:00
case LUA_TNUMBER:
printlogf(L, "Debug", "%d number: %g", i, lua_tonumber(L, i));
2010-10-20 15:34:01 +00:00
break;
2012-02-15 11:15:32 +00:00
default:
printlogf(L, "Debug", "%d %s", i, lua_typename(L, t));
2010-10-20 15:34:01 +00:00
break;
2010-10-17 15:24:55 +00:00
}
2010-10-17 20:26:37 +00:00
}
2010-10-17 15:24:55 +00:00
return 0;
}
2010-10-16 18:21:01 +00:00
/**
2010-11-17 18:52:55 +00:00
* Reads the directories entries.
2010-11-20 14:21:55 +00:00
*
2010-10-18 09:02:51 +00:00
* @param (Lua stack) absolute path to directory.
* @return (Lua stack) a table of directory names.
2012-02-15 11:15:32 +00:00
* names are keys, values are boolean
2010-11-17 18:52:55 +00:00
* true on dirs.
2010-10-16 18:21:01 +00:00
*/
2010-10-17 15:24:55 +00:00
static int
2010-11-17 18:52:55 +00:00
l_readdir (lua_State *L)
2010-10-17 15:24:55 +00:00
{
2010-10-16 18:21:01 +00:00
const char * dirname = luaL_checkstring(L, 1);
DIR *d;
d = opendir(dirname);
2010-10-17 20:26:37 +00:00
if (d == NULL) {
2010-11-03 14:54:33 +00:00
printlogf(L, "Error", "cannot open dir [%s].", dirname);
2010-10-17 20:26:37 +00:00
return 0;
2010-10-16 18:21:01 +00:00
}
2012-02-15 11:15:32 +00:00
2010-10-16 18:21:01 +00:00
lua_newtable(L);
2010-11-14 09:11:09 +00:00
while (!hup && !term) {
2010-10-16 18:21:01 +00:00
struct dirent *de = readdir(d);
bool isdir;
2012-02-15 11:15:32 +00:00
if (de == NULL) break; // finished
2010-11-17 18:52:55 +00:00
2012-02-15 11:15:32 +00:00
// ignores . and ..
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) continue;
2010-11-17 18:52:55 +00:00
2010-10-16 18:21:01 +00:00
if (de->d_type == DT_UNKNOWN) {
2012-02-15 11:15:32 +00:00
// must call stat on some systems :-/
2010-11-17 18:52:55 +00:00
char *entry = s_malloc(strlen(dirname) + strlen(de->d_name) + 2);
2010-10-16 18:21:01 +00:00
struct stat st;
2010-11-17 18:52:55 +00:00
strcpy(entry, dirname);
strcat(entry, "/");
strcat(entry, de->d_name);
lstat(entry, &st);
2010-10-16 18:21:01 +00:00
isdir = S_ISDIR(st.st_mode);
2010-11-17 18:52:55 +00:00
free(entry);
2010-10-16 18:21:01 +00:00
} else {
2012-02-15 11:15:32 +00:00
// readdir can trusted
2010-10-16 18:21:01 +00:00
isdir = de->d_type == DT_DIR;
}
2012-02-15 11:15:32 +00:00
// adds this entry to the Lua table
2010-10-16 18:21:01 +00:00
lua_pushstring(L, de->d_name);
2010-11-17 18:52:55 +00:00
lua_pushboolean(L, isdir);
2010-10-16 18:21:01 +00:00
lua_settable(L, -3);
}
2010-11-20 22:54:20 +00:00
closedir(d);
2010-10-16 18:21:01 +00:00
return 1;
}
2010-10-16 10:26:48 +00:00
2010-10-18 12:23:46 +00:00
/**
* Terminates lsyncd daemon.
2012-02-15 11:15:32 +00:00
*
2010-10-18 12:23:46 +00:00
* @param (Lua stack) exitcode for lsyncd.
*
* Does not return.
*/
2012-02-15 11:15:32 +00:00
int
l_terminate(lua_State *L)
2010-10-18 12:23:46 +00:00
{
int exitcode = luaL_checkinteger(L, 1);
exit(exitcode);
return 0;
}
2010-10-27 19:34:56 +00:00
/**
* Configures core parameters.
2012-02-15 11:15:32 +00:00
*
2010-10-27 19:34:56 +00:00
* @param (Lua stack) a string for a core configuratoin
2012-02-15 11:15:32 +00:00
* @param (Lua stack) --differes depending on string.
2010-10-27 19:34:56 +00:00
*/
2012-02-15 11:15:32 +00:00
static int
l_configure(lua_State *L)
2010-10-27 19:34:56 +00:00
{
const char * command = luaL_checkstring(L, 1);
2010-11-06 10:33:26 +00:00
if (!strcmp(command, "running")) {
2012-02-15 11:15:32 +00:00
// set by runner after first initialize
// from this on log to configurated log end instead of
// stdout/stderr
2011-08-29 09:21:40 +00:00
first_time = false;
if (!settings.nodaemon && !settings.log_file) {
settings.log_syslog = true;
2012-02-15 11:15:32 +00:00
const char * log_ident = settings.log_ident ? settings.log_ident : "lsyncd";
openlog(log_ident, 0, settings.log_facility);
}
2010-11-14 09:11:09 +00:00
if (!settings.nodaemon && !is_daemon) {
2010-11-20 13:22:47 +00:00
logstring("Debug", "daemonizing now.");
daemonize(L);
2010-11-13 21:50:21 +00:00
}
if (settings.pidfile) write_pidfile(L, settings.pidfile);
2010-11-13 21:50:21 +00:00
} else if (!strcmp(command, "nodaemon")) {
settings.nodaemon = true;
2010-11-13 21:50:21 +00:00
} else if (!strcmp(command, "logfile")) {
const char * file = luaL_checkstring(L, 2);
2012-02-15 11:15:32 +00:00
if (settings.log_file) free(settings.log_file);
2010-11-13 21:50:21 +00:00
settings.log_file = s_strdup(file);
2010-11-17 11:14:36 +00:00
} else if (!strcmp(command, "pidfile")) {
const char * file = luaL_checkstring(L, 2);
2012-02-15 11:15:32 +00:00
if (settings.pidfile) free(settings.pidfile);
2010-11-17 11:14:36 +00:00
settings.pidfile = s_strdup(file);
} else if (!strcmp(command, "logfacility")) {
if (lua_isstring(L, 2)) {
const char * fname = luaL_checkstring(L, 2);
int i;
for(i = 0; facilitynames[i].c_name; i++) {
2012-02-15 11:15:32 +00:00
if (!strcasecmp(fname, facilitynames[i].c_name)) break;
}
if (!facilitynames[i].c_name) {
printlogf(L, "Error", "Logging facility '%s' unknown.", fname);
exit(-1); //ERRNO
}
settings.log_facility = facilitynames[i].c_val;
} else if (lua_isnumber(L, 2)) {
settings.log_facility = luaL_checknumber(L, 2);
} else {
printlogf(L, "Error", "Logging facility must be a number or string");
exit(-1); // ERRNO;
}
} else if (!strcmp(command, "logident")) {
const char * ident = luaL_checkstring(L, 2);
2012-02-15 11:15:32 +00:00
if (settings.log_ident) free(settings.log_ident);
settings.log_ident = s_strdup(ident);
2010-10-27 19:34:56 +00:00
} else {
printlogf(L, "Error", "Internal error, unknown parameter in l_configure(%s)", command);
2010-10-27 19:34:56 +00:00
exit(-1); //ERRNO
}
2010-10-27 19:34:56 +00:00
return 0;
}
2010-12-01 12:19:17 +00:00
/**
* Allows the user to observe filedescriptors
*
2012-02-15 11:15:32 +00:00
* @param (Lua stack) filedescriptor.
2010-12-01 12:19:17 +00:00
* @param (Lua stack) function to call on ready
* @param (Lua stack) function to call on writey
*/
2012-02-15 11:15:32 +00:00
static int
2010-12-01 12:19:17 +00:00
l_observe_fd(lua_State *L)
{
int fd = luaL_checknumber(L, 1);
bool ready = false;
bool writey = false;
2012-02-15 11:15:32 +00:00
// Stores the user function in the lua registry.
// It uses the address of the cores ready/write functions
// for the user as key
2010-12-01 12:19:17 +00:00
if (!lua_isnoneornil(L, 2)) {
lua_pushlightuserdata(L, (void *) user_obs_ready);
lua_gettable(L, LUA_REGISTRYINDEX);
if lua_isnil(L, -1) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushlightuserdata(L, (void *) user_obs_ready);
lua_pushvalue(L, -2);
lua_settable(L, LUA_REGISTRYINDEX);
}
lua_pushnumber(L, fd);
lua_pushvalue(L, 2);
lua_settable(L, -3);
lua_pop(L, 1);
ready = true;
}
if (!lua_isnoneornil(L, 3)) {
lua_pushlightuserdata(L, (void *) user_obs_writey);
lua_gettable(L, LUA_REGISTRYINDEX);
if lua_isnil(L, -1) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushlightuserdata(L, (void *) user_obs_writey);
lua_pushvalue(L, -2);
lua_settable(L, LUA_REGISTRYINDEX);
}
lua_pushnumber(L, fd);
lua_pushvalue(L, 3);
lua_settable(L, -3);
lua_pop(L, 1);
writey = true;
}
/* tells the core to watch the fd */
2012-02-15 11:15:32 +00:00
observe_fd(fd,
ready ? user_obs_ready : NULL,
2010-12-01 12:19:17 +00:00
writey ? user_obs_writey : NULL,
user_obs_tidy,
NULL);
return 0;
}
/**
* Removes a user observance
2012-02-15 11:15:32 +00:00
* @param (Lua stack) filedescriptor.
2010-12-01 12:19:17 +00:00
*/
extern int
l_nonobserve_fd(lua_State *L)
{
int fd = luaL_checknumber(L, 1);
2012-02-15 11:15:32 +00:00
// removes the read function
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) user_obs_ready);
lua_gettable(L, LUA_REGISTRYINDEX);
if (!lua_isnil(L, -1)) {
lua_pushnumber(L, fd);
lua_pushnil(L);
lua_settable(L, -2);
}
lua_pop(L, 1);
2012-02-15 11:15:32 +00:00
2010-12-01 12:19:17 +00:00
lua_pushlightuserdata(L, (void *) user_obs_writey);
lua_gettable(L, LUA_REGISTRYINDEX);
if (!lua_isnil(L, -1)) {
lua_pushnumber(L, fd);
lua_pushnil(L);
lua_settable(L, -2);
}
lua_pop(L, 1);
nonobserve_fd(fd);
return 0;
}
2012-09-25 15:29:12 +00:00
static const luaL_Reg lsyncdlib[] = {
2010-12-01 12:19:17 +00:00
{"configure", l_configure },
{"exec", l_exec },
{"log", l_log },
{"now", l_now },
{"nonobserve_fd", l_nonobserve_fd },
{"observe_fd", l_observe_fd },
{"readdir", l_readdir },
{"realdir", l_realdir },
{"stackdump", l_stackdump },
{"terminate", l_terminate },
2010-10-19 20:14:55 +00:00
{NULL, NULL}
};
/**
* Adds two jiffies or a number to a jiffy
*/
2012-02-15 11:15:32 +00:00
static int
l_jiffies_add(lua_State *L)
{
clock_t *p1 = (clock_t *) lua_touserdata(L, 1);
clock_t *p2 = (clock_t *) lua_touserdata(L, 2);
2010-11-29 11:37:46 +00:00
if (p1 && p2) {
logstring("Error", "Cannot add to timestamps!");
2012-02-15 11:15:32 +00:00
exit(-1); // ERRNO
2010-11-29 11:37:46 +00:00
}
{
clock_t a1 = p1 ? *p1 : luaL_checknumber(L, 1) * clocks_per_sec;
clock_t a2 = p2 ? *p2 : luaL_checknumber(L, 2) * clocks_per_sec;
clock_t *r = (clock_t *) lua_newuserdata(L, sizeof(clock_t));
luaL_getmetatable(L, "Lsyncd.jiffies");
lua_setmetatable(L, -2);
2012-02-15 11:15:32 +00:00
*r = a1 + a2;
2010-11-29 11:37:46 +00:00
return 1;
}
}
/**
* Adds two jiffies or a number to a jiffy
*/
2012-02-15 11:15:32 +00:00
static int
l_jiffies_sub(lua_State *L)
{
clock_t *p1 = (clock_t *) lua_touserdata(L, 1);
clock_t *p2 = (clock_t *) lua_touserdata(L, 2);
2010-11-29 11:37:46 +00:00
if (p1 && p2) {
2012-02-15 11:15:32 +00:00
// substracting two timestamps result in a timespan in seconds
2010-11-29 11:37:46 +00:00
clock_t a1 = *p1;
clock_t a2 = *p2;
lua_pushnumber(L, ((double) (a1 -a2)) / clocks_per_sec);
return 1;
}
2012-02-15 11:15:32 +00:00
// makes a timestamp earlier by NUMBER seconds
clock_t a1 = p1 ? *p1 : luaL_checknumber(L, 1) * clocks_per_sec;
clock_t a2 = p2 ? *p2 : luaL_checknumber(L, 2) * clocks_per_sec;
clock_t *r = (clock_t *) lua_newuserdata(L, sizeof(clock_t));
luaL_getmetatable(L, "Lsyncd.jiffies");
lua_setmetatable(L, -2);
2012-02-15 11:15:32 +00:00
*r = a1 - a2;
return 1;
}
/**
* Substracts two jiffies or a number to a jiffy
*/
2012-02-15 11:15:32 +00:00
static int
l_jiffies_eq(lua_State *L)
{
clock_t a1 = (*(clock_t *) luaL_checkudata(L, 1, "Lsyncd.jiffies"));
clock_t a2 = (*(clock_t *) luaL_checkudata(L, 2, "Lsyncd.jiffies"));
lua_pushboolean(L, a1 == a2);
return 1;
}
/**
* True if jiffy1 before jiffy2
*/
2012-02-15 11:15:32 +00:00
static int
l_jiffies_lt(lua_State *L)
{
clock_t a1 = (*(clock_t *) luaL_checkudata(L, 1, "Lsyncd.jiffies"));
clock_t a2 = (*(clock_t *) luaL_checkudata(L, 2, "Lsyncd.jiffies"));
lua_pushboolean(L, time_before(a1, a2));
return 1;
}
/**
* True if jiffy1 before or == jiffy2
*/
2012-02-15 11:15:32 +00:00
static int
l_jiffies_le(lua_State *L)
{
clock_t a1 = (*(clock_t *) luaL_checkudata(L, 1, "Lsyncd.jiffies"));
clock_t a2 = (*(clock_t *) luaL_checkudata(L, 2, "Lsyncd.jiffies"));
lua_pushboolean(L, (a1 == a2) || time_before(a1, a2));
return 1;
}
/**
* Registers the lsyncd lib
*/
void
2012-02-15 11:15:32 +00:00
register_lsyncd(lua_State *L)
{
luaL_register(L, LSYNCD_LIBNAME, lsyncdlib);
lua_setglobal(L, LSYNCD_LIBNAME);
2012-02-15 11:15:32 +00:00
// creates the metatable for jiffies userdata
luaL_newmetatable(L, "Lsyncd.jiffies");
2012-10-01 20:58:25 +00:00
int mt = lua_gettop(L);
lua_pushcfunction(L, l_jiffies_add);
2012-10-01 20:58:25 +00:00
lua_setfield(L, mt, "__add");
lua_pushcfunction(L, l_jiffies_sub);
2012-10-01 20:58:25 +00:00
lua_setfield(L, mt, "__sub");
2012-02-15 11:15:32 +00:00
lua_pushcfunction(L, l_jiffies_lt);
2012-10-01 20:58:25 +00:00
lua_setfield(L, mt, "__lt");
2012-02-15 11:15:32 +00:00
lua_pushcfunction(L, l_jiffies_le);
2012-10-01 20:58:25 +00:00
lua_setfield(L, mt, "__le");
2012-02-15 11:15:32 +00:00
lua_pushcfunction(L, l_jiffies_eq);
2012-10-01 20:58:25 +00:00
lua_setfield(L, mt, "__eq");
lua_pop(L, 1); // pop(mt)
2012-02-15 11:15:32 +00:00
#ifdef LSYNCD_WITH_INOTIFY
lua_getglobal(L, LSYNCD_LIBNAME);
register_inotify(L);
lua_setfield(L, -2, LSYNCD_INOTIFYLIBNAME);
lua_pop(L, 1);
#endif
if (lua_gettop(L)) {
logstring("Error", "internal, stack not empty in lsyncd_register()");
exit(-1); // ERRNO
}
}
2010-10-19 20:14:55 +00:00
/*****************************************************************************
2012-02-15 11:15:32 +00:00
* Lsyncd Core
2010-11-03 14:54:33 +00:00
****************************************************************************/
2010-10-19 20:14:55 +00:00
2010-11-10 15:57:37 +00:00
/**
* Pushes a function from the runner on the stack.
* Prior it pushed the callError handler.
*/
extern void
2012-02-15 11:15:32 +00:00
load_runner_func(lua_State *L,
2010-11-11 20:43:20 +00:00
const char *name)
2010-11-10 15:57:37 +00:00
{
printlogf(L, "Call", "%s()", name);
2012-02-15 11:15:32 +00:00
// pushes the error handler
2010-11-10 15:57:37 +00:00
lua_pushlightuserdata(L, (void *) &callError);
lua_gettable(L, LUA_REGISTRYINDEX);
2012-02-15 11:15:32 +00:00
// pushes the function
2010-11-10 15:57:37 +00:00
lua_pushlightuserdata(L, (void *) &runner);
lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushstring(L, name);
lua_gettable(L, -2);
lua_remove(L, -2);
}
2010-10-20 15:34:01 +00:00
/**
* Daemonizes.
2012-02-15 11:15:32 +00:00
*
* Lsyncds own implementation over daemon(0, 0) since
* a) OSX keeps bugging about it being deprecated
2012-02-15 11:15:32 +00:00
* b) for reason since blindly closing stdin/out/err is unsafe, since
* they might not have existed and actually close the monitors fd!
*/
static void
daemonize(lua_State *L)
{
pid_t pid, sid;
pid = fork();
2012-02-15 11:15:32 +00:00
if (pid < 0) {
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "Failure in daemonize at fork: %s", strerror(errno));
exit(-1); // ERRNO
}
2012-02-15 11:15:32 +00:00
if (pid > 0) exit(0); // return parent to shell
sid = setsid();
if (sid < 0) {
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "Failure in daemonize at setsid: %s", strerror(errno));
exit(-1); // ERRNO
}
2012-02-15 11:15:32 +00:00
// goto root dir
if ((chdir("/")) < 0) {
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "Failure in daemonize at chdir(\"/\"): %s", strerror(errno));
exit(-1); // ERRNO
}
2012-02-15 11:15:32 +00:00
// does what clibs daemon(0, 0) cannot do,
// checks if there were no stdstreams and it might close used fds!
if (observances_len && observances->fd < 3) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Normal",
"daemonize not closing stdin/out/err, since there seem to none.");
return;
}
2012-02-15 11:15:32 +00:00
// disconnects stdstreams
if (!freopen("/dev/null", "r", stdin) ||
!freopen("/dev/null", "w", stdout) ||
!freopen("/dev/null", "w", stderr)
) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error", "Failure in daemonize at freopen(/dev/null, std[in|out|err])");
}
2012-02-15 11:15:32 +00:00
is_daemon = true;
}
2010-10-19 10:12:11 +00:00
/**
* Normal operation happens in here.
*/
2010-11-10 15:57:37 +00:00
static void
2010-10-19 10:12:11 +00:00
masterloop(lua_State *L)
{
2010-11-14 09:11:09 +00:00
while(true) {
2010-10-24 16:41:58 +00:00
bool have_alarm;
2012-02-15 11:15:32 +00:00
bool force_alarm = false;
clock_t now = times(dummy_tms);
clock_t alarm_time = 0;
2010-10-19 10:12:11 +00:00
2012-03-16 15:05:16 +00:00
// memory usage debugging
// lua_gc(L, LUA_GCCOLLECT, 0);
// printf("gccount: %d\n", lua_gc(L, LUA_GCCOUNT, 0) * 1024 + lua_gc(L, LUA_GCCOUNTB, 0));
2012-02-15 11:15:32 +00:00
// queries runner about soonest alarm
load_runner_func(L, "getAlarm");
2012-02-15 12:47:58 +00:00
if (lua_pcall(L, 0, 1, -2)) exit(-1); // ERRNO
2012-02-15 11:15:32 +00:00
2010-11-08 12:14:10 +00:00
if (lua_type(L, -1) == LUA_TBOOLEAN) {
have_alarm = false;
force_alarm = lua_toboolean(L, -1);
2010-11-08 12:14:10 +00:00
} else {
have_alarm = true;
2012-02-15 11:15:32 +00:00
alarm_time = *((clock_t *) luaL_checkudata(L, -1, "Lsyncd.jiffies"));
2010-11-05 18:20:33 +00:00
}
lua_pop(L, 2);
2010-10-19 10:12:11 +00:00
2012-02-15 11:15:32 +00:00
if (force_alarm || (have_alarm && time_before_eq(alarm_time, now))) {
// there is a delay that wants to be handled already thus instead
// of reading/writing from observances it jumps directly to
// handling
2012-02-15 11:15:32 +00:00
// TODO: Actually it might be smarter to handler observances
// eitherway. since event queues might overflow.
2010-11-03 15:56:23 +00:00
logstring("Masterloop", "immediately handling delays.");
2010-10-24 21:35:29 +00:00
} else {
2012-02-15 12:47:58 +00:00
// use select() to determine what happens next
// + a new event on an observance
// + an alarm on timeout
// + the return of a child process
2010-10-25 08:42:27 +00:00
struct timespec tv;
2010-10-19 10:12:11 +00:00
2012-02-15 11:15:32 +00:00
if (have_alarm) {
// TODO use trunc instead of long converstions
2010-11-04 13:43:57 +00:00
double d = ((double)(alarm_time - now)) / clocks_per_sec;
tv.tv_sec = d;
tv.tv_nsec = ((d - (long) d)) * 1000000000.0;
2012-02-15 11:15:32 +00:00
printlogf(L, "Masterloop",
2010-11-04 13:43:57 +00:00
"going into select (timeout %f seconds)", d);
2010-10-24 21:35:29 +00:00
} else {
2010-11-04 13:43:57 +00:00
logstring("Masterloop", "going into select (no timeout).");
2010-10-19 10:12:11 +00:00
}
2012-02-15 12:47:58 +00:00
// time for Lsyncd to try to put itself to rest into a select(),
// configures timeouts, filedescriptors and signals
// that will wake it
2010-11-12 15:39:43 +00:00
{
fd_set rfds;
fd_set wfds;
sigset_t sigset;
int pi, pr;
2010-11-12 15:39:43 +00:00
sigemptyset(&sigset);
2010-11-12 15:39:43 +00:00
FD_ZERO(&rfds);
FD_ZERO(&wfds);
for(pi = 0; pi < observances_len; pi++) {
2010-12-01 12:19:17 +00:00
struct observance *obs = observances + pi;
if (obs->ready) FD_SET(obs->fd, &rfds);
if (obs->writey) FD_SET(obs->fd, &wfds);
2010-11-12 15:39:43 +00:00
}
2010-12-07 12:50:31 +00:00
if (!observances_len) {
2012-02-15 11:15:32 +00:00
logstring("Error",
2010-12-07 12:50:31 +00:00
"Internal fail, no observances, no monitor!");
exit(-1);
}
2012-02-15 11:15:32 +00:00
// the great select, this is the very heart beat
pr = pselect(
observances[observances_len - 1].fd + 1,
2012-02-15 11:15:32 +00:00
&rfds, &wfds, NULL,
2010-11-12 15:39:43 +00:00
have_alarm ? &tv : NULL, &sigset);
if (pr >= 0) {
2012-02-15 11:15:32 +00:00
// walks through the observances calling ready/writey
observance_action = true;
for(pi = 0; pi < observances_len; pi++) {
struct observance *obs = observances + pi;
2012-02-16 08:09:19 +00:00
if (hup || term) break;
if (obs->ready && FD_ISSET(obs->fd, &rfds)) {
obs->ready(L, obs);
}
2012-02-16 08:09:19 +00:00
2012-02-15 12:47:58 +00:00
if (hup || term) break;
2012-02-16 08:09:19 +00:00
2012-02-15 11:15:32 +00:00
if (nonobservances_len > 0 &&
nonobservances[nonobservances_len-1] == obs->fd) {
2012-02-15 12:47:58 +00:00
// TODO breaks if more nonobserves
// ready() nonobserved itself
// --- what?
continue;
}
if (obs->writey && FD_ISSET(obs->fd, &wfds)) {
obs->writey(L, obs);
}
}
observance_action = false;
2012-02-15 12:47:58 +00:00
// work through delayed nonobserve_fd() calls
for (pi = 0; pi < nonobservances_len; pi++) {
nonobserve_fd(nonobservances[pi]);
}
nonobservances_len = 0;
2010-11-12 15:39:43 +00:00
}
}
2012-02-15 11:15:32 +00:00
}
// collects zombified child processes
2010-10-23 19:19:46 +00:00
while(1) {
int status;
2010-10-24 13:52:28 +00:00
pid_t pid = waitpid(0, &status, WNOHANG);
2012-02-15 12:47:58 +00:00
if (pid <= 0) break;
2012-02-15 11:15:32 +00:00
load_runner_func(L, "collectProcess");
2010-10-23 19:19:46 +00:00
lua_pushinteger(L, pid);
lua_pushinteger(L, WEXITSTATUS(status));
2010-11-04 13:52:34 +00:00
if (lua_pcall(L, 2, 0, -4)) {
exit(-1); // ERRNO
}
2010-11-03 21:02:14 +00:00
lua_pop(L, 1);
2012-02-15 11:15:32 +00:00
}
2010-10-23 19:19:46 +00:00
2012-02-15 11:15:32 +00:00
// reacts on HUP signal
2010-11-14 09:11:09 +00:00
if (hup) {
load_runner_func(L, "hup");
if (lua_pcall(L, 0, 0, -2)) {
exit(-1); // ERRNO
}
lua_pop(L, 1);
hup = 0;
}
2012-02-15 11:15:32 +00:00
// reacts on TERM signal
2010-11-14 09:11:09 +00:00
if (term == 1) {
load_runner_func(L, "term");
if (lua_pcall(L, 0, 0, -2)) {
exit(-1); // ERRNO
}
lua_pop(L, 1);
term = 2;
}
2012-02-15 11:15:32 +00:00
// lets the runner do stuff every cycle,
// like starting new processes, writing the statusfile etc.
2010-11-10 22:03:02 +00:00
load_runner_func(L, "cycle");
l_now(L);
2012-02-15 11:15:32 +00:00
if (lua_pcall(L, 1, 1, -3)) exit(-1); // ERRNO
2010-11-14 09:11:09 +00:00
if (!lua_toboolean(L, -1)) {
2012-02-15 11:15:32 +00:00
// cycle told core to break mainloop
2010-11-14 09:11:09 +00:00
lua_pop(L, 2);
return;
}
lua_pop(L, 2);
2010-12-01 13:17:04 +00:00
if (lua_gettop(L)) {
logstring("Error", "internal, stack is dirty.")
l_stackdump(L);
exit(-1); // ERRNO
}
2010-10-19 10:12:11 +00:00
}
}
2010-10-18 10:26:15 +00:00
/**
* The effective main for one run.
* HUP signals may cause several runs of the one main.
2010-10-18 10:26:15 +00:00
*/
2010-10-17 15:24:55 +00:00
int
2010-11-14 09:11:09 +00:00
main1(int argc, char *argv[])
2010-10-14 13:52:01 +00:00
{
2012-02-15 11:15:32 +00:00
// the Lua interpreter
2010-10-27 19:34:56 +00:00
lua_State* L;
2012-02-15 11:15:32 +00:00
// scripts
2010-11-03 21:02:14 +00:00
char * lsyncd_runner_file = NULL;
int argp = 1;
2012-02-15 11:15:32 +00:00
// load Lua
2012-09-25 15:29:12 +00:00
L = luaL_newstate();
2010-11-11 19:52:20 +00:00
luaL_openlibs(L);
{
2012-02-15 11:15:32 +00:00
// checks the lua version
2010-11-11 19:52:20 +00:00
const char *version;
int major, minor;
lua_getglobal(L, "_VERSION");
version = luaL_checkstring(L, -1);
if (sscanf(version, "Lua %d.%d", &major, &minor) != 2) {
fprintf(stderr, "cannot parse lua library version!\n");
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-11 19:52:20 +00:00
}
if ((major < 5) || (major == 5 && minor < 1)) {
fprintf(stderr, "lua library is too old. Need 5.1 at least");
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-11 19:52:20 +00:00
}
lua_pop(L, 1);
}
2010-11-03 21:02:14 +00:00
2010-11-03 16:04:11 +00:00
{
2012-02-15 11:15:32 +00:00
// prepares logging early
2010-11-03 21:02:14 +00:00
int i = 1;
2010-11-03 16:04:11 +00:00
add_logcat("Normal", LOG_NOTICE);
2010-12-10 13:17:01 +00:00
add_logcat("Warn", LOG_WARNING);
2010-11-03 16:04:11 +00:00
add_logcat("Error", LOG_ERR);
while (i < argc) {
if (strcmp(argv[i], "-log") && strcmp(argv[i], "--log")) {
i++; continue;
}
2012-02-15 12:47:58 +00:00
if (++i >= argc) break;
2010-11-03 21:02:14 +00:00
if (!add_logcat(argv[i], LOG_NOTICE)) {
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "'%s' is not a valid logging category", argv[i]);
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-03 16:04:11 +00:00
}
}
}
2010-11-03 14:54:33 +00:00
2012-02-15 11:15:32 +00:00
// registers lsycnd core
register_lsyncd(L);
2010-10-16 10:26:48 +00:00
2011-11-21 13:31:34 +00:00
if (check_logcat("Debug") <= settings.log_level) {
2012-02-15 12:47:58 +00:00
// printlogf doesnt support %ld :-(
2010-11-04 13:43:57 +00:00
printf("kernels clocks_per_sec=%ld\n", clocks_per_sec);
}
2012-02-15 11:15:32 +00:00
// checks if the user overrode default runner file
2010-11-03 21:02:14 +00:00
if (argp < argc && !strcmp(argv[argp], "--runner")) {
2010-11-04 14:23:34 +00:00
if (argp + 1 >= argc) {
2012-02-15 11:15:32 +00:00
logstring("Error", "Lsyncd Lua-runner file missing after --runner.");
logstring("Error", "Using a statically included runner as default.");
2010-11-20 13:22:47 +00:00
exit(-1); //ERRNO
2010-10-19 21:56:00 +00:00
}
lsyncd_runner_file = argv[argp + 1];
argp += 2;
}
2010-10-27 19:34:56 +00:00
if (lsyncd_runner_file) {
2012-02-15 12:47:58 +00:00
// checks if the runner file exists
2010-10-19 21:56:00 +00:00
struct stat st;
if (stat(lsyncd_runner_file, &st)) {
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "Cannot find Lsyncd Lua-runner at '%s'.", lsyncd_runner_file);
2010-11-03 14:54:33 +00:00
printlogf(L, "Error", "Maybe specify another place?");
2012-02-15 12:47:58 +00:00
printlogf(L, "Error", "%s --runner RUNNER_FILE CONFIG_FILE", argv[0]);
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-27 19:34:56 +00:00
}
// loads the runner file
2010-10-27 19:34:56 +00:00
if (luaL_loadfile(L, lsyncd_runner_file)) {
2012-02-15 11:15:32 +00:00
printlogf(L, "Error",
"error loading '%s': %s", lsyncd_runner_file, lua_tostring(L, -1));
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-19 21:56:00 +00:00
}
2010-11-03 21:02:14 +00:00
} else {
2012-02-15 12:47:58 +00:00
// loads the runner from binary
if (luaL_loadbuffer(L, runner_out, runner_size, "runner")) {
printlogf(L, "Error", "loading precompiled runner: %s", lua_tostring(L, -1));
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-27 19:34:56 +00:00
}
2010-11-03 21:02:14 +00:00
}
2010-11-10 15:57:37 +00:00
{
2012-02-15 12:47:58 +00:00
// place to store the lua runners functions
// executes the runner defining all its functions
2010-11-10 15:57:37 +00:00
if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
printlogf(L, "Error", "preparing runner: %s", lua_tostring(L, -1));
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-10 15:57:37 +00:00
}
lua_pushlightuserdata(L, (void *)&runner);
2012-02-15 12:47:58 +00:00
// switches the value (result of preparing) and the key &runner
2010-11-10 15:57:37 +00:00
lua_insert(L, 1);
2012-02-15 12:47:58 +00:00
// saves the table of the runners functions in the lua registry
2010-11-10 15:57:37 +00:00
lua_settable(L, LUA_REGISTRYINDEX);
2012-02-15 12:47:58 +00:00
// saves the error function extra
lua_pushlightuserdata(L, (void *) &callError); // &callError is the key
lua_pushlightuserdata(L, (void *) &runner); // &runner[callError] the value
2010-11-10 15:57:37 +00:00
lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushstring(L, "callError");
lua_gettable(L, -2);
lua_remove(L, -2);
lua_settable(L, LUA_REGISTRYINDEX);
2010-10-17 17:13:53 +00:00
}
2010-10-18 17:09:59 +00:00
{
2012-02-15 12:47:58 +00:00
// asserts version match between runner and core
2010-10-18 17:09:59 +00:00
const char *lversion;
lua_getglobal(L, "lsyncd_version");
lversion = luaL_checkstring(L, -1);
if (strcmp(lversion, PACKAGE_VERSION)) {
2010-11-03 14:54:33 +00:00
printlogf(L, "Error",
2010-10-27 19:34:56 +00:00
"Version mismatch '%s' is '%s', but core is '%s'",
lsyncd_runner_file ? lsyncd_runner_file : "internal runner",
lversion, PACKAGE_VERSION);
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-18 17:09:59 +00:00
}
2010-11-03 21:02:14 +00:00
lua_pop(L, 1);
2010-10-18 17:09:59 +00:00
}
{
// loads the defaults from binary
if (luaL_loadbuffer(L, defaults_out, defaults_size, "defaults")) {
printlogf(L, "Error", "loading defaults: %s", lua_tostring(L, -1));
exit(-1); // ERRNO
}
// prepares the defaults
if (lua_pcall(L, 0, 0, 0)) {
printlogf(L, "Error", "preparing defaults: %s", lua_tostring(L, -1));
exit(-1); // ERRNO
}
}
2010-10-27 09:06:13 +00:00
{
2012-02-15 12:47:58 +00:00
// checks if there is a "-help" or "--help"
2010-10-27 09:06:13 +00:00
int i;
for(i = argp; i < argc; i++) {
if (!strcmp(argv[i],"-help") || !strcmp(argv[i],"--help")) {
2010-11-10 15:57:37 +00:00
load_runner_func(L, "help");
2010-11-04 13:52:34 +00:00
if (lua_pcall(L, 0, 0, -2)) {
exit(-1); // ERRNO
}
2010-11-03 21:02:14 +00:00
lua_pop(L, 1);
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-27 09:06:13 +00:00
}
}
}
2010-11-03 21:02:14 +00:00
{
2012-02-15 11:15:32 +00:00
// starts the option parser in lua script
2010-11-03 21:02:14 +00:00
int idx = 1;
const char *s;
2012-02-15 11:15:32 +00:00
// creates a table with all remaining argv option arguments
2010-11-10 15:57:37 +00:00
load_runner_func(L, "configure");
2010-11-03 21:02:14 +00:00
lua_newtable(L);
while(argp < argc) {
lua_pushnumber(L, idx++);
lua_pushstring(L, argv[argp++]);
lua_settable(L, -3);
}
2012-02-15 11:15:32 +00:00
// creates a table with the cores event monitor interfaces
2010-11-28 09:37:43 +00:00
idx = 0;
lua_newtable(L);
while (monitors[idx]) {
lua_pushnumber(L, idx + 1);
lua_pushstring(L, monitors[idx++]);
lua_settable(L, -3);
}
if (lua_pcall(L, 2, 1, -3)) {
2010-11-04 13:52:34 +00:00
exit(-1); // ERRNO
}
if (first_time) {
// If not first time, simply retains the config file given
s = lua_tostring(L, -1);
if (s) lsyncd_config_file = s_strdup(s);
2010-11-03 21:02:14 +00:00
}
2012-02-15 11:15:32 +00:00
lua_pop(L, 2);
2010-11-03 21:02:14 +00:00
}
// checks existence of the config file
2010-11-03 21:02:14 +00:00
if (lsyncd_config_file) {
2010-10-27 09:06:13 +00:00
struct stat st;
// gets the absolute path to the config file
// so in case of HUPing the daemon, it finds it again
char * apath = get_realpath(lsyncd_config_file);
if (!apath) {
printlogf(L, "Error", "Cannot find config file at '%s'.", lsyncd_config_file);
exit(-1); // ERRNO
}
free(lsyncd_config_file);
lsyncd_config_file = apath;
2010-10-27 09:06:13 +00:00
if (stat(lsyncd_config_file, &st)) {
printlogf(L, "Error", "Cannot find config file at '%s'.", lsyncd_config_file);
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-10-27 09:06:13 +00:00
}
2012-02-15 11:15:32 +00:00
// loads and executes the config file
2010-11-03 21:02:14 +00:00
if (luaL_loadfile(L, lsyncd_config_file)) {
printlogf(L, "Error",
"error loading %s: %s", lsyncd_config_file, lua_tostring(L, -1));
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-03 21:02:14 +00:00
}
2010-11-03 21:02:14 +00:00
if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
printlogf(L, "Error",
"error preparing %s: %s", lsyncd_config_file, lua_tostring(L, -1));
2010-11-14 09:11:09 +00:00
exit(-1); // ERRNO
2010-11-03 21:02:14 +00:00
}
2010-10-17 17:13:53 +00:00
}
2010-10-16 10:26:48 +00:00
#ifdef LSYNCD_WITH_INOTIFY
open_inotify(L);
#endif
#ifdef LSYNCD_WITH_FSEVENTS
open_fsevents(L);
#endif
2010-11-11 20:43:20 +00:00
2010-10-25 08:42:27 +00:00
{
2010-10-27 19:34:56 +00:00
/* adds signal handlers *
2012-02-15 11:15:32 +00:00
* listens to SIGCHLD, but blocks it until pselect()
2010-10-27 19:34:56 +00:00
* opens up*/
2010-10-25 08:42:27 +00:00
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
signal(SIGCHLD, sig_child);
2010-10-25 21:04:28 +00:00
sigprocmask(SIG_BLOCK, &set, NULL);
2012-02-15 11:15:32 +00:00
2010-11-14 09:11:09 +00:00
signal(SIGHUP, sig_handler);
signal(SIGTERM, sig_handler);
2010-10-25 08:42:27 +00:00
}
2010-10-24 21:35:29 +00:00
2010-10-25 21:04:28 +00:00
{
2012-02-15 11:15:32 +00:00
/* runs initialitions from runner
2010-10-27 19:34:56 +00:00
* lua code will set configuration and add watches */
2010-11-10 15:57:37 +00:00
load_runner_func(L, "initialize");
2011-08-29 09:21:40 +00:00
lua_pushboolean(L, first_time);
if (lua_pcall(L, 1, 0, -3)) exit(-1); // ERRNO
2010-11-03 21:02:14 +00:00
lua_pop(L, 1);
2010-10-25 21:04:28 +00:00
}
2010-10-18 17:09:59 +00:00
2010-10-19 10:12:11 +00:00
masterloop(L);
2010-10-18 17:09:59 +00:00
2012-02-15 11:15:32 +00:00
// cleanup
{
2012-02-15 11:15:32 +00:00
// tidies up all observances
int i;
for(i = 0; i < observances_len; i++) {
struct observance *obs = observances + i;
obs->tidy(obs);
}
observances_len = 0;
nonobservances_len = 0;
}
2010-11-14 09:11:09 +00:00
{
2012-02-15 11:15:32 +00:00
// frees logging categories
2010-11-14 09:11:09 +00:00
int ci;
struct logcat *lc;
for(ci = 'A'; ci <= 'Z'; ci++) {
2010-11-29 16:38:31 +00:00
for(lc = logcats[ci - 'A']; lc && lc->name; lc++) {
2010-11-14 09:11:09 +00:00
free(lc->name);
lc->name = NULL;
}
2010-11-29 16:38:31 +00:00
if (logcats[ci - 'A']) {
free(logcats[ci - 'A']);
logcats[ci - 'A'] = NULL;
2010-11-14 09:11:09 +00:00
}
}
}
2010-10-14 13:52:01 +00:00
lua_close(L);
return 0;
}
2010-11-14 09:11:09 +00:00
/**
* Main
*/
int
main(int argc, char *argv[])
{
2012-02-15 11:15:32 +00:00
// gets a kernel parameter
2010-11-14 09:11:09 +00:00
clocks_per_sec = sysconf(_SC_CLK_TCK);
2012-02-15 12:47:58 +00:00
while(!term) main1(argc, argv);
2010-11-14 09:11:09 +00:00
return 0;
}