1 files changed, 108 insertions, 54 deletions

diff --git a/src/process.c b/src/process.c
index c5eb321..ec64589 100644
--- a/src/process.c
+++ b/src/process.c
@@ -15,24 +15,38 @@
    with wydawca. If not, see <http://www.gnu.org/licenses/>. */
 
 #include "wydawca.h"
 
 struct spool_list
 {
   struct spool_list *next;
   struct spool spool;
 };
 
 static struct spool_list *spool_list;
 
+int
+for_each_spool (int (*fun) (struct spool *, void *), void *data)
+{
+  struct spool_list *sp;
+  
+  for (sp = spool_list; sp; sp = sp->next)
+    {
+      int rc = fun (&sp->spool, data);
+      if (rc)
+	return rc;
+    }
+  return 0;
+}
+
 void
 register_spool (struct spool *spool)
 {
   struct spool_list *sp = grecs_malloc (sizeof *sp);
   sp->spool = *spool;
   sp->next = spool_list;
   spool_list = sp;
 }
 
 static int
 spool_check_alias (struct spool *spool, const char *name)
 {
@@ -113,40 +127,104 @@ parse_file_name (const char *name, struct file_info *finfo)
 	  && memcmp (name + len - suftab[i].len,
 		     suftab[i].suf, suftab[i].len) == 0)
 	{
 	  finfo->name = grecs_strdup (name);
 	  finfo->type = suftab[i].type;
 	  finfo->root_len = len - suftab[i].len;
 	  return;
 	}
     }
   abort (); /* should not happen */
 }
 
-int
+void
+file_info_cleanup (struct file_info *finfo)
+{
+  free (finfo->name);
+  memset (finfo, 0, sizeof (*finfo));
+}
+
+static 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;
 }
 
+int
+spool_cwd_add_new_file (const struct spool *spool, const char *name,
+			int uc, uid_t *uv)
+{
+  struct stat st;
+  struct file_info finfo;
+
+  if (stat (name, &st))
+    {
+      logmsg (LOG_ERR, _("cannot stat file %s/%s: %s"),
+	      spool->source_dir, name, strerror (errno));
+      return -1;
+    }
+
+  if (!S_ISREG (st.st_mode))
+    {
+      logmsg (LOG_NOTICE, _("not a regular file: %s/%s"),
+	      spool->source_dir, name);
+      return -1;
+    }
+
+  if (!match_uid_p (st.st_uid, uc, uv))
+    {
+      if (debug_level)
+	logmsg (LOG_DEBUG, _("ignoring file: %s/%s"),
+		spool->source_dir, name);
+      return -1;
+    }
+      
+  finfo.sb = st;
+  parse_file_name (name, &finfo);
+
+  if (debug_level)
+    logmsg (LOG_DEBUG, _("found file %s: %s, stem: %.*s"), name,
+	    file_type_str (finfo.type), finfo.root_len, finfo.name);
+
+  register_file (&finfo, spool);
+  return 0;
+}
+
+int
+spool_add_new_file (const struct spool *spool, const char *name,
+		    int uc, uid_t *uv)
+{
+  if (debug_level)
+    logmsg (LOG_DEBUG, "%s -> %s, adding %s", spool->source_dir,
+	    mu_url_to_string (spool->dest_url), name);
+
+  if (chdir (spool->source_dir))
+    {
+      logmsg (LOG_ERR, _("cannot chdir to %s: %s"), spool->source_dir,
+	      strerror (errno));
+      return -1;
+    }
+  return spool_cwd_add_new_file (spool, name, uc, uv);
+}
+
 /* Scan upload directory from the DPAIR and register all files found
    there, forming triplets when possible */
 void
