Implement all directives

git-svn-id: file:///svnroot/wydawca/trunk@284 6bb4bd81-ecc2-4fd4-a2d4-9571d19c0d33

1 files changed, 93 insertions, 69 deletions

diff --git a/src/directive.c b/src/directive.c
index 0e06502..ee52dd7 100644
--- a/src/directive.c
+++ b/src/directive.c
@@ -19,56 +19,56 @@
 /* Directive file support */
 
 int
-directive_parse (struct file_register *reg)
+directive_parse (struct file_triplet *trp)
 {
   size_t dcount, i;
   char *p;
 
   if (debug_level > 2)
     logmsg (LOG_DEBUG, "%s: parsing directive blurb: %s",
-	    reg->file[file_directive].name, reg->blurb);
+	    trp->file[file_directive].name, trp->blurb);
   
   dcount = 0;
-  for (p = reg->blurb; *p; p++)
+  for (p = trp->blurb; *p; p++)
     if (*p == '\n')
       dcount++;
       
-  reg->directive = xcalloc (dcount + 1, sizeof reg->directive[0]);
-  p = reg->blurb;
+  trp->directive = xcalloc (dcount + 1, sizeof trp->directive[0]);
+  p = trp->blurb;
   for (i = 0; i < dcount; )
     {
-      reg->directive[i] = p;
+      trp->directive[i] = p;
       p = strchr (p, '\n');
       if (p)
 	*p++ = 0;
-      if (trim (reg->directive[i]) == 0) /* ignore empty lines */
+      if (trim (trp->directive[i]) == 0) /* ignore empty lines */
 	continue;
-      if (strchr (reg->directive[i], ':') == NULL)
+      if (strchr (trp->directive[i], ':') == NULL)
 	{
 	  logmsg (LOG_ERR, "%s: invalid line: %s",
-		  reg->file[file_directive].name, reg->directive[i]);
-	  free (reg->directive);
-	  reg->directive = NULL;
+		  trp->file[file_directive].name, trp->directive[i]);
+	  free (trp->directive);
+	  trp->directive = NULL;
 	  return 1;
 	}
       i++;
       if (!p)
 	break;
     }
-  reg->directive[i] = NULL;
+  trp->directive[i] = NULL;
   return 0;
 }
 
 int
