+static void output_flist(struct file_list *flist)
+{
+ char uidbuf[16], gidbuf[16], depthbuf[16];
+ struct file_struct *file;
+ const char *root, *dir, *slash, *name, *trail;
+ const char *who = who_am_i();
+ int i;
+
+ for (i = 0; i < flist->count; i++) {
+ file = flist->files[i];
+ if ((am_root || am_sender) && preserve_uid) {
+ snprintf(uidbuf, sizeof uidbuf, " uid=%ld",
+ (long)F_UID(file));
+ } else
+ *uidbuf = '\0';
+ if (preserve_gid && F_GID(file) != GID_NONE) {
+ snprintf(gidbuf, sizeof gidbuf, " gid=%ld",
+ (long)F_GID(file));
+ } else
+ *gidbuf = '\0';
+ if (!am_sender)
+ snprintf(depthbuf, sizeof depthbuf, "%d", F_DEPTH(file));
+ if (F_IS_ACTIVE(file)) {
+ root = am_sender ? NS(F_ROOTDIR(file)) : depthbuf;
+ if ((dir = file->dirname) == NULL)
+ dir = slash = "";
+ else
+ slash = "/";
+ name = file->basename;
+ trail = S_ISDIR(file->mode) ? "/" : "";
+ } else
+ root = dir = slash = name = trail = "";
+ rprintf(FINFO, "[%s] i=%d %s %s%s%s%s mode=0%o len=%.0f%s%s flags=%x\n",
+ who, i, root, dir, slash, name, trail, (int)file->mode,
+ (double)F_LENGTH(file), uidbuf, gidbuf, file->flags);
+ }
+}
+
+enum fnc_state { s_DIR, s_SLASH, s_BASE, s_TRAILING };
+enum fnc_type { t_PATH, t_ITEM };
+
+/* Compare the names of two file_struct entities, similar to how strcmp()
+ * would do if it were operating on the joined strings.
+ *
+ * Some differences beginning with protocol_version 29: (1) directory names
+ * are compared with an assumed trailing slash so that they compare in a
+ * way that would cause them to sort immediately prior to any content they
+ * may have; (2) a directory of any name compares after a non-directory of
+ * any name at the same depth; (3) a directory with name "." compares prior
+ * to anything else. These changes mean that a directory and a non-dir
+ * with the same name will not compare as equal (protocol_version >= 29).
+ *
+ * The dirname component can be an empty string, but the basename component
+ * cannot (and never is in the current codebase). The basename component
+ * may be NULL (for a removed item), in which case it is considered to be
+ * after any existing item. */
+int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
+{
+ int dif;
+ const uchar *c1, *c2;
+ enum fnc_state state1, state2;
+ enum fnc_type type1, type2;
+ enum fnc_type t_path = protocol_version >= 29 ? t_PATH : t_ITEM;
+
+ if (!f1 || !F_IS_ACTIVE(f1)) {
+ if (!f2 || !F_IS_ACTIVE(f2))
+ return 0;
+ return -1;
+ }
+ if (!f2 || !F_IS_ACTIVE(f2))
+ return 1;
+
+ c1 = (uchar*)f1->dirname;
+ c2 = (uchar*)f2->dirname;
+ if (c1 == c2)
+ c1 = c2 = NULL;
+ if (!c1) {
+ type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
+ c1 = (const uchar*)f1->basename;
+ if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
+ type1 = t_ITEM;
+ state1 = s_TRAILING;
+ c1 = (uchar*)"";
+ } else
+ state1 = s_BASE;
+ } else {
+ type1 = t_path;
+ state1 = s_DIR;
+ }
+ if (!c2) {
+ type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
+ c2 = (const uchar*)f2->basename;
+ if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
+ type2 = t_ITEM;
+ state2 = s_TRAILING;
+ c2 = (uchar*)"";
+ } else
+ state2 = s_BASE;
+ } else {
+ type2 = t_path;
+ state2 = s_DIR;
+ }
+
+ if (type1 != type2)
+ return type1 == t_PATH ? 1 : -1;
+
+ do {
+ if (!*c1) {
+ switch (state1) {
+ case s_DIR:
+ state1 = s_SLASH;
+ c1 = (uchar*)"/";
+ break;
+ case s_SLASH:
+ type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
+ c1 = (const uchar*)f1->basename;
+ if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
+ type1 = t_ITEM;
+ state1 = s_TRAILING;
+ c1 = (uchar*)"";
+ } else
+ state1 = s_BASE;
+ break;
+ case s_BASE:
+ state1 = s_TRAILING;
+ if (type1 == t_PATH) {
+ c1 = (uchar*)"/";
+ break;
+ }
+ /* FALL THROUGH */
+ case s_TRAILING:
+ type1 = t_ITEM;
+ break;
+ }
+ if (*c2 && type1 != type2)
+ return type1 == t_PATH ? 1 : -1;
+ }
+ if (!*c2) {
+ switch (state2) {
+ case s_DIR:
+ state2 = s_SLASH;
+ c2 = (uchar*)"/";
+ break;
+ case s_SLASH:
+ type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
+ c2 = (const uchar*)f2->basename;
+ if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
+ type2 = t_ITEM;
+ state2 = s_TRAILING;
+ c2 = (uchar*)"";
+ } else
+ state2 = s_BASE;
+ break;
+ case s_BASE:
+ state2 = s_TRAILING;
+ if (type2 == t_PATH) {
+ c2 = (uchar*)"/";
+ break;
+ }
+ /* FALL THROUGH */
+ case s_TRAILING:
+ if (!*c1)
+ return 0;
+ type2 = t_ITEM;
+ break;
+ }
+ if (type1 != type2)
+ return type1 == t_PATH ? 1 : -1;
+ }
+ } while ((dif = (int)*c1++ - (int)*c2++) == 0);
+
+ return dif;
+}
+
+char *f_name_buf(void)
+{
+ static char names[5][MAXPATHLEN];
+ static unsigned int n;
+
+ n = (n + 1) % (sizeof names / sizeof names[0]);
+
+ return names[n];
+}
+
+/* Return a copy of the full filename of a flist entry, using the indicated
+ * buffer or one of 5 static buffers if fbuf is NULL. No size-checking is
+ * done because we checked the size when creating the file_struct entry.
+ */
+char *f_name(struct file_struct *f, char *fbuf)
+{
+ if (!f || !F_IS_ACTIVE(f))
+ return NULL;
+
+ if (!fbuf)
+ fbuf = f_name_buf();
+
+ if (f->dirname) {
+ int len = strlen(f->dirname);
+ memcpy(fbuf, f->dirname, len);
+ fbuf[len] = '/';
+ strlcpy(fbuf + len + 1, f->basename, MAXPATHLEN - (len + 1));
+ } else
+ strlcpy(fbuf, f->basename, MAXPATHLEN);
+
+ return fbuf;
+}
+
+/* Do a non-recursive scan of the named directory, possibly ignoring all
+ * exclude rules except for the daemon's. If "dlen" is >=0, it is the length
+ * of the dirname string, and also indicates that "dirname" is a MAXPATHLEN
+ * buffer (the functions we call will append names onto the end, but the old
+ * dir value will be restored on exit). */
+struct file_list *get_dirlist(char *dirname, int dlen, int ignore_filter_rules)
+{
+ struct file_list *dirlist;
+ char dirbuf[MAXPATHLEN];
+ int save_recurse = recurse;
+ int save_xfer_dirs = xfer_dirs;
+
+ if (dlen < 0) {
+ dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
+ if (dlen >= MAXPATHLEN)
+ return NULL;
+ dirname = dirbuf;
+ }
+
+ dirlist = flist_new("get_dirlist");
+
+ recurse = 0;
+ xfer_dirs = 1;
+ send_directory(ignore_filter_rules ? -2 : -1, dirlist, dirname, dlen);
+ xfer_dirs = save_xfer_dirs;
+ recurse = save_recurse;
+ if (do_progress)
+ flist_count_offset += dirlist->count;
+
+ clean_flist(dirlist, 0, 0);
+
+ if (verbose > 3)
+ output_flist(dirlist);
+
+ return dirlist;
+}