-scan_spool_unlocked (const struct spool *spool, int uc, uid_t *uv)
+scan_spool_unlocked (struct spool *spool, int uc, uid_t *uv)
 {
   DIR *dir;
   struct dirent *ent;
 
   if (debug_level)
     logmsg (LOG_DEBUG, "%s -> %s", spool->source_dir,
 	    mu_url_to_string (spool->dest_url));
 
   if (chdir (spool->source_dir))
     {
       logmsg (LOG_ERR, _("cannot chdir to %s: %s"), spool->source_dir,
 	      strerror (errno));
@@ -157,130 +235,106 @@ scan_spool_unlocked (const struct spool *spool, int uc, uid_t *uv)
   if (!dir)
     {
       logmsg (LOG_ERR, _("cannot open directory %s: %s"), spool->source_dir,
 	      strerror (errno));
       return;
     }
 
   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)
 	continue;
-
-      if (stat (ent->d_name, &st))
-	{
-	  logmsg (LOG_ERR, _("cannot stat file %s/%s: %s"),
-		  spool->source_dir, ent->d_name,
-		  strerror (errno));
-	  continue;
-	}
-
-      if (!S_ISREG (st.st_mode))
-	{
-	  logmsg (LOG_NOTICE, _("not a regular file: %s/%s"),
-		  spool->source_dir, ent->d_name);
-	  continue;
-	}
-
-      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, _("found file %s: %s, stem: %.*s"), ent->d_name,
-		  file_type_str (finfo.type), finfo.root_len, finfo.name);
-
-      register_file (&finfo, spool);
+      spool_cwd_add_new_file (spool, ent->d_name, uc, uv);
     }
 
   closedir (dir);
 
   if (count_collected_triplets () > 0)
-    {
-      int i;
-
-      for (i = 0; i < dictionary_count; i++)
-        {
-          if (dictionary_init (spool->dictionary[i]))
-            {
-              logmsg (LOG_ERR, _("failed to initialize dictionary %d"), i);
-              return;
-            }
-        }
-      enumerate_triplets (spool);
-   }
+    spool_commit_triplets (spool);
+  
   timer_stop (spool->tag);
   timer_stop ("spool");
 }
 
 int
-scan_spool (const struct spool *spool, int uc, uid_t *uv)
+scan_spool (struct spool *spool, int uc, uid_t *uv)
 {
   char *lockfile = wydawca_lockname (spool->tag);
   int rc = wydawca_lock (lockfile);
   switch (rc)
     {
     case LOCK_OK:
       scan_spool_unlocked (spool, uc, uv);
       wydawca_unlock (lockfile);
       break;
 
     case LOCK_FAILURE:
       logmsg (LOG_ERR, _("cannot lock spool %s"), spool->tag);
       break;
 
     case LOCK_RETRY:
       logmsg (LOG_WARNING, _("timed out while looking spool %s"), spool->tag);
       break;
     }
   free (lockfile);
   return rc;
 }
 
-static void
-close_dictionaries (struct spool *spool)
+int
+spool_open_dictionaries (struct spool *spool)
+{
+  if (!spool->dict_inited)
+    {
+      int i;
+      
+      for (i = 0; i < dictionary_count; i++)
+	{
+          if (dictionary_init (spool->dictionary[i]))
+            {
+              logmsg (LOG_ERR, _("failed to initialize dictionary %d"), i);
+              return -1;
+            }
+        }
+      spool->dict_inited = 1;
+    }
+  return 0;
+}
+
+void
+spool_close_dictionaries (struct spool *spool)
 {
   int i;
   for (i = 0; i < NITEMS (spool->dictionary); i++)
     dictionary_done (spool->dictionary[i]);
+  spool->dict_inited = 0;
 }
 
 /* Scan all configured update directories */
 int
 scan_all_spools (int uidc, uid_t *uidv)
 {
   struct spool_list *sp;
   int rc = 0;
   
   timer_start ("wydawca");
   for (sp = spool_list; sp; sp = sp->next)
     if (enabled_spool_p (&sp->spool))
       if (scan_spool (&sp->spool, uidc, uidv))
 	rc++;
 
   for (sp = spool_list; sp; sp = sp->next)
-    close_dictionaries (&sp->spool);
+    spool_close_dictionaries (&sp->spool);
   timer_stop ("wydawca");
   return rc;
 }
 
 void
 spool_create_timers ()
 {
   struct spool_list *sp;
 
   for (sp = spool_list; sp; sp = sp->next)
     timer_start (sp->spool.tag);
 }