options.c

   1 /*  -*- c-file-style: "linux" -*-
   2  *
   3  * Copyright (C) 1998-2001 by Andrew Tridgell <tridge@samba.org>
   4  * Copyright (C) 2000, 2001, 2002 by Martin Pool <mbp@samba.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "rsync.h"
  22 #include "popt.h"
  23
  24 extern int sanitize_paths;
  25 extern int select_timeout;
  26 extern char curr_dir[MAXPATHLEN];
  27 extern struct exclude_list_struct exclude_list;
  28 extern struct exclude_list_struct server_exclude_list;
  29
  30 int make_backups = 0;
  31
  32 /**
  33  * If 1, send the whole file as literal data rather than trying to
  34  * create an incremental diff.
  35  *
  36  * If -1, then look at whether we're local or remote and go by that.
  37  *
  38  * @sa disable_deltas_p()
  39  **/
  40 int whole_file = -1;
  41
  42 int archive_mode = 0;
  43 int keep_dirlinks = 0;
  44 int copy_links = 0;
  45 int preserve_links = 0;
  46 int preserve_hard_links = 0;
  47 int preserve_perms = 0;
  48 int preserve_devices = 0;
  49 int preserve_uid = 0;
  50 int preserve_gid = 0;
  51 int preserve_times = 0;
  52 int update_only = 0;
  53 int cvs_exclude = 0;
  54 int dry_run = 0;
  55 int local_server = 0;
  56 int ignore_times = 0;
  57 int delete_mode = 0;
  58 int delete_excluded = 0;
  59 int one_file_system = 0;
  60 int protocol_version = PROTOCOL_VERSION;
  61 int sparse_files = 0;
  62 int do_compression = 0;
  63 int am_root = 0;
  64 int orig_umask = 0;
  65 int relative_paths = -1;
  66 int implied_dirs = 1;
  67 int numeric_ids = 0;
  68 int force_delete = 0;
  69 int io_timeout = 0;
  70 int read_only = 0;
  71 int module_id = -1;
  72 int am_server = 0;
  73 int am_sender = 0;
  74 int am_generator = 0;
  75 char *files_from = NULL;
  76 int filesfrom_fd = -1;
  77 char *remote_filesfrom_file = NULL;
  78 int eol_nulls = 0;
  79 int recurse = 0;
  80 int am_daemon = 0;
  81 int daemon_over_rsh = 0;
  82 int do_stats = 0;
  83 int do_progress = 0;
  84 int keep_partial = 0;
  85 int safe_symlinks = 0;
  86 int copy_unsafe_links = 0;
  87 int size_only = 0;
  88 int bwlimit = 0;
  89 size_t bwlimit_writemax = 0;
  90 int delete_after = 0;
  91 int only_existing = 0;
  92 int opt_ignore_existing = 0;
  93 int max_delete = 0;
  94 int ignore_errors = 0;
  95 int modify_window = 0;
  96 int blocking_io = -1;
  97 int checksum_seed = 0;
  98 int inplace = 0;
  99 unsigned int block_size = 0;
 100
 101
 102 /** Network address family. **/
 103 #ifdef INET6
 104 int default_af_hint = 0;        /* Any protocol */
 105 #else
 106 int default_af_hint = AF_INET;  /* Must use IPv4 */
 107 #endif
 108
 109 /** Do not go into the background when run as --daemon.  Good
 110  * for debugging and required for running as a service on W32,
 111  * or under Unix process-monitors. **/
 112 int no_detach = 0;
 113
 114 int write_batch = 0;
 115 int read_batch = 0;
 116 int backup_dir_len = 0;
 117 int backup_suffix_len;
 118 unsigned int backup_dir_remainder;
 119
 120 char *backup_suffix = NULL;
 121 char *tmpdir = NULL;
 122 char *partial_dir = NULL;
 123 char *compare_dest = NULL;
 124 char *config_file = NULL;
 125 char *shell_cmd = NULL;
 126 char *log_format = NULL;
 127 char *password_file = NULL;
 128 char *rsync_path = RSYNC_PATH;
 129 char *backup_dir = NULL;
 130 char backup_dir_buf[MAXPATHLEN];
 131 int rsync_port = RSYNC_PORT;
 132 int link_dest = 0;
 133
 134 int verbose = 0;
 135 int quiet = 0;
 136 int always_checksum = 0;
 137 int list_only = 0;
 138
 139 #define MAX_BATCH_NAME_LEN 256  /* Must be less than MAXPATHLEN-13 */
 140 char *batch_name = NULL;
 141
 142 static int daemon_opt;   /* sets am_daemon after option error-reporting */
 143 static int modify_window_set;
 144
 145 /** Local address to bind.  As a character string because it's
 146  * interpreted by the IPv6 layer: should be a numeric IP4 or IP6
 147  * address, or a hostname. **/
 148 char *bind_address;
 149
 150
 151 static void print_rsync_version(enum logcode f)
 152 {
 153         char const *got_socketpair = "no ";
 154         char const *have_inplace = "no ";
 155         char const *hardlinks = "no ";
 156         char const *links = "no ";
 157         char const *ipv6 = "no ";
 158         STRUCT_STAT *dumstat;
 159
 160 #ifdef HAVE_SOCKETPAIR
 161         got_socketpair = "";
 162 #endif
 163
 164 #if HAVE_FTRUNCATE
 165         have_inplace = "";
 166 #endif
 167
 168 #if SUPPORT_HARD_LINKS
 169         hardlinks = "";
 170 #endif
 171
 172 #if SUPPORT_LINKS
 173         links = "";
 174 #endif
 175
 176 #if INET6
 177         ipv6 = "";
 178 #endif
 179
 180         rprintf(f, "%s  version %s  protocol version %d\n",
 181                 RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION);
 182         rprintf(f,
 183                 "Copyright (C) 1996-2004 by Andrew Tridgell and others\n");
 184         rprintf(f, "<http://rsync.samba.org/>\n");
 185         rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, "
 186                 "%shard links, %ssymlinks, batchfiles, \n",
 187                 (int) (sizeof (OFF_T) * 8),
 188                 got_socketpair, hardlinks, links);
 189
 190         /* Note that this field may not have type ino_t.  It depends
 191          * on the complicated interaction between largefile feature
 192          * macros. */
 193         rprintf(f, "              %sinplace, %sIPv6, %d-bit system inums, %d-bit internal inums\n",
 194                 have_inplace, ipv6,
 195                 (int) (sizeof dumstat->st_ino * 8),
 196                 (int) (sizeof (uint64) * 8));
 197 #ifdef MAINTAINER_MODE
 198         rprintf(f, "              panic action: \"%s\"\n",
 199                 get_panic_action());
 200 #endif
 201
 202 #ifdef INT64_IS_OFF_T
 203         if (sizeof (int64) < 8)
 204                 rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
 205 #endif
 206
 207         rprintf(f,
 208 "\n"
 209 "rsync comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n"
 210 "are welcome to redistribute it under certain conditions.  See the GNU\n"
 211 "General Public Licence for details.\n"
 212                 );
 213 }
 214
 215
 216 void usage(enum logcode F)
 217 {
 218   print_rsync_version(F);
 219
 220   rprintf(F,"\nrsync is a file transfer program capable of efficient remote update\nvia a fast differencing algorithm.\n\n");
 221
 222   rprintf(F,"Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST\n");
 223   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST:SRC DEST\n");
 224   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... DEST\n");
 225   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]\n");
 226   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST\n");
 227   rprintf(F,"  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]\n");
 228   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST\n");
 229   rprintf(F,"SRC on single-colon remote HOST will be expanded by remote shell\n");
 230   rprintf(F,"SRC on server remote HOST may contain shell wildcards or multiple\n");
 231   rprintf(F,"  sources separated by space as long as they have same top-level\n");
 232   rprintf(F,"\nOptions\n");
 233   rprintf(F," -v, --verbose               increase verbosity\n");
 234   rprintf(F," -q, --quiet                 decrease verbosity\n");
 235   rprintf(F," -c, --checksum              always checksum\n");
 236   rprintf(F," -a, --archive               archive mode, equivalent to -rlptgoD\n");
 237   rprintf(F," -r, --recursive             recurse into directories\n");
 238   rprintf(F," -R, --relative              use relative path names\n");
 239   rprintf(F,"     --no-relative           turn off --relative\n");
 240   rprintf(F,"     --no-implied-dirs       don't send implied dirs with -R\n");
 241   rprintf(F," -b, --backup                make backups (see --suffix & --backup-dir)\n");
 242   rprintf(F,"     --backup-dir            make backups into this directory\n");
 243   rprintf(F,"     --suffix=SUFFIX         backup suffix (default %s w/o --backup-dir)\n",BACKUP_SUFFIX);
 244   rprintf(F," -u, --update                update only (don't overwrite newer files)\n");
 245   rprintf(F,"     --inplace               update destination files inplace (SEE MAN PAGE)\n");
 246   rprintf(F," -K, --keep-dirlinks         treat symlinked dir on receiver as dir\n");
 247   rprintf(F," -l, --links                 copy symlinks as symlinks\n");
 248   rprintf(F," -L, --copy-links            copy the referent of all symlinks\n");
 249   rprintf(F,"     --copy-unsafe-links     copy the referent of \"unsafe\" symlinks\n");
 250   rprintf(F,"     --safe-links            ignore \"unsafe\" symlinks\n");
 251   rprintf(F," -H, --hard-links            preserve hard links\n");
 252   rprintf(F," -p, --perms                 preserve permissions\n");
 253   rprintf(F," -o, --owner                 preserve owner (root only)\n");
 254   rprintf(F," -g, --group                 preserve group\n");
 255   rprintf(F," -D, --devices               preserve devices (root only)\n");
 256   rprintf(F," -t, --times                 preserve times\n");
 257   rprintf(F," -S, --sparse                handle sparse files efficiently\n");
 258   rprintf(F," -n, --dry-run               show what would have been transferred\n");
 259   rprintf(F," -W, --whole-file            copy whole files, no incremental checks\n");
 260   rprintf(F,"     --no-whole-file         turn off --whole-file\n");
 261   rprintf(F," -x, --one-file-system       don't cross filesystem boundaries\n");
 262   rprintf(F," -B, --block-size=SIZE       checksum blocking size (default %d)\n",BLOCK_SIZE);
 263   rprintf(F," -e, --rsh=COMMAND           specify the remote shell\n");
 264   rprintf(F,"     --rsync-path=PATH       specify path to rsync on the remote machine\n");
 265   rprintf(F,"     --existing              only update files that already exist\n");
 266   rprintf(F,"     --ignore-existing       ignore files that already exist on receiving side\n");
 267   rprintf(F,"     --delete                delete files that don't exist on the sending side\n");
 268   rprintf(F,"     --delete-excluded       also delete excluded files on the receiving side\n");
 269   rprintf(F,"     --delete-after          receiver deletes after transferring, not before\n");
 270   rprintf(F,"     --ignore-errors         delete even if there are I/O errors\n");
 271   rprintf(F,"     --max-delete=NUM        don't delete more than NUM files\n");
 272   rprintf(F,"     --partial               keep partially transferred files\n");
 273   rprintf(F,"     --partial-dir=DIR       put a partially transferred file into DIR\n");
 274   rprintf(F,"     --force                 force deletion of directories even if not empty\n");
 275   rprintf(F,"     --numeric-ids           don't map uid/gid values by user/group name\n");
 276   rprintf(F,"     --timeout=TIME          set I/O timeout in seconds\n");
 277   rprintf(F," -I, --ignore-times          turn off mod time & file size quick check\n");
 278   rprintf(F,"     --size-only             ignore mod time for quick check (use size)\n");
 279   rprintf(F,"     --modify-window=NUM     compare mod times with reduced accuracy\n");
 280   rprintf(F," -T, --temp-dir=DIR          create temporary files in directory DIR\n");
 281   rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
 282   rprintf(F,"     --link-dest=DIR         create hardlinks to DIR for unchanged files\n");
 283   rprintf(F," -P                          equivalent to --partial --progress\n");
 284   rprintf(F," -z, --compress              compress file data\n");
 285   rprintf(F," -C, --cvs-exclude           auto ignore files in the same way CVS does\n");
 286   rprintf(F,"     --exclude=PATTERN       exclude files matching PATTERN\n");
 287   rprintf(F,"     --exclude-from=FILE     exclude patterns listed in FILE\n");
 288   rprintf(F,"     --include=PATTERN       don't exclude files matching PATTERN\n");
 289   rprintf(F,"     --include-from=FILE     don't exclude patterns listed in FILE\n");
 290   rprintf(F,"     --files-from=FILE       read FILE for list of source-file names\n");
 291   rprintf(F," -0, --from0                 all *-from file lists are delimited by nulls\n");
 292   rprintf(F,"     --version               print version number\n");
 293   rprintf(F,"     --daemon                run as an rsync daemon\n");
 294   rprintf(F,"     --no-detach             do not detach from the parent\n");
 295   rprintf(F,"     --address=ADDRESS       bind to the specified address\n");
 296   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");
 297   rprintf(F,"     --port=PORT             specify alternate rsyncd port number\n");
 298   rprintf(F,"     --blocking-io           use blocking I/O for the remote shell\n");
 299   rprintf(F,"     --no-blocking-io        turn off --blocking-io\n");
 300   rprintf(F,"     --stats                 give some file transfer stats\n");
 301   rprintf(F,"     --progress              show progress during transfer\n");
 302   rprintf(F,"     --log-format=FORMAT     log file transfers using specified format\n");
 303   rprintf(F,"     --password-file=FILE    get password from FILE\n");
 304   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth, KBytes per second\n");
 305   rprintf(F,"     --write-batch=FILE      write a batch to FILE\n");
 306   rprintf(F,"     --read-batch=FILE       read a batch from FILE\n");
 307   rprintf(F,"     --checksum-seed=NUM     set block/file checksum seed\n");
 308 #ifdef INET6
 309   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 310   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 311 #endif
 312   rprintf(F," -h, --help                  show this help screen\n");
 313
 314   rprintf(F,"\n");
 315
 316   rprintf(F,"\nPlease see the rsync(1) and rsyncd.conf(5) man pages for full documentation\n");
 317   rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
 318 }
 319
 320 enum {OPT_VERSION = 1000, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
 321       OPT_DELETE_AFTER, OPT_DELETE_EXCLUDED, OPT_LINK_DEST,
 322       OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
 323       OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_TIMEOUT,
 324       OPT_REFUSED_BASE = 9000};
 325
 326 static struct poptOption long_options[] = {
 327   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 328   {"version",          0,  POPT_ARG_NONE,   0,              OPT_VERSION, 0, 0},
 329   {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
 330   {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path, 0, 0, 0 },
 331   {"password-file",    0,  POPT_ARG_STRING, &password_file, 0, 0, 0 },
 332   {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
 333   {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
 334   {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
 335   {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system, 0, 0, 0 },
 336   {"delete",           0,  POPT_ARG_NONE,   &delete_mode, 0, 0, 0 },
 337   {"existing",         0,  POPT_ARG_NONE,   &only_existing, 0, 0, 0 },
 338   {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing, 0, 0, 0 },
 339   {"delete-after",     0,  POPT_ARG_NONE,   0,              OPT_DELETE_AFTER, 0, 0 },
 340   {"delete-excluded",  0,  POPT_ARG_NONE,   0,              OPT_DELETE_EXCLUDED, 0, 0 },
 341   {"force",            0,  POPT_ARG_NONE,   &force_delete, 0, 0, 0 },
 342   {"numeric-ids",      0,  POPT_ARG_NONE,   &numeric_ids, 0, 0, 0 },
 343   {"exclude",          0,  POPT_ARG_STRING, 0,              OPT_EXCLUDE, 0, 0 },
 344   {"include",          0,  POPT_ARG_STRING, 0,              OPT_INCLUDE, 0, 0 },
 345   {"exclude-from",     0,  POPT_ARG_STRING, 0,              OPT_EXCLUDE_FROM, 0, 0 },
 346   {"include-from",     0,  POPT_ARG_STRING, 0,              OPT_INCLUDE_FROM, 0, 0 },
 347   {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
 348   {"help",            'h', POPT_ARG_NONE,   0,              'h', 0, 0 },
 349   {"backup",          'b', POPT_ARG_NONE,   &make_backups, 0, 0, 0 },
 350   {"dry-run",         'n', POPT_ARG_NONE,   &dry_run, 0, 0, 0 },
 351   {"sparse",          'S', POPT_ARG_NONE,   &sparse_files, 0, 0, 0 },
 352   {"cvs-exclude",     'C', POPT_ARG_NONE,   &cvs_exclude, 0, 0, 0 },
 353   {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
 354   {"inplace",          0,  POPT_ARG_NONE,   &inplace, 0, 0, 0 },
 355   {"keep-dirlinks",   'K', POPT_ARG_NONE,   &keep_dirlinks, 0, 0, 0 },
 356   {"links",           'l', POPT_ARG_NONE,   &preserve_links, 0, 0, 0 },
 357   {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
 358   {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
 359   {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 360   {"copy-unsafe-links", 0, POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
 361   {"perms",           'p', POPT_ARG_NONE,   &preserve_perms, 0, 0, 0 },
 362   {"owner",           'o', POPT_ARG_NONE,   &preserve_uid, 0, 0, 0 },
 363   {"group",           'g', POPT_ARG_NONE,   &preserve_gid, 0, 0, 0 },
 364   {"devices",         'D', POPT_ARG_NONE,   &preserve_devices, 0, 0, 0 },
 365   {"times",           't', POPT_ARG_NONE,   &preserve_times, 0, 0, 0 },
 366   {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
 367   {"verbose",         'v', POPT_ARG_NONE,   0,               'v', 0, 0 },
 368   {"quiet",           'q', POPT_ARG_NONE,   0,               'q', 0, 0 },
 369   {"archive",         'a', POPT_ARG_NONE,   &archive_mode, 0, 0, 0 },
 370   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 371   {"sender",           0,  POPT_ARG_NONE,   0,              OPT_SENDER, 0, 0 },
 372   {"recursive",       'r', POPT_ARG_NONE,   &recurse, 0, 0, 0 },
 373   {"relative",        'R', POPT_ARG_VAL,    &relative_paths, 1, 0, 0 },
 374   {"no-relative",      0,  POPT_ARG_VAL,    &relative_paths, 0, 0, 0 },
 375   {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
 376   {"block-size",      'B', POPT_ARG_INT,    &block_size, 0, 0, 0 },
 377   {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
 378   {"timeout",          0,  POPT_ARG_INT,    &io_timeout, OPT_TIMEOUT, 0, 0 },
 379   {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
 380   {"compare-dest",     0,  POPT_ARG_STRING, &compare_dest, 0, 0, 0 },
 381   {"link-dest",        0,  POPT_ARG_STRING, &compare_dest,  OPT_LINK_DEST, 0, 0 },
 382   /* TODO: Should this take an optional int giving the compression level? */
 383   {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
 384   {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
 385   {"no-detach",        0,  POPT_ARG_NONE,   &no_detach, 0, 0, 0 },
 386   {"stats",            0,  POPT_ARG_NONE,   &do_stats, 0, 0, 0 },
 387   {"progress",         0,  POPT_ARG_NONE,   &do_progress, 0, 0, 0 },
 388   {"partial",          0,  POPT_ARG_NONE,   &keep_partial, 0, 0, 0 },
 389   {"partial-dir",      0,  POPT_ARG_STRING, &partial_dir, 0, 0, 0 },
 390   {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors, 0, 0, 0 },
 391   {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
 392   {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
 393   {0,                 'P', POPT_ARG_NONE,   0,              'P', 0, 0 },
 394   {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
 395   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 396   {"log-format",       0,  POPT_ARG_STRING, &log_format, 0, 0, 0 },
 397   {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
 398   {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
 399   {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
 400   {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links, 0, 0, 0 },
 401   {"read-batch",       0,  POPT_ARG_STRING, &batch_name,  OPT_READ_BATCH, 0, 0 },
 402   {"write-batch",      0,  POPT_ARG_STRING, &batch_name,  OPT_WRITE_BATCH, 0, 0 },
 403   {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
 404   {"from0",           '0', POPT_ARG_NONE,   &eol_nulls, 0, 0, 0},
 405   {"no-implied-dirs",  0,  POPT_ARG_VAL,    &implied_dirs, 0, 0, 0 },
 406   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 407   {"checksum-seed",    0,  POPT_ARG_INT,    &checksum_seed, 0, 0, 0 },
 408 #ifdef INET6
 409   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 410   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 411 #endif
 412   {0,0,0,0, 0, 0, 0}
 413 };
 414
 415
 416 static char err_buf[200];
 417
 418
 419 /**
 420  * Store the option error message, if any, so that we can log the
 421  * connection attempt (which requires parsing the options), and then
 422  * show the error later on.
 423  **/
 424 void option_error(void)
 425 {
 426         if (!err_buf[0]) {
 427                 strcpy(err_buf, "Error parsing options: "
 428                     "option may be supported on client but not on server?\n");
 429         }
 430
 431         rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
 432 }
 433
 434
 435 /**
 436  * Tweak the option table to disable all options that the rsyncd.conf
 437  * file has told us to refuse.
 438  **/
 439 static void set_refuse_options(char *bp)
 440 {
 441         struct poptOption *op;
 442         char *cp;
 443         int match_short, is_wild;
 444
 445         while (1) {
 446                 while (*bp == ' ') bp++;
 447                 if (!*bp)
 448                         break;
 449                 if ((cp = strchr(bp, ' ')) != NULL)
 450                         *cp= '\0';
 451                 /* If they specify "delete", reject all delete options. */
 452                 if (strcmp(bp, "delete") == 0)
 453                         bp = "delete*";
 454                 match_short = !bp[1] && *bp != '*';
 455                 is_wild = !match_short && strpbrk(bp, "*?[") != NULL;
 456                 for (op = long_options; ; op++) {
 457                         if (!op->longName) {
 458                                 rprintf(FLOG,
 459                                     "No match for refuse-options string \"%s\"\n",
 460                                     bp);
 461                                 break;
 462                         }
 463                         if (match_short ? *bp == op->shortName
 464                                         : wildmatch(bp, op->longName)) {
 465                                 op->val = (op - long_options) + OPT_REFUSED_BASE;
 466                                 if (!is_wild)
 467                                         break;
 468                         }
 469                 }
 470                 if (!cp)
 471                         break;
 472                 *cp = ' ';
 473                 bp = cp + 1;
 474         }
 475 }
 476
 477
 478 static int count_args(char const **argv)
 479 {
 480         int i = 0;
 481
 482         while (argv[i] != NULL)
 483                 i++;
 484
 485         return i;
 486 }
 487
 488
 489 /**
 490  * Process command line arguments.  Called on both local and remote.
 491  *
 492  * @retval 1 if all options are OK; with globals set to appropriate
 493  * values
 494  *
 495  * @retval 0 on error, with err_buf containing an explanation
 496  **/
 497 int parse_arguments(int *argc, const char ***argv, int frommain)
 498 {
 499         int opt;
 500         char *ref = lp_refuse_options(module_id);
 501         const char *arg;
 502         poptContext pc;
 503
 504         if (ref && *ref)
 505                 set_refuse_options(ref);
 506
 507         /* TODO: Call poptReadDefaultConfig; handle errors. */
 508
 509         /* The context leaks in case of an error, but if there's a
 510          * problem we always exit anyhow. */
 511         pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
 512
 513         while ((opt = poptGetNextOpt(pc)) != -1) {
 514                 /* most options are handled automatically by popt;
 515                  * only special cases are returned and listed here. */
 516
 517                 switch (opt) {
 518                 case OPT_VERSION:
 519                         print_rsync_version(FINFO);
 520                         exit_cleanup(0);
 521
 522                 case OPT_MODIFY_WINDOW:
 523                         /* The value has already been set by popt, but
 524                          * we need to remember that we're using a
 525                          * non-default setting. */
 526                         modify_window_set = 1;
 527                         break;
 528
 529                 case OPT_DELETE_AFTER:
 530                         delete_after = 1;
 531                         delete_mode = 1;
 532                         break;
 533
 534                 case OPT_DELETE_EXCLUDED:
 535                         delete_excluded = 1;
 536                         delete_mode = 1;
 537                         break;
 538
 539                 case OPT_EXCLUDE:
 540                         if (am_server || sanitize_paths)
 541                                 return 0; /* Impossible... */
 542                         add_exclude(&exclude_list, poptGetOptArg(pc), 0);
 543                         break;
 544
 545                 case OPT_INCLUDE:
 546                         if (am_server || sanitize_paths)
 547                                 return 0; /* Impossible... */
 548                         add_exclude(&exclude_list, poptGetOptArg(pc),
 549                                     XFLG_DEF_INCLUDE);
 550                         break;
 551
 552                 case OPT_EXCLUDE_FROM:
 553                         if (am_server || sanitize_paths)
 554                                 return 0; /* Impossible... */
 555                         arg = poptGetOptArg(pc);
 556                         add_exclude_file(&exclude_list, arg,
 557                                          XFLG_FATAL_ERRORS);
 558                         break;
 559
 560                 case OPT_INCLUDE_FROM:
 561                         if (am_server || sanitize_paths)
 562                                 return 0; /* Impossible... */
 563                         arg = poptGetOptArg(pc);
 564                         add_exclude_file(&exclude_list, arg,
 565                                          XFLG_FATAL_ERRORS | XFLG_DEF_INCLUDE);
 566                         break;
 567
 568                 case 'h':
 569                         usage(FINFO);
 570                         exit_cleanup(0);
 571
 572                 case 'v':
 573                         verbose++;
 574                         break;
 575
 576                 case 'q':
 577                         if (frommain)
 578                                 quiet++;
 579                         break;
 580
 581                 case OPT_SENDER:
 582                         if (!am_server) {
 583                                 usage(FERROR);
 584                                 exit_cleanup(RERR_SYNTAX);
 585                         }
 586                         am_sender = 1;
 587                         break;
 588
 589                 case 'P':
 590                         do_progress = 1;
 591                         keep_partial = 1;
 592                         break;
 593
 594                 case OPT_WRITE_BATCH:
 595                         /* batch_name is already set */
 596                         write_batch = 1;
 597                         break;
 598
 599                 case OPT_READ_BATCH:
 600                         /* batch_name is already set */
 601                         read_batch = 1;
 602                         break;
 603
 604                 case OPT_TIMEOUT:
 605                         if (io_timeout && io_timeout < select_timeout)
 606                                 select_timeout = io_timeout;
 607                         break;
 608
 609                 case OPT_LINK_DEST:
 610 #if HAVE_LINK
 611                         link_dest = 1;
 612                         break;
 613 #else
 614                         snprintf(err_buf, sizeof err_buf,
 615                                  "hard links are not supported on this %s\n",
 616                                  am_server ? "server" : "client");
 617                         return 0;
 618 #endif
 619
 620                 default:
 621                         /* A large opt value means that set_refuse_options()
 622                          * turned this option off (opt-BASE is its index). */
 623                         if (opt >= OPT_REFUSED_BASE) {
 624                                 struct poptOption *op =
 625                                     &long_options[opt-OPT_REFUSED_BASE];
 626                                 int n = snprintf(err_buf, sizeof err_buf,
 627                                     "This server does not support --%s\n",
 628                                     op->longName) - 1;
 629                                 if (op->shortName) {
 630                                         snprintf(err_buf+n, sizeof err_buf-n,
 631                                             " (-%c)\n", op->shortName);
 632                                 }
 633                         } else {
 634                                 snprintf(err_buf, sizeof err_buf,
 635                                     "%s%s: %s\n",
 636                                     am_server ? "on remote machine: " : "",
 637                                     poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 638                                     poptStrerror(opt));
 639                         }
 640                         return 0;
 641                 }
 642         }
 643
 644 #if !SUPPORT_LINKS
 645         if (preserve_links && !am_sender) {
 646                 snprintf(err_buf, sizeof err_buf,
 647                          "symlinks are not supported on this %s\n",
 648                          am_server ? "server" : "client");
 649                 return 0;
 650         }
 651 #endif
 652
 653 #if !SUPPORT_HARD_LINKS
 654         if (preserve_hard_links) {
 655                 snprintf(err_buf, sizeof err_buf,
 656                          "hard links are not supported on this %s\n",
 657                          am_server ? "server" : "client");
 658                 return 0;
 659         }
 660 #endif
 661
 662         if (block_size > MAX_MAP_SIZE) {
 663                 rprintf(FINFO, "limiting block-size to %d bytes\n",
 664                         MAX_MAP_SIZE);
 665                 block_size = MAX_MAP_SIZE;
 666         }
 667
 668         if (write_batch && read_batch) {
 669                 snprintf(err_buf, sizeof err_buf,
 670                         "--write-batch and --read-batch can not be used together\n");
 671                 return 0;
 672         }
 673         if (write_batch || read_batch) {
 674                 if (dry_run) {
 675                         snprintf(err_buf, sizeof err_buf,
 676                                 "--%s-batch cannot be used with --dry_run (-n)\n",
 677                                 write_batch ? "write" : "read");
 678                         return 0;
 679                 }
 680                 if (am_server) {
 681                         rprintf(FINFO,
 682                                 "ignoring --%s-batch option sent to server\n",
 683                                 write_batch ? "write" : "read");
 684                         /* We don't actually exit_cleanup(), so that we can
 685                          * still service older version clients that still send
 686                          * batch args to server. */
 687                         read_batch = write_batch = 0;
 688                         batch_name = NULL;
 689                 }
 690         }
 691         if (read_batch && files_from) {
 692                 snprintf(err_buf, sizeof err_buf,
 693                         "--read-batch cannot be used with --files-from\n");
 694                 return 0;
 695         }
 696         if (batch_name && strlen(batch_name) > MAX_BATCH_NAME_LEN) {
 697                 snprintf(err_buf, sizeof err_buf,
 698                         "the batch-file name must be %d characters or less.\n",
 699                         MAX_BATCH_NAME_LEN);
 700                 return 0;
 701         }
 702
 703         if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
 704                 snprintf(err_buf, sizeof err_buf,
 705                          "the --temp-dir path is WAY too long.\n");
 706                 return 0;
 707         }
 708
 709         if (archive_mode) {
 710                 if (!files_from)
 711                         recurse = 1;
 712 #if SUPPORT_LINKS
 713                 preserve_links = 1;
 714 #endif
 715                 preserve_perms = 1;
 716                 preserve_times = 1;
 717                 preserve_gid = 1;
 718                 preserve_uid = 1;
 719                 preserve_devices = 1;
 720         }
 721
 722         if (relative_paths < 0)
 723                 relative_paths = files_from? 1 : 0;
 724
 725         *argv = poptGetArgs(pc);
 726         if (*argv)
 727                 *argc = count_args(*argv);
 728         else
 729                 *argc = 0;
 730
 731         if (sanitize_paths) {
 732                 int i;
 733                 for (i = *argc; i-- > 0; )
 734                         (*argv)[i] = alloc_sanitize_path((*argv)[i], NULL);
 735                 if (tmpdir)
 736                         tmpdir = alloc_sanitize_path(tmpdir, curr_dir);
 737                 if (partial_dir)
 738                         partial_dir = alloc_sanitize_path(partial_dir, curr_dir);
 739                 if (compare_dest)
 740                         compare_dest = alloc_sanitize_path(compare_dest, curr_dir);
 741                 if (backup_dir)
 742                         backup_dir = alloc_sanitize_path(backup_dir, curr_dir);
 743                 if (files_from)
 744                         files_from = alloc_sanitize_path(files_from, curr_dir);
 745         }
 746         if (server_exclude_list.head && !am_sender) {
 747                 struct exclude_list_struct *elp = &server_exclude_list;
 748                 if (tmpdir) {
 749                         clean_fname(tmpdir);
 750                         if (check_exclude(elp, tmpdir, 1) < 0)
 751                                 goto options_rejected;
 752                 }
 753                 if (partial_dir) {
 754                         clean_fname(partial_dir);
 755                         if (check_exclude(elp, partial_dir, 1) < 0)
 756                                 goto options_rejected;
 757                 }
 758                 if (compare_dest) {
 759                         clean_fname(compare_dest);
 760                         if (check_exclude(elp, compare_dest, 1) < 0)
 761                                 goto options_rejected;
 762                 }
 763                 if (backup_dir) {
 764                         clean_fname(backup_dir);
 765                         if (check_exclude(elp, backup_dir, 1) < 0)
 766                                 goto options_rejected;
 767                 }
 768         }
 769         if (server_exclude_list.head && files_from) {
 770                 clean_fname(files_from);
 771                 if (check_exclude(&server_exclude_list, files_from, 0) < 0) {
 772                     options_rejected:
 773                         snprintf(err_buf, sizeof err_buf,
 774                             "Your options have been rejected by the server.\n");
 775                         return 0;
 776                 }
 777         }
 778
 779         if (daemon_opt) {
 780                 daemon_opt = 0;
 781                 am_daemon = 1;
 782                 return 1;
 783         }
 784
 785         if (!backup_suffix)
 786                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
 787         backup_suffix_len = strlen(backup_suffix);
 788         if (strchr(backup_suffix, '/') != NULL) {
 789                 snprintf(err_buf, sizeof err_buf,
 790                         "--suffix cannot contain slashes: %s\n",
 791                         backup_suffix);
 792                 return 0;
 793         }
 794         if (backup_dir) {
 795                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
 796                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
 797                 if (backup_dir_remainder < 32) {
 798                         snprintf(err_buf, sizeof err_buf,
 799                                 "the --backup-dir path is WAY too long.\n");
 800                         return 0;
 801                 }
 802                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
 803                         backup_dir_buf[backup_dir_len++] = '/';
 804                         backup_dir_buf[backup_dir_len] = '\0';
 805                 }
 806                 if (verbose > 1 && !am_sender)
 807                         rprintf(FINFO, "backup_dir is %s\n", backup_dir_buf);
 808         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
 809                 snprintf(err_buf, sizeof err_buf,
 810                         "--suffix cannot be a null string without --backup-dir\n");
 811                 return 0;
 812         }
 813
 814         if (do_progress && !verbose)
 815                 verbose = 1;
 816
 817         if (bwlimit) {
 818                 bwlimit_writemax = (size_t)bwlimit * 128;
 819                 if (bwlimit_writemax < 512)
 820                         bwlimit_writemax = 512;
 821         }
 822
 823         if (inplace) {
 824 #if HAVE_FTRUNCATE
 825                 if (partial_dir) {
 826                         snprintf(err_buf, sizeof err_buf,
 827                                  "--inplace cannot be used with --partial-dir\n");
 828                         return 0;
 829                 }
 830                 keep_partial = 0;
 831 #else
 832                 snprintf(err_buf, sizeof err_buf,
 833                          "--inplace is not supported on this %s\n",
 834                          am_server ? "server" : "client");
 835                 return 0;
 836 #endif
 837         } else if (partial_dir) {
 838                 if (strcmp(partial_dir, ".") == 0)
 839                         partial_dir = NULL;
 840                 keep_partial = 1;
 841         }
 842
 843         if (files_from) {
 844                 char *colon;
 845                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
 846                         usage(FERROR);
 847                         exit_cleanup(RERR_SYNTAX);
 848                 }
 849                 if (strcmp(files_from, "-") == 0) {
 850                         filesfrom_fd = 0;
 851                         if (am_server)
 852                                 remote_filesfrom_file = "-";
 853                 }
 854                 else if ((colon = find_colon(files_from)) != 0) {
 855                         if (am_server) {
 856                                 usage(FERROR);
 857                                 exit_cleanup(RERR_SYNTAX);
 858                         }
 859                         remote_filesfrom_file = colon+1 + (colon[1] == ':');
 860                         if (strcmp(remote_filesfrom_file, "-") == 0) {
 861                                 snprintf(err_buf, sizeof err_buf,
 862                                         "Invalid --files-from remote filename\n");
 863                                 return 0;
 864                         }
 865                 } else {
 866                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
 867                         if (filesfrom_fd < 0) {
 868                                 snprintf(err_buf, sizeof err_buf,
 869                                         "failed to open files-from file %s: %s\n",
 870                                         files_from, strerror(errno));
 871                                 return 0;
 872                         }
 873                 }
 874         }
 875
 876         return 1;
 877 }
 878
 879
 880 /**
 881  * Construct a filtered list of options to pass through from the
 882  * client to the server.
 883  *
 884  * This involves setting options that will tell the server how to
 885  * behave, and also filtering out options that are processed only
 886  * locally.
 887  **/
 888 void server_options(char **args,int *argc)
 889 {
 890         int ac = *argc;
 891         static char argstr[50];
 892         char *arg;
 893
 894         int i, x;
 895
 896         if (blocking_io == -1)
 897                 blocking_io = 0;
 898
 899         args[ac++] = "--server";
 900
 901         if (daemon_over_rsh) {
 902                 args[ac++] = "--daemon";
 903                 *argc = ac;
 904                 /* if we're passing --daemon, we're done */
 905                 return;
 906         }
 907
 908         if (!am_sender)
 909                 args[ac++] = "--sender";
 910
 911         x = 1;
 912         argstr[0] = '-';
 913         for (i = 0; i < verbose; i++)
 914                 argstr[x++] = 'v';
 915
 916         /* the -q option is intentionally left out */
 917         if (make_backups)
 918                 argstr[x++] = 'b';
 919         if (update_only)
 920                 argstr[x++] = 'u';
 921         if (dry_run)
 922                 argstr[x++] = 'n';
 923         if (preserve_links)
 924                 argstr[x++] = 'l';
 925         if (copy_links)
 926                 argstr[x++] = 'L';
 927         if (keep_dirlinks && am_sender)
 928                 argstr[x++] = 'K';
 929
 930         if (whole_file > 0)
 931                 argstr[x++] = 'W';
 932         /* We don't need to send --no-whole-file, because it's the
 933          * default for remote transfers, and in any case old versions
 934          * of rsync will not understand it. */
 935
 936         if (preserve_hard_links)
 937                 argstr[x++] = 'H';
 938         if (preserve_uid)
 939                 argstr[x++] = 'o';
 940         if (preserve_gid)
 941                 argstr[x++] = 'g';
 942         if (preserve_devices)
 943                 argstr[x++] = 'D';
 944         if (preserve_times)
 945                 argstr[x++] = 't';
 946         if (preserve_perms)
 947                 argstr[x++] = 'p';
 948         if (recurse)
 949                 argstr[x++] = 'r';
 950         if (always_checksum)
 951                 argstr[x++] = 'c';
 952         if (cvs_exclude)
 953                 argstr[x++] = 'C';
 954         if (ignore_times)
 955                 argstr[x++] = 'I';
 956         if (relative_paths)
 957                 argstr[x++] = 'R';
 958         if (one_file_system)
 959                 argstr[x++] = 'x';
 960         if (sparse_files)
 961                 argstr[x++] = 'S';
 962         if (do_compression)
 963                 argstr[x++] = 'z';
 964
 965         /* this is a complete hack - blame Rusty
 966
 967            this is a hack to make the list_only (remote file list)
 968            more useful */
 969         if (list_only && !recurse)
 970                 argstr[x++] = 'r';
 971
 972         argstr[x] = 0;
 973
 974         if (x != 1)
 975                 args[ac++] = argstr;
 976
 977         if (block_size) {
 978                 if (asprintf(&arg, "-B%u", block_size) < 0)
 979                         goto oom;
 980                 args[ac++] = arg;
 981         }
 982
 983         if (max_delete && am_sender) {
 984                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
 985                         goto oom;
 986                 args[ac++] = arg;
 987         }
 988
 989         if (io_timeout) {
 990                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
 991                         goto oom;
 992                 args[ac++] = arg;
 993         }
 994
 995         if (bwlimit) {
 996                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
 997                         goto oom;
 998                 args[ac++] = arg;
 999         }
1000
1001         if (backup_dir) {
1002                 args[ac++] = "--backup-dir";
1003                 args[ac++] = backup_dir;
1004         }
1005
1006         /* Only send --suffix if it specifies a non-default value. */
1007         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1008                 /* We use the following syntax to avoid weirdness with '~'. */
1009                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1010                         goto oom;
1011                 args[ac++] = arg;
1012         }
1013
1014         if (am_sender) {
1015                 if (delete_excluded)
1016                         args[ac++] = "--delete-excluded";
1017                 else if (delete_mode
1018                     && (!delete_after || protocol_version < 27))
1019                         args[ac++] = "--delete";
1020
1021                 if (delete_after)
1022                         args[ac++] = "--delete-after";
1023
1024                 if (force_delete)
1025                         args[ac++] = "--force";
1026         }
1027
1028         if (size_only)
1029                 args[ac++] = "--size-only";
1030
1031         if (modify_window_set) {
1032                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1033                         goto oom;
1034                 args[ac++] = arg;
1035         }
1036
1037         if (checksum_seed) {
1038                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1039                         goto oom;
1040                 args[ac++] = arg;
1041         }
1042
1043         if (partial_dir && am_sender) {
1044                 args[ac++] = "--partial-dir";
1045                 args[ac++] = partial_dir;
1046         } else if (keep_partial)
1047                 args[ac++] = "--partial";
1048
1049         if (ignore_errors)
1050                 args[ac++] = "--ignore-errors";
1051
1052         if (copy_unsafe_links)
1053                 args[ac++] = "--copy-unsafe-links";
1054
1055         if (safe_symlinks)
1056                 args[ac++] = "--safe-links";
1057
1058         if (numeric_ids)
1059                 args[ac++] = "--numeric-ids";
1060
1061         if (only_existing && am_sender)
1062                 args[ac++] = "--existing";
1063
1064         if (opt_ignore_existing && am_sender)
1065                 args[ac++] = "--ignore-existing";
1066
1067         if (inplace)
1068                 args[ac++] = "--inplace";
1069
1070         if (tmpdir) {
1071                 args[ac++] = "--temp-dir";
1072                 args[ac++] = tmpdir;
1073         }
1074
1075         if (compare_dest && am_sender) {
1076                 /* the server only needs this option if it is not the sender,
1077                  *   and it may be an older version that doesn't know this
1078                  *   option, so don't send it if client is the sender.
1079                  */
1080                 args[ac++] = link_dest ? "--link-dest" : "--compare-dest";
1081                 args[ac++] = compare_dest;
1082         }
1083
1084         if (files_from && (!am_sender || remote_filesfrom_file)) {
1085                 if (remote_filesfrom_file) {
1086                         args[ac++] = "--files-from";
1087                         args[ac++] = remote_filesfrom_file;
1088                         if (eol_nulls)
1089                                 args[ac++] = "--from0";
1090                 } else {
1091                         args[ac++] = "--files-from=-";
1092                         args[ac++] = "--from0";
1093                 }
1094         }
1095
1096         *argc = ac;
1097         return;
1098
1099     oom:
1100         out_of_memory("server_options");
1101 }
1102
1103 /**
1104  * Return the position of a ':' IF it is not part of a filename (i.e. as
1105  * long as it doesn't occur after a slash.
1106  */
1107 char *find_colon(char *s)
1108 {
1109         char *p, *p2;
1110
1111         p = strchr(s,':');
1112         if (!p)
1113                 return NULL;
1114
1115         /* now check to see if there is a / in the string before the : - if there is then
1116            discard the colon on the assumption that the : is part of a filename */
1117         p2 = strchr(s,'/');
1118         if (p2 && p2 < p)
1119                 return NULL;
1120
1121         return p;
1122 }