+extern int checksum_len;
+extern char *partial_dir;
+extern char *basis_dir[];
+extern int compare_dest;
+extern int copy_dest;
+extern int link_dest;
+extern int whole_file;
+extern int list_only;
+extern int new_root_dir;
+extern int read_batch;
+extern int safe_symlinks;
+extern long block_size; /* "long" because popt can't set an int32. */
+extern int max_delete;
+extern int force_delete;
+extern int one_file_system;
+extern struct stats stats;
+extern dev_t filesystem_dev;
+extern char *backup_dir;
+extern char *backup_suffix;
+extern int backup_suffix_len;
+extern struct file_list *the_file_list;
+extern struct filter_list_struct server_filter_list;
+
+static int deletion_count = 0; /* used to implement --max-delete */
+
+/* For calling delete_item() */
+#define DEL_RECURSE (1<<1) /* recurse */
+
+enum nonregtype {
+ TYPE_DIR, TYPE_SPECIAL, TYPE_DEVICE, TYPE_SYMLINK
+};
+
+enum delret {
+ DR_SUCCESS = 0, DR_FAILURE, DR_AT_LIMIT, DR_PINNED, DR_NOT_EMPTY
+};
+
+/* Forward declaration for delete_item(). */
+static enum delret delete_dir_contents(char *fname, int flags);
+
+
+static int is_backup_file(char *fn)
+{
+ int k = strlen(fn) - backup_suffix_len;
+ return k > 0 && strcmp(fn+k, backup_suffix) == 0;
+}
+
+/* Delete a file or directory. If DEL_RECURSE is set in the flags, this will
+ * delete recursively.
+ *
+ * Note that fname must point to a MAXPATHLEN buffer if the mode indicates it's
+ * a directory! (The buffer is used for recursion, but returned unchanged.)
+ */
+static enum delret delete_item(char *fname, int mode, char *replace, int flags)
+{
+ enum delret ret;
+ char *what;
+ int ok;
+
+ if (verbose > 2) {
+ rprintf(FINFO, "delete_item(%s) mode=%o flags=%d\n",
+ fname, mode, flags);
+ }
+
+ if (S_ISDIR(mode) && flags & DEL_RECURSE) {
+ ret = delete_dir_contents(fname, flags);
+ if (ret == DR_PINNED || ret == DR_NOT_EMPTY
+ || ret == DR_AT_LIMIT)
+ goto check_ret;
+ /* OK: try to delete the directory. */
+ }
+
+ if (!replace && max_delete >= 0 && ++deletion_count > max_delete)
+ return DR_AT_LIMIT;
+
+ if (S_ISDIR(mode)) {
+ what = "rmdir";
+ ok = do_rmdir(fname) == 0;
+ } else if (make_backups && (backup_dir || !is_backup_file(fname))) {
+ what = "make_backup";
+ ok = make_backup(fname);
+ } else {
+ what = "unlink";
+ ok = robust_unlink(fname) == 0;
+ }
+
+ if (ok) {
+ if (!replace)
+ log_delete(fname, mode);
+ ret = DR_SUCCESS;
+ } else {
+ if (S_ISDIR(mode) && errno == ENOTEMPTY) {
+ rprintf(FINFO, "non-empty directory, %s, not deleted\n",
+ fname);
+ ret = DR_NOT_EMPTY;
+ } else if (errno != ENOENT) {
+ rsyserr(FERROR, errno, "delete_file: %s(%s) failed",
+ what, full_fname(fname));
+ ret = DR_FAILURE;
+ } else {
+ deletion_count--;
+ ret = DR_SUCCESS;
+ }
+ }
+
+ check_ret:
+ if (replace && ret != DR_SUCCESS) {
+ rprintf(FERROR, "could not make way for new %s: %s\n",
+ replace, fname);
+ }
+ return ret;
+}
+
+/* Prep directory is to be deleted, so delete all its contents. Note
+ * that fname must point to a MAXPATHLEN buffer! (The buffer is used
+ * for recursion, but returned unchanged.)
+ */
+static enum delret delete_dir_contents(char *fname, int flags)
+{
+ struct file_list *dirlist;
+ enum delret ret, result;
+ unsigned remainder;
+ void *save_filters;
+ int j, dlen;
+ char *p;
+
+ dlen = strlen(fname);
+ save_filters = push_local_filters(fname, dlen);
+
+ dirlist = get_dirlist(fname, dlen, 0);
+
+ p = fname + dlen;
+ if (dlen != 1 || *fname != '/')
+ *p++ = '/';
+ remainder = MAXPATHLEN - (p - fname);
+
+ ret = DR_SUCCESS;
+
+ for (j = dirlist->count; j--; ) {
+ struct file_struct *fp = dirlist->files[j];
+
+ if (fp->flags & FLAG_MOUNT_POINT) {
+ if (verbose > 1) {
+ rprintf(FINFO,
+ "mount point, %s, pins parent directory\n",
+ f_name(fp, NULL));
+ }
+ ret = DR_PINNED;
+ continue;
+ }
+
+ strlcpy(p, fp->basename, remainder);
+ result = delete_item(fname, fp->mode, NULL, flags);
+ if (result != DR_SUCCESS && ret == DR_SUCCESS)
+ ret = result == DR_PINNED ? result : DR_NOT_EMPTY;
+ }
+
+ fname[dlen] = '\0';
+
+ pop_local_filters(save_filters);
+ flist_free(dirlist);
+
+ return ret;
+}