Added alloc_sanitize_path().

[rsync/rsync.git] / options.c

diff --git a/options.c b/options.c
index 5db7d62..166faf8 100644 (file)
--- a/options.c
+++ b/options.c
@@ -108,6 +108,7 @@ int write_batch = 0;
 int read_batch = 0;
 int backup_dir_len = 0;
 int backup_suffix_len;
+unsigned int backup_dir_remainder;
 
 char *backup_suffix = NULL;
 char *tmpdir = NULL;
@@ -118,6 +119,7 @@ char *log_format = NULL;
 char *password_file = NULL;
 char *rsync_path = RSYNC_PATH;
 char *backup_dir = NULL;
+char backup_dir_buf[MAXPATHLEN];
 int rsync_port = RSYNC_PORT;
 int link_dest = 0;
 
@@ -301,7 +303,8 @@ void usage(enum logcode F)
 enum {OPT_VERSION = 1000, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
       OPT_DELETE_AFTER, OPT_DELETE_EXCLUDED, OPT_LINK_DEST,
       OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
-      OPT_READ_BATCH, OPT_WRITE_BATCH};
+      OPT_READ_BATCH, OPT_WRITE_BATCH,
+      OPT_REFUSED_BASE = 9000};
 
 static struct poptOption long_options[] = {
   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
@@ -412,35 +415,34 @@ void option_error(void)
 
 
 /**
- * Check to see if we should refuse this option
+ * Tweak the option table to disable all options that the rsyncd.conf
+ * file has told us to refuse.
  **/
-static int check_refuse_options(char *ref, int opt)
+static void set_refuse_options(char *bp)
 {
-       int i, len;
-       char *p;
-       const char *name;
-
-       for (i = 0; long_options[i].longName; i++) {
-               if (long_options[i].val == opt)
-                       break;
-       }
-
-       if (!long_options[i].longName)
-               return 0;
-
-       name = long_options[i].longName;
-       len = strlen(name);
-
-       while ((p = strstr(ref,name))) {
-               if ((p==ref || p[-1]==' ') &&
-                   (p[len] == ' ' || p[len] == 0)) {
-                       snprintf(err_buf, sizeof err_buf,
-                                "The '%s' option is not supported by this server\n", name);
-                       return 1;
+       struct poptOption *op;
+       char *cp;
+
+       while (1) {
+               if ((cp = strchr(bp, ' ')) != NULL)
+                       *cp= '\0';
+               for (op = long_options; ; op++) {
+                       if (!op->longName) {
+                               rprintf(FLOG,
+                                   "Unknown option %s in \"refuse options\" setting\n",
+                                   bp);
+                               break;
+                       }
+                       if (strcmp(bp, op->longName) == 0) {
+                               op->val = (op - long_options)+OPT_REFUSED_BASE;
+                               break;
+                       }
                }
-               ref += len;
+               if (!cp)
+                       break;
+               *cp = ' ';
+               bp = cp + 1;
        }
-       return 0;
 }
 
 
@@ -469,6 +471,9 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
        char *ref = lp_refuse_options(module_id);
        poptContext pc;
 
+       if (ref && *ref)
+               set_refuse_options(ref);
+
        /* TODO: Call poptReadDefaultConfig; handle errors. */
 
        /* The context leaks in case of an error, but if there's a
@@ -476,9 +481,6 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
        pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
 
        while ((opt = poptGetNextOpt(pc)) != -1) {
-               if (ref && check_refuse_options(ref, opt))
-                       return 0;
-
                /* most options are handled automatically by popt;
                 * only special cases are returned and listed here. */
 
@@ -575,13 +577,26 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
                        return 0;
 #endif
 
-
                default:
-                       snprintf(err_buf, sizeof err_buf,
-                                "%s%s: %s\n",
-                                am_server ? "on remote machine: " : "",
-                                poptBadOption(pc, POPT_BADOPTION_NOALIAS),
-                                poptStrerror(opt));
+                       /* A large opt value means that set_refuse_options()
+                        * turned this option off (opt-BASE is its index). */
+                       if (opt >= OPT_REFUSED_BASE) {
+                               struct poptOption *op =
+                                   &long_options[opt-OPT_REFUSED_BASE];
+                               int n = snprintf(err_buf, sizeof err_buf,
+                                   "This server does not support --%s\n",
+                                   op->longName) - 1;
+                               if (op->shortName) {
+                                       snprintf(err_buf+n, sizeof err_buf-n,
+                                           " (-%c)\n", op->shortName);
+                               }
+                       } else {
+                               snprintf(err_buf, sizeof err_buf,
+                                   "%s%s: %s\n",
+                                   am_server ? "on remote machine: " : "",
+                                   poptBadOption(pc, POPT_BADOPTION_NOALIAS),
+                                   poptStrerror(opt));
+                       }
                        return 0;
                }
        }
@@ -646,16 +661,27 @@ int parse_arguments(int *argc, const char ***argv, int frommain)
                relative_paths = files_from? 1 : 0;
 
        if (!backup_suffix)
-               backup_suffix = backup_dir? "" : BACKUP_SUFFIX;
+               backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
        backup_suffix_len = strlen(backup_suffix);
        if (strchr(backup_suffix, '/') != NULL) {
                rprintf(FERROR, "--suffix cannot contain slashes: %s\n",
                        backup_suffix);
                exit_cleanup(RERR_SYNTAX);
        }
-       if (backup_dir)
-               backup_dir_len = strlen(backup_dir);
-       else if (!backup_suffix_len) {
+       if (backup_dir) {
+               backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
+               backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
+               if (backup_dir_remainder < 32) {
+                       rprintf(FERROR, "the --backup-dir path is WAY too long.\n");
+                       exit_cleanup(RERR_SYNTAX);
+               }
+               if (backup_dir_buf[backup_dir_len - 1] != '/') {
+                       backup_dir_buf[backup_dir_len++] = '/';
+                       backup_dir_buf[backup_dir_len] = '\0';
+               }
+               if (verbose > 1)
+                       rprintf(FINFO, "backup_dir is %s\n", backup_dir_buf);
+       } else if (!backup_suffix_len) {
                rprintf(FERROR,
                        "--suffix cannot be a null string without --backup-dir\n");
                exit_cleanup(RERR_SYNTAX);