path: root/src/nssync.c

/* This file is part of NSsync 
   Copyright (C) 2011 Sergey Poznyakoff
  
   NSsync is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
  
   NSsync is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with NSsync.  If not, see <http://www.gnu.org/licenses/>. */

#include "nssync.h"
#include <sys/stat.h>
#include <fcntl.h>

int lint_mode;
int dry_run_mode;
int preprocess_only;
int debug_level;
char *config_file = SYSCONFDIR "/nssync.conf";
char *slave_status_file;
char *pidfile;
int force;
char *tempdir;
char *reload_command = "/usr/sbin/rndc reload";
char *compare_command = "cmp $oldfile $newfile > /dev/null";
unsigned error_count;
unsigned changed_zones;

#include "cmdline.h"

void
verror(const char *fmt, va_list ap)
{
	fprintf(stderr, "%s: ", program_name);
	vfprintf(stderr, fmt, ap);
	fputc('\n', stderr);
}

void
error(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	verror(fmt, ap);
	va_end(ap);
}

void
debug_printf(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	fprintf(stderr, "%s: DEBUG: ", program_name);
	vfprintf(stderr, fmt, ap);
	fputc('\n', stderr);
	va_end(ap);
}
		

/* Create the directory DIR, eventually creating all intermediate directories
   starting from DIR + BASELEN. */
int
create_hierarchy(char *dir, size_t baselen)
{
	int rc;
	struct stat st;
	char *p;
	
	if (stat(dir, &st) == 0) {
		if (!S_ISDIR(st.st_mode)) {
			error(_("component %s is not a directory"), dir);
			return 1;
		}
		return 0;
	} else if (errno != ENOENT) {
		error(_("cannot stat file %s: %s"), dir, strerror(errno));
		return 1;
	}

	p = strrchr(dir, '/');
	if (p) {
		if (p - dir + 1 < baselen) {
			error(_("base directory %s does not exist"), dir);
			return 1;
		}
		*p = 0;
	}

	rc = create_hierarchy(dir, baselen);
	if (rc == 0) {
		if (p)
			*p = '/';
		if (mkdir(dir, 0744)) {
			error(_("cannot create directory %s: %s"),
			      dir, strerror(errno));
			rc = 1;
		}
	}
	return rc;
}

static int
trycreate(const char *file_name)
{
	int rc = 1;
	char *dir_name = grecs_strdup(file_name);
	char *p = strrchr(dir_name, '/');

	if (p) {
		size_t len = strlen(bind_working_dir);
		if (strncmp(dir_name, bind_working_dir, len) == 0) {
			*p = 0;
			rc = create_hierarchy(dir_name, len);
		}
	}
	free(dir_name);
	return rc;
}
	  
int
copy_file(const char *file_name, FILE *infile, const char *dst_file)
{
	int out_fd;
	struct stat st;
	int rc;
	char *buf;
	size_t bufsize;
	size_t fsize;
  
	changed_zones++;
	if (dry_run_mode)
		return 0;
	
	if (fstat(fileno(infile), &st)) {
		error("cannot stat source file %s: %s",
		      file_name, strerror(errno));
		return 1;
	}

	out_fd = open(dst_file, O_WRONLY|O_TRUNC|O_CREAT, 0640);
	if (out_fd == -1) {
		if (errno == ENOENT) {
			if (trycreate(dst_file))
				return 1;
			out_fd = open(dst_file, O_WRONLY|O_TRUNC|O_CREAT,
				      0640);
		}
		if (out_fd == -1) {
			error("cannot create destination file %s: %s",
			      dst_file, strerror(errno));
			return 1;
		}
	}

	buf = NULL;
	fsize = st.st_size;

	for (bufsize = fsize; bufsize > 0 && (buf = malloc (bufsize)) == NULL;
	     bufsize /= 2)
		;
	if (bufsize == 0)
		grecs_alloc_die ();

	rc = 0;
	fseeko(infile, 0, SEEK_SET);
	while (fsize > 0) {
		size_t rest;
		size_t rdbytes;
		
		rest = fsize > bufsize ? bufsize : fsize;
		rdbytes = fread(buf, 1, rest, infile);
		if (rdbytes == -1) {
			error("unexpected error reading %s: %s",
			      file_name, strerror(errno));
			rc = 1;
			break;
		}
		rest = write(out_fd, buf, rdbytes);
		if (rest == -1)	{
			error("unexpected error writing to %s: %s",
			      dst_file, strerror(errno));
			rc = 1;
			break;
		} else if (rest != rdbytes) {
			error("short write on %s", dst_file);
			rc = 1;
		}
		fsize -= rdbytes;
	}
	free(buf);

	close(out_fd);
	if (rc)
		unlink(dst_file);

	return rc;
}

/* Move FILE to DST_FILE. If they reside on different devices, use copy_file
   + unlink. */
int
move_file(const char *file, const char *dst_file)
{
	int rc = 0;

	rc = rename(file, dst_file);
	if (rc && errno == ENOENT) {
		if (trycreate(dst_file))
			return 1;
		rc = rename(file, dst_file);
	}
	if (rc) {
		if (errno == EXDEV) {
			FILE *fp = fopen(file, "r");
			if (!fp) {
				error("cannot open %s for reading: %s",
				      file, strerror(errno));
				return 1;
			}
			rc = copy_file (file, fp, dst_file);
			fclose(fp);
			if (rc) {
				error(_("cannot copy %s to %s: %s"),
				      file, dst_file, strerror(errno));
				rc = 1;
			} else if (unlink(file)) {
				error(_("cannot unlink %s: %s"),
				      file, strerror(errno));
			}
		} else {
			error(_("cannot move %s to %s: %s"),
			      file, dst_file, strerror(errno));
			rc = 1;
		}
	}
	return rc;
}


