Initial implementation of daemon mode.

* gconf/gconf-gram.y (string_to_sockaddr_: Take struct gconf_sockaddr as the
first argument.
* gconf/gconf.h (struct gconf_sockaddr): New data type.
* src/job.c, src/net.c, src/pidfile.c: New files.
* src/Makefile.am (wydawca_SOURCES): Add job.c, net.c, pidfile.c
* src/cmdline.opt: New options: --cron (change semantics), --force,
--foreground, --single-process, --spool
* src/wydawca.c: New daemon mode.
* src/config.c: New statements: spool.alias, daemon, foreground,
single-process, wakeup-interval, pidfile, listen
* src/directive.c, src/diskio.c, src/gpg.c, src/mail.c, src/null.c,
src/process.c, src/triplet.c, src/verify.c, src/vtab.c, src/wydawca.h: use
static struct spool wherever feasible.
* src/triplet.c: New meta-variable "spool"
* tests/etc/wydawca.rcin: Update.
* tests/upload-dry.at: Update.

17 files changed, 885 insertions, 150 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 7ba9832..903b754 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -22,14 +22,17 @@ wydawca_SOURCES=\
  config.c\
  directive.c\
  diskio.c\
  exec.c\
  gpg.c\
  interval.c\
+ job.c\
  meta.c\
  method.c\
+ net.c\
+ pidfile.c\
  process.c\
  sql.c\
  sql.h\
  triplet.c\
  verify.c\
  wydawca.c\
@@ -53,10 +56,11 @@ incdir=$(pkgdatadir)/$(VERSION)/include
 inc_DATA = $(PP_SETUP_FILE)
 
 LDADD=../gconf/libgconf.a ../gnu/libgnu.a @SQLLIB@ @GPGMELIB@ @MAILUTILS_LIBS@
 INCLUDES = -I$(top_srcdir)/gconf -I$(top_srcdir)/gnu -I../gnu @MAILUTILS_INCLUDES@
 AM_CPPFLAGS= \
  -DSYSCONFDIR=\"$(sysconfdir)\"\
+ -DLOCALSTATEDIR=\"$(localstatedir)\"\
  -DDEFAULT_VERSION_INCLUDE_DIR=\"$(incdir)\"\
  -DDEFAULT_INCLUDE_DIR=\"$(pkgdatadir)/include\"\
  -DDEFAULT_PREPROCESSOR="$(DEFAULT_PREPROCESSOR)"
 
diff --git a/src/cmdline.opt b/src/cmdline.opt
index 53bdd00..b61517b 100644
--- a/src/cmdline.opt
+++ b/src/cmdline.opt
@@ -15,25 +15,27 @@
    with wydawca. If not, see <http://www.gnu.org/licenses/>. */
 
 static struct obstack pp_cmd_stack;
 static int pp_cmd_stack_init;
 
 static gl_list_t source_list;
+static gl_list_t tag_list;
 
 static bool
 source_eq (const void *elt1, const void *elt2)
 {
   return strcmp ((const char *)elt1, (const char *)elt2) == 0;
 }
 
 int
 enabled_spool_p (const struct spool *spool)
 {
-  if (!source_list)
-    return 1;
-  return !!gl_list_search (source_list, spool->source_dir);
+  if (source_list || tag_list)
+    return (source_list && gl_list_search (source_list, spool->source_dir))
+            || (tag_list && gl_list_search (tag_list, spool->tag));
+  return 1;	
 }
 
 OPTIONS_BEGIN(gnu, "wydawca",
               [<wydawca synchronizes files from a set of upload directories with the corresponding distribution sites>],
 	      [<UID [UID...]>])
 
@@ -58,33 +60,67 @@ OPTION(dry-run,n,,
 BEGIN
 	log_to_stderr = 1;
 	debug_level++;
 	dry_run_mode = 1;
 END
 
+OPTION(cron,,,
+       [<force cron mode>])
+BEGIN
+	cron_option = 1;
+	log_to_stderr = 0;
+END
+
+OPTION(force,,,
+       [<force start up even if the pid file already exists>])
+BEGIN
+	force_startup = 1;
+END	
+
+OPTION(foreground,,,
+       [<foreground mode>])
+BEGIN
+	foreground_option = 1;
+END
+
+OPTION(single-process,,,
+       [<single process mode>])
+BEGIN
+	single_process_option = 1;
+END	
+
 OPTION(config-file,c,FILE,
        [<use FILE instead of the default configuration>])
 BEGIN
 	conffile = optarg;
 END
 
+OPTION(spool,S,TAG,
+       [<process only spool with the given tag>])
+BEGIN
+	if (!tag_list)
+          tag_list = gl_list_create_empty (&gl_linked_list_implementation,
+				           source_eq, NULL,
+				           NULL, false);
+        gl_list_add_last (tag_list, optarg);   
+END
+
 OPTION(source,s,SOURCE-DIR,
        [<process only spool with the given source (may be used multiple times)>])
 BEGIN
 	if (!source_list)
           source_list = gl_list_create_empty (&gl_linked_list_implementation,
 				              source_eq, NULL,
 			                      NULL, false);
         gl_list_add_last (source_list, optarg);   
 END       
 
 GROUP(Logging)
 
-OPTION(cron,,,
-       [<log to syslog>])
-ALIAS(syslog)
+OPTION(syslog,,,
+       [<log to syslog>])       
 BEGIN
 	log_to_stderr = 0;
 END
 
 OPTION(stderr,e,,
        [<log to stderr>])
diff --git a/src/config.c b/src/config.c
index dd444fe..94afb20 100644
--- a/src/config.c
+++ b/src/config.c
@@ -260,17 +260,12 @@ cb_mailer (enum gconf_callback_command cmd,
 	   void *cb_data)
 {
   int rc;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
-  if (cmd != gconf_callback_set_value)
-    {
-      gconf_error (locus, 0, _("Unexpected block statement"));
-      return 1;
-    }
   rc = mu_mailer_create (&mailer, value->v.string);
   if (rc)
     gconf_error (locus, 0, _("cannot create mailer `%s': %s"),
 		 value->v.string, mu_strerror (rc));
   return rc;
 }
@@ -1082,28 +1077,23 @@ cb_access_method (enum gconf_callback_command cmd,
     gconf_error (locus, 0, _("invalid use of block statement"));
   }
   return 0;
 }
 
 static int
-cb_destination_url (enum gconf_callback_command cmd,
-		    gconf_locus_t *locus,
-		    void *varptr,
-		    gconf_value_t *value,
-		    void *cb_data)
+cb_url (enum gconf_callback_command cmd,
+	gconf_locus_t *locus,
+	void *varptr,
+	gconf_value_t *value,
+	void *cb_data)
 {
   mu_url_t *purl = varptr, url;
   int rc;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
-  if (cmd != gconf_callback_set_value)
-    {
-      gconf_error (locus, 0, _("Unexpected block statement"));
-      return 1;
-    }
   rc = mu_url_create (&url, value->v.string);
   if (rc)
     {
       gconf_error (locus, 0, _("cannot create URL `%s': %s"),
 		   value->v.string, mu_strerror (rc));
       return rc;
@@ -1119,17 +1109,21 @@ cb_destination_url (enum gconf_callback_command cmd,
   *purl = url;
   return 0;
 }
 
 
 static struct gconf_keyword spool_kw[] = {
+  { "url", N_("arg"), N_("URL corresponding to this spool"),
+    gconf_type_string, NULL, offsetof(struct spool, url) },
+  { "alias", N_("arg"), N_("Aliases"),
+    gconf_type_string|GCONF_LIST, NULL, offsetof(struct spool, aliases) },
   { "source", N_("dir"), N_("Source directory"),
     gconf_type_string, NULL, offsetof(struct spool, source_dir) },
   { "destination", N_("dir"), N_("Destination directory"),
     gconf_type_string, NULL, offsetof(struct spool, dest_url),
-    cb_destination_url },
+    cb_url },
   { "file-sweep-time", N_("interval"), N_("Define file sweep time"),
     gconf_type_string, NULL, offsetof(struct spool, file_sweep_time),
     cb_interval },
   { "access-method", N_("ident"), N_("Define access method"),
     gconf_type_section, NULL, offsetof(struct spool, access_method),
     cb_access_method, NULL, access_method_kw },
@@ -1161,13 +1155,13 @@ cb_spool (enum gconf_callback_command cmd,
       if (!value || value->type != GCONF_TYPE_STRING)
 	{
 	  gconf_error (locus, 0, _("tag must be a string"));
 	  return 1;
 	}
       spool = xzalloc (sizeof (*spool));
-      spool->url = xstrdup (value->v.string);
+      spool->tag = xstrdup (value->v.string);
       spool->file_sweep_time = file_sweep_time;
       for (i = 0; i < NITEMS (spool->access_method); i++)
 	spool->access_method[i] = default_access_method[i];
       spool->archive = default_archive_descr;
       *pdata = spool;
       break;
@@ -1230,12 +1224,24 @@ cb_spool (enum gconf_callback_command cmd,
   return 0;
 }
 
 
 
 static struct gconf_keyword wydawca_kw[] = {
+  { "daemon", NULL, N_("Enable daemon mode"),
+    gconf_type_bool, &daemon_mode },
+  { "foreground", NULL, N_("Start in foreground even in daemon mode"),
+    gconf_type_bool, &foreground },
+  { "single-process", NULL, N_("Do not spawn subprocesses"),
+    gconf_type_bool, &single_process },
+  { "wakeup-interval", N_("time"), N_("Set wake-up interval"),
+    gconf_type_string, &wakeup_interval, 0, cb_interval },
+  { "pidfile", N_("file"), N_("Set pid file name"),
+    gconf_type_string, &pidfile },
+  { "listen", N_("socket"), N_("Listen on this address"),
+    gconf_type_sockaddr, &listen_sockaddr, },
   { "mailer", N_("url"), N_("Set mailer URL"),
     gconf_type_string, &mailer, 0, cb_mailer },
   { "admin-address", N_("email"), N_("Set admin email address"),
     gconf_type_string, &admin_address, 0, cb_email_address },
   { "from-address", N_("email"), N_("Set sender email address"),
     gconf_type_string, &from_address, 0, cb_email_address },
diff --git a/src/directive.c b/src/directive.c
index 46e3196..37ce241 100644
--- a/src/directive.c
+++ b/src/directive.c
@@ -299,13 +299,13 @@ verify_directive_format (struct file_triplet *trp)
     }
   return 0;
 }
 
 /* Process the directives from TRP, using given SPOOL */
 int
-process_directives (struct file_triplet *trp, struct spool *spool)
+process_directives (struct file_triplet *trp, const struct spool *spool)
 {
   int rc, n;
   const char *key, *val;
   char *relative_dir;
 
   UPDATE_STATS (STAT_COMPLETE_TRIPLETS);
diff --git a/src/diskio.c b/src/diskio.c
index 69a3cbe..ccff5c2 100644
--- a/src/diskio.c
+++ b/src/diskio.c
@@ -302,13 +302,13 @@ tar_append_file (const char *archive, const char *file)
      UID, GID        - Ownership
      RELDIR          - Directory part of FILE
 
    Do nothing if dry_run_mode is set.    */
 int
 backup_file (const char *dst_file, const char *dst_dir, const char *file,
-	     struct archive_descr *archive, uid_t uid, gid_t gid,
+	     const struct archive_descr *archive, uid_t uid, gid_t gid,
 	     const char *reldir)
 {
   int rc = 0;
   char *adir;
   char *file_name;
 
@@ -377,13 +377,13 @@ backup_file (const char *dst_file, const char *dst_dir, const char *file,
 }
 
 /* Select the appropriate backup type and backup a file. See backup_file
    for the argument description. */
 int
 do_archive_file (const char *dst_file, const char *dst_dir, const char *file,
-		 struct archive_descr *archive, uid_t uid, gid_t gid,
+		 const struct archive_descr *archive, uid_t uid, gid_t gid,
 		 const char *reldir)
 {
   switch (archive->type)
     {
     case archive_none:
       break;
@@ -407,13 +407,13 @@ do_archive_file (const char *dst_file, const char *dst_dir, const char *file,
 /* Move the part FILE_ID of the triplet TRP between the directories in
    DPAIR. RELDIR gives relative directory (i.e. the directory part of
    the file name) for backup purposes.
 
    Do nothing if dry_run_mode is set. */
 int
-dir_move_file (struct file_triplet *trp, struct spool *spool,
+dir_move_file (struct file_triplet *trp, const struct spool *spool,
 	       enum file_type file_id, const char *reldir)
 {
   char *dst_file;
   int rc = 0;
   char *dst_dir = create_directory (spool->dest_dir, reldir,
 				    TRIPLET_UID (trp), TRIPLET_GID (trp));
@@ -444,13 +444,13 @@ dir_move_file (struct file_triplet *trp, struct spool *spool,
 
 /* Archive the file FILE_NAME, located in DPAIR->dest_dir, and remove the
    file. Get user IDs from the triplet TRP.
    Do nothing if dry_run_mode is set.
 */
 int
-archive_single_file (struct file_triplet *trp, struct spool *spool,
+archive_single_file (struct file_triplet *trp, const struct spool *spool,
 		     const char *file_name, const char *reldir,
 		     int noentok)
 {
   char *dst_file;
   int rc = 0;
   char *dst_dir = create_directory (spool->dest_dir, reldir,
@@ -514,13 +514,13 @@ make_signame (const char *file_name)
 /* Archive the file FILE_NAME, located in DPAIR->dest_dir, and remove the
    file. Get user IDs from the triplet TRP. Unless FILE_NAME ends in
    ".sig", do the same with FILE_NAME.sig, if such a file exists.
    Do nothing if dry_run_mode is set.
 */
 int
-dir_archive_file (struct file_triplet *trp, struct spool *spool,
+dir_archive_file (struct file_triplet *trp, const struct spool *spool,
 		  const char *reldir, const char *file_name)
 {
   int rc;
   char *signame;
 
   rc = archive_single_file (trp, spool, file_name, reldir, 0);
@@ -534,13 +534,13 @@ dir_archive_file (struct file_triplet *trp, struct spool *spool,
 
 /* Create a symbolic link from WANTED_SRC to WANTED_DST in the subdirectory
    RELDIR of DPAIR->dest_dir. Get ownership information from TRP.
 
    Do nothing if dry_run_mode is set. */
 int
-dir_symlink_file (struct file_triplet *trp, struct spool *spool,
+dir_symlink_file (struct file_triplet *trp, const struct spool *spool,
 		  const char *reldir,
 		  const char *wanted_src, const char *wanted_dst)
 {
   int rc = 0;
   struct saved_cwd cwd;
   char *dst_dir = create_directory (spool->dest_dir, reldir,
@@ -694,13 +694,13 @@ do_rmsymlink_file (const char *dst_file, int noentok)
 /* Remove the symbolic link DPAIR->dest_dir/RELDIR/FILE_NAME
 
    Get ownership information from TRP.
 
    Do nothing if dry_run_mode is set. */
 int
-dir_rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+dir_rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 		    const char *reldir, const char *file_name)
 {
   char *dst_file;
   int rc = 0;
   char *signame;
   char *dst_dir = create_directory (spool->dest_dir, reldir,
diff --git a/src/gpg.c b/src/gpg.c
index d6e2301..6f7dfb6 100644
--- a/src/gpg.c
+++ b/src/gpg.c
@@ -200,13 +200,13 @@ gpg_sig_ok_p (gpgme_ctx_t ctx, gpgme_signature_t sig)
 }
 
 /* Verify the directive file from TRP using public key PUBKEY */
 /* FIXME: spool currently unused */
 int
 verify_directive_signature (struct file_triplet *trp,
-			    struct spool *spool, const char *pubkey)
+			    const struct spool *spool, const char *pubkey)
 {
   gpgme_ctx_t ctx;
   gpgme_data_t key_data, directive_data, plain;
   off_t size;
   gpgme_error_t ec;
   int rc;
@@ -258,13 +258,13 @@ verify_directive_signature (struct file_triplet *trp,
 
 /* Verify the detached signature of TRP.
    NOTE: It is assumed that the public key is already registered (by
    a previous call to verify_directive_signature). */
 int
 verify_detached_signature (struct file_triplet *trp,
-			   struct spool *spool)
+			   const struct spool *spool)
 {
   gpgme_engine_info_t info;
   const char *argv[5];
 
   fail_if_err (gpgme_get_engine_info (&info));
   while (info && info->protocol != GPGME_PROTOCOL_OpenPGP)
diff --git a/src/job.c b/src/job.c
new file mode 100644
index 0000000..9678139
--- a/dev/null
+++ b/src/job.c
@@ -0,0 +1,278 @@
+/* wydawca - automatic release submission daemon
+   Copyright (C) 2009 Sergey Poznyakoff
+
+   This program 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 of the License, or (at your
+   option) any later version.
+
+   This program 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 this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "wydawca.h"
+
+#define STATE_FINISHED 0x01
+#define STATE_QUEUED   0x02
+#define STATE_ACTIVE   0x04
+  
+struct job
+{
+  struct job *next, *prev;
+  int state;
+  const struct spool *spool;
+  uid_t uid;
+  pid_t pid;
+  time_t timestamp;
+  int exit_status;
+};
+
+struct job *queue;
+size_t jobmax;
+size_t jobcnt;
+
+struct job *
+job_locate (const struct spool *spool, uid_t uid)
+{
+  struct job *p;
+  for (p = queue; p; p = p->next)
+    if (p->spool == spool && p->uid == uid)
+      break;
+  return p;
+}
+
+size_t
+job_active_count ()
+{
+  struct job *job;
+  size_t count = 0;
+  for (job = queue; job; job = job->next)
+    if (job->state & STATE_ACTIVE)
+      count++;
+  return count;
+}
+
+void
+wydawca_scanner (struct job *job)
+{
+  scan_spool (job->spool, 1, &job->uid);
+  mail_finish ();
+}
+
+int 
+job_start (struct job *job)
+{
+  pid_t pid;
+
+  if (jobmax && jobcnt == jobmax)
+    {
+      logmsg (LOG_NOTICE, "maximum number of processes active");
+      return 1;
+    }
+
+  if (debug_level)
+    logmsg (LOG_DEBUG, _("starting job: %s, %lu"), job->spool->tag, job->uid);
+  
+  if (single_process)
+    {
+      wydawca_scanner (job);
+      return 0;
+    }
+  
+  pid = fork ();
+  if (pid == 0)
+    {
+      wydawca_scanner (job);
+      exit (0);
+    }
+  else if (pid == -1)
+    {
+      logmsg (LOG_CRIT, "fork: %s", strerror (errno));
+      return -1;
+    }
+  else
+    {
+      job->state = STATE_ACTIVE;
+      job->pid = pid;
+      jobcnt++;
+    }
+  return 0;
+} 
+
+void
+job_remove (struct job *job)
+{
+  struct job *p;
+
+  if (debug_level)
+    logmsg (LOG_DEBUG, _("removing job: %s, %lu"), job->spool->tag, job->uid);
+  p = job->prev;
+  if (p)
+    p->next = job->next;
+  else
+    queue = job->next;
+
+  p = job->next;
+  if (p)
+    p->prev = job->prev;
+}
+
+void
+job_insert (struct job *job, struct job *elt)
+{
+  struct job *p;
+  
+  job->prev = elt;
+  if (!elt)
+    {
+      if (queue)
+	queue->prev = job;
+      job->next = queue;
+      queue = job;
+      return;
+    }
+
+  p = elt->next;
+  elt->next = job;
+
+  if (p)
+    p->prev = job;
+}
+	       
+int
+schedule_job (const struct spool *spool, uid_t uid)
+{
+  struct job *job;
+
+  if (debug_level)
+    logmsg (LOG_DEBUG, _("scheduling job: %s, %lu"), spool->tag, uid);
+  
+  job = job_locate (spool, uid);
+  if (!job)
+    {
+      job = xzalloc (sizeof (*job));
+      job->spool = spool;
+      job->uid = uid;
+      job->pid = -1;
+      time (&job->timestamp);
+      job_insert (job, NULL);
+    }
+  
+  job->state |= STATE_QUEUED;
+  job_start (job);
+}      
+
+static void
+print_status (struct job *job, int expect_term)
+{
+  struct passwd *pw = getpwuid (job->uid);
+  int status = job->exit_status;
+  
+  if (WIFEXITED (status))
+    {
+      if (WEXITSTATUS (status) == 0)
+	{
+	  if (debug_level)
+	    logmsg (LOG_DEBUG,
+		    _("%lu (%s, %s) exited successfully"),
+		    (unsigned long) job->pid, job->spool->tag, pw->pw_name);
+	}
+      else
+	logmsg (LOG_ERR,
+		_("%lu (%s, %s) failed with status %d"),
+		(unsigned long) job->pid, job->spool->tag, pw->pw_name,
+		WEXITSTATUS (status));
+    }
+  else if (WIFSIGNALED (status))
+    {
+      int prio;
+      if (expect_term && WTERMSIG (status) == SIGTERM)
+	{
+	  if (!debug_level)
+	    return;
+	  prio = LOG_DEBUG;
+	}
+      else
+	prio = LOG_ERR;
+
+      logmsg (prio,
+	      _("%lu (%s, %s) terminated on signal %d"),
+	      job->pid, job->spool->tag, pw->pw_name, WTERMSIG (status));
+    }
+  else if (WIFSTOPPED (status))
+    logmsg (LOG_NOTICE,
+	    _("%lu (%s, %s) stopped on signal %d"),
+	    job->pid, job->spool->tag, pw->pw_name, WSTOPSIG (status));
+#ifdef WCOREDUMP
+  else if (WCOREDUMP (status))
+    logmsg (LOG_NOTICE,
+	    _("%lu (%s, %s) dumped core"),
+	    job->pid, job->spool->tag, pw->pw_name);
+#endif
+  else
+    logmsg (LOG_ERR,
+	    _("%lu (%s, %s) terminated with unrecognized status"),
+	    job->pid, job->spool->tag, pw->pw_name);
+}
+
+static int wakeup;
+
+RETSIGTYPE
+queue_signal (int sig)
+{
+  wakeup = 1;
+  signal (sig, queue_signal);
+}
+
+void
+job_queue_runner ()
+{
+  int status;
+  struct job *job;
+
+  if (!wakeup)
+    return;
+  wakeup = 0;
+
+  for (;;)
+    {
+      pid_t pid = waitpid ((pid_t)-1, &status, WNOHANG);
+      if (pid <= 0)
+	break;
+      for (job = queue; job; job = job->next)
+	{
+	  if ((job->state & STATE_ACTIVE) && job->pid == pid)
+	    {
+	      job->state &= ~STATE_ACTIVE;
+	      job->state |= STATE_FINISHED;
+	      job->exit_status = status;
+	      jobcnt--;
+	    }
+	}
+    }
+  
+  for (job = queue; job;)
+    {
+      struct job *next = job->next;
+      if (job->state & STATE_FINISHED)
+	{
+	  print_status (job, 0);
+	  if ((job->state &= ~STATE_FINISHED) == 0)
+	    job_remove (job);
+	}
+      if (job->state == STATE_QUEUED)
+	if (job_start (job))
+	  pause ();
+      job = next;
+    }	    
+}
+
+void
+job_init ()
+{
+  signal (SIGCHLD, queue_signal);
+}
diff --git a/src/mail.c b/src/mail.c
index 7987819..ea74b8c 100644
--- a/src/mail.c
+++ b/src/mail.c
@@ -101,13 +101,16 @@ mail_send_message (mu_address_t rcpt, const char *text)
 }
 
 void
 mail_finish ()
 {
   if (mailer_opened)
-    mu_mailer_close (mailer);
+    {
+      mu_mailer_close (mailer);
+      mailer_opened = 0;
+    }
 }
 
 
 struct message_template
 {
   char *name;
@@ -266,43 +269,43 @@ get_recipient (struct access_method *method, struct file_triplet *trp,
   char *text;
   int rc;
   void *md;
 
   if (method->type == method_none)
     {
-      *errp = "access method is not configured";
+      *errp = N_("access method is not configured");
       return NULL;
     }
 
   md = method_open (method);
   if (!md)
     {
-      *errp = "failed to open access method";
+      *errp = N_("failed to open access method");
       return NULL;
     }
 
   make_default_meta (def, trp->user, trp->project);
   meta_escape (method, md, def);
   text = meta_expand_string (method->query, def, NULL);
   meta_free (def);
 
   rc = method_run (method, md, text);
   free (text);
   if (rc)
     {
-      *errp = "cannot obtain recipient emails";
+      *errp = N_("cannot obtain recipient emails");
       method_close (method, md);
       return NULL;
     }
 
   nrows = method_num_rows (method);
   ncols = method_num_cols (method);
 
   if (nrows == 0)
     {
-      *errp = "cannot obtain recipient emails";
+      *errp = N_("cannot obtain recipient emails");
       return NULL;
     }
 
   for (i = 0; i < nrows; i++)
     {
       mu_address_t addr;
@@ -347,13 +350,13 @@ do_notify (struct file_triplet *trp, enum notification_event ev,
 
   if (!rcpt)
     {
       logmsg (LOG_ERR, _("not notifying %s (project %s) about %s: %s"),
 	      notification_target_str (ntf->tgt),
 	      trp->project,
-	      notification_event_str (ev), errp);
+	      notification_event_str (ev), gettext (errp));
       return;
     }
 
   if (debug_level)
     {
       size_t size;
diff --git a/src/net.c b/src/net.c
new file mode 100644
index 0000000..efb6225
--- a/dev/null
+++ b/src/net.c
@@ -0,0 +1,227 @@
+/* wydawca - automatic release submission daemon
+   Copyright (C) 2007, 2009 Sergey Poznyakoff
+
+   Wydawca 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 of the License, or (at your
+   option) any later version.
+
+   Wydawca 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 wydawca. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "wydawca.h"
+
+static int
+open_listener ()
+{
+  int fd;
+
+  if (listen_sockaddr.sa == NULL)
+    {
+      logmsg (LOG_CRIT, _("listener address is not configured"));
+      exit (1);
+    }
+  
+  fd = socket (listen_sockaddr.sa->sa_family, SOCK_STREAM, 0);
+  if (fd == -1)
+    {
+      logmsg (LOG_CRIT, _("cannot create socket: %s"),
+	      strerror(errno));
+      exit (1);
+    }
+  if (listen_sockaddr.sa->sa_family == AF_UNIX)
+    {
+      struct stat st;
+      struct sockaddr_un *s_un = (struct sockaddr_un *) listen_sockaddr.sa;
+      if (stat (s_un->sun_path, &st))
+	{
+	  if (errno != ENOENT)
+	    {
+	      logmsg (LOG_CRIT, _("%s: cannot stat socket: %s"),
+		      s_un->sun_path, strerror (errno));
+	      exit (1);
+	    }
+	}
+      else
+	{
+	  /* FIXME: Check permissions? */
+	  if (!S_ISSOCK (st.st_mode))
+	    {
+	      logmsg (LOG_CRIT, _("%s: not a socket"),
+		      s_un->sun_path, strerror (errno));
+	      exit (1);
+	    }
+	  unlink (s_un->sun_path);
+	}
+      /* FIXME: Setup umask */
+    }
+  else
+    {
+      int yes = 1;
+      setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (void *) &yes, sizeof(yes));
+    }
+  
+  if (bind (fd, listen_sockaddr.sa, listen_sockaddr.len) < 0)
+    {
+      logmsg (LOG_CRIT, _("cannot bind to local address: %s"),
+	      strerror (errno));
+      close (fd);
+      exit (1);
+    }
+  if (listen (fd, 8) == -1) 
+    {
+      logmsg (LOG_CRIT, "listen: %s", strerror (errno));
+      close (fd);
+      exit (1);
+    }
+    
+  return fd;
+}
+
+static void
+trim_crlf (char *s)
+{
+  size_t len = strlen (s);
+  if (len > 0 && s[len-1] == '\n')
+    {
+      s[--len] = 0;
+      if (len > 0 && s[len-1] == '\r')
+	s[--len] = 0;
+    }
+}
+    
+void
+handle_connection (FILE *fp)
+{
+  char *buf = NULL;
+  size_t buflen = 0;
+  const struct spool *spool;
+  char *p;
+  struct passwd *pw;
+  
+  if (getline (&buf, &buflen, fp) <= 0)
+    return;
+  trim_crlf (buf);
+  if (debug_level)
+    logmsg (LOG_DEBUG, "recv: %s", buf);
+  spool = wydawca_find_spool (buf);
+  if (!spool)
+    {
+      fprintf (fp, "- Unknown service name\r\n");
+      free (buf);
+      return;
+    }
+  else if (spool->url)
+    fprintf (fp, "+ OK, URL %s\r\n", spool->url);
+  else
+    fprintf (fp, "+ OK, spool %s\r\n", spool->tag);
+    
+  if (getline (&buf, &buflen, fp) <= 0)
+    {
+      logmsg (LOG_ERR, "protocol error");
+      free (buf);
+      return;
+    }
+  
+  if (debug_level)
+    logmsg (LOG_DEBUG, "recv: %s", buf);
+
+  p = strchr (buf, ' ');
+  if (p)
+    {
+      *p++ = 0;
+      while (*p && (*p == ' ' || *p == '\t'))
+	p++;
+    }
+  else
+    p = "";
+
+  pw = getpwnam (buf);
+  if (pw)
+    schedule_job (spool, pw->pw_uid);
+  else
+    logmsg (LOG_ERR, "no such user: %s", buf);
+  free (buf);
+}
+
+static int reconfigure;
+static int terminate;
+
+RETSIGTYPE
+sig_hup (int sig)
+{
+  reconfigure = 1;
+  terminate = 1;
+}
+
+RETSIGTYPE
+sig_term (int sig)
+{
+  terminate = 1;
+}
+
+void
+wydawca_listener ()
+{
+  int ctlfd = open_listener ();
+
+  job_init ();
+  signal (SIGHUP, sig_hup);
+  signal (SIGTERM, sig_term);
+  signal (SIGQUIT, sig_term);
+  signal (SIGINT, sig_term);
+  while (!terminate)
+    {
+      int fd;
+      FILE *fp;
+      int rc;
+      fd_set rset;
+      struct timeval to, *pto;
+      union {
+	struct sockaddr sa;
+	struct sockaddr_in s_in;
+	struct sockaddr_un s_un;
+      } addr;
+      socklen_t len;
+       
+      job_queue_runner ();
+      FD_ZERO (&rset);
+      FD_SET (ctlfd, &rset);
+
+      if (wakeup_interval)
+	{
+	  to.tv_sec = wakeup_interval;
+	  to.tv_usec = 0;
+	  *pto = to;
+	}
+      else
+	pto = NULL;
+
+      rc = select (ctlfd + 1, &rset, NULL, NULL, pto);
+      if (rc == 0)
+	continue;
+      else if (rc < 0)
+	{
+	  if (errno == EINTR)
+	    continue;
+	  logmsg (LOG_ERR, "select: %s", strerror (errno));
+	  break;
+	}
+
+      len = sizeof (addr);
+      fd = accept (ctlfd, (struct sockaddr*) &addr, &len);
+      if (fd == -1)
+	continue;
+      /* FIXME: Check if the connection is allowed */
+      fp = fdopen (fd, "r+");
+      handle_connection (fp);
+      fclose (fp);
+    }
+}
+      
+  
diff --git a/src/null.c b/src/null.c
index 7ead150..6a1b0a7 100644
--- a/src/null.c
+++ b/src/null.c
@@ -14,56 +14,56 @@
    You should have received a copy of the GNU General Public License along
    with wydawca. If not, see <http://www.gnu.org/licenses/>. */
 
 #include "wydawca.h"
 
 int
-null_move_file (struct file_triplet *trp, struct spool *spool,
+null_move_file (struct file_triplet *trp, const struct spool *spool,
 		enum file_type file_id, const char *reldir)
 {
   const char *file_name = trp->file[file_id].name;
   if (debug_level)
-    logmsg (LOG_DEBUG, _("%s: installing file `%s/%s'"),
-	    spool->url, reldir, file_name);
+    logmsg (LOG_DEBUG, _("spool %s: installing file `%s/%s'"),
+	    spool->tag, reldir, file_name);
   UPDATE_STATS (STAT_UPLOADS);
   if (unlink (file_name))
     {
       logmsg (LOG_ERR, _("cannot unlink %s: %s"),
 	      file_name, strerror (errno));
       return 1;
     }
   return 0;
 }
 
 int
-null_archive_file (struct file_triplet *trp, struct spool *spool,
+null_archive_file (struct file_triplet *trp, const struct spool *spool,
 		   const char *file_name, const char *reldir)
 {
   if (debug_level)
-    logmsg (LOG_DEBUG, _("%s: archiving `%s'"),  spool->url, file_name);
+    logmsg (LOG_DEBUG, _("spool %s: archiving `%s'"), spool->tag, file_name);
   UPDATE_STATS (STAT_ARCHIVES);
   return 0;
 }
 
 int
-null_symlink_file (struct file_triplet *trp, struct spool *spool,
+null_symlink_file (struct file_triplet *trp, const struct spool *spool,
 		   const char *reldir,
 		   const char *wanted_src, const char *wanted_dst)
 {
   if (debug_level)
-    logmsg (LOG_DEBUG, _("%s: symlinking `%s' to `%s'"),
-	    spool->url, wanted_src, wanted_dst);
+    logmsg (LOG_DEBUG, _("spool %s: symlinking `%s' to `%s'"),
+	    spool->tag, wanted_src, wanted_dst);
   UPDATE_STATS (STAT_SYMLINKS);
   return 0;
 }
 
 int
-null_rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+null_rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 		     const char *reldir, const char *file_name)
 {
   if (debug_level)
-    logmsg (LOG_DEBUG, _("%s: removing symlink `%s/%s'"),
-	    spool->url, reldir, file_name);
+    logmsg (LOG_DEBUG, _("spool %s: removing symlink `%s/%s'"),
+	    spool->tag, reldir, file_name);
   UPDATE_STATS (STAT_RMSYMLINKS);
   return 0;
 }
 
diff --git a/src/pidfile.c b/src/pidfile.c
new file mode 100644
index 0000000..484cabd
--- a/dev/null
+++ b/src/pidfile.c
@@ -0,0 +1,90 @@
+/* wydawca - automatic release submission daemon
+   Copyright (C) 2007, 2009 Sergey Poznyakoff
+
+   Wydawca 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 of the License, or (at your
+   option) any later version.
+
+   Wydawca 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 wydawca. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "wydawca.h"
+
+char *pidfile = LOCALSTATEDIR "/run/wydawca.pid";
+int force_startup;
+
+
+void
+remove_pidfile (void)
+{
+  unlink (pidfile);
+}
+
+void
+check_pidfile ()
+{
+  FILE *fp = fopen (pidfile, "r+");
+
+  if (fp)
+    {
+      unsigned long pid;
+      if (fscanf (fp, "%ul\n", &pid) != 1)
+	{
+	  logmsg (LOG_ERR, _("malformed pidfile %s"), pidfile);
+	  if (!force_startup)
+	    exit (1);
+	}
+      else 
+	{
+	  if (kill (pid, 0))
+	    {
+	      if (errno != ESRCH)
+		{
+		  logmsg (LOG_ERR,
+			  _("cannot verify if PID %lu is running: %s"),
+			  pid, strerror (errno));
+		  if (!force_startup)
+		    exit (1);
+		}
+	    }
+	  else if (!force_startup)
+	    {
+	      logmsg (LOG_ERR,
+		      _("another wydawca instance may be running (PID %lu)"),
+		      pid);
+	      exit (1);
+	    }
+	}
+      logmsg (LOG_NOTICE, _("replacing pidfile %s (PID %lu)"),
+	      pidfile, pid);
+      fseek (fp, 0, SEEK_SET);
+    }
+  else if (errno != ENOENT)
+    {
+      logmsg (LOG_ERR, _("cannot open pidfile %s: %s"), pidfile,
+	      strerror (errno));
+      exit (1);
+    }
+  else
+    {
+      fp = fopen (pidfile, "w");
+      if (!fp)
+	{
+	  logmsg (LOG_ERR,
+		  _("cannot open pidfile %s for writing: %s"),
+		  pidfile, strerror (errno));
+	  exit (1);
+	}
+    }
+  fprintf (fp, "%lu\n", getpid ());
+  fclose (fp);
+  atexit (remove_pidfile);
+}
+
+
diff --git a/src/process.c b/src/process.c
index 0d2bf5e..20bfd38 100644
--- a/src/process.c
+++ b/src/process.c
@@ -30,12 +30,47 @@ register_spool (struct spool *spool)
   struct spool_list *sp = xmalloc (sizeof *sp);
   sp->spool = *spool;
   sp->next = spool_list;
   spool_list = sp;
 }
 
+static int
+spool_check_alias (struct spool *spool, const char *name)
+{
+  int rc = 0;
+        
+  if (spool->aliases)
+    {
+      gl_list_iterator_t itr = gl_list_iterator (spool->aliases);
+      const void *p;
+      
+      while (gl_list_iterator_next (&itr, &p, NULL))
+	if (strcmp (name, p) == 0)
+	  {
+	    rc = 1;
+	    break;
+	  }
+      gl_list_iterator_free (&itr);
+    }
+  return rc;
+}
+
+struct spool *
+wydawca_find_spool (const char *name)
+{
+  struct spool_list *sp;
+
+  for (sp = spool_list; sp; sp = sp->next)
+    {
+      if (strcmp (sp->spool.tag, name) == 0
+	  || spool_check_alias (&sp->spool, name))
+	return &sp->spool;
+    }
+  return NULL;
+}
+
 /* Return true if NAME is a directory. If stat fails, return the error
    code in EC */
 int
 test_dir (const char *name, int *ec)
 {
   struct stat st;
@@ -97,16 +132,28 @@ parse_file_name (const char *name, struct file_info *finfo)
 	  return;
 	}
     }
   abort (); /* should not happen */
 }
 
+int
+match_uid_p (uid_t uid, int uc, uid_t *uv)
+{
+  int i;
+  if (!uv)
+    return 1;
+  for (i = 0; i < uc; i++)
+    if (uv[i] == uid)
+      return 1;
+  return 0;
+}
+
 /* Scan upload directory from the DPAIR and register all files found
    there, forming triplets when possible */
 void
-scan_spool (struct spool *spool)
+scan_spool (const struct spool *spool, int uc, uid_t *uv)
 {
   DIR *dir;
   struct dirent *ent;
 
   if (debug_level)
     logmsg (LOG_DEBUG, "%s -> %s", spool->source_dir,
@@ -124,14 +171,15 @@ scan_spool (struct spool *spool)
     {
       logmsg (LOG_ERR, _("cannot open directory %s: %s"), spool->source_dir,
 	      strerror (errno));
       return;
     }
 
-  timer_start ("directory");
-  timer_start (spool->url);
+  timer_start ("spool");
+  /* FIXME: prefix spool tag with something */
+  timer_start (spool->tag);
   while ((ent = readdir (dir)))
     {
       struct stat st;
       struct file_info finfo;
 
       if (strcmp (ent->d_name, ".") == 0 || strcmp (ent->d_name, "..") == 0)
@@ -149,25 +197,25 @@ scan_spool (struct spool *spool)
 	{
 	  logmsg (LOG_NOTICE, _("not a regular file: %s/%s"),
 		  spool->source_dir, ent->d_name);
 	  continue;
 	}
 
-      if (!match_uid_p (st.st_uid))
+      if (!match_uid_p (st.st_uid, uc, uv))
 	{
 	  if (debug_level)
 	    logmsg (LOG_DEBUG, _("ignoring file: %s/%s"),
 		    spool->source_dir, ent->d_name);
 	  continue;
 	}
       
       finfo.sb = st;
       parse_file_name (ent->d_name, &finfo);
 
       if (debug_level)
-	logmsg (LOG_DEBUG, _("file %s: %s, root %.*s"), ent->d_name,
+	logmsg (LOG_DEBUG, _("found file %s: %s, stem: %.*s"), ent->d_name,
 		  file_type_str (finfo.type), finfo.root_len, finfo.name);
 
       register_file (&finfo);
     }
 
   closedir (dir);
@@ -183,35 +231,35 @@ scan_spool (struct spool *spool)
               logmsg (LOG_ERR, _("failed to initialize access method %d"), i);
               return;
             }
         }
       enumerate_triplets (spool);
    }
-  timer_stop (spool->url);
-  timer_stop ("directory");
+  timer_stop (spool->tag);
+  timer_stop ("spool");
 }
 
 static void
 close_methods (struct spool *spool)
 {
   int i;
   for (i = 0; i < NITEMS (spool->access_method); i++)
     method_done (spool->access_method[i]);
 }
 
 /* Scan all configured update directories */
 void
-scan_directories ()
+scan_directories (int uidc, uid_t *uidv)
 {
   struct spool_list *sp;
 
   timer_start ("wydawca");
 
   for (sp = spool_list; sp; sp = sp->next)
     if (enabled_spool_p (&sp->spool))
-      scan_spool (&sp->spool);
+      scan_spool (&sp->spool, uidc, uidv);
 
   for (sp = spool_list; sp; sp = sp->next)
     close_methods (&sp->spool);
   timer_stop ("wydawca");
 }
 
diff --git a/src/triplet.c b/src/triplet.c
index 6641211..717fd2a 100644
--- a/src/triplet.c
+++ b/src/triplet.c
@@ -179,13 +179,13 @@ remove_triplet (struct file_triplet *trp)
 
 /* Process a single triplet from the table */
 static bool
 triplet_processor (void *data, void *proc_data)
 {
   struct file_triplet *trp = data;
-  struct spool *spool = proc_data;
+  const struct spool *spool = proc_data;
 
   trp->spool = spool;
 
   if (debug_level)
     logmsg (LOG_DEBUG, "FILE %s, DIST=%s, SIG=%s, DIRECTIVE=%s",
 	    trp->name,
@@ -227,20 +227,20 @@ triplet_processor (void *data, void *proc_data)
 
   return true;
 }
 
 /* Process all triplets from the table according to the SPOOL */
 void
-enumerate_triplets (struct spool *spool)
+enumerate_triplets (const struct spool *spool)
 {
   if (debug_level)
-    logmsg (LOG_DEBUG, _("processing files for %s (%s)"),
-	    spool->url, mu_url_to_string (spool->dest_url));
+    logmsg (LOG_DEBUG, _("processing spool %s (%s)"),
+	    spool->tag, mu_url_to_string (spool->dest_url));
   if (triplet_table)
     {
-      hash_do_for_each (triplet_table, triplet_processor, spool);
+      hash_do_for_each (triplet_table, triplet_processor, (void*) spool);
       hash_clear (triplet_table);
     }
 }
 
 size_t
 count_collected_triplets ()
@@ -254,12 +254,19 @@ expand_project_base (struct metadef *def, void *data)
 {
   struct file_triplet *trp = data;
   return trp->project;
 }
 
 static const char *
+expand_tag (struct metadef *def, void *data)
+{
+  struct file_triplet *trp = data;
+  return trp->spool->tag;
+}
+
+static const char *
 expand_url (struct metadef *def, void *data)
 {
   struct file_triplet *trp = data;
   return trp->spool->url;
 }
 
@@ -573,12 +580,13 @@ DECL_EXPAND_TIMER(system)
   DECL_TIMER(name, user),			\
   DECL_TIMER(name, system)  
 
 struct metadef triplet_meta[] = {
   { "project",        NULL, expand_project_base, NULL },
   { "url",            NULL, expand_url, NULL },
+  { "spool",          NULL, expand_tag, NULL },
   { "dir",            NULL, expand_relative_dir, NULL },
   { "dest-dir",       NULL, expand_dest_dir, NULL },
   { "source-dir",     NULL, expand_source_dir, NULL },
   { "triplet:full",   NULL, expand_triplet_full, NULL },
   { "triplet:upload", NULL, expand_triplet_upload, NULL },
   { "triplet:dist",   NULL, expand_triplet_dist, NULL },
diff --git a/src/verify.c b/src/verify.c
index 14651d2..522b865 100644
--- a/src/verify.c
+++ b/src/verify.c
@@ -89,13 +89,13 @@ make_default_meta (struct metadef def[5], const char *user,
   def[4].kw = NULL;
 }
 
 /* Verify if USER has upload rights on the directory (project) requested
    by TRP */
 int
-check_access_rights (struct file_triplet *trp, struct spool *spool,
+check_access_rights (struct file_triplet *trp, const struct spool *spool,
 		     const char *user)
 {
   struct access_method *method = spool->access_method[verify_method];
   int rc;
   char *command;
   const char *result;
@@ -140,13 +140,13 @@ check_access_rights (struct file_triplet *trp, struct spool *spool,
     }
 
   return 0;
 }
 
 int
-verify_directive_file (struct file_triplet *trp, struct spool *spool)
+verify_directive_file (struct file_triplet *trp, const struct spool *spool)
 {
   struct passwd *pw;
   char *command;
   struct access_method *method = spool->access_method[gpg_key_method];
   const char *pubkey;
   int rc;
diff --git a/src/vtab.c b/src/vtab.c
index c34896c..36d8af8 100644
--- a/src/vtab.c
+++ b/src/vtab.c
@@ -48,46 +48,46 @@ url_to_vtab (mu_url_t url, struct virt_tab *vtab)
       }
   return 1;
 }
 
 
 int
-move_file (struct file_triplet *trp, struct spool *spool,
+move_file (struct file_triplet *trp, const const struct spool *spool,
 	   enum file_type file_id, const char *reldir)
 {
   int rc = spool->vtab.move_file (trp, spool, file_id, reldir);
   report_add ("Move %s to %s: %s", trp->file[file_id].name, reldir,
 	      rc == 0 ? "OK" : "FAILED");
   return rc;
 }
 
 int
-archive_file (struct file_triplet *trp, struct spool *spool,
+archive_file (struct file_triplet *trp, const struct spool *spool,
 	      const char *reldir, const char *file_name)
 {
   int rc = spool->vtab.archive_file (trp, spool, reldir, file_name);
   report_add ("Archive and remove %s/%s: %s", reldir, file_name,
 	      rc == 0 ? "OK" : "FAILED");
   return rc;
 }
 
 int
-symlink_file (struct file_triplet *trp, struct spool *spool,
+symlink_file (struct file_triplet *trp, const struct spool *spool,
 	      const char *reldir,
 	      const char *wanted_src, const char *wanted_dst)
 {
   int rc = spool->vtab.symlink_file (trp, spool, reldir,
 				     wanted_src, wanted_dst);
   report_add ("Symlink %s to %s in %s/: %s", wanted_src, wanted_dst,
 	      reldir,
 	      rc == 0 ? "OK" : "FAILED");
   return rc;
 }
 
 int
-rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 		const char *reldir, const char *file_name)
 {
   int rc = spool->vtab.rmsymlink_file (trp, spool, reldir, file_name);
   report_add ("Remove symlink %s/%s: %s", reldir, file_name,
 	      rc == 0 ? "OK" : "FAILED");
   return rc;
diff --git a/src/wydawca.c b/src/wydawca.c
index ce78fc1..cc6c8f0 100644
--- a/src/wydawca.c
+++ b/src/wydawca.c
@@ -29,12 +29,22 @@ int syslog_include_prio; /* syslog messages include priority */
 unsigned long print_stats;         /* Print final statistics output */
 time_t file_sweep_time = 0;
 char *tar_command_name = "tar";
 int archive_signatures = 1; /* Archive sig files by default */
 int lint_mode = 0;
 int preprocess_only = 0;
+int cron_option = 0;
+int foreground_option = -1;
+int single_process_option = -1;
+
+int daemon_mode = 0;
+int foreground;
+int single_process;
+time_t wakeup_interval;
+
+struct gconf_sockaddr listen_sockaddr;
 
 unsigned wydawca_stat[MAX_STAT];
 
 
 /* Logging */
 void
@@ -103,52 +113,26 @@ logmsg (int prio, char *fmt, ...)
   va_start (ap, fmt);
   log_printer (prio, fmt, ap);
   va_end (ap);
 }
 
 
-
-enum {
-  SYSLOG_OPTION = 256,
-  CONFIG_HELP_OPTION,
-  DUMP_GRAMMAR_TRACE_OPTION,
-  DUMP_LEX_TRACE_OPTION
-};
-
-struct option options[] = {
-  { "config-file", required_argument, NULL, 'c' },
-  { "config-help", no_argument, NULL, CONFIG_HELP_OPTION },
-  { "dump-grammar-trace", no_argument, NULL, DUMP_GRAMMAR_TRACE_OPTION },
-  { "dump-lex-trace", no_argument, NULL, DUMP_LEX_TRACE_OPTION },
-  { "debug", no_argument, NULL, 'd' },
-  { "stderr", no_argument, NULL, 'e' },
-  { "syslog", no_argument, NULL, SYSLOG_OPTION },
-  { "cron", no_argument, NULL, SYSLOG_OPTION },
-  { "help", no_argument, NULL, 'h' },
-  { "version", no_argument, NULL, 'v' },
-  { "dry-run", no_argument, NULL, 'n' },
-  { "lint", no_argument, NULL, 't' },
-  { "include-directory", optional_argument, NULL, 'I' },
-  { NULL }
-};
-
-
 static char *stat_name[MAX_STAT] = {
-  "errors",
-  "warnings",
-  "bad signatures",
-  "access violation attempts",
-  "complete triplets",
-  "incomplete triplets",
-  "bad triplets",
-  "expired triplets",
-  "triplet successes",
-  "files uploaded",
-  "files archived",
-  "symlinks created",
-  "symlinks removed",
+  N_("errors"),
+  N_("warnings"),
+  N_("bad signatures"),
+  N_("access violation attempts"),
+  N_("complete triplets"),
+  N_("incomplete triplets"),
+  N_("bad triplets"),
+  N_("expired triplets"),
+  N_("triplet successes"),
+  N_("files uploaded"),
+  N_("files archived"),
+  N_("symlinks created"),
+  N_("symlinks removed"),
 };
 
 static char *stat_kwname[MAX_STAT] = {
   "stat:errors",
   "stat:warnings",
   "stat:bad_signatures",
@@ -209,13 +193,13 @@ logstats ()
   int i;
 
   if (stat_mask_p (print_stats))
     {
       for (i = 0; i < MAX_STAT; i++)
 	if (print_stats & STAT_MASK (i))
-	  logmsg (LOG_INFO, "%s: %u", stat_name[i], wydawca_stat[i]);
+	  logmsg (LOG_INFO, "%s: %u", gettext (stat_name[i]), wydawca_stat[i]);
     }
 
   mail_stats ();
 }
 
 
@@ -241,13 +225,13 @@ gconf_print_diag (gconf_locus_t *locus, int err, int errcode, const char *msg)
 	logmsg (err ? LOG_ERR : LOG_WARNING, "%s", msg);
     }
 }
 
 
 static int uidc;
-static char *uidv;
+static uid_t *uidv;
 
 static int
 collect_uids (int argc, char **argv)
 {
   int i;
     
@@ -269,24 +253,12 @@ collect_uids (int argc, char **argv)
 	}
       else
 	uidv[i] = pw->pw_uid;
     }
 }
 
-int
-match_uid_p (uid_t uid)
-{
-  int i;
-  if (!uidv)
-    return 1;
-  for (i = 0; i < uidc; i++)
-    if (uidv[i] == uid)
-      return 1;
-  return 0;
-}
-
 
 int
 wydawca_uid (uid_t uid)
 {
   int rc;
 
@@ -305,12 +277,27 @@ wydawca_uid (uid_t uid)
     logmsg (LOG_ERR, _("cannot switch to UID %d: %s (r=%d, e=%d)"),
 	    uid, strerror (errno), getuid (), geteuid ());
   return rc;
 }
 
 
+void
+wydawca_daemon ()
+{
+  check_pidfile ();
+
+  if (!foreground && daemon (0, 0))
+    {
+      logmsg (LOG_ERR, "%s", strerror (errno));
+      exit (1);
+    }
+
+  wydawca_listener ();
+}
+
+
 #include "cmdline.h"
 
 int
 main (int argc, char **argv)
 {
   program_name = argv[0];
@@ -330,28 +317,41 @@ main (int argc, char **argv)
 
   gconf_parse (conffile);
 
   if (lint_mode)
     exit (0);
 
+  if (cron_option)
+    daemon_mode = 0;
+  if (foreground_option >= 0)
+    foreground = foreground_option;
+  if (single_process_option >= 0)
+    single_process = single_process_option;
+  
   if (log_to_stderr == -1)
-    log_to_stderr = isatty (0);
+    log_to_stderr = (!daemon_mode || foreground) && isatty (0);
 
   gconf_log_to_stderr = log_to_stderr;
   if (!log_to_stderr)
     {
       openlog (syslog_tag, LOG_PID, log_facility);
       log_printer = syslog_printer;
     }
 
   mail_init ();
 
   logmsg (LOG_NOTICE, _("wydawca (%s) started"), PACKAGE_STRING);
-  scan_directories ();
 
+  if (!daemon_mode)
+    {
+      scan_directories (uidc, uidv);
+      logstats ();
+    }
+  else
+    wydawca_daemon ();
+  
   logmsg (LOG_NOTICE, _("wydawca (%s) finished"), PACKAGE_STRING);
-  logstats ();
   
   mail_finish ();
 
   exit (0);
 }
diff --git a/src/wydawca.h b/src/wydawca.h
index 3f28919..8a716e4 100644
--- a/src/wydawca.h
+++ b/src/wydawca.h
@@ -29,13 +29,20 @@
 #include <pwd.h>
 #include <grp.h>
 #include <signal.h>
 #include <limits.h>
 #include <dirent.h>
 #include <sys/stat.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <netdb.h>
+#include <arpa/inet.h>
 #include <fcntl.h>
+#include <time.h>
 
 #include <mailutils/types.h>
 #include <mailutils/url.h>
 #include <mailutils/errno.h>
 
 #define obstack_chunk_alloc malloc
@@ -44,12 +51,13 @@
 #include "error.h"
 #include "xalloc.h"
 #include "progname.h"
 #include "backupfile.h"
 #include "inttostr.h"
 #include "gconf.h"
+#include "gl_list.h"
 #include "argcv.h"
 
 #define gettext(s) s
 #define _(s) s
 #define N_(s) s
 
@@ -153,13 +161,13 @@ struct file_info
 /* File triplet */
 struct file_triplet
 {
   char *name;              /* Triplet base name */
   gid_t gid;               /* Owner GID */
   struct file_info file[FILE_TYPE_COUNT]; /* Components */
-  struct spool *spool;     /* Owning spool */
+  const struct spool *spool;     /* Owning spool */
   char **directive;        /* Decoded directive pairs (key: value\0) */
   char *blurb;             /* Block of directives: directive[i] points here */
   char *tmp;               /* Temporary storage */
   size_t tmpsize;          /* Size of memory allocated in tmp */
   /* Special data for template formatting */
   char *project;           /* Triplet project name (if known) */
@@ -176,34 +184,36 @@ struct file_triplet
 
 
 struct virt_tab
 {
   int (*test_url)      (mu_url_t url, gconf_locus_t *loc);
   int (*move_file)     (struct file_triplet *trp,
-			struct spool *spool,
+			const struct spool *spool,
 			enum file_type file_id,
 			const char *reldir);
   int (*archive_file)  (struct file_triplet *trp,
-			struct spool *spool,
+			const struct spool *spool,
 			const char *reldir,
 			const char *file_name);
   int (*symlink_file)  (struct file_triplet *trp,
-			struct spool *spool,
+			const struct spool *spool,
 			const char *reldir,
 			const char *wanted_src,
 			const char *wanted_dst);
   int (*rmsymlink_file)(struct file_triplet *trp,
-			struct spool *spool,
+			const struct spool *spool,
 			const char *reldir,
 			const char *file_name);
 };
 
 /* An upload spool. This structure contains all data necessary for releasing 
    files from source to destination */
 struct spool
 {
+  char *tag;
+  gl_list_t aliases;
   char *url;                             /* Download URL */
   char *source_dir;                      /* Source directory */
   mu_url_t dest_url;                     /* Destination URL */
   const char *dest_dir;                  /* Directory part of the above */
   struct virt_tab vtab;                  /* Virtual method table */
   
@@ -303,12 +313,21 @@ extern char *tar_command_name; /* Name of the tar command */
 extern unsigned wydawca_stat[MAX_STAT];
 extern unsigned long print_stats;
 extern int archive_signatures;
 
 extern char *admin_stat_message;
 
+extern char *pidfile;
+extern int force_startup;
+
+extern int daemon_mode;
+extern time_t wakeup_interval;
+extern int foreground;
+extern int single_process;
+extern struct gconf_sockaddr listen_sockaddr;
+
 #define UPDATE_STATS(what)			\
   do						\
     {						\
       if (what >= MAX_STAT) abort();		\
       wydawca_stat[what]++;			\
     }						\
@@ -338,16 +357,19 @@ enum exec_result
   };
 
 enum exec_result wydawca_exec (int argc, const char **argv, int *retcode);
 
 
 /* Directory scanning and registering */
-void scan_directories (void);
+void scan_spool (const struct spool *spool, int uc, uid_t *uv);
+void scan_directories (int, uid_t *);
+
 void register_spool (struct spool *spool);
+struct spool *wydawca_find_spool (const char *name);
 void register_file (struct file_info *finfo);
-void enumerate_triplets (struct spool *);
+void enumerate_triplets (const struct spool *);
 size_t count_collected_triplets (void);
 char *triplet_expand_param (const char *tmpl, struct file_triplet *trp);
 
 /* General-purpose method support */
 struct access_method *method_new (enum access_method_id id,
 				  enum access_method_type type);
@@ -366,18 +388,18 @@ int method_quote_string (struct access_method *method, void *handle,
 
 unsigned method_num_rows (struct access_method *method);
 unsigned method_num_cols (struct access_method *method);
 
 /* Verification functions */
 int verify_directive_file (struct file_triplet *trp,
-			   struct spool *spool);
+			   const struct spool *spool);
 int verify_directive_signature (struct file_triplet *trp,
-				struct spool *spool,
+				const struct spool *spool,
 				const char *pubkey);
 int verify_detached_signature (struct file_triplet *trp,
-			       struct spool *spool);
+			       const struct spool *spool);
 int fill_project_name (struct file_triplet *trp);
 
 /* Directive file support */
 int directive_parse (struct file_triplet *trp);
 int directive_get_value (struct file_triplet *trp, const char *key,
 			 const char **pval);
@@ -387,15 +409,14 @@ int directive_version_in_range_p (struct file_triplet *trp,
 int verify_directive_format (struct file_triplet *trp);
 int directive_first (struct file_triplet *trp,
 		     const char **pkey, const char **pval);
 int directive_next (struct file_triplet *trp, int n,
 		    const char **pkey, const char **pval);
 int process_directives (struct file_triplet *trp,
-			struct spool *spool);
+			const struct spool *spool);
 
-int match_uid_p (uid_t uid);
 int enabled_spool_p (const struct spool *spool);
 
 int wydawca_uid (uid_t uid);
 
 
 int parse_time_interval (const char *str, time_t *pint, const char **endp);
@@ -407,48 +428,48 @@ void config_help (void);
 
 
 /* vtab.c */
 int url_to_vtab (mu_url_t url, struct virt_tab *vtab);
 
 int
-move_file (struct file_triplet *trp, struct spool *spool,
+move_file (struct file_triplet *trp, const struct spool *spool,
 	   enum file_type file_id, const char *reldir);	  
 int
-archive_file (struct file_triplet *trp, struct spool *spool,
+archive_file (struct file_triplet *trp, const struct spool *spool,
 	      const char *reldir, const char *file_name);	  
 int
-symlink_file (struct file_triplet *trp, struct spool *spool,
+symlink_file (struct file_triplet *trp, const struct spool *spool,
 	      const char *reldir,
 	      const char *wanted_src, const char *wanted_dst);
 int
-rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 		const char *reldir, const char *file_name);
 
 
 /* diskio.c */
 
 int dir_test_url (mu_url_t url, gconf_locus_t *locus);
-int dir_move_file (struct file_triplet *trp, struct spool *spool,
+int dir_move_file (struct file_triplet *trp, const struct spool *spool,
 		   enum file_type file_id, const char *reldir);
-int dir_archive_file (struct file_triplet *trp, struct spool *spool,
+int dir_archive_file (struct file_triplet *trp, const struct spool *spool,
 		      const char *file_name, const char *reldir);
-int dir_symlink_file (struct file_triplet *trp, struct spool *spool,
+int dir_symlink_file (struct file_triplet *trp, const struct spool *spool,
 		      const char *reldir,
 		      const char *wanted_src, const char *wanted_dst);
-int dir_rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+int dir_rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 			const char *reldir, const char *file_name);
 
 /* null.c */
-int null_move_file (struct file_triplet *trp, struct spool *spool,
+int null_move_file (struct file_triplet *trp, const struct spool *spool,
 		    enum file_type file_id, const char *reldir);
-int null_archive_file (struct file_triplet *trp, struct spool *spool,
+int null_archive_file (struct file_triplet *trp, const struct spool *spool,
 		       const char *file_name, const char *reldir);
-int null_symlink_file (struct file_triplet *trp, struct spool *spool,
+int null_symlink_file (struct file_triplet *trp, const struct spool *spool,
 		       const char *reldir,
 		       const char *wanted_src, const char *wanted_dst);
-int null_rmsymlink_file (struct file_triplet *trp, struct spool *spool,
+int null_rmsymlink_file (struct file_triplet *trp, const struct spool *spool,
 			 const char *reldir, const char *file_name);
 
 
 /* timer.c */
 typedef struct timer_slot *wydawca_timer_t;
 
@@ -466,6 +487,20 @@ void timer_free_meta (struct metadef *def, size_t num);
 
 
 void report_init (void);
 void report_add (const char *fmt, ...);
 void report_finish (void);
 extern char *report_string;
+
+
+/* job.c */
+int schedule_job (const struct spool *spool, uid_t uid);
+void job_init (void);
+void job_queue_runner (void);
+
+
+/* profile.c */
+void check_pidfile (void);
+
+
+/* net.c */
+void wydawca_listener (void);