diff options
Diffstat (limited to 'src/config.c')
-rw-r--r-- | src/config.c | 476 |
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 @@ -124,24 +124,24 @@ safe_file_name_alloc (const char *file_name) } 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; } @@ -166,13 +166,13 @@ 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, @@ -200,13 +200,13 @@ 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, @@ -214,128 +214,128 @@ string_to_notification_target (gconf_locus_t *locus, const char *val, *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; @@ -343,55 +343,55 @@ cb_interval (enum gconf_callback_command cmd, 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; } @@ -428,21 +428,21 @@ static unsigned long stat_types[] = { 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) @@ -459,26 +459,26 @@ parse_single_statmask (gconf_locus_t *locus, const gconf_value_t *val, } 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) @@ -508,13 +508,13 @@ parse_statmask (gconf_locus_t *loc, gconf_value_t *val, unsigned long *pmask) { 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; @@ -527,27 +527,27 @@ parse_statmask (gconf_locus_t *loc, gconf_value_t *val, unsigned long *pmask) 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)) @@ -566,18 +566,18 @@ cb_sql_host (enum gconf_callback_command cmd, 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); @@ -586,126 +586,126 @@ cb_sql_host (enum gconf_callback_command cmd, 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[] = { @@ -728,216 +728,216 @@ static const enum backup_type backup_types[] = /* 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; } @@ -952,46 +952,46 @@ string_to_access_method_type (const char *str) 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) { @@ -1006,39 +1006,39 @@ cb_access_method_params (enum gconf_callback_command cmd, 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", @@ -1060,192 +1060,192 @@ string_to_access_method_id (gconf_locus_t *locus, 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; 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 1; } spool = xzalloc (sizeof (*spool)); 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; - case gconf_callback_section_end: + case grecs_callback_section_end: rc = 0; spool = *pdata; if (!spool->source_dir) { - gconf_error (locus, 0, _("source is not given")); + grecs_error (locus, 0, _("source is not given")); rc = 1; } else if (test_dir (spool->source_dir, &ec)) { if (ec) - gconf_error (locus, ec, _("cannot access %s"), spool->source_dir); + grecs_error (locus, ec, _("cannot access %s"), spool->source_dir); else - gconf_error (locus, 0, _("%s is not a directory"), + grecs_error (locus, 0, _("%s is not a directory"), spool->source_dir); rc = 1; } if (!spool->dest_url) { - gconf_error (locus, 0, _("destination is not given")); + grecs_error (locus, 0, _("destination is not given")); rc = 1; } else if (url_to_vtab (spool->dest_url, &spool->vtab)) { - gconf_error (locus, 0, _("unsupported url: %s"), + grecs_error (locus, 0, _("unsupported url: %s"), mu_url_to_string (spool->dest_url)); rc = 1; } else if (spool->vtab.test_url && spool->vtab.test_url (spool->dest_url, locus)) rc = 1; for (i = 0; i < access_method_count; i++) if (spool->access_method[i]->type == method_external) { - gconf_error (locus, 0, + grecs_error (locus, 0, _("Sorry, method type `external' is not yet supported")); rc = 1; } if (rc) return rc; @@ -1255,59 +1255,59 @@ cb_spool (enum gconf_callback_command cmd, mu_url_sget_path (spool->dest_url, &spool->dest_dir); register_spool (spool); free (spool); *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; } |