-directive_get_value (struct file_register *reg, const char *key,
+directive_get_value (struct file_triplet *trp, const char *key,
 		     const char **pval)
 {
   int keylen = strlen (key);
   int i;
 
-  for (i = 0; reg->directive[i]; i++)
+  for (i = 0; trp->directive[i]; i++)
     {
-      char *str = reg->directive[i];
+      char *str = trp->directive[i];
       int len = strlen (str);
       if (len > keylen && memcmp (str, key, keylen) == 0 && str[keylen] == ':')
 	{
@@ -84,25 +84,25 @@ directive_get_value (struct file_register *reg, const char *key,
 }
 
 static int
-_directive_seq_get (int n, struct file_register *reg,
+_directive_seq_get (int n, struct file_triplet *trp,
 		    const char **pkey, const char **pval)
 {
   char *p;
   size_t len;
 
-  if (reg->directive[n] == NULL)
+  if (trp->directive[n] == NULL)
     return 0;
   
-  p = strchr (reg->directive[n], ':');
-  len = p - reg->directive[n];
-  if (len + 1 > reg->tmpsize)
+  p = strchr (trp->directive[n], ':');
+  len = p - trp->directive[n];
+  if (len + 1 > trp->tmpsize)
     {
-      reg->tmpsize = len + 1;
-      reg->tmp = x2realloc (reg->tmp, &reg->tmpsize);
+      trp->tmpsize = len + 1;
+      trp->tmp = x2realloc (trp->tmp, &trp->tmpsize);
     }
-  memcpy (reg->tmp, reg->directive[n], len);
-  reg->tmp[len] = 0;
-  *pkey = reg->tmp;
+  memcpy (trp->tmp, trp->directive[n], len);
+  trp->tmp[len] = 0;
+  *pkey = trp->tmp;
   for (p++; *p && isspace (*p); p++)
     ;
   if (pval)
@@ -111,18 +111,18 @@ _directive_seq_get (int n, struct file_register *reg,
 }
 
 int
-directive_first (struct file_register *reg,
+directive_first (struct file_triplet *trp,
 		 const char **pkey, const char **pval)
 {
   int n = 0;
-  return _directive_seq_get (n, reg, pkey, pval);
+  return _directive_seq_get (n, trp, pkey, pval);
 }
 
 int
-directive_next (struct file_register *reg, int n,
+directive_next (struct file_triplet *trp, int n,
 		const char **pkey, const char **pval)
 {
-  return _directive_seq_get (n, reg, pkey, pval);
+  return _directive_seq_get (n, trp, pkey, pval);
 }
 
 int
@@ -144,23 +144,23 @@ directive_pack_version (const char *val, unsigned *pversion)
 }
 
 int
-directive_version_in_range_p (struct file_register *reg,
+directive_version_in_range_p (struct file_triplet *trp,
 			      unsigned from, unsigned to)
 {
   const char *val;
   int version;
   
-  if (directive_get_value (reg, "version", &val))
+  if (directive_get_value (trp, "version", &val))
     {
       logmsg (LOG_ERR, "%s: missing `version' directive",
-	      reg->file[file_directive].name);
+	      trp->file[file_directive].name);
       return 0;
     }
 
   if (directive_pack_version (val, &version))
     {
       logmsg (LOG_ERR, "%s: unparsable version: %s",
-	      reg->file[file_directive].name, val);
+	      trp->file[file_directive].name, val);
       return 0;
     }
 
@@ -168,7 +168,7 @@ directive_version_in_range_p (struct file_register *reg,
     return 1;
   
   logmsg (LOG_ERR, "%s: version %s is not in the allowed range",
-	  reg->file[file_directive].name, val);
+	  trp->file[file_directive].name, val);
   return 0;
 }
 
@@ -213,18 +213,18 @@ find_directive (const char *key)
 }
 
 int
-verify_directive_format (struct file_register *reg)
+verify_directive_format (struct file_triplet *trp)
 {
   int n, dnum;
   const char *key;
   
-  if (!directive_version_in_range_p (reg, MIN_DIRECTIVE_VERSION,
+  if (!directive_version_in_range_p (trp, MIN_DIRECTIVE_VERSION,
 				     MAX_DIRECTIVE_VERSION))
     return 1;
 
   dnum = 0;
-  for (n = directive_first (reg, &key, NULL); n;
-       n = directive_next (reg, n, &key, NULL))
+  for (n = directive_first (trp, &key, NULL); n;
+       n = directive_next (trp, n, &key, NULL))
     {
       if (strcmp (key, "comment") == 0)
 	continue;
@@ -235,7 +235,7 @@ verify_directive_format (struct file_register *reg)
 	  if (strcmp (key, "version"))
 	    {
 	      logmsg (LOG_ERR, "%s:%d: expected `%s' but found `%s'",
-		      reg->file[file_directive].name, n, "version", key);
+		      trp->file[file_directive].name, n, "version", key);
 	      return 1;
 	    }
 	  break;
@@ -244,7 +244,7 @@ verify_directive_format (struct file_register *reg)
 	  if (strcmp (key, "directory"))
 	    {
 	      logmsg (LOG_ERR, "%s:%d: expected `%s' but found `%s'",
-		      reg->file[file_directive].name, n, "directory", key);
+		      trp->file[file_directive].name, n, "directory", key);
 	      return 1;
 	    }
 	  break;
@@ -253,25 +253,25 @@ verify_directive_format (struct file_register *reg)
 	  if (find_directive (key) == unknown_dir)
 	    {
 	      logmsg (LOG_ERR, "%s:%d: unknown directive `%s'",
-		      reg->file[file_directive].name, n, key);
+		      trp->file[file_directive].name, n, key);
 	      return 1;
 	    }	      
 	}
     }
   
-  if (reg->file[file_dist].name && reg->file[file_signature].name)
+  if (trp->file[file_dist].name && trp->file[file_signature].name)
     {
       const char *filename;
-      if (directive_get_value (reg, "filename", &filename))
+      if (directive_get_value (trp, "filename", &filename))
 	{
 	  logmsg (LOG_ERR, "%s: missing `filename' directive",
-		  reg->file[file_directive].name);
+		  trp->file[file_directive].name);
 	  return 1;
 	}
-      if (strcmp (filename, reg->file[file_dist].name))
+      if (strcmp (filename, trp->file[file_dist].name))
 	{
 	  logmsg (LOG_ERR, "%s: filename %s does not match actual name",
-		  reg->file[file_dist].name, filename);
+		  trp->file[file_dist].name, filename);
 	  return 1;
 	}
     }
@@ -279,15 +279,14 @@ verify_directive_format (struct file_register *reg)
 }
 
 int
-process_directives (struct file_register *reg, struct directory_pair *dpair)
+process_directives (struct file_triplet *trp, struct directory_pair *dpair)
 {
   int n;
   const char *key, *val;
-  char *directory = NULL;
-  const char *relative_dir;
+  char *relative_dir;
   
-  for (n = directive_first (reg, &key, &val); n;
-       n = directive_next (reg, n, &key, &val))
+  for (n = directive_first (trp, &key, &val); n;
+       n = directive_next (trp, n, &key, &val))
     {
       enum directive d = find_directive (key);
       switch (d)
@@ -298,23 +297,16 @@ process_directives (struct file_register *reg, struct directory_pair *dpair)
 	  
 	case comment_dir:
 	  logmsg (LOG_NOTICE, "%s: COMMENT: %s",
-		  reg->file[file_directive].name, val);
+		  trp->file[file_directive].name, val);
 	  break;
 	  
 	case directory_dir:
- 	  directory = create_directory (dpair->dest_dir, val,
-					reg->file[file_dist].uid,
-					reg->gid);
-	  if (!directory)
-	    return 1;
-	  relative_dir = val;
+	  relative_dir = safe_file_name_alloc (val);
 	  break;
 	  
 	case filename_dir:
-	  if (move_file (reg, file_dist, directory,
-			 relative_dir, &dpair->archive)
-	      || move_file (reg, file_signature, directory,
-			    relative_dir, &dpair->archive))
+	  if (move_file (trp, dpair, file_dist, relative_dir)
+	      || move_file (trp, dpair, file_signature, relative_dir))
 	    return 1;
 	  break;
 	  
@@ -322,21 +314,53 @@ process_directives (struct file_register *reg, struct directory_pair *dpair)
 	  /* Already processed */
 	  break;
 	  
-	case rmsymlink_dir:
 	case archive_dir:
+	  if (archive_file (trp, dpair, val, relative_dir))
+	    return 1;
+	  break;
+
 	case symlink_dir:
+	  {
+	    int argc;
+	    char **argv;
+	    int rc = 0;
+
+	    if (rc = argcv_get (val, NULL, NULL, &argc, &argv))
+	      {
+		logmsg (LOG_ERR, "cannot parse symlink value `%s': %s",
+			val, strerror (rc));
+		return 1;
+	      }
+	    
+	    if (argc != 2)
+	      {
+		rc = 1;
+		logmsg (LOG_ERR,
+			"wrong number of arguments to %s directive: `%s'",
+			key, val);
+	      }
+	    else
+	      rc = symlink_file (trp, dpair, relative_dir, argv[0], argv[1]);
+		
+	    argcv_free (argc, argv);
+	    if (rc)
+	      return 1;
+	  }
+	  break;
+	    
+	case rmsymlink_dir:
 	  logmsg (LOG_CRIT, "%s: %s directive is not supported yet",
-		  reg->file[file_directive].name, key);
+		  trp->file[file_directive].name, key);
 	}
     }
 
-  free (directory);
-  
-  if (!dry_run_mode && unlink (reg->file[file_directive].name))
+  if (!dry_run_mode && unlink (trp->file[file_directive].name))
     {
       logmsg (LOG_CRIT, "%s: cannot unlink directive file: %s",
-	      reg->file[file_directive].name, strerror (errno));
+	      trp->file[file_directive].name, strerror (errno));
     }
-      
+
+  free (relative_dir);
+  
   return 0;
 }