1 files changed, 238 insertions, 238 deletions

diff --git a/src/config.c b/src/config.c
index 11ac92d..60b5792 100644
--- a/src/config.c
+++ b/src/config.c
@@ -118,36 +118,36 @@ safe_file_name_alloc (const char *file_name)
 {
   char *s = xstrdup (file_name);
   char *ns = safe_file_name (s);
   if (!ns)
     free (s);
   return ns;
 }
 
 int
 string_to (const char *what, const char *str,
 	   const char **args, int *vals,
 	   int *pret,
-	   gconf_locus_t *locus)
+	   grecs_locus_t *locus)
 {
   ptrdiff_t x = ARGMATCH (str, args, vals);
 
   if (x == (ptrdiff_t)-1)
     {
-      gconf_error (locus, 0, _("unknown %s: %s"), what, str);
+      grecs_error (locus, 0, _("unknown %s: %s"), what, str);
       return 1;
     }
   else if (x == (ptrdiff_t)-2)
     {
-      gconf_error (locus, 0, _("ambiguous %s: %s"), what, str);
+      grecs_error (locus, 0, _("ambiguous %s: %s"), what, str);
       return 1;
     }
   *pret = vals[x];
   return 0;
 }
 
 static const char *event_args[] = {
   "success",
   "bad-ownership",
   "bad-directive-signature",
   "bad-detached-signature",
   NULL
@@ -160,25 +160,25 @@ static int event_types[] = {
   ev_bad_detached_signature
 };
 
 ARGMATCH_VERIFY (event_args, event_types);
 
 const char *
 notification_event_str (enum notification_event evt)
 {
   return event_args[evt];
 }
 
 int
-string_to_notification_event (gconf_locus_t *locus, const char *val,
+string_to_notification_event (grecs_locus_t *locus, const char *val,
 			      enum notification_event *pret)
 {
   int rc, res;
   rc = string_to ("notification event", val,
 		  event_args, event_types,
 		  &res,
 		  locus);
   *pret = res;
   return rc;
 }
 
 static const char *target_args[] = {
@@ -194,210 +194,210 @@ static int target_types[] = {
   notify_user          /* User (uploader) */
 };
 
 ARGMATCH_VERIFY (target_args, target_types);
 
 const char *
 notification_target_str (enum notification_target tgt)
 {
   return target_args[tgt];
 }
 
 int
-string_to_notification_target (gconf_locus_t *locus, const char *val,
+string_to_notification_target (grecs_locus_t *locus, const char *val,
 			       enum notification_target *pret)
 {
   int rc, res;
   rc = string_to ("notification target", val,
 		  target_args, target_types,
 		  &res,
 		  locus);
   *pret = res;
   return rc;
 }
 
 
 int
-assert_string_arg (gconf_locus_t *locus,
-		   enum gconf_callback_command cmd,
-		   const gconf_value_t *value)
+assert_string_arg (grecs_locus_t *locus,
+		   enum grecs_callback_command cmd,
+		   const grecs_value_t *value)
 {
-  if (cmd != gconf_callback_set_value)
+  if (cmd != grecs_callback_set_value)
     {
-      gconf_error (locus, 0, _("Unexpected block statement"));
+      grecs_error (locus, 0, _("Unexpected block statement"));
       return 1;
     }
   if (!value || value->type != GCONF_TYPE_STRING)
     {
-      gconf_error (locus, 0, _("expected scalar value as a tag"));
+      grecs_error (locus, 0, _("expected scalar value as a tag"));
       return 1;
     }
   return 0;
 }
 
-gconf_value_t *
-get_arg (gconf_locus_t *locus, gconf_value_t *value, unsigned n, int type)
+grecs_value_t *
+get_arg (grecs_locus_t *locus, grecs_value_t *value, unsigned n, int type)
 {
   if (n >= value->v.arg.c)
     {
-      gconf_error (locus, 0, _("not enough arguments"));
+      grecs_error (locus, 0, _("not enough arguments"));
       return NULL;
     }
   value = value->v.arg.v + n;
   if (value->type != type)
     {
-      gconf_error (locus, 0, _("argument %d has wrong type"), n);
+      grecs_error (locus, 0, _("argument %d has wrong type"), n);
       return NULL;
     }
   return value;
 }
 
 
 static int
-cb_mailer (enum gconf_callback_command cmd,
-	   gconf_locus_t *locus,
+cb_mailer (enum grecs_callback_command cmd,
+	   grecs_locus_t *locus,
 	   void *varptr,
-	   gconf_value_t *value,
+	   grecs_value_t *value,
 	   void *cb_data)
 {
   int rc;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   rc = mu_mailer_create (&mailer, value->v.string);
   if (rc)
-    gconf_error (locus, 0, _("cannot create mailer `%s': %s"),
+    grecs_error (locus, 0, _("cannot create mailer `%s': %s"),
 		 value->v.string, mu_strerror (rc));
   return rc;
 }
 
 static int
-cb_email_address (enum gconf_callback_command cmd,
-		  gconf_locus_t *locus,
+cb_email_address (enum grecs_callback_command cmd,
+		  grecs_locus_t *locus,
 		  void *varptr,
-		  gconf_value_t *value,
+		  grecs_value_t *value,
 		  void *cb_data)
 {
   int rc;
   mu_address_t addr = NULL;
 
   switch (value->type)
     {
     case GCONF_TYPE_STRING:
       rc = mu_address_create (&addr, value->v.string);
       if (rc)
 	{
-	  gconf_error (locus, 0, _("%s: invalid email address: %s"),
+	  grecs_error (locus, 0, _("%s: invalid email address: %s"),
 		       value->v.string, mu_strerror (rc));
 	  return rc;
 	}
       break;
 
     case GCONF_TYPE_LIST:
       {
 	const void *p;
 	gl_list_iterator_t itr = gl_list_iterator (value->v.list);
 	
 	while (gl_list_iterator_next (&itr, &p, NULL))
 	  {
-	    const gconf_value_t *vp = p;
+	    const grecs_value_t *vp = p;
 	    mu_address_t a;
 	    if (assert_string_arg (locus, cmd, vp))
 	      return 1;
 
 	    rc = mu_address_create (&a, vp->v.string);
 	    if (rc == 0)
 	      rc = mu_address_union (&addr, a);
 	    else
 	      {
-		gconf_error (locus, 0, _("%s: invalid email address: %s"),
+		grecs_error (locus, 0, _("%s: invalid email address: %s"),
 			     vp->v.string, mu_strerror (rc));
 	      }
 	    mu_address_destroy (&a);
 	    if (rc)
 	      break;
 	  }
       }
       break;
 
     case GCONF_TYPE_ARRAY:
-      gconf_error (locus, 0, _("too many arguments"));
+      grecs_error (locus, 0, _("too many arguments"));
       return 1;
     }
       
   *(mu_address_t*) varptr = addr;
   return rc;
 }
 
 static int
-cb_interval (enum gconf_callback_command cmd,
-	     gconf_locus_t *locus,
+cb_interval (enum grecs_callback_command cmd,
+	     grecs_locus_t *locus,
 	     void *varptr,
-	     gconf_value_t *value,
+	     grecs_value_t *value,
 	     void *cb_data)
 {
   int rc;
   time_t interval;
   const char *endp;
 
   /* FIXME 1: Support arrays */
   if (assert_string_arg (locus, cmd, value))
     return 1;
 
   /* FIXME 2: Support ISO intervals? */
   rc = parse_time_interval (value->v.string, &interval, &endp);
   if (rc)
-    gconf_error (locus, 0, _("unrecognized interval format (near `%s')"),
+    grecs_error (locus, 0, _("unrecognized interval format (near `%s')"),
 		 endp);
   else
     *(time_t*) varptr = interval;
   return 0;
 }
 
 static int
-cb_absolute_name (enum gconf_callback_command cmd,
-		  gconf_locus_t *locus,
+cb_absolute_name (enum grecs_callback_command cmd,
+		  grecs_locus_t *locus,
 		  void *varptr,
-		  gconf_value_t *value,
+		  grecs_value_t *value,
 		  void *cb_data)
 {
   char *word;
 
   /* FIXME 1: Support arrays */
   if (assert_string_arg (locus, cmd, value))
     return 1;
 
   word = safe_file_name ((char*)value->v.string);
   if (!word || word[0] != '/')
-    gconf_error (locus, 0, _("must be an absolute file name"));
+    grecs_error (locus, 0, _("must be an absolute file name"));
   else
     *(char**) varptr = word;
   return 0;
 }
 
 static int
-cb_set_umask (enum gconf_callback_command cmd,
-	      gconf_locus_t *locus,
+cb_set_umask (enum grecs_callback_command cmd,
+	      grecs_locus_t *locus,
 	      void *varptr,
-	      gconf_value_t *value,
+	      grecs_value_t *value,
 	      void *cb_data)
 {
   char *p;
   mode_t m;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   m = strtoul (value->v.string, &p, 8) & 0777;
   if (*p)
-    gconf_error (locus, 0, _("invalid umask (near %s)"), p);
+    grecs_error (locus, 0, _("invalid umask (near %s)"), p);
   else
     umask (m);
   return 0;
 }
 
 
 static const char *stat_args[] = {
   "errors",
   "warnings",
   "bad-signatures",
   "access-violations",
   "complete-triplets",
@@ -422,69 +422,69 @@ static unsigned long stat_types[] = {
   STAT_BAD_TRIPLETS,
   STAT_EXPIRED_TRIPLETS,
   STAT_TRIPLET_SUCCESS,
   STAT_UPLOADS,
   STAT_ARCHIVES,
   STAT_SYMLINKS,
   STAT_RMSYMLINKS
 };
 
 ARGMATCH_VERIFY (stat_args, stat_types);
 
 static int
-parse_single_statmask (gconf_locus_t *locus, const gconf_value_t *val,
+parse_single_statmask (grecs_locus_t *locus, const grecs_value_t *val,
 		       unsigned long *pmask, int *invert)
 {
   const char *arg;
   ptrdiff_t x;
 
   if (val->type != GCONF_TYPE_STRING)
     {
-      gconf_error (locus, 0, _("expected scalar value but found list"));
+      grecs_error (locus, 0, _("expected scalar value but found list"));
       return 1;
     }
 
   arg = val->v.string;
 
   if (strcmp (arg, "all") == 0)
     {
       *pmask = STAT_MASK_ALL;
       *invert = 1;
       return 0;
     }
   else if (strcmp (arg, "none") == 0)
     {
       *pmask = STAT_MASK_NONE;
       *invert = 0;
       return 0;
     }
 
   x = ARGMATCH (arg, stat_args, stat_types);
 
   if (x == (ptrdiff_t)-1)
     {
-      gconf_error (locus, 0, _("unknown statistics type: %s"), arg);
+      grecs_error (locus, 0, _("unknown statistics type: %s"), arg);
       return 1;
     }
   else if (x == (ptrdiff_t)-2)
     {
-      gconf_error (locus, 0, _("ambiguous statistics type: %s"), arg);
+      grecs_error (locus, 0, _("ambiguous statistics type: %s"), arg);
       return 1;
     }
   *pmask = STAT_MASK (stat_types[x]);
   return 0;
 }
 
 static int
-parse_statmask (gconf_locus_t *loc, gconf_value_t *val, unsigned long *pmask)
+parse_statmask (grecs_locus_t *loc, grecs_value_t *val, unsigned long *pmask)
 {
   int err = 0;
   int invert = 0;
   unsigned long mask = 0;
 
   switch (val->type)
     {
     case GCONF_TYPE_STRING:
       err = parse_single_statmask (loc, val, &mask, &invert);
       break;
 
     case GCONF_TYPE_ARRAY:
@@ -502,216 +502,216 @@ parse_statmask (gconf_locus_t *loc, gconf_value_t *val, unsigned long *pmask)
 	      mask |= x;
 	  }
       }
       break;
 
     case GCONF_TYPE_LIST:
       {
 	const void *p;
 	gl_list_iterator_t itr = gl_list_iterator (val->v.list);
 
 	while (gl_list_iterator_next (&itr, &p, NULL))
 	  {
-	    const gconf_value_t *vp = p;
+	    const grecs_value_t *vp = p;
 	    unsigned long x;
 
 	    if (parse_single_statmask (loc, vp, &x, &invert))
 	      err = 1;
 	    else if (invert)
 	      mask &= ~x;
 	    else
 	      mask |= x;
 	  }
       }
       break;
     }
   if (!err)
     *pmask = mask;
   return err;
 }
 
 static int
-cb_statistics (enum gconf_callback_command cmd,
-	       gconf_locus_t *locus,
+cb_statistics (enum grecs_callback_command cmd,
+	       grecs_locus_t *locus,
 	       void *varptr,
-	       gconf_value_t *value,
+	       grecs_value_t *value,
 	       void *cb_data)
 {
   return parse_statmask (locus, value, varptr);
 }
 
 
 static int
-cb_sql_host (enum gconf_callback_command cmd,
-	     gconf_locus_t *locus,
+cb_sql_host (enum grecs_callback_command cmd,
+	     grecs_locus_t *locus,
 	     void *varptr,
-	     gconf_value_t *value,
+	     grecs_value_t *value,
 	     void *cb_data)
 {
   struct sqlconn *pconn = varptr;
   char *p;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
 
   p = strchr (value->v.string, ':');
   if (p)
     {
       /* FIXME: Modifies constant string */
       *p++ = 0;
       if (p[0] == '/')
 	{
 	  pconn->socket = xstrdup (p);
 	  pconn->host = xstrdup ("localhost");
 	}
       else
 	{
 	  char *end;
 	  unsigned long n = strtoul (p, &end, 10);
 	  if (*end)
 	    {
-	      gconf_error (locus, 0, _("invalid port number (near %s)"), end);
+	      grecs_error (locus, 0, _("invalid port number (near %s)"), end);
 	      return 0;
 	    }
 	  if (n == 0 || n > USHRT_MAX)
 	    {
-	      gconf_error (locus, 0, _("port number out of range 1..%d"),
+	      grecs_error (locus, 0, _("port number out of range 1..%d"),
 			   USHRT_MAX);
 	      return 0;
 	    }
 	  pconn->port = n;
 	  /* Save host name */
 	  pconn->host = xstrdup (value->v.string);
 	}
     }
   else
     pconn->host = xstrdup (value->v.string);
   return 0;
 }
 
 static int
-cb_sql (enum gconf_callback_command cmd,
-	gconf_locus_t *locus,
+cb_sql (enum grecs_callback_command cmd,
+	grecs_locus_t *locus,
 	void *varptr,
-	gconf_value_t *value,
+	grecs_value_t *value,
 	void *cb_data)
 {
   struct sqlconn *pconn;
   void **pdata = cb_data;
 
   switch (cmd) {
-  case gconf_callback_section_begin:
+  case grecs_callback_section_begin:
     if (!value || value->type != GCONF_TYPE_STRING)
       {
-	gconf_error(locus, 0, _("tag must be a string"));
+	grecs_error(locus, 0, _("tag must be a string"));
 	return 0;
       }
     pconn = xzalloc (sizeof (*pconn));
     pconn->ident = strdup (value->v.string);
     *pdata = pconn;
     break;
 
-  case gconf_callback_section_end:
+  case grecs_callback_section_end:
     pconn = *pdata;
     sql_register_conn (pconn);
     free (pconn);
     *pdata = NULL;
     break;
 
-  case gconf_callback_set_value:
-    gconf_error (locus, 0, _("invalid use of block statement"));
+  case grecs_callback_set_value:
+    grecs_error (locus, 0, _("invalid use of block statement"));
   }
   return 0;
 }
 
-static struct gconf_keyword sql_kw[] = {
+static struct grecs_keyword sql_kw[] = {
   { "host", N_("host"), N_("Set SQL server hostname or IP address"),
-    gconf_type_string, NULL, 0, cb_sql_host },
+    grecs_type_string, NULL, 0, cb_sql_host },
   { "database", N_("dbname"), N_("Set database name"),
-    gconf_type_string, NULL, offsetof(struct sqlconn, database), },
+    grecs_type_string, NULL, offsetof(struct sqlconn, database), },
   { "user", N_("name"), N_("Set SQL user name"),
-    gconf_type_string, NULL, offsetof(struct sqlconn, user) },
+    grecs_type_string, NULL, offsetof(struct sqlconn, user) },
   { "password", N_("arg"), N_("Set SQL user password"),
-    gconf_type_string, NULL, offsetof(struct sqlconn, password) },
+    grecs_type_string, NULL, offsetof(struct sqlconn, password) },
   { NULL }
 };
 
 
 static int
-cb_syslog_facility (enum gconf_callback_command cmd,
-		    gconf_locus_t *locus,
+cb_syslog_facility (enum grecs_callback_command cmd,
+		    grecs_locus_t *locus,
 		    void *varptr,
-		    gconf_value_t *value,
+		    grecs_value_t *value,
 		    void *cb_data)
 {
   if (assert_string_arg (locus, cmd, value))
     return 1;
 
   if (mu_string_to_syslog_facility (value->v.string, varptr))
-    gconf_error (locus, 0, _("Unknown syslog facility `%s'"),
+    grecs_error (locus, 0, _("Unknown syslog facility `%s'"),
 		 value->v.string);
   return 0;
 }
 
 
 static int
-cb_define_message (enum gconf_callback_command cmd,
-		   gconf_locus_t *locus,
+cb_define_message (enum grecs_callback_command cmd,
+		   grecs_locus_t *locus,
 		   void *varptr,
-		   gconf_value_t *value,
+		   grecs_value_t *value,
 		   void *cb_data)
 {
   const char *ident;
 
-  if (cmd != gconf_callback_set_value)
+  if (cmd != grecs_callback_set_value)
     {
-      gconf_error (locus, 0, _("Unexpected block statement"));
+      grecs_error (locus, 0, _("Unexpected block statement"));
       return 1;
     }
   if (!value || value->type != GCONF_TYPE_ARRAY || value->v.arg.c != 2)
     {
-      gconf_error (locus, 0, _("expected two arguments"));
+      grecs_error (locus, 0, _("expected two arguments"));
       return 1;
     }
 
   if (value->v.arg.v[0].type != GCONF_TYPE_STRING)
     {
-      gconf_error (locus, 0, _("first argument not a string"));
+      grecs_error (locus, 0, _("first argument not a string"));
       return 1;
     }
   ident = value->v.arg.v[0].v.string;
 
   if (value->v.arg.v[1].type != GCONF_TYPE_STRING)
     {
-      gconf_error (locus, 0, _("second argument not a string"));
+      grecs_error (locus, 0, _("second argument not a string"));
       return 1;
     }
 
   register_message_template (ident, value->v.arg.v[1].v.string);
   return 0;
 }
 
 
 
-static struct gconf_keyword syslog_kw[] = {
+static struct grecs_keyword syslog_kw[] = {
   { "facility",
     N_("name"),
     N_("Set syslog facility. Arg is one of the following: user, daemon, "
        "auth, authpriv, mail, cron, local0 through local7 (case-insensitive), "
        "or a facility number."),
-    gconf_type_string, &log_facility, 0, cb_syslog_facility },
+    grecs_type_string, &log_facility, 0, cb_syslog_facility },
   { "tag", N_("string"), N_("Tag syslog messages with this string"),
-    gconf_type_string, &syslog_tag },
+    grecs_type_string, &syslog_tag },
   { "print-priority", N_("arg"), N_("Prefix each message with its priority"),
-    gconf_type_bool, &syslog_include_prio },
+    grecs_type_bool, &syslog_include_prio },
   { NULL },
 };
 
 
 static char const * const backup_args[] =
 {
   /* In a series of synonyms, present the most meaningful first, so
      that argmatch_valid be more readable. */
   "none", "off",
   "simple", "never",
   "existing", "nil",
   "numbered", "t",
@@ -722,329 +722,329 @@ static const enum backup_type backup_types[] =
 {
   no_backups, no_backups,
   simple_backups, simple_backups,
   numbered_existing_backups, numbered_existing_backups,
   numbered_backups, numbered_backups
 };
 
 /* Ensure that these two vectors have the same number of elements,
    not counting the final NULL in the first one.  */
 ARGMATCH_VERIFY (backup_args, backup_types);
 
 static enum backup_type
-get_backup_version (gconf_locus_t *locus, const char *ctx,
+get_backup_version (grecs_locus_t *locus, const char *ctx,
 		    const char *version)
 {
   if (version == 0 || *version == 0)
     return numbered_existing_backups;
   else
     {
       ptrdiff_t d = ARGMATCH (version, backup_args, backup_types);
       if (d == -2)
 	{
 	  if (ctx)
-	    gconf_error (locus, 0, _("%s: ambiguous backup type `%s'"),
+	    grecs_error (locus, 0, _("%s: ambiguous backup type `%s'"),
 			 ctx, version);
 	  else
-	    gconf_error (locus, 0, _("ambiguous backup type `%s'"), version);
+	    grecs_error (locus, 0, _("ambiguous backup type `%s'"), version);
 	  return no_backups;
 	}
       else if (d == -1)
 	{
 	  if (ctx)
-	    gconf_error (locus, 0, _("%s: invalid backup type `%s'"),
+	    grecs_error (locus, 0, _("%s: invalid backup type `%s'"),
 			 ctx, version);
 	  else
-	    gconf_error (locus, 0, _("invalid backup type `%s'"), version);
+	    grecs_error (locus, 0, _("invalid backup type `%s'"), version);
 	  return no_backups;
 	}
       return backup_types[d];
     }
 }
 
 static int
-cb_backup (enum gconf_callback_command cmd,
-	   gconf_locus_t *locus,
+cb_backup (enum grecs_callback_command cmd,
+	   grecs_locus_t *locus,
 	   void *varptr,
-	   gconf_value_t *value,
+	   grecs_value_t *value,
 	   void *cb_data)
 {
   enum backup_type *ptype = varptr;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   *ptype = get_backup_version (locus, NULL, value->v.string);
   return 0;
 }
 
-static struct gconf_keyword archive_kw[] = {
+static struct grecs_keyword archive_kw[] = {
   { "name", N_("file-or-dir"), N_("Name of archive file or directory"),
-    gconf_type_string, NULL, offsetof(struct archive_descr, name) },
+    grecs_type_string, NULL, offsetof(struct archive_descr, name) },
   { "backup", N_("type"), N_("Define backup type"),
-    gconf_type_string, NULL, offsetof(struct archive_descr, backup_type),
+    grecs_type_string, NULL, offsetof(struct archive_descr, backup_type),
     cb_backup },
   { NULL }
 };
 
 static int
-cb_archive (enum gconf_callback_command cmd,
-	    gconf_locus_t *locus,
+cb_archive (enum grecs_callback_command cmd,
+	    grecs_locus_t *locus,
 	    void *varptr,
-	    gconf_value_t *value,
+	    grecs_value_t *value,
 	    void *cb_data)
 {
   struct archive_descr *arch = varptr;
   void **pdata = cb_data;
 
   switch (cmd)
     {
-    case gconf_callback_section_begin:
+    case grecs_callback_section_begin:
       *pdata = arch;
       /* fallthrough */
-    case gconf_callback_set_value:
+    case grecs_callback_set_value:
       if (!value)
 	{
-	  gconf_error (locus, 0, _("expected tag"));
+	  grecs_error (locus, 0, _("expected tag"));
 	  return 1;
 	}
 
       if (value->type != GCONF_TYPE_STRING)
 	{
-	  gconf_error (locus, 0, _("expected scalar value but found list"));
+	  grecs_error (locus, 0, _("expected scalar value but found list"));
 	  return 1;
 	}
 
       if (strcmp (value->v.string, "none") == 0)
 	arch->type = archive_none;
       else if (strcmp (value->v.string, "tar") == 0)
 	arch->type = archive_tar;
       else if (strcmp (value->v.string, "directory") == 0)
 	arch->type = archive_directory;
       else
 	{
-	  gconf_error (locus, 0, _("unknown archive type"));
+	  grecs_error (locus, 0, _("unknown archive type"));
 	  return 1;
 	}
-      if (cmd == gconf_callback_section_begin)
+      if (cmd == grecs_callback_section_begin)
 	return 0;
       break;
 
-    case gconf_callback_section_end:
+    case grecs_callback_section_end:
       break;
     }
 
   if (arch->type == archive_none)
     return 0;
 
   if (arch->name == NULL)
     {
-      gconf_error (locus, 0, _("at least archive name must be set"));
+      grecs_error (locus, 0, _("at least archive name must be set"));
       return 1;
     }
 
   if (arch->type == archive_tar && arch->backup_type != no_backups)
     {
-      gconf_warning (locus, 0, _("backup type ignored for this archive type"));
+      grecs_warning (locus, 0, _("backup type ignored for this archive type"));
       return 1;
     }
 
   return 0;
 }
 
 
-static struct gconf_keyword mail_statistics_kw[] = {
+static struct grecs_keyword mail_statistics_kw[] = {
   { "message", N_("text"), N_("Message text"),
-    gconf_type_string, &admin_stat_message },
+    grecs_type_string, &admin_stat_message },
   { "statistics",
     N_("items"), N_("Send mail if one or more of these items are set"),
-    gconf_type_string, &mail_admin_mask, 0, cb_statistics },
+    grecs_type_string, &mail_admin_mask, 0, cb_statistics },
   { NULL }
 };
 
 
 
 static int
-cb_event (enum gconf_callback_command cmd,
-	  gconf_locus_t *locus,
+cb_event (enum grecs_callback_command cmd,
+	  grecs_locus_t *locus,
 	  void *varptr,
-	  gconf_value_t *value,
+	  grecs_value_t *value,
 	  void *cb_data)
 {
   enum notification_event *pev = varptr;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   string_to_notification_event (locus, value->v.string, pev);
   return 0;
 }
 
 static int
-cb_recipient (enum gconf_callback_command cmd,
-	      gconf_locus_t *locus,
+cb_recipient (enum grecs_callback_command cmd,
+	      grecs_locus_t *locus,
 	      void *varptr,
-	      gconf_value_t *value,
+	      grecs_value_t *value,
 	      void *cb_data)
 {
   enum notification_target *tgt = varptr;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   string_to_notification_target (locus, value->v.string, tgt);
   return 0;
 }
 
-static struct gconf_keyword notify_event_kw[] = {
+static struct grecs_keyword notify_event_kw[] = {
   { "event", N_("ev-id"), N_("Event on which to notify"),
-    gconf_type_string, NULL, offsetof(struct notification, ev), cb_event },
+    grecs_type_string, NULL, offsetof(struct notification, ev), cb_event },
   { "recipient", N_("who"), N_("Notify this recipient"),
-    gconf_type_string, NULL, offsetof(struct notification, tgt),
+    grecs_type_string, NULL, offsetof(struct notification, tgt),
     cb_recipient },
   { "message", N_("text-or-id"),
     N_("Text of the notification or identifier of a defined message template"),
-    gconf_type_string, NULL, offsetof(struct notification, msg) },
+    grecs_type_string, NULL, offsetof(struct notification, msg) },
   { NULL }
 };
 
 static int
-cb_notify_event (enum gconf_callback_command cmd,
-		 gconf_locus_t *locus,
+cb_notify_event (enum grecs_callback_command cmd,
+		 grecs_locus_t *locus,
 		 void *varptr,
-		 gconf_value_t *value,
+		 grecs_value_t *value,
 		 void *cb_data)
 {
   struct notification *ntf;
   void **pdata = cb_data;
 
   switch (cmd) {
-  case gconf_callback_section_begin:
+  case grecs_callback_section_begin:
     ntf = xzalloc (sizeof (*ntf));
     *pdata = ntf;
     break;
 
-  case gconf_callback_section_end:
+  case grecs_callback_section_end:
     ntf = *pdata;
     if (!ntf->msg)
-      gconf_error (locus, 0, _("missing message definition"));
+      grecs_error (locus, 0, _("missing message definition"));
     else
       {
 	struct notification **p = (struct notification **) varptr;
 	ntf->next = *p;
 	*p = ntf;
 	/* FIXME: check ev and tgt? */
       }
     break;
 
-  case gconf_callback_set_value:
-    gconf_error (locus, 0, _("invalid use of block statement"));
+  case grecs_callback_set_value:
+    grecs_error (locus, 0, _("invalid use of block statement"));
   }
   return 0;
 }
 
 
 
 static enum access_method_type
 string_to_access_method_type (const char *str)
 {
   if (strcmp (str, "sql") == 0)
     return method_sql;
   else if (strcmp (str, "builtin") == 0)
     return method_builtin;
   else if (strcmp (str, "external") == 0)
     return method_external;
   else
     return method_none;
 }
 
 static int
-cb_access_method_type (enum gconf_callback_command cmd,
-		       gconf_locus_t *locus,
+cb_access_method_type (enum grecs_callback_command cmd,
+		       grecs_locus_t *locus,
 		       void *varptr,
-		       gconf_value_t *value,
+		       grecs_value_t *value,
 		       void *cb_data)
 {
   enum access_method_type *ptype = varptr;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   *ptype = string_to_access_method_type (value->v.string);
   if (*ptype == method_none)
-    gconf_error (locus, 0, _("unknown access method: %s"), value->v.string);
+    grecs_error (locus, 0, _("unknown access method: %s"), value->v.string);
   return 0;
 }
 
 static int
-cb_access_method_params (enum gconf_callback_command cmd,
-			 gconf_locus_t *locus,
+cb_access_method_params (enum grecs_callback_command cmd,
+			 grecs_locus_t *locus,
 			 void *varptr,
-			 gconf_value_t *value,
+			 grecs_value_t *value,
 			 void *cb_data)
 {
   struct access_method *meth = varptr;
   size_t size;
 
-  if (cmd != gconf_callback_set_value)
+  if (cmd != grecs_callback_set_value)
     {
-      gconf_error (locus, 0, _("Unexpected block statement"));
+      grecs_error (locus, 0, _("Unexpected block statement"));
       return 1;
     }
   if (!value || value->type != GCONF_TYPE_LIST)
     {
-      gconf_error (locus, 0, _("expected list value"));
+      grecs_error (locus, 0, _("expected list value"));
       return 1;
     }
 
   size = gl_list_size (value->v.list);
   if (size == 0)
     {
       meth->parmc = 0;
       meth->parmv = NULL;
     }
   else
     {
       int i;
       const void *p;
       gl_list_iterator_t itr = gl_list_iterator (value->v.list);
 
       meth->parmc = size;
       meth->parmv = xcalloc (size + 1, sizeof (meth->parmv[0]));
 
       for (i = 0; gl_list_iterator_next (&itr, &p, NULL); i++)
 	{
-	  const gconf_value_t *vp = p;
+	  const grecs_value_t *vp = p;
 
 	  if (assert_string_arg (locus, cmd, vp))
 	    break;
 
 	  meth->parmv[i] = xstrdup (vp->v.string);
 	}
       gl_list_iterator_free (&itr);
       meth->parmv[i] = NULL;
     }
   return 0;
 }
 
-static struct gconf_keyword access_method_kw[] = {
+static struct grecs_keyword access_method_kw[] = {
   { "type", N_("type"), N_("Method type"),
-    gconf_type_string, NULL, offsetof(struct access_method, type),
+    grecs_type_string, NULL, offsetof(struct access_method, type),
     cb_access_method_type },
   { "query", N_("string"), N_("Query template"),
-    gconf_type_string, NULL, offsetof(struct access_method, query) },
+    grecs_type_string, NULL, offsetof(struct access_method, query) },
   { "params", N_("arg"), N_("Set method parameters"),
-    gconf_type_string|GCONF_LIST, NULL, 0,
+    grecs_type_string|GCONF_LIST, NULL, 0,
     cb_access_method_params },
   { NULL }
 };
 
 int
-string_to_access_method_id (gconf_locus_t *locus,
+string_to_access_method_id (grecs_locus_t *locus,
 			    const char *str, enum access_method_id *idp)
 {
   static const char *id_str[] = {
     "verify-user",
     "gpg-key",
     "project-owner",
     "user-data",
     NULL
   };
   static int id_num[] = {
     verify_method,
     gpg_key_method,
@@ -1054,438 +1054,438 @@ string_to_access_method_id (gconf_locus_t *locus,
   ARGMATCH_VERIFY (id_str, id_num);
 
   int rc, res;
   rc = string_to ("access method", str,
 		  id_str, id_num,
 		  &res,
 		  locus);
   *idp = res;
   return rc;
 }
 
 static int
-cb_access_method (enum gconf_callback_command cmd,
-		 gconf_locus_t *locus,
+cb_access_method (enum grecs_callback_command cmd,
+		 grecs_locus_t *locus,
 		 void *varptr,
-		 gconf_value_t *value,
+		 grecs_value_t *value,
 		 void *cb_data)
 {
   struct access_method **pmeth, *meth;
   void **pdata = cb_data;
   enum access_method_id id;
 
   switch (cmd) {
-  case gconf_callback_section_begin:
+  case grecs_callback_section_begin:
     if (!value || value->type != GCONF_TYPE_STRING)
       {
-	gconf_error(locus, 0, _("tag must be a string"));
+	grecs_error(locus, 0, _("tag must be a string"));
 	return 0;
       }
     if (string_to_access_method_id (locus, value->v.string, &id))
       return 1;
     pmeth = (struct access_method **) varptr + id;
     *pmeth = method_new (id, method_builtin);
     *pdata = *pmeth;
     break;
 
-  case gconf_callback_section_end:
+  case grecs_callback_section_end:
     meth = *pdata;
     switch (meth->type)
       {
       case method_sql:
 	if (meth->parmc == 0 || !meth->parmv[0])
 	  {
-	    gconf_error (locus, 0, _("SQL connection is not declared"));
+	    grecs_error (locus, 0, _("SQL connection is not declared"));
 	    meth->type = method_none;
 	  }
 	else if (!sql_connection_exists_p (meth->parmv[0]))
 	  {
-	    gconf_error (locus, 0, _("SQL connection `%s' not declared"),
+	    grecs_error (locus, 0, _("SQL connection `%s' not declared"),
 			 meth->parmv[0]);
 	    meth->type = method_none;
 	  }
 	break;
 
       default:
 	/* FIXME: More checks ? */
 	break;
       }
     *pdata = NULL;
     break;
 
-  case gconf_callback_set_value:
-    gconf_error (locus, 0, _("invalid use of block statement"));
+  case grecs_callback_set_value:
+    grecs_error (locus, 0, _("invalid use of block statement"));
   }
   return 0;
 }
 
 static int
-cb_url (enum gconf_callback_command cmd,
-	gconf_locus_t *locus,
+cb_url (enum grecs_callback_command cmd,
+	grecs_locus_t *locus,
 	void *varptr,
-	gconf_value_t *value,
+	grecs_value_t *value,
 	void *cb_data)
 {
   mu_url_t *purl = varptr, url;
   int rc;
 
   if (assert_string_arg (locus, cmd, value))
     return 1;
   rc = mu_url_create (&url, value->v.string);
   if (rc)
     {
-      gconf_error (locus, 0, _("cannot create URL `%s': %s"),
+      grecs_error (locus, 0, _("cannot create URL `%s': %s"),
 		   value->v.string, mu_strerror (rc));
       return rc;
     }
   rc = mu_url_parse (url);
   if (rc)
     {
-      gconf_error (locus, 0, _("cannot parse URL `%s': %s"),
+      grecs_error (locus, 0, _("cannot parse URL `%s': %s"),
 		   value->v.string, mu_strerror (rc));
       mu_url_destroy (&url);
       return rc;
     }
   *purl = url;
   return 0;
 }
 
 
-static struct gconf_keyword spool_kw[] = {
+static struct grecs_keyword spool_kw[] = {
   { "url", N_("arg"), N_("URL corresponding to this spool"),
-    gconf_type_string, NULL, offsetof(struct spool, url) },
+    grecs_type_string, NULL, offsetof(struct spool, url) },
   { "alias", N_("arg"), N_("Aliases"),
-    gconf_type_string|GCONF_LIST, NULL, offsetof(struct spool, aliases) },
+    grecs_type_string|GCONF_LIST, NULL, offsetof(struct spool, aliases) },
   { "source", N_("dir"), N_("Source directory"),
-    gconf_type_string, NULL, offsetof(struct spool, source_dir) },
+    grecs_type_string, NULL, offsetof(struct spool, source_dir) },
   { "destination", N_("dir"), N_("Destination directory"),
-    gconf_type_string, NULL, offsetof(struct spool, dest_url),
+    grecs_type_string, NULL, offsetof(struct spool, dest_url),
     cb_url },
   { "file-sweep-time", N_("interval"), N_("Define file sweep time"),
-    gconf_type_string, NULL, offsetof(struct spool, file_sweep_time),
+    grecs_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),
+    grecs_type_section, NULL, offsetof(struct spool, access_method),
     cb_access_method, NULL, access_method_kw },
   { "archive", N_("type: string"), N_("Set up archivation"),
-    gconf_type_section, NULL, offsetof(struct spool, archive),
+    grecs_type_section, NULL, offsetof(struct spool, archive),
     cb_archive, NULL, archive_kw },
   { "archive-signatures", NULL, N_("Control implicit signature archivation"),
-    gconf_type_bool, &archive_signatures },
+    grecs_type_bool, &archive_signatures },
   { "notify-event", NULL, N_("Configure notification"),
-    gconf_type_section, NULL, offsetof(struct spool, notification),
+    grecs_type_section, NULL, offsetof(struct spool, notification),
     cb_notify_event, NULL, notify_event_kw },
 
   { NULL }
 };
 
 static int
-cb_spool (enum gconf_callback_command cmd,
-	  gconf_locus_t *locus,
+cb_spool (enum grecs_callback_command cmd,
+	  grecs_locus_t *locus,
 	  void *varptr,
-	  gconf_value_t *value,
+	  grecs_value_t *value,
 	  void *cb_data)
 {
   struct spool *spool;
   void **pdata = cb_data;
   int rc, ec, i;