int
compare(const char *oldfile, const char *newfile)
{
	const char *env[5];
	struct wordsplit ws;
	int rc;

	if (access(newfile, F_OK) && errno == ENOENT) {
		debug(2,("destination file %s does not exist", newfile));
		return 1;
	}
	
	env[0] = "oldfile";
	env[1] = oldfile;
	env[2] = "newfile";
	env[3] = newfile;
	env[4] = 0;
	ws.ws_env = env;
	if (wordsplit(compare_command, &ws,
		      WRDSF_NOCMD | WRDSF_ENV | WRDSF_ENV_KV |
		      WRDSF_NOSPLIT | WRDSF_KEEPUNDEF)) {
		error("cannot split compare-command: %s",
		      wordsplit_strerror(&ws));
		exit(EX_SOFTWARE);
	}

	debug(2,("running %s", ws.ws_wordv[0]));
	rc = system(ws.ws_wordv[0]);
	wordsplit_free(&ws);
	debug(2,("command returned %d", rc));
	return rc;
}


static void
synchronize(struct nssync *sp)
{
	const char *file_name;
	mode_t um;
	size_t size = 0;
	const char *env[5];
	struct wordsplit ws;
	int rc;
	
	debug(1, ("processing %s", sp->tag));
	if (grecs_asprintf(&sp->temp_file_name, &size,
			   "%s/%s.tmp", tempdir, sp->tag))
		grecs_alloc_die();
	
	um = umask(077);
	sp->fp = fopen(sp->temp_file_name, "w+");
	umask(um);
	if (!sp->fp) {
		error("cannot open %s: %s", sp->temp_file_name,
		      strerror(errno));
		return;
	}
	format_zones(sp);
	if (!dry_run_mode)
		unlink(sp->temp_file_name);
	free(sp->temp_file_name);
}

void
check_slave_status()
{
	FILE *fp;
	char *saved_file = NULL;
	char *saved_off;
	char *buf = NULL;
	size_t size = 0;
	char *sql_file, *sql_off;

	if (!slave_status_file)
		return;
	
        if (sql_get_slave_status(&sql_file, &sql_off)) {
                unlink(slave_status_file);
                return;
        }

	fp = fopen(slave_status_file, "r");
	if (fp) {
		if (grecs_getline(&buf, &size, fp) > 0) {
			buf[strlen(buf)-1] = 0;
			saved_file = buf;
			saved_off = strchr(saved_file, ' ');
			if (saved_off)
				*saved_off++ = 0;
		}
		fclose(fp);
	}

	if (!force && saved_file && saved_off &&
		 strcmp(sql_file, saved_file) == 0 &&
		 strcmp(sql_off, saved_off) == 0) {
		debug(1, ("slave status hasn't changed: nothing to do"));
		exit(0);
	}
	fp = fopen(slave_status_file, "w");
	if (fp) {
		fprintf(fp, "%s %s\n", sql_file, sql_off);
		fclose(fp);
	}
	free(sql_file);
	free(sql_off);
}

void
create_pidfile()
{
	FILE *fp;

	if (!pidfile)
		return;
	
	fp = fopen(pidfile, "w");
	if (!fp) {
		error(_("cannot create pidfile `%s': %s"),
		      pidfile, strerror(errno));
		exit(EX_TEMPFAIL);
	}
	fprintf(fp, "%lu", (unsigned long) getpid());
	fclose(fp);
}

void
remove_pidfile()
{
	if (pidfile && unlink(pidfile))
		error(_("cannot unlink pidfile `%s': %s"),
		      pidfile, strerror(errno));
}

/* Check whether pidfile NAME exists and if so, whether its PID is still
   active. Exit if it is. */
void
check_pidfile()
{
	unsigned long pid;
	FILE *fp;

	if (!pidfile)
		return;
	
	fp = fopen(pidfile, "r");
	
	if (!fp) {
		if (errno == ENOENT)
			return;
		error(_("cannot open pidfile `%s': %s"),
		      pidfile, strerror(errno));
		exit(EX_TEMPFAIL);
	}
	if (fscanf(fp, "%lu", &pid) != 1) {
		error(_("cannot get pid from pidfile `%s'"), pidfile);
	} else {
		if (kill(pid, 0) == 0) {
			error(_("%s appears to run with pid %lu. "
				"If it does not, remove `%s' and retry."),
			      program_name, pid, pidfile);
			exit(EX_TEMPFAIL);
		}
	}
		
	fclose(fp);
	if (unlink(pidfile)) {
		error(_("cannot unlink pidfile `%s': %s"),
		      pidfile, strerror(errno));
		exit(EX_NOPERM);
	}

	create_pidfile();
	atexit(remove_pidfile);
}



int
main(int argc, char **argv)
{
	struct grecs_list_entry *ep;
	
	config_init();
	parse_options(argc, argv);
        if (preprocess_only)
		exit(grecs_preproc_run(config_file, grecs_preprocessor) ?
		     EX_CONFIG : 0);
	config_parse();
	sql_connect();

	check_pidfile();
	
	check_slave_status();
	
	for (ep = synclist->head; ep; ep = ep->next)
		synchronize(ep->data);

	if (error_count) {
		error("exiting due to errors");
		exit(EX_UNAVAILABLE);
	}
	
	for (ep = synclist->head; ep; ep = ep->next)
		flush_zone_list(ep->data);

	if (error_count) {
		error("exiting due to errors");
		exit(EX_UNAVAILABLE);
	}
	
	if (changed_zones) {
		debug(1,("about to run %s", reload_command));
		if (!dry_run_mode) {
			int rc = system(reload_command);
			if (rc) {
				debug(1,("reload command returned %d", rc));
				exit(EX_UNAVAILABLE);
			}
		}
	}
	
	exit(0);
}