Annotation of embedaddon/rsync/flist.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Generate and receive file lists.
                      3:  *
                      4:  * Copyright (C) 1996 Andrew Tridgell
                      5:  * Copyright (C) 1996 Paul Mackerras
                      6:  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
                      7:  * Copyright (C) 2002-2009 Wayne Davison
                      8:  *
                      9:  * This program is free software; you can redistribute it and/or modify
                     10:  * it under the terms of the GNU General Public License as published by
                     11:  * the Free Software Foundation; either version 3 of the License, or
                     12:  * (at your option) any later version.
                     13:  *
                     14:  * This program is distributed in the hope that it will be useful,
                     15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     17:  * GNU General Public License for more details.
                     18:  *
                     19:  * You should have received a copy of the GNU General Public License along
                     20:  * with this program; if not, visit the http://fsf.org website.
                     21:  */
                     22: 
                     23: #include "rsync.h"
                     24: #include "ifuncs.h"
                     25: #include "rounding.h"
                     26: #include "io.h"
                     27: 
                     28: extern int verbose;
                     29: extern int am_root;
                     30: extern int am_server;
                     31: extern int am_daemon;
                     32: extern int am_sender;
                     33: extern int am_generator;
                     34: extern int inc_recurse;
                     35: extern int do_progress;
                     36: extern int always_checksum;
                     37: extern int module_id;
                     38: extern int ignore_errors;
                     39: extern int numeric_ids;
                     40: extern int recurse;
                     41: extern int use_qsort;
                     42: extern int xfer_dirs;
                     43: extern int filesfrom_fd;
                     44: extern int one_file_system;
                     45: extern int copy_dirlinks;
                     46: extern int preserve_uid;
                     47: extern int preserve_gid;
                     48: extern int preserve_acls;
                     49: extern int preserve_xattrs;
                     50: extern int preserve_links;
                     51: extern int preserve_hard_links;
                     52: extern int preserve_devices;
                     53: extern int preserve_specials;
                     54: extern int delete_during;
                     55: extern int eol_nulls;
                     56: extern int relative_paths;
                     57: extern int implied_dirs;
                     58: extern int ignore_perishable;
                     59: extern int non_perishable_cnt;
                     60: extern int prune_empty_dirs;
                     61: extern int copy_links;
                     62: extern int copy_unsafe_links;
                     63: extern int protocol_version;
                     64: extern int sanitize_paths;
                     65: extern int munge_symlinks;
                     66: extern int use_safe_inc_flist;
                     67: extern int need_unsorted_flist;
                     68: extern int sender_symlink_iconv;
                     69: extern int unsort_ndx;
                     70: extern uid_t our_uid;
                     71: extern struct stats stats;
                     72: extern char *filesfrom_host;
                     73: 
                     74: extern char curr_dir[MAXPATHLEN];
                     75: 
                     76: extern struct chmod_mode_struct *chmod_modes;
                     77: 
                     78: extern struct filter_list_struct filter_list;
                     79: extern struct filter_list_struct daemon_filter_list;
                     80: 
                     81: #ifdef ICONV_OPTION
                     82: extern int filesfrom_convert;
                     83: extern iconv_t ic_send, ic_recv;
                     84: #endif
                     85: 
                     86: #define PTR_SIZE (sizeof (struct file_struct *))
                     87: 
                     88: int io_error;
                     89: int checksum_len;
                     90: dev_t filesystem_dev; /* used to implement -x */
                     91: 
                     92: struct file_list *cur_flist, *first_flist, *dir_flist;
                     93: int send_dir_ndx = -1, send_dir_depth = -1;
                     94: int flist_cnt = 0; /* how many (non-tmp) file list objects exist */
                     95: int file_total = 0; /* total of all active items over all file-lists */
                     96: int flist_eof = 0; /* all the file-lists are now known */
                     97: 
                     98: #define NORMAL_NAME 0
                     99: #define SLASH_ENDING_NAME 1
                    100: #define DOTDIR_NAME 2
                    101: 
                    102: /* Starting from protocol version 26, we always use 64-bit ino_t and dev_t
                    103:  * internally, even if this platform does not allow files to have 64-bit inums.
                    104:  * The only exception is if we're on a platform with no 64-bit type at all.
                    105:  *
                    106:  * Because we use read_longint() to get these off the wire, if you transfer
                    107:  * devices or (for protocols < 30) hardlinks with dev or inum > 2**32 to a
                    108:  * machine with no 64-bit types then you will get an overflow error.
                    109:  *
                    110:  * Note that if you transfer devices from a 64-bit-devt machine (say, Solaris)
                    111:  * to a 32-bit-devt machine (say, Linux-2.2/x86) then the device numbers will
                    112:  * be truncated.  But it's a kind of silly thing to do anyhow. */
                    113: 
                    114: /* The tmp_* vars are used as a cache area by make_file() to store data
                    115:  * that the sender doesn't need to remember in its file list.  The data
                    116:  * will survive just long enough to be used by send_file_entry(). */
                    117: static dev_t tmp_rdev;
                    118: #ifdef SUPPORT_HARD_LINKS
                    119: static int64 tmp_dev = -1, tmp_ino;
                    120: #endif
                    121: static char tmp_sum[MAX_DIGEST_LEN];
                    122: 
                    123: static char empty_sum[MAX_DIGEST_LEN];
                    124: static int flist_count_offset; /* for --delete --progress */
                    125: static int dir_count = 0;
                    126: 
                    127: static void flist_sort_and_clean(struct file_list *flist, int strip_root);
                    128: static void output_flist(struct file_list *flist);
                    129: 
                    130: void init_flist(void)
                    131: {
                    132:        if (verbose > 4) {
                    133:                rprintf(FINFO, "FILE_STRUCT_LEN=%d, EXTRA_LEN=%d\n",
                    134:                        (int)FILE_STRUCT_LEN, (int)EXTRA_LEN);
                    135:        }
                    136:        checksum_len = protocol_version < 21 ? 2
                    137:                     : protocol_version < 30 ? MD4_DIGEST_LEN
                    138:                     : MD5_DIGEST_LEN;
                    139: }
                    140: 
                    141: static int show_filelist_p(void)
                    142: {
                    143:        return verbose && xfer_dirs && !am_server && !inc_recurse;
                    144: }
                    145: 
                    146: static void start_filelist_progress(char *kind)
                    147: {
                    148:        rprintf(FCLIENT, "%s ... ", kind);
                    149:        if (verbose > 1 || do_progress)
                    150:                rprintf(FCLIENT, "\n");
                    151:        rflush(FINFO);
                    152: }
                    153: 
                    154: static void emit_filelist_progress(int count)
                    155: {
                    156:        rprintf(FCLIENT, " %d files...\r", count);
                    157: }
                    158: 
                    159: static void maybe_emit_filelist_progress(int count)
                    160: {
                    161:        if (do_progress && show_filelist_p() && (count % 100) == 0)
                    162:                emit_filelist_progress(count);
                    163: }
                    164: 
                    165: static void finish_filelist_progress(const struct file_list *flist)
                    166: {
                    167:        if (do_progress) {
                    168:                /* This overwrites the progress line */
                    169:                rprintf(FINFO, "%d file%sto consider\n",
                    170:                        flist->used, flist->used == 1 ? " " : "s ");
                    171:        } else
                    172:                rprintf(FINFO, "done\n");
                    173: }
                    174: 
                    175: void show_flist_stats(void)
                    176: {
                    177:        /* Nothing yet */
                    178: }
                    179: 
                    180: /* Stat either a symlink or its referent, depending on the settings of
                    181:  * copy_links, copy_unsafe_links, etc.  Returns -1 on error, 0 on success.
                    182:  *
                    183:  * If path is the name of a symlink, then the linkbuf buffer (which must hold
                    184:  * MAXPATHLEN chars) will be set to the symlink's target string.
                    185:  *
                    186:  * The stat structure pointed to by stp will contain information about the
                    187:  * link or the referent as appropriate, if they exist. */
                    188: static int readlink_stat(const char *path, STRUCT_STAT *stp, char *linkbuf)
                    189: {
                    190: #ifdef SUPPORT_LINKS
                    191:        if (link_stat(path, stp, copy_dirlinks) < 0)
                    192:                return -1;
                    193:        if (S_ISLNK(stp->st_mode)) {
                    194:                int llen = readlink(path, linkbuf, MAXPATHLEN - 1);
                    195:                if (llen < 0)
                    196:                        return -1;
                    197:                linkbuf[llen] = '\0';
                    198:                if (copy_unsafe_links && unsafe_symlink(linkbuf, path)) {
                    199:                        if (verbose > 1) {
                    200:                                rprintf(FINFO,"copying unsafe symlink \"%s\" -> \"%s\"\n",
                    201:                                        path, linkbuf);
                    202:                        }
                    203:                        return x_stat(path, stp, NULL);
                    204:                }
                    205:                if (munge_symlinks && am_sender && llen > SYMLINK_PREFIX_LEN
                    206:                 && strncmp(linkbuf, SYMLINK_PREFIX, SYMLINK_PREFIX_LEN) == 0) {
                    207:                        memmove(linkbuf, linkbuf + SYMLINK_PREFIX_LEN,
                    208:                                llen - SYMLINK_PREFIX_LEN + 1);
                    209:                }
                    210:        }
                    211:        return 0;
                    212: #else
                    213:        return x_stat(path, stp, NULL);
                    214: #endif
                    215: }
                    216: 
                    217: int link_stat(const char *path, STRUCT_STAT *stp, int follow_dirlinks)
                    218: {
                    219: #ifdef SUPPORT_LINKS
                    220:        if (copy_links)
                    221:                return x_stat(path, stp, NULL);
                    222:        if (x_lstat(path, stp, NULL) < 0)
                    223:                return -1;
                    224:        if (follow_dirlinks && S_ISLNK(stp->st_mode)) {
                    225:                STRUCT_STAT st;
                    226:                if (x_stat(path, &st, NULL) == 0 && S_ISDIR(st.st_mode))
                    227:                        *stp = st;
                    228:        }
                    229:        return 0;
                    230: #else
                    231:        return x_stat(path, stp, NULL);
                    232: #endif
                    233: }
                    234: 
                    235: static inline int is_daemon_excluded(const char *fname, int is_dir)
                    236: {
                    237:        if (daemon_filter_list.head
                    238:         && check_filter(&daemon_filter_list, FLOG, fname, is_dir) < 0) {
                    239:                errno = ENOENT;
                    240:                return 1;
                    241:        }
                    242:        return 0;
                    243: }
                    244: 
                    245: static inline int path_is_daemon_excluded(char *path, int ignore_filename)
                    246: {
                    247:        if (daemon_filter_list.head) {
                    248:                char *slash = path;
                    249: 
                    250:                while ((slash = strchr(slash+1, '/')) != NULL) {
                    251:                        int ret;
                    252:                        *slash = '\0';
                    253:                        ret = check_filter(&daemon_filter_list, FLOG, path, 1);
                    254:                        *slash = '/';
                    255:                        if (ret < 0) {
                    256:                                errno = ENOENT;
                    257:                                return 1;
                    258:                        }
                    259:                }
                    260: 
                    261:                if (!ignore_filename
                    262:                 && check_filter(&daemon_filter_list, FLOG, path, 1) < 0) {
                    263:                        errno = ENOENT;
                    264:                        return 1;
                    265:                }
                    266:        }
                    267: 
                    268:        return 0;
                    269: }
                    270: 
                    271: /* This function is used to check if a file should be included/excluded
                    272:  * from the list of files based on its name and type etc.  The value of
                    273:  * filter_level is set to either SERVER_FILTERS or ALL_FILTERS. */
                    274: static int is_excluded(const char *fname, int is_dir, int filter_level)
                    275: {
                    276: #if 0 /* This currently never happens, so avoid a useless compare. */
                    277:        if (filter_level == NO_FILTERS)
                    278:                return 0;
                    279: #endif
                    280:        if (is_daemon_excluded(fname, is_dir))
                    281:                return 1;
                    282:        if (filter_level != ALL_FILTERS)
                    283:                return 0;
                    284:        if (filter_list.head
                    285:            && check_filter(&filter_list, FINFO, fname, is_dir) < 0)
                    286:                return 1;
                    287:        return 0;
                    288: }
                    289: 
                    290: static void send_directory(int f, struct file_list *flist,
                    291:                           char *fbuf, int len, int flags);
                    292: 
                    293: static const char *pathname, *orig_dir;
                    294: static int pathname_len;
                    295: 
                    296: /* Make sure flist can hold at least flist->used + extra entries. */
                    297: static void flist_expand(struct file_list *flist, int extra)
                    298: {
                    299:        struct file_struct **new_ptr;
                    300: 
                    301:        if (flist->used + extra <= flist->malloced)
                    302:                return;
                    303: 
                    304:        if (flist->malloced < FLIST_START)
                    305:                flist->malloced = FLIST_START;
                    306:        else if (flist->malloced >= FLIST_LINEAR)
                    307:                flist->malloced += FLIST_LINEAR;
                    308:        else
                    309:                flist->malloced *= 2;
                    310: 
                    311:        /* In case count jumped or we are starting the list
                    312:         * with a known size just set it. */
                    313:        if (flist->malloced < flist->used + extra)
                    314:                flist->malloced = flist->used + extra;
                    315: 
                    316:        new_ptr = realloc_array(flist->files, struct file_struct *,
                    317:                                flist->malloced);
                    318: 
                    319:        if (verbose >= 2 && flist->malloced != FLIST_START) {
                    320:                rprintf(FCLIENT, "[%s] expand file_list pointer array to %.0f bytes, did%s move\n",
                    321:                    who_am_i(),
                    322:                    (double)sizeof flist->files[0] * flist->malloced,
                    323:                    (new_ptr == flist->files) ? " not" : "");
                    324:        }
                    325: 
                    326:        flist->files = new_ptr;
                    327: 
                    328:        if (!flist->files)
                    329:                out_of_memory("flist_expand");
                    330: }
                    331: 
                    332: static void flist_done_allocating(struct file_list *flist)
                    333: {
                    334:        void *ptr = pool_boundary(flist->file_pool, 8*1024);
                    335:        if (flist->pool_boundary == ptr)
                    336:                flist->pool_boundary = NULL; /* list didn't use any pool memory */
                    337:        else
                    338:                flist->pool_boundary = ptr;
                    339: }
                    340: 
                    341: /* Call this with EITHER (1) "file, NULL, 0" to chdir() to the file's
                    342:  * F_PATHNAME(), or (2) "NULL, dir, dirlen" to chdir() to the supplied dir,
                    343:  * with dir == NULL taken to be the starting directory, and dirlen < 0
                    344:  * indicating that strdup(dir) should be called and then the -dirlen length
                    345:  * value checked to ensure that it is not daemon-excluded. */
                    346: int change_pathname(struct file_struct *file, const char *dir, int dirlen)
                    347: {
                    348:        if (dirlen < 0) {
                    349:                char *cpy = strdup(dir);
                    350:                if (*cpy != '/')
                    351:                        change_dir(orig_dir, CD_SKIP_CHDIR);
                    352:                if (path_is_daemon_excluded(cpy, 0))
                    353:                        goto chdir_error;
                    354:                dir = cpy;
                    355:                dirlen = -dirlen;
                    356:        } else {
                    357:                if (file) {
                    358:                        if (pathname == F_PATHNAME(file))
                    359:                                return 1;
                    360:                        dir = F_PATHNAME(file);
                    361:                        if (dir)
                    362:                                dirlen = strlen(dir);
                    363:                } else if (pathname == dir)
                    364:                        return 1;
                    365:                if (dir && *dir != '/')
                    366:                        change_dir(orig_dir, CD_SKIP_CHDIR);
                    367:        }
                    368: 
                    369:        pathname = dir;
                    370:        pathname_len = dirlen;
                    371: 
                    372:        if (!dir)
                    373:                dir = orig_dir;
                    374: 
                    375:        if (!change_dir(dir, CD_NORMAL)) {
                    376:          chdir_error:
                    377:                io_error |= IOERR_GENERAL;
                    378:                rsyserr(FERROR_XFER, errno, "change_dir %s failed", full_fname(dir));
                    379:                if (dir != orig_dir)
                    380:                        change_dir(orig_dir, CD_NORMAL);
                    381:                pathname = NULL;
                    382:                pathname_len = 0;
                    383:                return 0;
                    384:        }
                    385: 
                    386:        return 1;
                    387: }
                    388: 
                    389: static void send_file_entry(int f, const char *fname, struct file_struct *file,
                    390: #ifdef SUPPORT_LINKS
                    391:                            const char *symlink_name, int symlink_len,
                    392: #endif
                    393:                            int ndx, int first_ndx)
                    394: {
                    395:        static time_t modtime;
                    396:        static mode_t mode;
                    397: #ifdef SUPPORT_HARD_LINKS
                    398:        static int64 dev;
                    399: #endif
                    400:        static dev_t rdev;
                    401:        static uint32 rdev_major;
                    402:        static uid_t uid;
                    403:        static gid_t gid;
                    404:        static const char *user_name, *group_name;
                    405:        static char lastname[MAXPATHLEN];
                    406:        int first_hlink_ndx = -1;
                    407:        int l1, l2;
                    408:        int xflags;
                    409: 
                    410:        /* Initialize starting value of xflags. */
                    411:        if (protocol_version >= 30 && S_ISDIR(file->mode)) {
                    412:                dir_count++;
                    413:                if (file->flags & FLAG_CONTENT_DIR)
                    414:                        xflags = file->flags & FLAG_TOP_DIR;
                    415:                else if (file->flags & FLAG_IMPLIED_DIR)
                    416:                        xflags = XMIT_TOP_DIR | XMIT_NO_CONTENT_DIR;
                    417:                else
                    418:                        xflags = XMIT_NO_CONTENT_DIR;
                    419:        } else
                    420:                xflags = file->flags & FLAG_TOP_DIR; /* FLAG_TOP_DIR == XMIT_TOP_DIR */
                    421: 
                    422:        if (file->mode == mode)
                    423:                xflags |= XMIT_SAME_MODE;
                    424:        else
                    425:                mode = file->mode;
                    426: 
                    427:        if (preserve_devices && IS_DEVICE(mode)) {
                    428:                if (protocol_version < 28) {
                    429:                        if (tmp_rdev == rdev)
                    430:                                xflags |= XMIT_SAME_RDEV_pre28;
                    431:                        else
                    432:                                rdev = tmp_rdev;
                    433:                } else {
                    434:                        rdev = tmp_rdev;
                    435:                        if ((uint32)major(rdev) == rdev_major)
                    436:                                xflags |= XMIT_SAME_RDEV_MAJOR;
                    437:                        else
                    438:                                rdev_major = major(rdev);
                    439:                        if (protocol_version < 30 && (uint32)minor(rdev) <= 0xFFu)
                    440:                                xflags |= XMIT_RDEV_MINOR_8_pre30;
                    441:                }
                    442:        } else if (preserve_specials && IS_SPECIAL(mode)) {
                    443:                /* Special files don't need an rdev number, so just make
                    444:                 * the historical transmission of the value efficient. */
                    445:                if (protocol_version < 28)
                    446:                        xflags |= XMIT_SAME_RDEV_pre28;
                    447:                else {
                    448:                        rdev = MAKEDEV(major(rdev), 0);
                    449:                        xflags |= XMIT_SAME_RDEV_MAJOR;
                    450:                        if (protocol_version < 30)
                    451:                                xflags |= XMIT_RDEV_MINOR_8_pre30;
                    452:                }
                    453:        } else if (protocol_version < 28)
                    454:                rdev = MAKEDEV(0, 0);
                    455:        if (!preserve_uid || ((uid_t)F_OWNER(file) == uid && *lastname))
                    456:                xflags |= XMIT_SAME_UID;
                    457:        else {
                    458:                uid = F_OWNER(file);
                    459:                if (!numeric_ids) {
                    460:                        user_name = add_uid(uid);
                    461:                        if (inc_recurse && user_name)
                    462:                                xflags |= XMIT_USER_NAME_FOLLOWS;
                    463:                }
                    464:        }
                    465:        if (!preserve_gid || ((gid_t)F_GROUP(file) == gid && *lastname))
                    466:                xflags |= XMIT_SAME_GID;
                    467:        else {
                    468:                gid = F_GROUP(file);
                    469:                if (!numeric_ids) {
                    470:                        group_name = add_gid(gid);
                    471:                        if (inc_recurse && group_name)
                    472:                                xflags |= XMIT_GROUP_NAME_FOLLOWS;
                    473:                }
                    474:        }
                    475:        if (file->modtime == modtime)
                    476:                xflags |= XMIT_SAME_TIME;
                    477:        else
                    478:                modtime = file->modtime;
                    479: 
                    480: #ifdef SUPPORT_HARD_LINKS
                    481:        if (tmp_dev != -1) {
                    482:                if (protocol_version >= 30) {
                    483:                        struct ht_int64_node *np = idev_find(tmp_dev, tmp_ino);
                    484:                        first_hlink_ndx = (int32)(long)np->data - 1;
                    485:                        if (first_hlink_ndx < 0) {
                    486:                                np->data = (void*)(long)(first_ndx + ndx + 1);
                    487:                                xflags |= XMIT_HLINK_FIRST;
                    488:                        }
                    489:                } else {
                    490:                        if (tmp_dev == dev) {
                    491:                                if (protocol_version >= 28)
                    492:                                        xflags |= XMIT_SAME_DEV_pre30;
                    493:                        } else
                    494:                                dev = tmp_dev;
                    495:                }
                    496:                xflags |= XMIT_HLINKED;
                    497:        }
                    498: #endif
                    499: 
                    500:        for (l1 = 0;
                    501:            lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
                    502:            l1++) {}
                    503:        l2 = strlen(fname+l1);
                    504: 
                    505:        if (l1 > 0)
                    506:                xflags |= XMIT_SAME_NAME;
                    507:        if (l2 > 255)
                    508:                xflags |= XMIT_LONG_NAME;
                    509: 
                    510:        /* We must make sure we don't send a zero flag byte or the
                    511:         * other end will terminate the flist transfer.  Note that
                    512:         * the use of XMIT_TOP_DIR on a non-dir has no meaning, so
                    513:         * it's harmless way to add a bit to the first flag byte. */
                    514:        if (protocol_version >= 28) {
                    515:                if (!xflags && !S_ISDIR(mode))
                    516:                        xflags |= XMIT_TOP_DIR;
                    517:                if ((xflags & 0xFF00) || !xflags) {
                    518:                        xflags |= XMIT_EXTENDED_FLAGS;
                    519:                        write_shortint(f, xflags);
                    520:                } else
                    521:                        write_byte(f, xflags);
                    522:        } else {
                    523:                if (!(xflags & 0xFF))
                    524:                        xflags |= S_ISDIR(mode) ? XMIT_LONG_NAME : XMIT_TOP_DIR;
                    525:                write_byte(f, xflags);
                    526:        }
                    527:        if (xflags & XMIT_SAME_NAME)
                    528:                write_byte(f, l1);
                    529:        if (xflags & XMIT_LONG_NAME)
                    530:                write_varint30(f, l2);
                    531:        else
                    532:                write_byte(f, l2);
                    533:        write_buf(f, fname + l1, l2);
                    534: 
                    535:        if (first_hlink_ndx >= 0) {
                    536:                write_varint(f, first_hlink_ndx);
                    537:                if (first_hlink_ndx >= first_ndx)
                    538:                        goto the_end;
                    539:        }
                    540: 
                    541:        write_varlong30(f, F_LENGTH(file), 3);
                    542:        if (!(xflags & XMIT_SAME_TIME)) {
                    543:                if (protocol_version >= 30)
                    544:                        write_varlong(f, modtime, 4);
                    545:                else
                    546:                        write_int(f, modtime);
                    547:        }
                    548:        if (!(xflags & XMIT_SAME_MODE))
                    549:                write_int(f, to_wire_mode(mode));
                    550:        if (preserve_uid && !(xflags & XMIT_SAME_UID)) {
                    551:                if (protocol_version < 30)
                    552:                        write_int(f, uid);
                    553:                else {
                    554:                        write_varint(f, uid);
                    555:                        if (xflags & XMIT_USER_NAME_FOLLOWS) {
                    556:                                int len = strlen(user_name);
                    557:                                write_byte(f, len);
                    558:                                write_buf(f, user_name, len);
                    559:                        }
                    560:                }
                    561:        }
                    562:        if (preserve_gid && !(xflags & XMIT_SAME_GID)) {
                    563:                if (protocol_version < 30)
                    564:                        write_int(f, gid);
                    565:                else {
                    566:                        write_varint(f, gid);
                    567:                        if (xflags & XMIT_GROUP_NAME_FOLLOWS) {
                    568:                                int len = strlen(group_name);
                    569:                                write_byte(f, len);
                    570:                                write_buf(f, group_name, len);
                    571:                        }
                    572:                }
                    573:        }
                    574:        if ((preserve_devices && IS_DEVICE(mode))
                    575:         || (preserve_specials && IS_SPECIAL(mode))) {
                    576:                if (protocol_version < 28) {
                    577:                        if (!(xflags & XMIT_SAME_RDEV_pre28))
                    578:                                write_int(f, (int)rdev);
                    579:                } else {
                    580:                        if (!(xflags & XMIT_SAME_RDEV_MAJOR))
                    581:                                write_varint30(f, major(rdev));
                    582:                        if (protocol_version >= 30)
                    583:                                write_varint(f, minor(rdev));
                    584:                        else if (xflags & XMIT_RDEV_MINOR_8_pre30)
                    585:                                write_byte(f, minor(rdev));
                    586:                        else
                    587:                                write_int(f, minor(rdev));
                    588:                }
                    589:        }
                    590: 
                    591: #ifdef SUPPORT_LINKS
                    592:        if (symlink_len) {
                    593:                write_varint30(f, symlink_len);
                    594:                write_buf(f, symlink_name, symlink_len);
                    595:        }
                    596: #endif
                    597: 
                    598: #ifdef SUPPORT_HARD_LINKS
                    599:        if (tmp_dev != -1 && protocol_version < 30) {
                    600:                /* Older protocols expect the dev number to be transmitted
                    601:                 * 1-incremented so that it is never zero. */
                    602:                if (protocol_version < 26) {
                    603:                        /* 32-bit dev_t and ino_t */
                    604:                        write_int(f, (int32)(dev+1));
                    605:                        write_int(f, (int32)tmp_ino);
                    606:                } else {
                    607:                        /* 64-bit dev_t and ino_t */
                    608:                        if (!(xflags & XMIT_SAME_DEV_pre30))
                    609:                                write_longint(f, dev+1);
                    610:                        write_longint(f, tmp_ino);
                    611:                }
                    612:        }
                    613: #endif
                    614: 
                    615:        if (always_checksum && (S_ISREG(mode) || protocol_version < 28)) {
                    616:                const char *sum;
                    617:                if (S_ISREG(mode))
                    618:                        sum = tmp_sum;
                    619:                else {
                    620:                        /* Prior to 28, we sent a useless set of nulls. */
                    621:                        sum = empty_sum;
                    622:                }
                    623:                write_buf(f, sum, checksum_len);
                    624:        }
                    625: 
                    626:   the_end:
                    627:        strlcpy(lastname, fname, MAXPATHLEN);
                    628: 
                    629:        if (S_ISREG(mode) || S_ISLNK(mode))
                    630:                stats.total_size += F_LENGTH(file);
                    631: }
                    632: 
                    633: static struct file_struct *recv_file_entry(int f, struct file_list *flist, int xflags)
                    634: {
                    635:        static int64 modtime;
                    636:        static mode_t mode;
                    637: #ifdef SUPPORT_HARD_LINKS
                    638:        static int64 dev;
                    639: #endif
                    640:        static dev_t rdev;
                    641:        static uint32 rdev_major;
                    642:        static uid_t uid;
                    643:        static gid_t gid;
                    644:        static uint16 gid_flags;
                    645:        static char lastname[MAXPATHLEN], *lastdir;
                    646:        static int lastdir_depth, lastdir_len = -1;
                    647:        static unsigned int del_hier_name_len = 0;
                    648:        static int in_del_hier = 0;
                    649:        char thisname[MAXPATHLEN];
                    650:        unsigned int l1 = 0, l2 = 0;
                    651:        int alloc_len, basename_len, linkname_len;
                    652:        int extra_len = file_extra_cnt * EXTRA_LEN;
                    653:        int first_hlink_ndx = -1;
                    654:        int64 file_length;
                    655:        const char *basename;
                    656:        struct file_struct *file;
                    657:        alloc_pool_t *pool;
                    658:        char *bp;
                    659: 
                    660:        if (xflags & XMIT_SAME_NAME)
                    661:                l1 = read_byte(f);
                    662: 
                    663:        if (xflags & XMIT_LONG_NAME)
                    664:                l2 = read_varint30(f);
                    665:        else
                    666:                l2 = read_byte(f);
                    667: 
                    668:        if (l2 >= MAXPATHLEN - l1) {
                    669:                rprintf(FERROR,
                    670:                        "overflow: xflags=0x%x l1=%d l2=%d lastname=%s [%s]\n",
                    671:                        xflags, l1, l2, lastname, who_am_i());
                    672:                overflow_exit("recv_file_entry");
                    673:        }
                    674: 
                    675:        strlcpy(thisname, lastname, l1 + 1);
                    676:        read_sbuf(f, &thisname[l1], l2);
                    677:        thisname[l1 + l2] = 0;
                    678: 
                    679:        /* Abuse basename_len for a moment... */
                    680:        basename_len = strlcpy(lastname, thisname, MAXPATHLEN);
                    681: 
                    682: #ifdef ICONV_OPTION
                    683:        if (ic_recv != (iconv_t)-1) {
                    684:                xbuf outbuf, inbuf;
                    685: 
                    686:                INIT_CONST_XBUF(outbuf, thisname);
                    687:                INIT_XBUF(inbuf, lastname, basename_len, -1);
                    688: 
                    689:                if (iconvbufs(ic_recv, &inbuf, &outbuf, 0) < 0) {
                    690:                        io_error |= IOERR_GENERAL;
                    691:                        rprintf(FERROR_UTF8,
                    692:                            "[%s] cannot convert filename: %s (%s)\n",
                    693:                            who_am_i(), lastname, strerror(errno));
                    694:                        outbuf.len = 0;
                    695:                }
                    696:                thisname[outbuf.len] = '\0';
                    697:        }
                    698: #endif
                    699: 
                    700:        if (*thisname)
                    701:                clean_fname(thisname, 0);
                    702: 
                    703:        if (sanitize_paths)
                    704:                sanitize_path(thisname, thisname, "", 0, SP_DEFAULT);
                    705: 
                    706:        if ((basename = strrchr(thisname, '/')) != NULL) {
                    707:                int len = basename++ - thisname;
                    708:                if (len != lastdir_len || memcmp(thisname, lastdir, len) != 0) {
                    709:                        lastdir = new_array(char, len + 1);
                    710:                        memcpy(lastdir, thisname, len);
                    711:                        lastdir[len] = '\0';
                    712:                        lastdir_len = len;
                    713:                        lastdir_depth = count_dir_elements(lastdir);
                    714:                }
                    715:        } else
                    716:                basename = thisname;
                    717:        basename_len = strlen(basename) + 1; /* count the '\0' */
                    718: 
                    719: #ifdef SUPPORT_HARD_LINKS
                    720:        if (protocol_version >= 30
                    721:         && BITS_SETnUNSET(xflags, XMIT_HLINKED, XMIT_HLINK_FIRST)) {
                    722:                first_hlink_ndx = read_varint(f);
                    723:                if (first_hlink_ndx < 0 || first_hlink_ndx >= flist->ndx_start + flist->used) {
                    724:                        rprintf(FERROR,
                    725:                                "hard-link reference out of range: %d (%d)\n",
                    726:                                first_hlink_ndx, flist->ndx_start + flist->used);
                    727:                        exit_cleanup(RERR_PROTOCOL);
                    728:                }
                    729:                if (first_hlink_ndx >= flist->ndx_start) {
                    730:                        struct file_struct *first = flist->files[first_hlink_ndx - flist->ndx_start];
                    731:                        file_length = F_LENGTH(first);
                    732:                        modtime = first->modtime;
                    733:                        mode = first->mode;
                    734:                        if (preserve_uid)
                    735:                                uid = F_OWNER(first);
                    736:                        if (preserve_gid)
                    737:                                gid = F_GROUP(first);
                    738:                        if (preserve_devices && IS_DEVICE(mode)) {
                    739:                                uint32 *devp = F_RDEV_P(first);
                    740:                                rdev = MAKEDEV(DEV_MAJOR(devp), DEV_MINOR(devp));
                    741:                                extra_len += DEV_EXTRA_CNT * EXTRA_LEN;
                    742:                        }
                    743:                        if (preserve_links && S_ISLNK(mode))
                    744:                                linkname_len = strlen(F_SYMLINK(first)) + 1;
                    745:                        else
                    746:                                linkname_len = 0;
                    747:                        goto create_object;
                    748:                }
                    749:        }
                    750: #endif
                    751: 
                    752:        file_length = read_varlong30(f, 3);
                    753:        if (!(xflags & XMIT_SAME_TIME)) {
                    754:                if (protocol_version >= 30) {
                    755:                        modtime = read_varlong(f, 4);
                    756: #if SIZEOF_TIME_T < SIZEOF_INT64
                    757:                        if (!am_generator && (int64)(time_t)modtime != modtime) {
                    758:                                rprintf(FERROR_XFER,
                    759:                                    "Time value of %s truncated on receiver.\n",
                    760:                                    lastname);
                    761:                        }
                    762: #endif
                    763:                } else
                    764:                        modtime = read_int(f);
                    765:        }
                    766:        if (!(xflags & XMIT_SAME_MODE))
                    767:                mode = from_wire_mode(read_int(f));
                    768: 
                    769:        if (chmod_modes && !S_ISLNK(mode))
                    770:                mode = tweak_mode(mode, chmod_modes);
                    771: 
                    772:        if (preserve_uid && !(xflags & XMIT_SAME_UID)) {
                    773:                if (protocol_version < 30)
                    774:                        uid = (uid_t)read_int(f);
                    775:                else {
                    776:                        uid = (uid_t)read_varint(f);
                    777:                        if (xflags & XMIT_USER_NAME_FOLLOWS)
                    778:                                uid = recv_user_name(f, uid);
                    779:                        else if (inc_recurse && am_root && !numeric_ids)
                    780:                                uid = match_uid(uid);
                    781:                }
                    782:        }
                    783:        if (preserve_gid && !(xflags & XMIT_SAME_GID)) {
                    784:                if (protocol_version < 30)
                    785:                        gid = (gid_t)read_int(f);
                    786:                else {
                    787:                        gid = (gid_t)read_varint(f);
                    788:                        gid_flags = 0;
                    789:                        if (xflags & XMIT_GROUP_NAME_FOLLOWS)
                    790:                                gid = recv_group_name(f, gid, &gid_flags);
                    791:                        else if (inc_recurse && (!am_root || !numeric_ids))
                    792:                                gid = match_gid(gid, &gid_flags);
                    793:                }
                    794:        }
                    795: 
                    796:        if ((preserve_devices && IS_DEVICE(mode))
                    797:         || (preserve_specials && IS_SPECIAL(mode))) {
                    798:                if (protocol_version < 28) {
                    799:                        if (!(xflags & XMIT_SAME_RDEV_pre28))
                    800:                                rdev = (dev_t)read_int(f);
                    801:                } else {
                    802:                        uint32 rdev_minor;
                    803:                        if (!(xflags & XMIT_SAME_RDEV_MAJOR))
                    804:                                rdev_major = read_varint30(f);
                    805:                        if (protocol_version >= 30)
                    806:                                rdev_minor = read_varint(f);
                    807:                        else if (xflags & XMIT_RDEV_MINOR_8_pre30)
                    808:                                rdev_minor = read_byte(f);
                    809:                        else
                    810:                                rdev_minor = read_int(f);
                    811:                        rdev = MAKEDEV(rdev_major, rdev_minor);
                    812:                }
                    813:                if (IS_DEVICE(mode))
                    814:                        extra_len += DEV_EXTRA_CNT * EXTRA_LEN;
                    815:                file_length = 0;
                    816:        } else if (protocol_version < 28)
                    817:                rdev = MAKEDEV(0, 0);
                    818: 
                    819: #ifdef SUPPORT_LINKS
                    820:        if (preserve_links && S_ISLNK(mode)) {
                    821:                linkname_len = read_varint30(f) + 1; /* count the '\0' */
                    822:                if (linkname_len <= 0 || linkname_len > MAXPATHLEN) {
                    823:                        rprintf(FERROR, "overflow: linkname_len=%d\n",
                    824:                                linkname_len - 1);
                    825:                        overflow_exit("recv_file_entry");
                    826:                }
                    827: #ifdef ICONV_OPTION
                    828:                /* We don't know how much extra room we need to convert
                    829:                 * the as-yet-unread symlink data, so let's hope that a
                    830:                 * double-size buffer is plenty. */
                    831:                if (sender_symlink_iconv)
                    832:                        linkname_len *= 2;
                    833: #endif
                    834:                if (munge_symlinks)
                    835:                        linkname_len += SYMLINK_PREFIX_LEN;
                    836:        }
                    837:        else
                    838: #endif
                    839:                linkname_len = 0;
                    840: 
                    841: #ifdef SUPPORT_HARD_LINKS
                    842:   create_object:
                    843:        if (preserve_hard_links) {
                    844:                if (protocol_version < 28 && S_ISREG(mode))
                    845:                        xflags |= XMIT_HLINKED;
                    846:                if (xflags & XMIT_HLINKED)
                    847:                        extra_len += (inc_recurse+1) * EXTRA_LEN;
                    848:        }
                    849: #endif
                    850: 
                    851: #ifdef SUPPORT_ACLS
                    852:        /* Directories need an extra int32 for the default ACL. */
                    853:        if (preserve_acls && S_ISDIR(mode))
                    854:                extra_len += EXTRA_LEN;
                    855: #endif
                    856: 
                    857:        if (always_checksum && S_ISREG(mode))
                    858:                extra_len += SUM_EXTRA_CNT * EXTRA_LEN;
                    859: 
                    860: #if SIZEOF_INT64 >= 8
                    861:        if (file_length > 0xFFFFFFFFu && S_ISREG(mode))
                    862:                extra_len += EXTRA_LEN;
                    863: #endif
                    864:        if (file_length < 0) {
                    865:                rprintf(FERROR, "Offset underflow: file-length is negative\n");
                    866:                exit_cleanup(RERR_UNSUPPORTED);
                    867:        }
                    868: 
                    869:        if (inc_recurse && S_ISDIR(mode)) {
                    870:                if (one_file_system) {
                    871:                        /* Room to save the dir's device for -x */
                    872:                        extra_len += DEV_EXTRA_CNT * EXTRA_LEN;
                    873:                }
                    874:                pool = dir_flist->file_pool;
                    875:        } else
                    876:                pool = flist->file_pool;
                    877: 
                    878: #if EXTRA_ROUNDING > 0
                    879:        if (extra_len & (EXTRA_ROUNDING * EXTRA_LEN))
                    880:                extra_len = (extra_len | (EXTRA_ROUNDING * EXTRA_LEN)) + EXTRA_LEN;
                    881: #endif
                    882: 
                    883:        alloc_len = FILE_STRUCT_LEN + extra_len + basename_len
                    884:                  + linkname_len;
                    885:        bp = pool_alloc(pool, alloc_len, "recv_file_entry");
                    886: 
                    887:        memset(bp, 0, extra_len + FILE_STRUCT_LEN);
                    888:        bp += extra_len;
                    889:        file = (struct file_struct *)bp;
                    890:        bp += FILE_STRUCT_LEN;
                    891: 
                    892:        memcpy(bp, basename, basename_len);
                    893: 
                    894: #ifdef SUPPORT_HARD_LINKS
                    895:        if (xflags & XMIT_HLINKED)
                    896:                file->flags |= FLAG_HLINKED;
                    897: #endif
                    898:        file->modtime = (time_t)modtime;
                    899:        file->len32 = (uint32)file_length;
                    900: #if SIZEOF_INT64 >= 8
                    901:        if (file_length > 0xFFFFFFFFu && S_ISREG(mode)) {
                    902: #if SIZEOF_CAPITAL_OFF_T < 8
                    903:                rprintf(FERROR, "Offset overflow: attempted 64-bit file-length\n");
                    904:                exit_cleanup(RERR_UNSUPPORTED);
                    905: #else
                    906:                file->flags |= FLAG_LENGTH64;
                    907:                OPT_EXTRA(file, 0)->unum = (uint32)(file_length >> 32);
                    908: #endif
                    909:        }
                    910: #endif
                    911:        file->mode = mode;
                    912:        if (preserve_uid)
                    913:                F_OWNER(file) = uid;
                    914:        if (preserve_gid) {
                    915:                F_GROUP(file) = gid;
                    916:                file->flags |= gid_flags;
                    917:        }
                    918:        if (unsort_ndx)
                    919:                F_NDX(file) = flist->used + flist->ndx_start;
                    920: 
                    921:        if (basename != thisname) {
                    922:                file->dirname = lastdir;
                    923:                F_DEPTH(file) = lastdir_depth + 1;
                    924:        } else
                    925:                F_DEPTH(file) = 1;
                    926: 
                    927:        if (S_ISDIR(mode)) {
                    928:                if (basename_len == 1+1 && *basename == '.') /* +1 for '\0' */
                    929:                        F_DEPTH(file)--;
                    930:                if (protocol_version >= 30) {
                    931:                        if (!(xflags & XMIT_NO_CONTENT_DIR)) {
                    932:                                if (xflags & XMIT_TOP_DIR)
                    933:                                        file->flags |= FLAG_TOP_DIR;
                    934:                                file->flags |= FLAG_CONTENT_DIR;
                    935:                        } else if (xflags & XMIT_TOP_DIR)
                    936:                                file->flags |= FLAG_IMPLIED_DIR;
                    937:                } else if (xflags & XMIT_TOP_DIR) {
                    938:                        in_del_hier = recurse;
                    939:                        del_hier_name_len = F_DEPTH(file) == 0 ? 0 : l1 + l2;
                    940:                        if (relative_paths && del_hier_name_len > 2
                    941:                            && lastname[del_hier_name_len-1] == '.'
                    942:                            && lastname[del_hier_name_len-2] == '/')
                    943:                                del_hier_name_len -= 2;
                    944:                        file->flags |= FLAG_TOP_DIR | FLAG_CONTENT_DIR;
                    945:                } else if (in_del_hier) {
                    946:                        if (!relative_paths || !del_hier_name_len
                    947:                         || (l1 >= del_hier_name_len
                    948:                          && lastname[del_hier_name_len] == '/'))
                    949:                                file->flags |= FLAG_CONTENT_DIR;
                    950:                        else
                    951:                                in_del_hier = 0;
                    952:                }
                    953:        }
                    954: 
                    955:        if (preserve_devices && IS_DEVICE(mode)) {
                    956:                uint32 *devp = F_RDEV_P(file);
                    957:                DEV_MAJOR(devp) = major(rdev);
                    958:                DEV_MINOR(devp) = minor(rdev);
                    959:        }
                    960: 
                    961: #ifdef SUPPORT_LINKS
                    962:        if (linkname_len) {
                    963:                bp += basename_len;
                    964:                if (first_hlink_ndx >= flist->ndx_start) {
                    965:                        struct file_struct *first = flist->files[first_hlink_ndx - flist->ndx_start];
                    966:                        memcpy(bp, F_SYMLINK(first), linkname_len);
                    967:                } else {
                    968:                        if (munge_symlinks) {
                    969:                                strlcpy(bp, SYMLINK_PREFIX, linkname_len);
                    970:                                bp += SYMLINK_PREFIX_LEN;
                    971:                                linkname_len -= SYMLINK_PREFIX_LEN;
                    972:                        }
                    973: #ifdef ICONV_OPTION
                    974:                        if (sender_symlink_iconv) {
                    975:                                xbuf outbuf, inbuf;
                    976: 
                    977:                                alloc_len = linkname_len;
                    978:                                linkname_len /= 2;
                    979: 
                    980:                                /* Read the symlink data into the end of our double-sized
                    981:                                 * buffer and then convert it into the right spot. */
                    982:                                INIT_XBUF(inbuf, bp + alloc_len - linkname_len,
                    983:                                          linkname_len - 1, (size_t)-1);
                    984:                                read_sbuf(f, inbuf.buf, inbuf.len);
                    985:                                INIT_XBUF(outbuf, bp, 0, alloc_len);
                    986: 
                    987:                                if (iconvbufs(ic_recv, &inbuf, &outbuf, 0) < 0) {
                    988:                                        io_error |= IOERR_GENERAL;
                    989:                                        rprintf(FERROR_XFER,
                    990:                                            "[%s] cannot convert symlink data for: %s (%s)\n",
                    991:                                            who_am_i(), full_fname(thisname), strerror(errno));
                    992:                                        bp = (char*)file->basename;
                    993:                                        *bp++ = '\0';
                    994:                                        outbuf.len = 0;
                    995:                                }
                    996:                                bp[outbuf.len] = '\0';
                    997:                        } else
                    998: #endif
                    999:                                read_sbuf(f, bp, linkname_len - 1);
                   1000:                        if (sanitize_paths && !munge_symlinks && *bp)
                   1001:                                sanitize_path(bp, bp, "", lastdir_depth, SP_DEFAULT);
                   1002:                }
                   1003:        }
                   1004: #endif
                   1005: 
                   1006: #ifdef SUPPORT_HARD_LINKS
                   1007:        if (preserve_hard_links && xflags & XMIT_HLINKED) {
                   1008:                if (protocol_version >= 30) {
                   1009:                        if (xflags & XMIT_HLINK_FIRST) {
                   1010:                                F_HL_GNUM(file) = flist->ndx_start + flist->used;
                   1011:                        } else
                   1012:                                F_HL_GNUM(file) = first_hlink_ndx;
                   1013:                } else {
                   1014:                        static int32 cnt = 0;
                   1015:                        struct ht_int64_node *np;
                   1016:                        int64 ino;
                   1017:                        int32 ndx;
                   1018:                        if (protocol_version < 26) {
                   1019:                                dev = read_int(f);
                   1020:                                ino = read_int(f);
                   1021:                        } else {
                   1022:                                if (!(xflags & XMIT_SAME_DEV_pre30))
                   1023:                                        dev = read_longint(f);
                   1024:                                ino = read_longint(f);
                   1025:                        }
                   1026:                        np = idev_find(dev, ino);
                   1027:                        ndx = (int32)(long)np->data - 1;
                   1028:                        if (ndx < 0) {
                   1029:                                ndx = cnt++;
                   1030:                                np->data = (void*)(long)cnt;
                   1031:                        }
                   1032:                        F_HL_GNUM(file) = ndx;
                   1033:                }
                   1034:        }
                   1035: #endif
                   1036: 
                   1037:        if (always_checksum && (S_ISREG(mode) || protocol_version < 28)) {
                   1038:                if (S_ISREG(mode))
                   1039:                        bp = F_SUM(file);
                   1040:                else {
                   1041:                        /* Prior to 28, we get a useless set of nulls. */
                   1042:                        bp = tmp_sum;
                   1043:                }
                   1044:                if (first_hlink_ndx >= flist->ndx_start) {
                   1045:                        struct file_struct *first = flist->files[first_hlink_ndx - flist->ndx_start];
                   1046:                        memcpy(bp, F_SUM(first), checksum_len);
                   1047:                } else
                   1048:                        read_buf(f, bp, checksum_len);
                   1049:        }
                   1050: 
                   1051: #ifdef SUPPORT_ACLS
                   1052:        if (preserve_acls && !S_ISLNK(mode))
                   1053:                receive_acl(f, file);
                   1054: #endif
                   1055: #ifdef SUPPORT_XATTRS
                   1056:        if (preserve_xattrs)
                   1057:                receive_xattr(f, file);
                   1058: #endif
                   1059: 
                   1060:        if (S_ISREG(mode) || S_ISLNK(mode))
                   1061:                stats.total_size += file_length;
                   1062: 
                   1063:        return file;
                   1064: }
                   1065: 
                   1066: /* Create a file_struct for a named file by reading its stat() information
                   1067:  * and performing extensive checks against global options.
                   1068:  *
                   1069:  * Returns a pointer to the new file struct, or NULL if there was an error
                   1070:  * or this file should be excluded.
                   1071:  *
                   1072:  * Note: Any error (here or in send_file_name) that results in the omission of
                   1073:  * an existent source file from the file list should set
                   1074:  * "io_error |= IOERR_GENERAL" to avoid deletion of the file from the
                   1075:  * destination if --delete is on. */
                   1076: struct file_struct *make_file(const char *fname, struct file_list *flist,
                   1077:                              STRUCT_STAT *stp, int flags, int filter_level)
                   1078: {
                   1079:        static char *lastdir;
                   1080:        static int lastdir_len = -1;
                   1081:        struct file_struct *file;
                   1082:        char thisname[MAXPATHLEN];
                   1083:        char linkname[MAXPATHLEN];
                   1084:        int alloc_len, basename_len, linkname_len;
                   1085:        int extra_len = file_extra_cnt * EXTRA_LEN;
                   1086:        const char *basename;
                   1087:        alloc_pool_t *pool;
                   1088:        STRUCT_STAT st;
                   1089:        char *bp;
                   1090: 
                   1091:        if (strlcpy(thisname, fname, sizeof thisname) >= sizeof thisname) {
                   1092:                io_error |= IOERR_GENERAL;
                   1093:                rprintf(FERROR_XFER, "skipping overly long name: %s\n", fname);
                   1094:                return NULL;
                   1095:        }
                   1096:        clean_fname(thisname, 0);
                   1097:        if (sanitize_paths)
                   1098:                sanitize_path(thisname, thisname, "", 0, SP_DEFAULT);
                   1099: 
                   1100:        if (stp && S_ISDIR(stp->st_mode)) {
                   1101:                st = *stp; /* Needed for "symlink/." with --relative. */
                   1102:                *linkname = '\0'; /* make IBM code checker happy */
                   1103:        } else if (readlink_stat(thisname, &st, linkname) != 0) {
                   1104:                int save_errno = errno;
                   1105:                /* See if file is excluded before reporting an error. */
                   1106:                if (filter_level != NO_FILTERS
                   1107:                 && (is_excluded(thisname, 0, filter_level)
                   1108:                  || is_excluded(thisname, 1, filter_level))) {
                   1109:                        if (ignore_perishable && save_errno != ENOENT)
                   1110:                                non_perishable_cnt++;
                   1111:                        return NULL;
                   1112:                }
                   1113:                if (save_errno == ENOENT) {
                   1114: #ifdef SUPPORT_LINKS
                   1115:                        /* When our options tell us to follow a symlink that
                   1116:                         * points nowhere, tell the user about the symlink
                   1117:                         * instead of giving a "vanished" message.  We only
                   1118:                         * dereference a symlink if one of the --copy*links
                   1119:                         * options was specified, so there's no need for the
                   1120:                         * extra lstat() if one of these options isn't on. */
                   1121:                        if ((copy_links || copy_unsafe_links || copy_dirlinks)
                   1122:                         && x_lstat(thisname, &st, NULL) == 0
                   1123:                         && S_ISLNK(st.st_mode)) {
                   1124:                                io_error |= IOERR_GENERAL;
                   1125:                                rprintf(FERROR_XFER, "symlink has no referent: %s\n",
                   1126:                                        full_fname(thisname));
                   1127:                        } else
                   1128: #endif
                   1129:                        {
                   1130:                                enum logcode c = am_daemon && protocol_version < 28
                   1131:                                               ? FERROR : FWARNING;
                   1132:                                io_error |= IOERR_VANISHED;
                   1133:                                rprintf(c, "file has vanished: %s\n",
                   1134:                                        full_fname(thisname));
                   1135:                        }
                   1136:                } else {
                   1137:                        io_error |= IOERR_GENERAL;
                   1138:                        rsyserr(FERROR_XFER, save_errno, "readlink_stat(%s) failed",
                   1139:                                full_fname(thisname));
                   1140:                }
                   1141:                return NULL;
                   1142:        }
                   1143: 
                   1144:        if (filter_level == NO_FILTERS)
                   1145:                goto skip_filters;
                   1146: 
                   1147:        if (S_ISDIR(st.st_mode)) {
                   1148:                if (!xfer_dirs) {
                   1149:                        rprintf(FINFO, "skipping directory %s\n", thisname);
                   1150:                        return NULL;
                   1151:                }
                   1152:                /* -x only affects dirs because we need to avoid recursing
                   1153:                 * into a mount-point directory, not to avoid copying a
                   1154:                 * symlinked file if -L (or similar) was specified. */
                   1155:                if (one_file_system && st.st_dev != filesystem_dev
                   1156:                 && BITS_SETnUNSET(flags, FLAG_CONTENT_DIR, FLAG_TOP_DIR)) {
                   1157:                        if (one_file_system > 1) {
                   1158:                                if (verbose > 1) {
                   1159:                                        rprintf(FINFO,
                   1160:                                            "[%s] skipping mount-point dir %s\n",
                   1161:                                            who_am_i(), thisname);
                   1162:                                }
                   1163:                                return NULL;
                   1164:                        }
                   1165:                        flags |= FLAG_MOUNT_DIR;
                   1166:                        flags &= ~FLAG_CONTENT_DIR;
                   1167:                }
                   1168:        } else
                   1169:                flags &= ~FLAG_CONTENT_DIR;
                   1170: 
                   1171:        if (is_excluded(thisname, S_ISDIR(st.st_mode) != 0, filter_level)) {
                   1172:                if (ignore_perishable)
                   1173:                        non_perishable_cnt++;
                   1174:                return NULL;
                   1175:        }
                   1176: 
                   1177:        if (lp_ignore_nonreadable(module_id)) {
                   1178: #ifdef SUPPORT_LINKS
                   1179:                if (!S_ISLNK(st.st_mode))
                   1180: #endif
                   1181:                        if (access(thisname, R_OK) != 0)
                   1182:                                return NULL;
                   1183:        }
                   1184: 
                   1185:   skip_filters:
                   1186: 
                   1187:        /* Only divert a directory in the main transfer. */
                   1188:        if (flist) {
                   1189:                if (flist->prev && S_ISDIR(st.st_mode)
                   1190:                 && flags & FLAG_DIVERT_DIRS) {
                   1191:                        /* Room for parent/sibling/next-child info. */
                   1192:                        extra_len += DIRNODE_EXTRA_CNT * EXTRA_LEN;
                   1193:                        if (relative_paths)
                   1194:                                extra_len += PTR_EXTRA_CNT * EXTRA_LEN;
                   1195:                        pool = dir_flist->file_pool;
                   1196:                } else
                   1197:                        pool = flist->file_pool;
                   1198:        } else {
                   1199: #ifdef SUPPORT_ACLS
                   1200:                /* Directories need an extra int32 for the default ACL. */
                   1201:                if (preserve_acls && S_ISDIR(st.st_mode))
                   1202:                        extra_len += EXTRA_LEN;
                   1203: #endif
                   1204:                pool = NULL;
                   1205:        }
                   1206: 
                   1207:        if (verbose > 2) {
                   1208:                rprintf(FINFO, "[%s] make_file(%s,*,%d)\n",
                   1209:                        who_am_i(), thisname, filter_level);
                   1210:        }
                   1211: 
                   1212:        if ((basename = strrchr(thisname, '/')) != NULL) {
                   1213:                int len = basename++ - thisname;
                   1214:                if (len != lastdir_len || memcmp(thisname, lastdir, len) != 0) {
                   1215:                        lastdir = new_array(char, len + 1);
                   1216:                        memcpy(lastdir, thisname, len);
                   1217:                        lastdir[len] = '\0';
                   1218:                        lastdir_len = len;
                   1219:                }
                   1220:        } else
                   1221:                basename = thisname;
                   1222:        basename_len = strlen(basename) + 1; /* count the '\0' */
                   1223: 
                   1224: #ifdef SUPPORT_LINKS
                   1225:        linkname_len = S_ISLNK(st.st_mode) ? strlen(linkname) + 1 : 0;
                   1226: #else
                   1227:        linkname_len = 0;
                   1228: #endif
                   1229: 
                   1230: #if SIZEOF_CAPITAL_OFF_T >= 8
                   1231:        if (st.st_size > 0xFFFFFFFFu && S_ISREG(st.st_mode))
                   1232:                extra_len += EXTRA_LEN;
                   1233: #endif
                   1234: 
                   1235: #if EXTRA_ROUNDING > 0
                   1236:        if (extra_len & (EXTRA_ROUNDING * EXTRA_LEN))
                   1237:                extra_len = (extra_len | (EXTRA_ROUNDING * EXTRA_LEN)) + EXTRA_LEN;
                   1238: #endif
                   1239: 
                   1240:        alloc_len = FILE_STRUCT_LEN + extra_len + basename_len
                   1241:                  + linkname_len;
                   1242:        if (pool)
                   1243:                bp = pool_alloc(pool, alloc_len, "make_file");
                   1244:        else {
                   1245:                if (!(bp = new_array(char, alloc_len)))
                   1246:                        out_of_memory("make_file");
                   1247:        }
                   1248: 
                   1249:        memset(bp, 0, extra_len + FILE_STRUCT_LEN);
                   1250:        bp += extra_len;
                   1251:        file = (struct file_struct *)bp;
                   1252:        bp += FILE_STRUCT_LEN;
                   1253: 
                   1254:        memcpy(bp, basename, basename_len);
                   1255: 
                   1256: #ifdef SUPPORT_HARD_LINKS
                   1257:        if (preserve_hard_links && flist && flist->prev) {
                   1258:                if (protocol_version >= 28
                   1259:                 ? (!S_ISDIR(st.st_mode) && st.st_nlink > 1)
                   1260:                 : S_ISREG(st.st_mode)) {
                   1261:                        tmp_dev = (int64)st.st_dev;
                   1262:                        tmp_ino = (int64)st.st_ino;
                   1263:                } else
                   1264:                        tmp_dev = -1;
                   1265:        }
                   1266: #endif
                   1267: 
                   1268: #ifdef HAVE_STRUCT_STAT_ST_RDEV
                   1269:        if (IS_DEVICE(st.st_mode)) {
                   1270:                tmp_rdev = st.st_rdev;
                   1271:                st.st_size = 0;
                   1272:        } else if (IS_SPECIAL(st.st_mode))
                   1273:                st.st_size = 0;
                   1274: #endif
                   1275: 
                   1276:        file->flags = flags;
                   1277:        file->modtime = st.st_mtime;
                   1278:        file->len32 = (uint32)st.st_size;
                   1279: #if SIZEOF_CAPITAL_OFF_T >= 8
                   1280:        if (st.st_size > 0xFFFFFFFFu && S_ISREG(st.st_mode)) {
                   1281:                file->flags |= FLAG_LENGTH64;
                   1282:                OPT_EXTRA(file, 0)->unum = (uint32)(st.st_size >> 32);
                   1283:        }
                   1284: #endif
                   1285:        file->mode = st.st_mode;
                   1286:        if (preserve_uid)
                   1287:                F_OWNER(file) = st.st_uid;
                   1288:        if (preserve_gid)
                   1289:                F_GROUP(file) = st.st_gid;
                   1290:        if (am_generator && st.st_uid == our_uid)
                   1291:                file->flags |= FLAG_OWNED_BY_US;
                   1292: 
                   1293:        if (basename != thisname)
                   1294:                file->dirname = lastdir;
                   1295: 
                   1296: #ifdef SUPPORT_LINKS
                   1297:        if (linkname_len)
                   1298:                memcpy(bp + basename_len, linkname, linkname_len);
                   1299: #endif
                   1300: 
                   1301:        if (always_checksum && am_sender && S_ISREG(st.st_mode))
                   1302:                file_checksum(thisname, tmp_sum, st.st_size);
                   1303: 
                   1304:        if (am_sender)
                   1305:                F_PATHNAME(file) = pathname;
                   1306:        else if (!pool)
                   1307:                F_DEPTH(file) = extra_len / EXTRA_LEN;
                   1308: 
                   1309:        if (basename_len == 0+1) {
                   1310:                if (!pool)
                   1311:                        unmake_file(file);
                   1312:                return NULL;
                   1313:        }
                   1314: 
                   1315:        if (unsort_ndx)
                   1316:                F_NDX(file) = dir_count;
                   1317: 
                   1318:        return file;
                   1319: }
                   1320: 
                   1321: /* Only called for temporary file_struct entries created by make_file(). */
                   1322: void unmake_file(struct file_struct *file)
                   1323: {
                   1324:        free(REQ_EXTRA(file, F_DEPTH(file)));
                   1325: }
                   1326: 
                   1327: static struct file_struct *send_file_name(int f, struct file_list *flist,
                   1328:                                          const char *fname, STRUCT_STAT *stp,
                   1329:                                          int flags, int filter_level)
                   1330: {
                   1331:        struct file_struct *file;
                   1332: 
                   1333:        file = make_file(fname, flist, stp, flags, filter_level);
                   1334:        if (!file)
                   1335:                return NULL;
                   1336: 
                   1337:        if (chmod_modes && !S_ISLNK(file->mode))
                   1338:                file->mode = tweak_mode(file->mode, chmod_modes);
                   1339: 
                   1340:        if (f >= 0) {
                   1341:                char fbuf[MAXPATHLEN];
                   1342: #ifdef SUPPORT_LINKS
                   1343:                const char *symlink_name;
                   1344:                int symlink_len;
                   1345: #ifdef ICONV_OPTION
                   1346:                char symlink_buf[MAXPATHLEN];
                   1347: #endif
                   1348: #endif
                   1349: #if defined SUPPORT_ACLS || defined SUPPORT_XATTRS
                   1350:                stat_x sx;
                   1351: #endif
                   1352: 
                   1353: #ifdef SUPPORT_LINKS
                   1354:                if (preserve_links && S_ISLNK(file->mode)) {
                   1355:                        symlink_name = F_SYMLINK(file);
                   1356:                        symlink_len = strlen(symlink_name);
                   1357:                        if (symlink_len == 0) {
                   1358:                                io_error |= IOERR_GENERAL;
                   1359:                                f_name(file, fbuf);
                   1360:                                rprintf(FERROR_XFER,
                   1361:                                    "skipping symlink with 0-length value: %s\n",
                   1362:                                    full_fname(fbuf));
                   1363:                                return NULL;
                   1364:                        }
                   1365:                } else {
                   1366:                        symlink_name = NULL;
                   1367:                        symlink_len = 0;
                   1368:                }
                   1369: #endif
                   1370: 
                   1371: #ifdef ICONV_OPTION
                   1372:                if (ic_send != (iconv_t)-1) {
                   1373:                        xbuf outbuf, inbuf;
                   1374: 
                   1375:                        INIT_CONST_XBUF(outbuf, fbuf);
                   1376: 
                   1377:                        if (file->dirname) {
                   1378:                                INIT_XBUF_STRLEN(inbuf, (char*)file->dirname);
                   1379:                                outbuf.size -= 2; /* Reserve room for '/' & 1 more char. */
                   1380:                                if (iconvbufs(ic_send, &inbuf, &outbuf, 0) < 0)
                   1381:                                        goto convert_error;
                   1382:                                outbuf.size += 2;
                   1383:                                fbuf[outbuf.len++] = '/';
                   1384:                        }
                   1385: 
                   1386:                        INIT_XBUF_STRLEN(inbuf, (char*)file->basename);
                   1387:                        if (iconvbufs(ic_send, &inbuf, &outbuf, 0) < 0) {
                   1388:                          convert_error:
                   1389:                                io_error |= IOERR_GENERAL;
                   1390:                                rprintf(FERROR_XFER,
                   1391:                                    "[%s] cannot convert filename: %s (%s)\n",
                   1392:                                    who_am_i(), f_name(file, fbuf), strerror(errno));
                   1393:                                return NULL;
                   1394:                        }
                   1395:                        fbuf[outbuf.len] = '\0';
                   1396: 
                   1397: #ifdef SUPPORT_LINKS
                   1398:                        if (symlink_len && sender_symlink_iconv) {
                   1399:                                INIT_XBUF(inbuf, (char*)symlink_name, symlink_len, (size_t)-1);
                   1400:                                INIT_CONST_XBUF(outbuf, symlink_buf);
                   1401:                                if (iconvbufs(ic_send, &inbuf, &outbuf, 0) < 0) {
                   1402:                                        io_error |= IOERR_GENERAL;
                   1403:                                        f_name(file, fbuf);
                   1404:                                        rprintf(FERROR_XFER,
                   1405:                                            "[%s] cannot convert symlink data for: %s (%s)\n",
                   1406:                                            who_am_i(), full_fname(fbuf), strerror(errno));
                   1407:                                        return NULL;
                   1408:                                }
                   1409:                                symlink_buf[outbuf.len] = '\0';
                   1410: 
                   1411:                                symlink_name = symlink_buf;
                   1412:                                symlink_len = outbuf.len;
                   1413:                        }
                   1414: #endif
                   1415:                } else
                   1416: #endif
                   1417:                        f_name(file, fbuf);
                   1418: 
                   1419: #ifdef SUPPORT_ACLS
                   1420:                if (preserve_acls && !S_ISLNK(file->mode)) {
                   1421:                        sx.st.st_mode = file->mode;
                   1422:                        sx.acc_acl = sx.def_acl = NULL;
                   1423:                        if (get_acl(fname, &sx) < 0) {
                   1424:                                io_error |= IOERR_GENERAL;
                   1425:                                return NULL;
                   1426:                        }
                   1427:                }
                   1428: #endif
                   1429: #ifdef SUPPORT_XATTRS
                   1430:                if (preserve_xattrs) {
                   1431:                        sx.st.st_mode = file->mode;
                   1432:                        sx.xattr = NULL;
                   1433:                        if (get_xattr(fname, &sx) < 0) {
                   1434:                                io_error |= IOERR_GENERAL;
                   1435:                                return NULL;
                   1436:                        }
                   1437:                }
                   1438: #endif
                   1439: 
                   1440:                send_file_entry(f, fbuf, file,
                   1441: #ifdef SUPPORT_LINKS
                   1442:                                symlink_name, symlink_len,
                   1443: #endif
                   1444:                                flist->used, flist->ndx_start);
                   1445: 
                   1446: #ifdef SUPPORT_ACLS
                   1447:                if (preserve_acls && !S_ISLNK(file->mode)) {
                   1448:                        send_acl(f, &sx);
                   1449:                        free_acl(&sx);
                   1450:                }
                   1451: #endif
                   1452: #ifdef SUPPORT_XATTRS
                   1453:                if (preserve_xattrs) {
                   1454:                        F_XATTR(file) = send_xattr(f, &sx);
                   1455:                        free_xattr(&sx);
                   1456:                }
                   1457: #endif
                   1458:        }
                   1459: 
                   1460:        maybe_emit_filelist_progress(flist->used + flist_count_offset);
                   1461: 
                   1462:        flist_expand(flist, 1);
                   1463:        flist->files[flist->used++] = file;
                   1464: 
                   1465:        return file;
                   1466: }
                   1467: 
                   1468: static void send_if_directory(int f, struct file_list *flist,
                   1469:                              struct file_struct *file,
                   1470:                              char *fbuf, unsigned int ol,
                   1471:                              int flags)
                   1472: {
                   1473:        char is_dot_dir = fbuf[ol-1] == '.' && (ol == 1 || fbuf[ol-2] == '/');
                   1474: 
                   1475:        if (S_ISDIR(file->mode)
                   1476:            && !(file->flags & FLAG_MOUNT_DIR) && f_name(file, fbuf)) {
                   1477:                void *save_filters;
                   1478:                unsigned int len = strlen(fbuf);
                   1479:                if (len > 1 && fbuf[len-1] == '/')
                   1480:                        fbuf[--len] = '\0';
                   1481:                save_filters = push_local_filters(fbuf, len);
                   1482:                send_directory(f, flist, fbuf, len, flags);
                   1483:                pop_local_filters(save_filters);
                   1484:                fbuf[ol] = '\0';
                   1485:                if (is_dot_dir)
                   1486:                        fbuf[ol-1] = '.';
                   1487:        }
                   1488: }
                   1489: 
                   1490: static int file_compare(const void *file1, const void *file2)
                   1491: {
                   1492:        return f_name_cmp(*(struct file_struct **)file1,
                   1493:                          *(struct file_struct **)file2);
                   1494: }
                   1495: 
                   1496: /* The guts of a merge-sort algorithm.  This was derived from the glibc
                   1497:  * version, but I (Wayne) changed the merge code to do less copying and
                   1498:  * to require only half the amount of temporary memory. */
                   1499: static void fsort_tmp(struct file_struct **fp, size_t num,
                   1500:                      struct file_struct **tmp)
                   1501: {
                   1502:        struct file_struct **f1, **f2, **t;
                   1503:        size_t n1, n2;
                   1504: 
                   1505:        n1 = num / 2;
                   1506:        n2 = num - n1;
                   1507:        f1 = fp;
                   1508:        f2 = fp + n1;
                   1509: 
                   1510:        if (n1 > 1)
                   1511:                fsort_tmp(f1, n1, tmp);
                   1512:        if (n2 > 1)
                   1513:                fsort_tmp(f2, n2, tmp);
                   1514: 
                   1515:        while (f_name_cmp(*f1, *f2) <= 0) {
                   1516:                if (!--n1)
                   1517:                        return;
                   1518:                f1++;
                   1519:        }
                   1520: 
                   1521:        t = tmp;
                   1522:        memcpy(t, f1, n1 * PTR_SIZE);
                   1523: 
                   1524:        *f1++ = *f2++, n2--;
                   1525: 
                   1526:        while (n1 > 0 && n2 > 0) {
                   1527:                if (f_name_cmp(*t, *f2) <= 0)
                   1528:                        *f1++ = *t++, n1--;
                   1529:                else
                   1530:                        *f1++ = *f2++, n2--;
                   1531:        }
                   1532: 
                   1533:        if (n1 > 0)
                   1534:                memcpy(f1, t, n1 * PTR_SIZE);
                   1535: }
                   1536: 
                   1537: /* This file-struct sorting routine makes sure that any identical names in
                   1538:  * the file list stay in the same order as they were in the original list.
                   1539:  * This is particularly vital in inc_recurse mode where we expect a sort
                   1540:  * on the flist to match the exact order of a sort on the dir_flist. */
                   1541: static void fsort(struct file_struct **fp, size_t num)
                   1542: {
                   1543:        if (num <= 1)
                   1544:                return;
                   1545: 
                   1546:        if (use_qsort)
                   1547:                qsort(fp, num, PTR_SIZE, file_compare);
                   1548:        else {
                   1549:                struct file_struct **tmp = new_array(struct file_struct *,
                   1550:                                                     (num+1) / 2);
                   1551:                fsort_tmp(fp, num, tmp);
                   1552:                free(tmp);
                   1553:        }
                   1554: }
                   1555: 
                   1556: /* We take an entire set of sibling dirs from the sorted flist and link them
                   1557:  * into the tree, setting the appropriate parent/child/sibling pointers. */
                   1558: static void add_dirs_to_tree(int parent_ndx, struct file_list *from_flist,
                   1559:                             int dir_cnt)
                   1560: {
                   1561:        int i;
                   1562:        int32 *dp = NULL;
                   1563:        int32 *parent_dp = parent_ndx < 0 ? NULL
                   1564:                         : F_DIR_NODE_P(dir_flist->sorted[parent_ndx]);
                   1565: 
                   1566:        flist_expand(dir_flist, dir_cnt);
                   1567:        dir_flist->sorted = dir_flist->files;
                   1568: 
                   1569:        for (i = 0; dir_cnt; i++) {
                   1570:                struct file_struct *file = from_flist->sorted[i];
                   1571: 
                   1572:                if (!S_ISDIR(file->mode))
                   1573:                        continue;
                   1574: 
                   1575:                dir_flist->files[dir_flist->used++] = file;
                   1576:                dir_cnt--;
                   1577: 
                   1578:                if (file->basename[0] == '.' && file->basename[1] == '\0')
                   1579:                        continue;
                   1580: 
                   1581:                if (dp)
                   1582:                        DIR_NEXT_SIBLING(dp) = dir_flist->used - 1;
                   1583:                else if (parent_dp)
                   1584:                        DIR_FIRST_CHILD(parent_dp) = dir_flist->used - 1;
                   1585:                else
                   1586:                        send_dir_ndx = dir_flist->used - 1;
                   1587: 
                   1588:                dp = F_DIR_NODE_P(file);
                   1589:                DIR_PARENT(dp) = parent_ndx;
                   1590:                DIR_FIRST_CHILD(dp) = -1;
                   1591:        }
                   1592:        if (dp)
                   1593:                DIR_NEXT_SIBLING(dp) = -1;
                   1594: }
                   1595: 
                   1596: static void interpret_stat_error(const char *fname, int is_dir)
                   1597: {
                   1598:        if (errno == ENOENT) {
                   1599:                io_error |= IOERR_VANISHED;
                   1600:                rprintf(FWARNING, "%s has vanished: %s\n",
                   1601:                        is_dir ? "directory" : "file", full_fname(fname));
                   1602:        } else {
                   1603:                io_error |= IOERR_GENERAL;
                   1604:                rsyserr(FERROR_XFER, errno, "link_stat %s failed",
                   1605:                        full_fname(fname));
                   1606:        }
                   1607: }
                   1608: 
                   1609: /* This function is normally called by the sender, but the receiving side also
                   1610:  * calls it from get_dirlist() with f set to -1 so that we just construct the
                   1611:  * file list in memory without sending it over the wire.  Also, get_dirlist()
                   1612:  * might call this with f set to -2, which also indicates that local filter
                   1613:  * rules should be ignored. */
                   1614: static void send_directory(int f, struct file_list *flist, char *fbuf, int len,
                   1615:                           int flags)
                   1616: {
                   1617:        struct dirent *di;
                   1618:        unsigned remainder;
                   1619:        char *p;
                   1620:        DIR *d;
                   1621:        int divert_dirs = (flags & FLAG_DIVERT_DIRS) != 0;
                   1622:        int start = flist->used;
                   1623:        int filter_level = f == -2 ? SERVER_FILTERS : ALL_FILTERS;
                   1624: 
                   1625:        assert(flist != NULL);
                   1626: 
                   1627:        if (!(d = opendir(fbuf))) {
                   1628:                if (errno == ENOENT) {
                   1629:                        if (am_sender) /* Can abuse this for vanished error w/ENOENT: */
                   1630:                                interpret_stat_error(fbuf, True);
                   1631:                        return;
                   1632:                }
                   1633:                io_error |= IOERR_GENERAL;
                   1634:                rsyserr(FERROR_XFER, errno, "opendir %s failed", full_fname(fbuf));
                   1635:                return;
                   1636:        }
                   1637: 
                   1638:        p = fbuf + len;
                   1639:        if (len == 1 && *fbuf == '/')
                   1640:                remainder = MAXPATHLEN - 1;
                   1641:        else if (len < MAXPATHLEN-1) {
                   1642:                *p++ = '/';
                   1643:                *p = '\0';
                   1644:                remainder = MAXPATHLEN - (len + 1);
                   1645:        } else
                   1646:                remainder = 0;
                   1647: 
                   1648:        for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) {
                   1649:                unsigned name_len;
                   1650:                char *dname = d_name(di);
                   1651:                if (dname[0] == '.' && (dname[1] == '\0'
                   1652:                    || (dname[1] == '.' && dname[2] == '\0')))
                   1653:                        continue;
                   1654:                name_len = strlcpy(p, dname, remainder);
                   1655:                if (name_len >= remainder) {
                   1656:                        char save = fbuf[len];
                   1657:                        fbuf[len] = '\0';
                   1658:                        io_error |= IOERR_GENERAL;
                   1659:                        rprintf(FERROR_XFER,
                   1660:                                "filename overflows max-path len by %u: %s/%s\n",
                   1661:                                name_len - remainder + 1, fbuf, dname);
                   1662:                        fbuf[len] = save;
                   1663:                        continue;
                   1664:                }
                   1665:                if (dname[0] == '\0') {
                   1666:                        io_error |= IOERR_GENERAL;
                   1667:                        rprintf(FERROR_XFER,
                   1668:                                "cannot send file with empty name in %s\n",
                   1669:                                full_fname(fbuf));
                   1670:                        continue;
                   1671:                }
                   1672: 
                   1673:                send_file_name(f, flist, fbuf, NULL, flags, filter_level);
                   1674:        }
                   1675: 
                   1676:        fbuf[len] = '\0';
                   1677: 
                   1678:        if (errno) {
                   1679:                io_error |= IOERR_GENERAL;
                   1680:                rsyserr(FERROR_XFER, errno, "readdir(%s)", full_fname(fbuf));
                   1681:        }
                   1682: 
                   1683:        closedir(d);
                   1684: 
                   1685:        if (f >= 0 && recurse && !divert_dirs) {
                   1686:                int i, end = flist->used - 1;
                   1687:                /* send_if_directory() bumps flist->used, so use "end". */
                   1688:                for (i = start; i <= end; i++)
                   1689:                        send_if_directory(f, flist, flist->files[i], fbuf, len, flags);
                   1690:        }
                   1691: }
                   1692: 
                   1693: static void send_implied_dirs(int f, struct file_list *flist, char *fname,
                   1694:                              char *start, char *limit, int flags, char name_type)
                   1695: {
                   1696:        static char lastpath[MAXPATHLEN] = "";
                   1697:        static int lastpath_len = 0;
                   1698:        static struct file_struct *lastpath_struct = NULL;
                   1699:        struct file_struct *file;
                   1700:        item_list *relname_list;
                   1701:        relnamecache **rnpp;
                   1702:        int len, need_new_dir, depth = 0;
                   1703:        struct filter_list_struct save_filter_list = filter_list;
                   1704: 
                   1705:        flags = (flags | FLAG_IMPLIED_DIR) & ~(FLAG_TOP_DIR | FLAG_CONTENT_DIR);
                   1706:        filter_list.head = filter_list.tail = NULL; /* Don't filter implied dirs. */
                   1707: 
                   1708:        if (inc_recurse) {
                   1709:                if (lastpath_struct && F_PATHNAME(lastpath_struct) == pathname
                   1710:                 && lastpath_len == limit - fname
                   1711:                 && strncmp(lastpath, fname, lastpath_len) == 0)
                   1712:                        need_new_dir = 0;
                   1713:                else
                   1714:                        need_new_dir = 1;
                   1715:        } else {
                   1716:                char *tp = fname, *lp = lastpath;
                   1717:                /* Skip any initial directories in our path that we
                   1718:                 * have in common with lastpath. */
                   1719:                assert(start == fname);
                   1720:                for ( ; ; tp++, lp++) {
                   1721:                        if (tp == limit) {
                   1722:                                if (*lp == '/' || *lp == '\0')
                   1723:                                        goto done;
                   1724:                                break;
                   1725:                        }
                   1726:                        if (*lp != *tp)
                   1727:                                break;
                   1728:                        if (*tp == '/') {
                   1729:                                start = tp;
                   1730:                                depth++;
                   1731:                        }
                   1732:                }
                   1733:                need_new_dir = 1;
                   1734:        }
                   1735: 
                   1736:        if (need_new_dir) {
                   1737:                int save_copy_links = copy_links;
                   1738:                int save_xfer_dirs = xfer_dirs;
                   1739:                char *slash;
                   1740: 
                   1741:                copy_links = xfer_dirs = 1;
                   1742: 
                   1743:                *limit = '\0';
                   1744: 
                   1745:                for (slash = start; (slash = strchr(slash+1, '/')) != NULL; ) {
                   1746:                        *slash = '\0';
                   1747:                        file = send_file_name(f, flist, fname, NULL, flags, ALL_FILTERS);
                   1748:                        depth++;
                   1749:                        if (!inc_recurse && file && S_ISDIR(file->mode))
                   1750:                                change_local_filter_dir(fname, strlen(fname), depth);
                   1751:                        *slash = '/';
                   1752:                }
                   1753: 
                   1754:                file = send_file_name(f, flist, fname, NULL, flags, ALL_FILTERS);
                   1755:                if (inc_recurse) {
                   1756:                        if (file && !S_ISDIR(file->mode))
                   1757:                                file = NULL;
                   1758:                        lastpath_struct = file;
                   1759:                } else if (file && S_ISDIR(file->mode))
                   1760:                        change_local_filter_dir(fname, strlen(fname), ++depth);
                   1761: 
                   1762:                strlcpy(lastpath, fname, sizeof lastpath);
                   1763:                lastpath_len = limit - fname;
                   1764: 
                   1765:                *limit = '/';
                   1766: 
                   1767:                copy_links = save_copy_links;
                   1768:                xfer_dirs = save_xfer_dirs;
                   1769: 
                   1770:                if (!inc_recurse)
                   1771:                        goto done;
                   1772:        }
                   1773: 
                   1774:        if (!lastpath_struct)
                   1775:                goto done; /* dir must have vanished */
                   1776: 
                   1777:        len = strlen(limit+1);
                   1778:        memcpy(&relname_list, F_DIR_RELNAMES_P(lastpath_struct), sizeof relname_list);
                   1779:        if (!relname_list) {
                   1780:                if (!(relname_list = new0(item_list)))
                   1781:                        out_of_memory("send_implied_dirs");
                   1782:                memcpy(F_DIR_RELNAMES_P(lastpath_struct), &relname_list, sizeof relname_list);
                   1783:        }
                   1784:        rnpp = EXPAND_ITEM_LIST(relname_list, relnamecache *, 32);
                   1785:        if (!(*rnpp = (relnamecache*)new_array(char, sizeof (relnamecache) + len)))
                   1786:                out_of_memory("send_implied_dirs");
                   1787:        (*rnpp)->name_type = name_type;
                   1788:        strlcpy((*rnpp)->fname, limit+1, len + 1);
                   1789: 
                   1790: done:
                   1791:        filter_list = save_filter_list;
                   1792: }
                   1793: 
                   1794: static NORETURN void fatal_unsafe_io_error(void)
                   1795: {
                   1796:        /* This (sadly) can only happen when pushing data because
                   1797:         * the sender does not know about what kind of delete
                   1798:         * is in effect on the receiving side when pulling. */
                   1799:        rprintf(FERROR_XFER, "FATAL I/O ERROR: dying to avoid a --delete-during issue with a pre-3.0.7 receiver.\n");
                   1800:        exit_cleanup(RERR_UNSUPPORTED);
                   1801: }
                   1802: 
                   1803: static void send1extra(int f, struct file_struct *file, struct file_list *flist)
                   1804: {
                   1805:        char fbuf[MAXPATHLEN];
                   1806:        item_list *relname_list;
                   1807:        int len, dlen, flags = FLAG_DIVERT_DIRS | FLAG_CONTENT_DIR;
                   1808:        size_t j;
                   1809: 
                   1810:        f_name(file, fbuf);
                   1811:        dlen = strlen(fbuf);
                   1812: 
                   1813:        if (!change_pathname(file, NULL, 0))
                   1814:                exit_cleanup(RERR_FILESELECT);
                   1815: 
                   1816:        change_local_filter_dir(fbuf, dlen, send_dir_depth);
                   1817: 
                   1818:        if (file->flags & FLAG_CONTENT_DIR) {
                   1819:                if (one_file_system) {
                   1820:                        STRUCT_STAT st;
                   1821:                        if (link_stat(fbuf, &st, copy_dirlinks) != 0) {
                   1822:                                interpret_stat_error(fbuf, True);
                   1823:                                return;
                   1824:                        }
                   1825:                        filesystem_dev = st.st_dev;
                   1826:                }
                   1827:                send_directory(f, flist, fbuf, dlen, flags);
                   1828:        }
                   1829: 
                   1830:        if (!relative_paths)
                   1831:                return;
                   1832: 
                   1833:        memcpy(&relname_list, F_DIR_RELNAMES_P(file), sizeof relname_list);
                   1834:        if (!relname_list)
                   1835:                return;
                   1836: 
                   1837:        for (j = 0; j < relname_list->count; j++) {
                   1838:                char *slash;
                   1839:                relnamecache *rnp = ((relnamecache**)relname_list->items)[j];
                   1840:                char name_type = rnp->name_type;
                   1841: 
                   1842:                fbuf[dlen] = '/';
                   1843:                len = strlcpy(fbuf + dlen + 1, rnp->fname, sizeof fbuf - dlen - 1);
                   1844:                free(rnp);
                   1845:                if (len >= (int)sizeof fbuf)
                   1846:                        continue; /* Impossible... */
                   1847: 
                   1848:                slash = strchr(fbuf+dlen+1, '/');
                   1849:                if (slash) {
                   1850:                        send_implied_dirs(f, flist, fbuf, fbuf+dlen+1, slash, flags, name_type);
                   1851:                        continue;
                   1852:                }
                   1853: 
                   1854:                if (name_type != NORMAL_NAME) {
                   1855:                        STRUCT_STAT st;
                   1856:                        if (link_stat(fbuf, &st, 1) != 0) {
                   1857:                                interpret_stat_error(fbuf, True);
                   1858:                                continue;
                   1859:                        }
                   1860:                        send_file_name(f, flist, fbuf, &st, FLAG_TOP_DIR | flags, ALL_FILTERS);
                   1861:                } else
                   1862:                        send_file_name(f, flist, fbuf, NULL, FLAG_TOP_DIR | flags, ALL_FILTERS);
                   1863:        }
                   1864: 
                   1865:        free(relname_list);
                   1866: }
                   1867: 
                   1868: void send_extra_file_list(int f, int at_least)
                   1869: {
                   1870:        struct file_list *flist;
                   1871:        int64 start_write;
                   1872:        uint16 prev_flags;
                   1873:        int old_cnt, save_io_error = io_error;
                   1874: 
                   1875:        if (flist_eof)
                   1876:                return;
                   1877: 
                   1878:        /* Keep sending data until we have the requested number of
                   1879:         * files in the upcoming file-lists. */
                   1880:        old_cnt = cur_flist->used;
                   1881:        for (flist = first_flist; flist != cur_flist; flist = flist->next)
                   1882:                old_cnt += flist->used;
                   1883:        while (file_total - old_cnt < at_least) {
                   1884:                struct file_struct *file = dir_flist->sorted[send_dir_ndx];
                   1885:                int dir_ndx, dstart = dir_count;
                   1886:                const char *pathname = F_PATHNAME(file);
                   1887:                int32 *dp;
                   1888: 
                   1889:                flist = flist_new(0, "send_extra_file_list");
                   1890:                start_write = stats.total_written;
                   1891: 
                   1892:                if (unsort_ndx)
                   1893:                        dir_ndx = F_NDX(file);
                   1894:                else
                   1895:                        dir_ndx = send_dir_ndx;
                   1896:                write_ndx(f, NDX_FLIST_OFFSET - dir_ndx);
                   1897:                flist->parent_ndx = dir_ndx;
                   1898: 
                   1899:                send1extra(f, file, flist);
                   1900:                prev_flags = file->flags;
                   1901:                dp = F_DIR_NODE_P(file);
                   1902: 
                   1903:                /* If there are any duplicate directory names that follow, we
                   1904:                 * send all the dirs together in one file-list.  The dir_flist
                   1905:                 * tree links all the child subdirs onto the last dup dir. */
                   1906:                while ((dir_ndx = DIR_NEXT_SIBLING(dp)) >= 0
                   1907:                    && dir_flist->sorted[dir_ndx]->flags & FLAG_DUPLICATE) {
                   1908:                        send_dir_ndx = dir_ndx;
                   1909:                        file = dir_flist->sorted[dir_ndx];
                   1910:                        /* Try to avoid some duplicate scanning of identical dirs. */
                   1911:                        if (F_PATHNAME(file) == pathname && prev_flags & FLAG_CONTENT_DIR)
                   1912:                                file->flags &= ~FLAG_CONTENT_DIR;
                   1913:                        send1extra(f, file, flist);
                   1914:                        prev_flags = file->flags;
                   1915:                        dp = F_DIR_NODE_P(file);
                   1916:                }
                   1917: 
                   1918:                if (io_error == save_io_error || ignore_errors)
                   1919:                        write_byte(f, 0);
                   1920:                else if (use_safe_inc_flist) {
                   1921:                        write_shortint(f, XMIT_EXTENDED_FLAGS|XMIT_IO_ERROR_ENDLIST);
                   1922:                        write_varint(f, io_error);
                   1923:                } else {
                   1924:                        if (delete_during)
                   1925:                                fatal_unsafe_io_error();
                   1926:                        write_byte(f, 0);
                   1927:                }
                   1928: 
                   1929:                if (need_unsorted_flist) {
                   1930:                        if (!(flist->sorted = new_array(struct file_struct *, flist->used)))
                   1931:                                out_of_memory("send_extra_file_list");
                   1932:                        memcpy(flist->sorted, flist->files,
                   1933:                               flist->used * sizeof (struct file_struct*));
                   1934:                } else
                   1935:                        flist->sorted = flist->files;
                   1936: 
                   1937:                flist_sort_and_clean(flist, 0);
                   1938: 
                   1939:                add_dirs_to_tree(send_dir_ndx, flist, dir_count - dstart);
                   1940:                flist_done_allocating(flist);
                   1941: 
                   1942:                file_total += flist->used;
                   1943:                stats.flist_size += stats.total_written - start_write;
                   1944:                stats.num_files += flist->used;
                   1945:                if (verbose > 3)
                   1946:                        output_flist(flist);
                   1947: 
                   1948:                if (DIR_FIRST_CHILD(dp) >= 0) {
                   1949:                        send_dir_ndx = DIR_FIRST_CHILD(dp);
                   1950:                        send_dir_depth++;
                   1951:                } else {
                   1952:                        while (DIR_NEXT_SIBLING(dp) < 0) {
                   1953:                                if ((send_dir_ndx = DIR_PARENT(dp)) < 0) {
                   1954:                                        write_ndx(f, NDX_FLIST_EOF);
                   1955:                                        flist_eof = 1;
                   1956:                                        change_local_filter_dir(NULL, 0, 0);
                   1957:                                        goto finish;
                   1958:                                }
                   1959:                                send_dir_depth--;
                   1960:                                file = dir_flist->sorted[send_dir_ndx];
                   1961:                                dp = F_DIR_NODE_P(file);
                   1962:                        }
                   1963:                        send_dir_ndx = DIR_NEXT_SIBLING(dp);
                   1964:                }
                   1965:        }
                   1966: 
                   1967:   finish:
                   1968:        if (io_error != save_io_error && !ignore_errors)
                   1969:                send_msg_int(MSG_IO_ERROR, io_error);
                   1970: }
                   1971: 
                   1972: struct file_list *send_file_list(int f, int argc, char *argv[])
                   1973: {
                   1974:        static const char *lastdir;
                   1975:        static int lastdir_len = -1;
                   1976:        int len, dirlen;
                   1977:        STRUCT_STAT st;
                   1978:        char *p, *dir;
                   1979:        struct file_list *flist;
                   1980:        struct timeval start_tv, end_tv;
                   1981:        int64 start_write;
                   1982:        int use_ff_fd = 0;
                   1983:        int disable_buffering;
                   1984:        int flags = recurse ? FLAG_CONTENT_DIR : 0;
                   1985:        int reading_remotely = filesfrom_host != NULL;
                   1986:        int rl_flags = (reading_remotely ? 0 : RL_DUMP_COMMENTS)
                   1987: #ifdef ICONV_OPTION
                   1988:                     | (filesfrom_convert ? RL_CONVERT : 0)
                   1989: #endif
                   1990:                     | (eol_nulls || reading_remotely ? RL_EOL_NULLS : 0);
                   1991:        int implied_dot_dir = 0;
                   1992: 
                   1993:        rprintf(FLOG, "building file list\n");
                   1994:        if (show_filelist_p())
                   1995:                start_filelist_progress("building file list");
                   1996:        else if (inc_recurse && verbose && !am_server)
                   1997:                rprintf(FCLIENT, "sending incremental file list\n");
                   1998: 
                   1999:        start_write = stats.total_written;
                   2000:        gettimeofday(&start_tv, NULL);
                   2001: 
                   2002:        if (relative_paths && protocol_version >= 30)
                   2003:                implied_dirs = 1; /* We send flagged implied dirs */
                   2004: 
                   2005: #ifdef SUPPORT_HARD_LINKS
                   2006:        if (preserve_hard_links && protocol_version >= 30 && !cur_flist)
                   2007:                init_hard_links();
                   2008: #endif
                   2009: 
                   2010:        flist = cur_flist = flist_new(0, "send_file_list");
                   2011:        if (inc_recurse) {
                   2012:                dir_flist = flist_new(FLIST_TEMP, "send_file_list");
                   2013:                flags |= FLAG_DIVERT_DIRS;
                   2014:        } else
                   2015:                dir_flist = cur_flist;
                   2016: 
                   2017:        disable_buffering = io_start_buffering_out(f);
                   2018:        if (filesfrom_fd >= 0) {
                   2019:                if (argv[0] && !change_dir(argv[0], CD_NORMAL)) {
                   2020:                        rsyserr(FERROR_XFER, errno, "change_dir %s failed",
                   2021:                                full_fname(argv[0]));
                   2022:                        exit_cleanup(RERR_FILESELECT);
                   2023:                }
                   2024:                use_ff_fd = 1;
                   2025:        }
                   2026: 
                   2027:        if (!orig_dir)
                   2028:                orig_dir = strdup(curr_dir);
                   2029: 
                   2030:        while (1) {
                   2031:                char fbuf[MAXPATHLEN], *fn, name_type;
                   2032: 
                   2033:                if (use_ff_fd) {
                   2034:                        if (read_line(filesfrom_fd, fbuf, sizeof fbuf, rl_flags) == 0)
                   2035:                                break;
                   2036:                        sanitize_path(fbuf, fbuf, "", 0, SP_KEEP_DOT_DIRS);
                   2037:                } else {
                   2038:                        if (argc-- == 0)
                   2039:                                break;
                   2040:                        strlcpy(fbuf, *argv++, MAXPATHLEN);
                   2041:                        if (sanitize_paths)
                   2042:                                sanitize_path(fbuf, fbuf, "", 0, SP_KEEP_DOT_DIRS);
                   2043:                }
                   2044: 
                   2045:                len = strlen(fbuf);
                   2046:                if (relative_paths) {
                   2047:                        /* We clean up fbuf below. */
                   2048:                        name_type = NORMAL_NAME;
                   2049:                } else if (!len || fbuf[len - 1] == '/') {
                   2050:                        if (len == 2 && fbuf[0] == '.') {
                   2051:                                /* Turn "./" into just "." rather than "./." */
                   2052:                                fbuf[--len] = '\0';
                   2053:                        } else {
                   2054:                                if (len + 1 >= MAXPATHLEN)
                   2055:                                        overflow_exit("send_file_list");
                   2056:                                fbuf[len++] = '.';
                   2057:                                fbuf[len] = '\0';
                   2058:                        }
                   2059:                        name_type = DOTDIR_NAME;
                   2060:                } else if (len > 1 && fbuf[len-1] == '.' && fbuf[len-2] == '.'
                   2061:                    && (len == 2 || fbuf[len-3] == '/')) {
                   2062:                        if (len + 2 >= MAXPATHLEN)
                   2063:                                overflow_exit("send_file_list");
                   2064:                        fbuf[len++] = '/';
                   2065:                        fbuf[len++] = '.';
                   2066:                        fbuf[len] = '\0';
                   2067:                        name_type = DOTDIR_NAME;
                   2068:                } else if (fbuf[len-1] == '.' && (len == 1 || fbuf[len-2] == '/'))
                   2069:                        name_type = DOTDIR_NAME;
                   2070:                else
                   2071:                        name_type = NORMAL_NAME;
                   2072: 
                   2073:                dir = NULL;
                   2074: 
                   2075:                if (!relative_paths) {
                   2076:                        p = strrchr(fbuf, '/');
                   2077:                        if (p) {
                   2078:                                *p = '\0';
                   2079:                                if (p == fbuf)
                   2080:                                        dir = "/";
                   2081:                                else
                   2082:                                        dir = fbuf;
                   2083:                                len -= p - fbuf + 1;
                   2084:                                fn = p + 1;
                   2085:                        } else
                   2086:                                fn = fbuf;
                   2087:                } else {
                   2088:                        if ((p = strstr(fbuf, "/./")) != NULL) {
                   2089:                                *p = '\0';
                   2090:                                if (p == fbuf)
                   2091:                                        dir = "/";
                   2092:                                else {
                   2093:                                        dir = fbuf;
                   2094:                                        clean_fname(dir, 0);
                   2095:                                }
                   2096:                                fn = p + 3;
                   2097:                                while (*fn == '/')
                   2098:                                        fn++;
                   2099:                                if (!*fn)
                   2100:                                        *--fn = '\0'; /* ensure room for '.' */
                   2101:                        } else
                   2102:                                fn = fbuf;
                   2103:                        /* A leading ./ can be used in relative mode to affect
                   2104:                         * the dest dir without its name being in the path. */
                   2105:                        if (*fn == '.' && fn[1] == '/' && fn[2] && !implied_dot_dir)
                   2106:                                implied_dot_dir = -1;
                   2107:                        len = clean_fname(fn, CFN_KEEP_TRAILING_SLASH
                   2108:                                            | CFN_DROP_TRAILING_DOT_DIR);
                   2109:                        if (len == 1) {
                   2110:                                if (fn[0] == '/') {
                   2111:                                        fn = "/.";
                   2112:                                        len = 2;
                   2113:                                        name_type = DOTDIR_NAME;
                   2114:                                } else if (fn[0] == '.')
                   2115:                                        name_type = DOTDIR_NAME;
                   2116:                        } else if (fn[len-1] == '/') {
                   2117:                                fn[--len] = '\0';
                   2118:                                if (len == 1 && *fn == '.')
                   2119:                                        name_type = DOTDIR_NAME;
                   2120:                                else
                   2121:                                        name_type = SLASH_ENDING_NAME;
                   2122:                        }
                   2123:                        /* Reject a ".." dir in the active part of the path. */
                   2124:                        for (p = fn; (p = strstr(p, "..")) != NULL; p += 2) {
                   2125:                                if ((p[2] == '/' || p[2] == '\0')
                   2126:                                 && (p == fn || p[-1] == '/')) {
                   2127:                                        rprintf(FERROR,
                   2128:                                            "found \"..\" dir in relative path: %s\n",
                   2129:                                            fn);
                   2130:                                        exit_cleanup(RERR_SYNTAX);
                   2131:                                }
                   2132:                        }
                   2133:                }
                   2134: 
                   2135:                if (!*fn) {
                   2136:                        len = 1;
                   2137:                        fn = ".";
                   2138:                        name_type = DOTDIR_NAME;
                   2139:                }
                   2140: 
                   2141:                dirlen = dir ? strlen(dir) : 0;
                   2142:                if (dirlen != lastdir_len || memcmp(lastdir, dir, dirlen) != 0) {
                   2143:                        if (!change_pathname(NULL, dir, -dirlen))
                   2144:                                goto bad_path;
                   2145:                        lastdir = pathname;
                   2146:                        lastdir_len = pathname_len;
                   2147:                } else if (!change_pathname(NULL, lastdir, lastdir_len)) {
                   2148:                    bad_path:
                   2149:                        if (implied_dot_dir < 0)
                   2150:                                implied_dot_dir = 0;
                   2151:                        continue;
                   2152:                }
                   2153: 
                   2154:                if (implied_dot_dir < 0) {
                   2155:                        implied_dot_dir = 1;
                   2156:                        send_file_name(f, flist, ".", NULL, (flags | FLAG_IMPLIED_DIR) & ~FLAG_CONTENT_DIR, ALL_FILTERS);
                   2157:                }
                   2158: 
                   2159:                if (fn != fbuf)
                   2160:                        memmove(fbuf, fn, len + 1);
                   2161: 
                   2162:                if (link_stat(fbuf, &st, copy_dirlinks || name_type != NORMAL_NAME) != 0
                   2163:                 || (name_type != DOTDIR_NAME && is_daemon_excluded(fbuf, S_ISDIR(st.st_mode)))
                   2164:                 || (relative_paths && path_is_daemon_excluded(fbuf, 1))) {
                   2165:                        io_error |= IOERR_GENERAL;
                   2166:                        rsyserr(FERROR_XFER, errno, "link_stat %s failed",
                   2167:                                full_fname(fbuf));
                   2168:                        continue;
                   2169:                }
                   2170: 
                   2171:                /* A dot-dir should not be excluded! */
                   2172:                if (name_type != DOTDIR_NAME
                   2173:                 && is_excluded(fbuf, S_ISDIR(st.st_mode) != 0, ALL_FILTERS))
                   2174:                        continue;
                   2175: 
                   2176:                if (S_ISDIR(st.st_mode) && !xfer_dirs) {
                   2177:                        rprintf(FINFO, "skipping directory %s\n", fbuf);
                   2178:                        continue;
                   2179:                }
                   2180: 
                   2181:                if (inc_recurse && relative_paths && *fbuf) {
                   2182:                        if ((p = strchr(fbuf+1, '/')) != NULL) {
                   2183:                                if (p - fbuf == 1 && *fbuf == '.') {
                   2184:                                        if ((fn = strchr(p+1, '/')) != NULL)
                   2185:                                                p = fn;
                   2186:                                } else
                   2187:                                        fn = p;
                   2188:                                send_implied_dirs(f, flist, fbuf, fbuf, p, flags, name_type);
                   2189:                                if (fn == p)
                   2190:                                        continue;
                   2191:                        }
                   2192:                } else if (implied_dirs && (p=strrchr(fbuf,'/')) && p != fbuf) {
                   2193:                        /* Send the implied directories at the start of the
                   2194:                         * source spec, so we get their permissions right. */
                   2195:                        send_implied_dirs(f, flist, fbuf, fbuf, p, flags, 0);
                   2196:                }
                   2197: 
                   2198:                if (one_file_system)
                   2199:                        filesystem_dev = st.st_dev;
                   2200: 
                   2201:                if (recurse || (xfer_dirs && name_type != NORMAL_NAME)) {
                   2202:                        struct file_struct *file;
                   2203:                        file = send_file_name(f, flist, fbuf, &st,
                   2204:                                              FLAG_TOP_DIR | FLAG_CONTENT_DIR | flags,
                   2205:                                              NO_FILTERS);
                   2206:                        if (!file)
                   2207:                                continue;
                   2208:                        if (inc_recurse) {
                   2209:                                if (name_type == DOTDIR_NAME) {
                   2210:                                        if (send_dir_depth < 0) {
                   2211:                                                send_dir_depth = 0;
                   2212:                                                change_local_filter_dir(fbuf, len, send_dir_depth);
                   2213:                                        }
                   2214:                                        send_directory(f, flist, fbuf, len, flags);
                   2215:                                }
                   2216:                        } else
                   2217:                                send_if_directory(f, flist, file, fbuf, len, flags);
                   2218:                } else
                   2219:                        send_file_name(f, flist, fbuf, &st, flags, NO_FILTERS);
                   2220:        }
                   2221: 
                   2222:        gettimeofday(&end_tv, NULL);
                   2223:        stats.flist_buildtime = (int64)(end_tv.tv_sec - start_tv.tv_sec) * 1000
                   2224:                              + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
                   2225:        if (stats.flist_buildtime == 0)
                   2226:                stats.flist_buildtime = 1;
                   2227:        start_tv = end_tv;
                   2228: 
                   2229:        /* Indicate end of file list */
                   2230:        if (io_error == 0 || ignore_errors)
                   2231:                write_byte(f, 0);
                   2232:        else if (use_safe_inc_flist) {
                   2233:                write_shortint(f, XMIT_EXTENDED_FLAGS|XMIT_IO_ERROR_ENDLIST);
                   2234:                write_varint(f, io_error);
                   2235:        } else {
                   2236:                if (delete_during && inc_recurse)
                   2237:                        fatal_unsafe_io_error();
                   2238:                write_byte(f, 0);
                   2239:        }
                   2240: 
                   2241: #ifdef SUPPORT_HARD_LINKS
                   2242:        if (preserve_hard_links && protocol_version >= 30 && !inc_recurse)
                   2243:                idev_destroy();
                   2244: #endif
                   2245: 
                   2246:        if (show_filelist_p())
                   2247:                finish_filelist_progress(flist);
                   2248: 
                   2249:        gettimeofday(&end_tv, NULL);
                   2250:        stats.flist_xfertime = (int64)(end_tv.tv_sec - start_tv.tv_sec) * 1000
                   2251:                             + (end_tv.tv_usec - start_tv.tv_usec) / 1000;
                   2252: 
                   2253:        /* When converting names, both sides keep an unsorted file-list array
                   2254:         * because the names will differ on the sending and receiving sides
                   2255:         * (both sides will use the unsorted index number for each item). */
                   2256: 
                   2257:        /* Sort the list without removing any duplicates.  This allows the
                   2258:         * receiving side to ask for whatever name it kept.  For incremental
                   2259:         * recursion mode, the sender marks duplicate dirs so that it can
                   2260:         * send them together in a single file-list. */
                   2261:        if (need_unsorted_flist) {
                   2262:                if (!(flist->sorted = new_array(struct file_struct *, flist->used)))
                   2263:                        out_of_memory("send_file_list");
                   2264:                memcpy(flist->sorted, flist->files,
                   2265:                       flist->used * sizeof (struct file_struct*));
                   2266:        } else
                   2267:                flist->sorted = flist->files;
                   2268:        flist_sort_and_clean(flist, 0);
                   2269:        file_total += flist->used;
                   2270: 
                   2271:        if (numeric_ids <= 0 && !inc_recurse)
                   2272:                send_id_list(f);
                   2273: 
                   2274:        set_msg_fd_in(-1);
                   2275: 
                   2276:        /* send the io_error flag */
                   2277:        if (protocol_version < 30)
                   2278:                write_int(f, ignore_errors ? 0 : io_error);
                   2279:        else if (!use_safe_inc_flist && io_error && !ignore_errors)
                   2280:                send_msg_int(MSG_IO_ERROR, io_error);
                   2281: 
                   2282:        if (disable_buffering)
                   2283:                io_end_buffering_out();
                   2284: 
                   2285:        stats.flist_size = stats.total_written - start_write;
                   2286:        stats.num_files = flist->used;
                   2287: 
                   2288:        if (verbose > 3)
                   2289:                output_flist(flist);
                   2290: 
                   2291:        if (verbose > 2)
                   2292:                rprintf(FINFO, "send_file_list done\n");
                   2293: 
                   2294:        if (inc_recurse) {
                   2295:                send_dir_depth = 1;
                   2296:                add_dirs_to_tree(-1, flist, dir_count);
                   2297:                if (!file_total || strcmp(flist->sorted[flist->low]->basename, ".") != 0)
                   2298:                        flist->parent_ndx = -1;
                   2299:                flist_done_allocating(flist);
                   2300:                if (send_dir_ndx < 0) {
                   2301:                        write_ndx(f, NDX_FLIST_EOF);
                   2302:                        flist_eof = 1;
                   2303:                }
                   2304:                else if (file_total == 1) {
                   2305:                        /* If we're creating incremental file-lists and there
                   2306:                         * was just 1 item in the first file-list, send 1 more
                   2307:                         * file-list to check if this is a 1-file xfer. */
                   2308:                        send_extra_file_list(f, 1);
                   2309:                }
                   2310:        }
                   2311: 
                   2312:        return flist;
                   2313: }
                   2314: 
                   2315: struct file_list *recv_file_list(int f)
                   2316: {
                   2317:        struct file_list *flist;
                   2318:        int dstart, flags;
                   2319:        int64 start_read;
                   2320:        int save_verbose = verbose;
                   2321: 
                   2322:        if (!first_flist)
                   2323:                rprintf(FLOG, "receiving file list\n");
                   2324:        if (show_filelist_p())
                   2325:                start_filelist_progress("receiving file list");
                   2326:        else if (inc_recurse && verbose && !am_server && !first_flist)
                   2327:                rprintf(FCLIENT, "receiving incremental file list\n");
                   2328: 
                   2329:        start_read = stats.total_read;
                   2330: 
                   2331: #ifdef SUPPORT_HARD_LINKS
                   2332:        if (preserve_hard_links && !first_flist)
                   2333:                init_hard_links();
                   2334: #endif
                   2335: 
                   2336:        flist = flist_new(0, "recv_file_list");
                   2337: 
                   2338:        if (inc_recurse) {
                   2339:                if (flist->ndx_start == 1)
                   2340:                        dir_flist = flist_new(FLIST_TEMP, "recv_file_list");
                   2341:                dstart = dir_flist->used;
                   2342:        } else {
                   2343:                dir_flist = flist;
                   2344:                dstart = 0;
                   2345:        }
                   2346: 
                   2347:        if (am_server && verbose > 2)
                   2348:                verbose = 2;
                   2349:        while ((flags = read_byte(f)) != 0) {
                   2350:                struct file_struct *file;
                   2351: 
                   2352:                if (protocol_version >= 28 && (flags & XMIT_EXTENDED_FLAGS))
                   2353:                        flags |= read_byte(f) << 8;
                   2354: 
                   2355:                if (flags == (XMIT_EXTENDED_FLAGS|XMIT_IO_ERROR_ENDLIST)) {
                   2356:                        int err;
                   2357:                        if (!use_safe_inc_flist) {
                   2358:                                rprintf(FERROR, "Invalid flist flag: %x\n", flags);
                   2359:                                exit_cleanup(RERR_PROTOCOL);
                   2360:                        }
                   2361:                        err = read_varint(f);
                   2362:                        if (!ignore_errors)
                   2363:                                io_error |= err;
                   2364:                        break;
                   2365:                }
                   2366: 
                   2367:                flist_expand(flist, 1);
                   2368:                file = recv_file_entry(f, flist, flags);
                   2369: 
                   2370:                if (inc_recurse && S_ISDIR(file->mode)) {
                   2371:                        flist_expand(dir_flist, 1);
                   2372:                        dir_flist->files[dir_flist->used++] = file;
                   2373:                }
                   2374: 
                   2375:                flist->files[flist->used++] = file;
                   2376: 
                   2377:                maybe_emit_filelist_progress(flist->used);
                   2378: 
                   2379:                if (verbose > 2) {
                   2380:                        char *name = f_name(file, NULL);
                   2381:                        rprintf(FINFO, "recv_file_name(%s)\n", NS(name));
                   2382:                }
                   2383:        }
                   2384:        file_total += flist->used;
                   2385:        verbose = save_verbose;
                   2386: 
                   2387:        if (verbose > 2)
                   2388:                rprintf(FINFO, "received %d names\n", flist->used);
                   2389: 
                   2390:        if (show_filelist_p())
                   2391:                finish_filelist_progress(flist);
                   2392: 
                   2393:        if (need_unsorted_flist) {
                   2394:                /* Create an extra array of index pointers that we can sort for
                   2395:                 * the generator's use (for wading through the files in sorted
                   2396:                 * order and for calling flist_find()).  We keep the "files"
                   2397:                 * list unsorted for our exchange of index numbers with the
                   2398:                 * other side (since their names may not sort the same). */
                   2399:                if (!(flist->sorted = new_array(struct file_struct *, flist->used)))
                   2400:                        out_of_memory("recv_file_list");
                   2401:                memcpy(flist->sorted, flist->files,
                   2402:                       flist->used * sizeof (struct file_struct*));
                   2403:                if (inc_recurse && dir_flist->used > dstart) {
                   2404:                        static int dir_flist_malloced = 0;
                   2405:                        if (dir_flist_malloced < dir_flist->malloced) {
                   2406:                                dir_flist->sorted = realloc_array(dir_flist->sorted,
                   2407:                                                        struct file_struct *,
                   2408:                                                        dir_flist->malloced);
                   2409:                                dir_flist_malloced = dir_flist->malloced;
                   2410:                        }
                   2411:                        memcpy(dir_flist->sorted + dstart, dir_flist->files + dstart,
                   2412:                               (dir_flist->used - dstart) * sizeof (struct file_struct*));
                   2413:                        fsort(dir_flist->sorted + dstart, dir_flist->used - dstart);
                   2414:                }
                   2415:        } else {
                   2416:                flist->sorted = flist->files;
                   2417:                if (inc_recurse && dir_flist->used > dstart) {
                   2418:                        dir_flist->sorted = dir_flist->files;
                   2419:                        fsort(dir_flist->sorted + dstart, dir_flist->used - dstart);
                   2420:                }
                   2421:        }
                   2422: 
                   2423:        if (inc_recurse)
                   2424:                flist_done_allocating(flist);
                   2425:        else if (f >= 0)
                   2426:                recv_id_list(f, flist);
                   2427: 
                   2428:        flist_sort_and_clean(flist, relative_paths);
                   2429: 
                   2430:        if (protocol_version < 30) {
                   2431:                /* Recv the io_error flag */
                   2432:                if (ignore_errors)
                   2433:                        read_int(f);
                   2434:                else
                   2435:                        io_error |= read_int(f);
                   2436:        } else if (inc_recurse && flist->ndx_start == 1) {
                   2437:                if (!file_total || strcmp(flist->sorted[flist->low]->basename, ".") != 0)
                   2438:                        flist->parent_ndx = -1;
                   2439:        }
                   2440: 
                   2441:        if (verbose > 3)
                   2442:                output_flist(flist);
                   2443: 
                   2444:        if (verbose > 2)
                   2445:                rprintf(FINFO, "recv_file_list done\n");
                   2446: 
                   2447:        stats.flist_size += stats.total_read - start_read;
                   2448:        stats.num_files += flist->used;
                   2449: 
                   2450:        return flist;
                   2451: }
                   2452: 
                   2453: /* This is only used once by the receiver if the very first file-list
                   2454:  * has exactly one item in it. */
                   2455: void recv_additional_file_list(int f)
                   2456: {
                   2457:        struct file_list *flist;
                   2458:        int ndx = read_ndx(f);
                   2459:        if (ndx == NDX_FLIST_EOF) {
                   2460:                flist_eof = 1;
                   2461:                change_local_filter_dir(NULL, 0, 0);
                   2462:        } else {
                   2463:                ndx = NDX_FLIST_OFFSET - ndx;
                   2464:                if (ndx < 0 || ndx >= dir_flist->used) {
                   2465:                        ndx = NDX_FLIST_OFFSET - ndx;
                   2466:                        rprintf(FERROR,
                   2467:                                "[%s] Invalid dir index: %d (%d - %d)\n",
                   2468:                                who_am_i(), ndx, NDX_FLIST_OFFSET,
                   2469:                                NDX_FLIST_OFFSET - dir_flist->used + 1);
                   2470:                        exit_cleanup(RERR_PROTOCOL);
                   2471:                }
                   2472:                if (verbose > 3) {
                   2473:                        rprintf(FINFO, "[%s] receiving flist for dir %d\n",
                   2474:                                who_am_i(), ndx);
                   2475:                }
                   2476:                flist = recv_file_list(f);
                   2477:                flist->parent_ndx = ndx;
                   2478:        }
                   2479: }
                   2480: 
                   2481: /* Search for an identically-named item in the file list.  Note that the
                   2482:  * items must agree in their directory-ness, or no match is returned. */
                   2483: int flist_find(struct file_list *flist, struct file_struct *f)
                   2484: {
                   2485:        int low = flist->low, high = flist->high;
                   2486:        int diff, mid, mid_up;
                   2487: 
                   2488:        while (low <= high) {
                   2489:                mid = (low + high) / 2;
                   2490:                if (F_IS_ACTIVE(flist->sorted[mid]))
                   2491:                        mid_up = mid;
                   2492:                else {
                   2493:                        /* Scan for the next non-empty entry using the cached
                   2494:                         * distance values.  If the value isn't fully up-to-
                   2495:                         * date, update it. */
                   2496:                        mid_up = mid + F_DEPTH(flist->sorted[mid]);
                   2497:                        if (!F_IS_ACTIVE(flist->sorted[mid_up])) {
                   2498:                                do {
                   2499:                                    mid_up += F_DEPTH(flist->sorted[mid_up]);
                   2500:                                } while (!F_IS_ACTIVE(flist->sorted[mid_up]));
                   2501:                                F_DEPTH(flist->sorted[mid]) = mid_up - mid;
                   2502:                        }
                   2503:                        if (mid_up > high) {
                   2504:                                /* If there's nothing left above us, set high to
                   2505:                                 * a non-empty entry below us and continue. */
                   2506:                                high = mid - (int)flist->sorted[mid]->len32;
                   2507:                                if (!F_IS_ACTIVE(flist->sorted[high])) {
                   2508:                                        do {
                   2509:                                            high -= (int)flist->sorted[high]->len32;
                   2510:                                        } while (!F_IS_ACTIVE(flist->sorted[high]));
                   2511:                                        flist->sorted[mid]->len32 = mid - high;
                   2512:                                }
                   2513:                                continue;
                   2514:                        }
                   2515:                }
                   2516:                diff = f_name_cmp(flist->sorted[mid_up], f);
                   2517:                if (diff == 0) {
                   2518:                        if (protocol_version < 29
                   2519:                            && S_ISDIR(flist->sorted[mid_up]->mode)
                   2520:                            != S_ISDIR(f->mode))
                   2521:                                return -1;
                   2522:                        return mid_up;
                   2523:                }
                   2524:                if (diff < 0)
                   2525:                        low = mid_up + 1;
                   2526:                else
                   2527:                        high = mid - 1;
                   2528:        }
                   2529:        return -1;
                   2530: }
                   2531: 
                   2532: /* Search for an identically-named item in the file list.  Differs from
                   2533:  * flist_find in that an item that agrees with "f" in directory-ness is
                   2534:  * preferred but one that does not is still found. */
                   2535: int flist_find_ignore_dirness(struct file_list *flist, struct file_struct *f)
                   2536: {
                   2537:        mode_t save_mode;
                   2538:        int ndx;
                   2539: 
                   2540:        /* First look for an item that agrees in directory-ness. */
                   2541:        ndx = flist_find(flist, f);
                   2542:        if (ndx >= 0)
                   2543:                return ndx;
                   2544: 
                   2545:        /* Temporarily flip f->mode to look for an item of opposite
                   2546:         * directory-ness. */
                   2547:        save_mode = f->mode;
                   2548:        f->mode = S_ISDIR(f->mode) ? S_IFREG : S_IFDIR;
                   2549:        ndx = flist_find(flist, f);
                   2550:        f->mode = save_mode;
                   2551:        return ndx;
                   2552: }
                   2553: 
                   2554: /*
                   2555:  * Free up any resources a file_struct has allocated
                   2556:  * and clear the file.
                   2557:  */
                   2558: void clear_file(struct file_struct *file)
                   2559: {
                   2560:        /* The +1 zeros out the first char of the basename. */
                   2561:        memset(file, 0, FILE_STRUCT_LEN + 1);
                   2562:        /* In an empty entry, F_DEPTH() is an offset to the next non-empty
                   2563:         * entry.  Likewise for len32 in the opposite direction.  We assume
                   2564:         * that we're alone for now since flist_find() will adjust the counts
                   2565:         * it runs into that aren't up-to-date. */
                   2566:        file->len32 = F_DEPTH(file) = 1;
                   2567: }
                   2568: 
                   2569: /* Allocate a new file list. */
                   2570: struct file_list *flist_new(int flags, char *msg)
                   2571: {
                   2572:        struct file_list *flist;
                   2573: 
                   2574:        if (!(flist = new0(struct file_list)))
                   2575:                out_of_memory(msg);
                   2576: 
                   2577:        if (flags & FLIST_TEMP) {
                   2578:                if (!(flist->file_pool = pool_create(SMALL_EXTENT, 0,
                   2579:                                                out_of_memory, POOL_INTERN)))
                   2580:                        out_of_memory(msg);
                   2581:        } else {
                   2582:                /* This is a doubly linked list with prev looping back to
                   2583:                 * the end of the list, but the last next pointer is NULL. */
                   2584:                if (!first_flist) {
                   2585:                        flist->file_pool = pool_create(NORMAL_EXTENT, 0,
                   2586:                                                out_of_memory, POOL_INTERN);
                   2587:                        if (!flist->file_pool)
                   2588:                                out_of_memory(msg);
                   2589: 
                   2590:                        flist->ndx_start = flist->flist_num = inc_recurse ? 1 : 0;
                   2591: 
                   2592:                        first_flist = cur_flist = flist->prev = flist;
                   2593:                } else {
                   2594:                        struct file_list *prev = first_flist->prev;
                   2595: 
                   2596:                        flist->file_pool = first_flist->file_pool;
                   2597: 
                   2598:                        flist->ndx_start = prev->ndx_start + prev->used + 1;
                   2599:                        flist->flist_num = prev->flist_num + 1;
                   2600: 
                   2601:                        flist->prev = prev;
                   2602:                        prev->next = first_flist->prev = flist;
                   2603:                }
                   2604:                flist->pool_boundary = pool_boundary(flist->file_pool, 0);
                   2605:                flist_cnt++;
                   2606:        }
                   2607: 
                   2608:        return flist;
                   2609: }
                   2610: 
                   2611: /* Free up all elements in a flist. */
                   2612: void flist_free(struct file_list *flist)
                   2613: {
                   2614:        if (!flist->prev) {
                   2615:                /* Was FLIST_TEMP dir-list. */
                   2616:        } else if (flist == flist->prev) {
                   2617:                first_flist = cur_flist = NULL;
                   2618:                file_total = 0;
                   2619:                flist_cnt = 0;
                   2620:        } else {
                   2621:                if (flist == cur_flist)
                   2622:                        cur_flist = flist->next;
                   2623:                if (flist == first_flist)
                   2624:                        first_flist = first_flist->next;
                   2625:                else {
                   2626:                        flist->prev->next = flist->next;
                   2627:                        if (!flist->next)
                   2628:                                flist->next = first_flist;
                   2629:                }
                   2630:                flist->next->prev = flist->prev;
                   2631:                file_total -= flist->used;
                   2632:                flist_cnt--;
                   2633:        }
                   2634: 
                   2635:        if (!flist->prev || !flist_cnt)
                   2636:                pool_destroy(flist->file_pool);
                   2637:        else
                   2638:                pool_free_old(flist->file_pool, flist->pool_boundary);
                   2639: 
                   2640:        if (flist->sorted && flist->sorted != flist->files)
                   2641:                free(flist->sorted);
                   2642:        free(flist->files);
                   2643:        free(flist);
                   2644: }
                   2645: 
                   2646: /* This routine ensures we don't have any duplicate names in our file list.
                   2647:  * duplicate names can cause corruption because of the pipelining. */
                   2648: static void flist_sort_and_clean(struct file_list *flist, int strip_root)
                   2649: {
                   2650:        char fbuf[MAXPATHLEN];
                   2651:        int i, prev_i;
                   2652: 
                   2653:        if (!flist)
                   2654:                return;
                   2655:        if (flist->used == 0) {
                   2656:                flist->high = -1;
                   2657:                flist->low = 0;
                   2658:                return;
                   2659:        }
                   2660: 
                   2661:        fsort(flist->sorted, flist->used);
                   2662: 
                   2663:        if (!am_sender || inc_recurse) {
                   2664:                for (i = prev_i = 0; i < flist->used; i++) {
                   2665:                        if (F_IS_ACTIVE(flist->sorted[i])) {
                   2666:                                prev_i = i;
                   2667:                                break;
                   2668:                        }
                   2669:                }
                   2670:                flist->low = prev_i;
                   2671:        } else {
                   2672:                i = prev_i = flist->used - 1;
                   2673:                flist->low = 0;
                   2674:        }
                   2675: 
                   2676:        while (++i < flist->used) {
                   2677:                int j;
                   2678:                struct file_struct *file = flist->sorted[i];
                   2679: 
                   2680:                if (!F_IS_ACTIVE(file))
                   2681:                        continue;
                   2682:                if (f_name_cmp(file, flist->sorted[prev_i]) == 0)
                   2683:                        j = prev_i;
                   2684:                else if (protocol_version >= 29 && S_ISDIR(file->mode)) {
                   2685:                        int save_mode = file->mode;
                   2686:                        /* Make sure that this directory doesn't duplicate a
                   2687:                         * non-directory earlier in the list. */
                   2688:                        flist->high = prev_i;
                   2689:                        file->mode = S_IFREG;
                   2690:                        j = flist_find(flist, file);
                   2691:                        file->mode = save_mode;
                   2692:                } else
                   2693:                        j = -1;
                   2694:                if (j >= 0) {
                   2695:                        int keep, drop;
                   2696:                        /* If one is a dir and the other is not, we want to
                   2697:                         * keep the dir because it might have contents in the
                   2698:                         * list.  Otherwise keep the first one. */
                   2699:                        if (S_ISDIR(file->mode)) {
                   2700:                                struct file_struct *fp = flist->sorted[j];
                   2701:                                if (!S_ISDIR(fp->mode))
                   2702:                                        keep = i, drop = j;
                   2703:                                else {
                   2704:                                        if (am_sender)
                   2705:                                                file->flags |= FLAG_DUPLICATE;
                   2706:                                        else { /* Make sure we merge our vital flags. */
                   2707:                                                fp->flags |= file->flags & (FLAG_TOP_DIR|FLAG_CONTENT_DIR);
                   2708:                                                fp->flags &= file->flags | ~FLAG_IMPLIED_DIR;
                   2709:                                        }
                   2710:                                        keep = j, drop = i;
                   2711:                                }
                   2712:                        } else
                   2713:                                keep = j, drop = i;
                   2714: 
                   2715:                        if (!am_sender) {
                   2716:                                if (verbose > 1) {
                   2717:                                        rprintf(FINFO,
                   2718:                                            "removing duplicate name %s from file list (%d)\n",
                   2719:                                            f_name(file, fbuf), drop + flist->ndx_start);
                   2720:                                }
                   2721:                                clear_file(flist->sorted[drop]);
                   2722:                        }
                   2723: 
                   2724:                        if (keep == i) {
                   2725:                                if (flist->low == drop) {
                   2726:                                        for (j = drop + 1;
                   2727:                                             j < i && !F_IS_ACTIVE(flist->sorted[j]);
                   2728:                                             j++) {}
                   2729:                                        flist->low = j;
                   2730:                                }
                   2731:                                prev_i = i;
                   2732:                        }
                   2733:                } else
                   2734:                        prev_i = i;
                   2735:        }
                   2736:        flist->high = prev_i;
                   2737: 
                   2738:        if (strip_root) {
                   2739:                /* We need to strip off the leading slashes for relative
                   2740:                 * paths, but this must be done _after_ the sorting phase. */
                   2741:                for (i = flist->low; i <= flist->high; i++) {
                   2742:                        struct file_struct *file = flist->sorted[i];
                   2743: 
                   2744:                        if (!file->dirname)
                   2745:                                continue;
                   2746:                        while (*file->dirname == '/')
                   2747:                                file->dirname++;
                   2748:                        if (!*file->dirname)
                   2749:                                file->dirname = NULL;
                   2750:                }
                   2751:        }
                   2752: 
                   2753:        if (prune_empty_dirs && !am_sender) {
                   2754:                int j, prev_depth = 0;
                   2755: 
                   2756:                prev_i = 0; /* It's OK that this isn't really true. */
                   2757: 
                   2758:                for (i = flist->low; i <= flist->high; i++) {
                   2759:                        struct file_struct *fp, *file = flist->sorted[i];
                   2760: 
                   2761:                        /* This temporarily abuses the F_DEPTH() value for a
                   2762:                         * directory that is in a chain that might get pruned.
                   2763:                         * We restore the old value if it gets a reprieve. */
                   2764:                        if (S_ISDIR(file->mode) && F_DEPTH(file)) {
                   2765:                                /* Dump empty dirs when coming back down. */
                   2766:                                for (j = prev_depth; j >= F_DEPTH(file); j--) {
                   2767:                                        fp = flist->sorted[prev_i];
                   2768:                                        if (F_DEPTH(fp) >= 0)
                   2769:                                                break;
                   2770:                                        prev_i = -F_DEPTH(fp)-1;
                   2771:                                        clear_file(fp);
                   2772:                                }
                   2773:                                prev_depth = F_DEPTH(file);
                   2774:                                if (is_excluded(f_name(file, fbuf), 1,
                   2775:                                                       ALL_FILTERS)) {
                   2776:                                        /* Keep dirs through this dir. */
                   2777:                                        for (j = prev_depth-1; ; j--) {
                   2778:                                                fp = flist->sorted[prev_i];
                   2779:                                                if (F_DEPTH(fp) >= 0)
                   2780:                                                        break;
                   2781:                                                prev_i = -F_DEPTH(fp)-1;
                   2782:                                                F_DEPTH(fp) = j;
                   2783:                                        }
                   2784:                                } else
                   2785:                                        F_DEPTH(file) = -prev_i-1;
                   2786:                                prev_i = i;
                   2787:                        } else {
                   2788:                                /* Keep dirs through this non-dir. */
                   2789:                                for (j = prev_depth; ; j--) {
                   2790:                                        fp = flist->sorted[prev_i];
                   2791:                                        if (F_DEPTH(fp) >= 0)
                   2792:                                                break;
                   2793:                                        prev_i = -F_DEPTH(fp)-1;
                   2794:                                        F_DEPTH(fp) = j;
                   2795:                                }
                   2796:                        }
                   2797:                }
                   2798:                /* Dump all remaining empty dirs. */
                   2799:                while (1) {
                   2800:                        struct file_struct *fp = flist->sorted[prev_i];
                   2801:                        if (F_DEPTH(fp) >= 0)
                   2802:                                break;
                   2803:                        prev_i = -F_DEPTH(fp)-1;
                   2804:                        clear_file(fp);
                   2805:                }
                   2806: 
                   2807:                for (i = flist->low; i <= flist->high; i++) {
                   2808:                        if (F_IS_ACTIVE(flist->sorted[i]))
                   2809:                                break;
                   2810:                }
                   2811:                flist->low = i;
                   2812:                for (i = flist->high; i >= flist->low; i--) {
                   2813:                        if (F_IS_ACTIVE(flist->sorted[i]))
                   2814:                                break;
                   2815:                }
                   2816:                flist->high = i;
                   2817:        }
                   2818: }
                   2819: 
                   2820: static void output_flist(struct file_list *flist)
                   2821: {
                   2822:        char uidbuf[16], gidbuf[16], depthbuf[16];
                   2823:        struct file_struct *file;
                   2824:        const char *root, *dir, *slash, *name, *trail;
                   2825:        const char *who = who_am_i();
                   2826:        int i;
                   2827: 
                   2828:        rprintf(FINFO, "[%s] flist start=%d, used=%d, low=%d, high=%d\n",
                   2829:                who, flist->ndx_start, flist->used, flist->low, flist->high);
                   2830:        for (i = 0; i < flist->used; i++) {
                   2831:                file = flist->files[i];
                   2832:                if ((am_root || am_sender) && uid_ndx) {
                   2833:                        snprintf(uidbuf, sizeof uidbuf, " uid=%u",
                   2834:                                 F_OWNER(file));
                   2835:                } else
                   2836:                        *uidbuf = '\0';
                   2837:                if (gid_ndx) {
                   2838:                        static char parens[] = "(\0)\0\0\0";
                   2839:                        char *pp = parens + (file->flags & FLAG_SKIP_GROUP ? 0 : 3);
                   2840:                        snprintf(gidbuf, sizeof gidbuf, " gid=%s%u%s",
                   2841:                                 pp, F_GROUP(file), pp + 2);
                   2842:                } else
                   2843:                        *gidbuf = '\0';
                   2844:                if (!am_sender)
                   2845:                        snprintf(depthbuf, sizeof depthbuf, "%d", F_DEPTH(file));
                   2846:                if (F_IS_ACTIVE(file)) {
                   2847:                        root = am_sender ? NS(F_PATHNAME(file)) : depthbuf;
                   2848:                        if ((dir = file->dirname) == NULL)
                   2849:                                dir = slash = "";
                   2850:                        else
                   2851:                                slash = "/";
                   2852:                        name = file->basename;
                   2853:                        trail = S_ISDIR(file->mode) ? "/" : "";
                   2854:                } else
                   2855:                        root = dir = slash = name = trail = "";
                   2856:                rprintf(FINFO,
                   2857:                        "[%s] i=%d %s %s%s%s%s mode=0%o len=%.0f%s%s flags=%x\n",
                   2858:                        who, i + flist->ndx_start,
                   2859:                        root, dir, slash, name, trail,
                   2860:                        (int)file->mode, (double)F_LENGTH(file),
                   2861:                        uidbuf, gidbuf, file->flags);
                   2862:        }
                   2863: }
                   2864: 
                   2865: enum fnc_state { s_DIR, s_SLASH, s_BASE, s_TRAILING };
                   2866: enum fnc_type { t_PATH, t_ITEM };
                   2867: 
                   2868: static int found_prefix;
                   2869: 
                   2870: /* Compare the names of two file_struct entities, similar to how strcmp()
                   2871:  * would do if it were operating on the joined strings.
                   2872:  *
                   2873:  * Some differences beginning with protocol_version 29: (1) directory names
                   2874:  * are compared with an assumed trailing slash so that they compare in a
                   2875:  * way that would cause them to sort immediately prior to any content they
                   2876:  * may have; (2) a directory of any name compares after a non-directory of
                   2877:  * any name at the same depth; (3) a directory with name "." compares prior
                   2878:  * to anything else.  These changes mean that a directory and a non-dir
                   2879:  * with the same name will not compare as equal (protocol_version >= 29).
                   2880:  *
                   2881:  * The dirname component can be an empty string, but the basename component
                   2882:  * cannot (and never is in the current codebase).  The basename component
                   2883:  * may be NULL (for a removed item), in which case it is considered to be
                   2884:  * after any existing item. */
                   2885: int f_name_cmp(const struct file_struct *f1, const struct file_struct *f2)
                   2886: {
                   2887:        int dif;
                   2888:        const uchar *c1, *c2;
                   2889:        enum fnc_state state1, state2;
                   2890:        enum fnc_type type1, type2;
                   2891:        enum fnc_type t_path = protocol_version >= 29 ? t_PATH : t_ITEM;
                   2892: 
                   2893:        if (!f1 || !F_IS_ACTIVE(f1)) {
                   2894:                if (!f2 || !F_IS_ACTIVE(f2))
                   2895:                        return 0;
                   2896:                return -1;
                   2897:        }
                   2898:        if (!f2 || !F_IS_ACTIVE(f2))
                   2899:                return 1;
                   2900: 
                   2901:        c1 = (uchar*)f1->dirname;
                   2902:        c2 = (uchar*)f2->dirname;
                   2903:        if (c1 == c2)
                   2904:                c1 = c2 = NULL;
                   2905:        if (!c1) {
                   2906:                type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
                   2907:                c1 = (const uchar*)f1->basename;
                   2908:                if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
                   2909:                        type1 = t_ITEM;
                   2910:                        state1 = s_TRAILING;
                   2911:                        c1 = (uchar*)"";
                   2912:                } else
                   2913:                        state1 = s_BASE;
                   2914:        } else {
                   2915:                type1 = t_path;
                   2916:                state1 = s_DIR;
                   2917:        }
                   2918:        if (!c2) {
                   2919:                type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
                   2920:                c2 = (const uchar*)f2->basename;
                   2921:                if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
                   2922:                        type2 = t_ITEM;
                   2923:                        state2 = s_TRAILING;
                   2924:                        c2 = (uchar*)"";
                   2925:                } else
                   2926:                        state2 = s_BASE;
                   2927:        } else {
                   2928:                type2 = t_path;
                   2929:                state2 = s_DIR;
                   2930:        }
                   2931: 
                   2932:        if (type1 != type2)
                   2933:                return type1 == t_PATH ? 1 : -1;
                   2934: 
                   2935:        do {
                   2936:                if (!*c1) {
                   2937:                        switch (state1) {
                   2938:                        case s_DIR:
                   2939:                                state1 = s_SLASH;
                   2940:                                c1 = (uchar*)"/";
                   2941:                                break;
                   2942:                        case s_SLASH:
                   2943:                                type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
                   2944:                                c1 = (const uchar*)f1->basename;
                   2945:                                if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
                   2946:                                        type1 = t_ITEM;
                   2947:                                        state1 = s_TRAILING;
                   2948:                                        c1 = (uchar*)"";
                   2949:                                } else
                   2950:                                        state1 = s_BASE;
                   2951:                                break;
                   2952:                        case s_BASE:
                   2953:                                state1 = s_TRAILING;
                   2954:                                if (type1 == t_PATH) {
                   2955:                                        c1 = (uchar*)"/";
                   2956:                                        break;
                   2957:                                }
                   2958:                                /* FALL THROUGH */
                   2959:                        case s_TRAILING:
                   2960:                                type1 = t_ITEM;
                   2961:                                break;
                   2962:                        }
                   2963:                        if (*c2 && type1 != type2)
                   2964:                                return type1 == t_PATH ? 1 : -1;
                   2965:                }
                   2966:                if (!*c2) {
                   2967:                        switch (state2) {
                   2968:                        case s_DIR:
                   2969:                                state2 = s_SLASH;
                   2970:                                c2 = (uchar*)"/";
                   2971:                                break;
                   2972:                        case s_SLASH:
                   2973:                                type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
                   2974:                                c2 = (const uchar*)f2->basename;
                   2975:                                if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
                   2976:                                        type2 = t_ITEM;
                   2977:                                        state2 = s_TRAILING;
                   2978:                                        c2 = (uchar*)"";
                   2979:                                } else
                   2980:                                        state2 = s_BASE;
                   2981:                                break;
                   2982:                        case s_BASE:
                   2983:                                state2 = s_TRAILING;
                   2984:                                if (type2 == t_PATH) {
                   2985:                                        c2 = (uchar*)"/";
                   2986:                                        break;
                   2987:                                }
                   2988:                                /* FALL THROUGH */
                   2989:                        case s_TRAILING:
                   2990:                                found_prefix = 1;
                   2991:                                if (!*c1)
                   2992:                                        return 0;
                   2993:                                type2 = t_ITEM;
                   2994:                                break;
                   2995:                        }
                   2996:                        if (type1 != type2)
                   2997:                                return type1 == t_PATH ? 1 : -1;
                   2998:                }
                   2999:        } while ((dif = (int)*c1++ - (int)*c2++) == 0);
                   3000: 
                   3001:        return dif;
                   3002: }
                   3003: 
                   3004: /* Returns 1 if f1's filename has all of f2's filename as a prefix.  This does
                   3005:  * not match if f2's basename is not an exact match of a path element in f1.
                   3006:  * E.g. /path/foo is not a prefix of /path/foobar/baz, but /path/foobar is. */
                   3007: int f_name_has_prefix(const struct file_struct *f1, const struct file_struct *f2)
                   3008: {
                   3009:        found_prefix = 0;
                   3010:        f_name_cmp(f1, f2);
                   3011:        return found_prefix;
                   3012: }
                   3013: 
                   3014: char *f_name_buf(void)
                   3015: {
                   3016:        static char names[5][MAXPATHLEN];
                   3017:        static unsigned int n;
                   3018: 
                   3019:        n = (n + 1) % (sizeof names / sizeof names[0]);
                   3020: 
                   3021:        return names[n];
                   3022: }
                   3023: 
                   3024: /* Return a copy of the full filename of a flist entry, using the indicated
                   3025:  * buffer or one of 5 static buffers if fbuf is NULL.  No size-checking is
                   3026:  * done because we checked the size when creating the file_struct entry.
                   3027:  */
                   3028: char *f_name(const struct file_struct *f, char *fbuf)
                   3029: {
                   3030:        if (!f || !F_IS_ACTIVE(f))
                   3031:                return NULL;
                   3032: 
                   3033:        if (!fbuf)
                   3034:                fbuf = f_name_buf();
                   3035: 
                   3036:        if (f->dirname) {
                   3037:                int len = strlen(f->dirname);
                   3038:                memcpy(fbuf, f->dirname, len);
                   3039:                fbuf[len] = '/';
                   3040:                strlcpy(fbuf + len + 1, f->basename, MAXPATHLEN - (len + 1));
                   3041:        } else
                   3042:                strlcpy(fbuf, f->basename, MAXPATHLEN);
                   3043: 
                   3044:        return fbuf;
                   3045: }
                   3046: 
                   3047: /* Do a non-recursive scan of the named directory, possibly ignoring all
                   3048:  * exclude rules except for the daemon's.  If "dlen" is >=0, it is the length
                   3049:  * of the dirname string, and also indicates that "dirname" is a MAXPATHLEN
                   3050:  * buffer (the functions we call will append names onto the end, but the old
                   3051:  * dir value will be restored on exit). */
                   3052: struct file_list *get_dirlist(char *dirname, int dlen, int flags)
                   3053: {
                   3054:        struct file_list *dirlist;
                   3055:        char dirbuf[MAXPATHLEN];
                   3056:        int save_recurse = recurse;
                   3057:        int save_xfer_dirs = xfer_dirs;
                   3058:        int save_prune_empty_dirs = prune_empty_dirs;
                   3059:        int senddir_fd = flags & GDL_IGNORE_FILTER_RULES ? -2 : -1;
                   3060: 
                   3061:        if (dlen < 0) {
                   3062:                dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
                   3063:                if (dlen >= MAXPATHLEN)
                   3064:                        return NULL;
                   3065:                dirname = dirbuf;
                   3066:        }
                   3067: 
                   3068:        dirlist = flist_new(FLIST_TEMP, "get_dirlist");
                   3069: 
                   3070:        recurse = 0;
                   3071:        xfer_dirs = 1;
                   3072:        send_directory(senddir_fd, dirlist, dirname, dlen, FLAG_CONTENT_DIR);
                   3073:        xfer_dirs = save_xfer_dirs;
                   3074:        recurse = save_recurse;
                   3075:        if (do_progress)
                   3076:                flist_count_offset += dirlist->used;
                   3077: 
                   3078:        prune_empty_dirs = 0;
                   3079:        dirlist->sorted = dirlist->files;
                   3080:        flist_sort_and_clean(dirlist, 0);
                   3081:        prune_empty_dirs = save_prune_empty_dirs;
                   3082: 
                   3083:        if (verbose > 3)
                   3084:                output_flist(dirlist);
                   3085: 
                   3086:        return dirlist;
                   3087: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>