xattr.c

説明を見る。

/* Extended Attribute support for rsync */
/* Copyright (C) 2004 Red Hat, Inc */
/* Written by Jay Fenlason, vaguely based on the ACLs patch */

/* This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "rsync.h"
#include "lib/sysxattr.h"

#ifdef SUPPORT_XATTRS

extern int dry_run;

#define RSYNC_XAL_INITIAL 5
#define RSYNC_XAL_LIST_INITIAL 100

typedef struct {
        size_t name_len;
        char *name;
        size_t datum_len;
        char *datum;
} rsync_xa;

typedef struct {
        size_t count;
        size_t alloc;
        rsync_xa *rxas;
} rsync_xal;

typedef struct {
        size_t count;
        size_t alloc;
        rsync_xal *rxals;
} rsync_xal_list;

static size_t namebuf_len = 0;
static char *namebuf = NULL;

static size_t datumbuf_len = 0;
static char *datumbuf = NULL;

static rsync_xal curr_rsync_xal = { 0, 0, NULL };
static rsync_xal_list rsync_xal_l = { 0, 0, NULL };


/* ------------------------------------------------------------------------- */

/* the below stuff is only used by the receiver */

/* structure to hold index to rsync_xal_l member corresponding to
 * flist->files[i] */

typedef struct {
        const struct file_struct *file;
        int xalidx;
} file_xal_index;

typedef struct {
        size_t count;
        size_t alloc;
        file_xal_index *filexalidxs;
} file_xal_index_list;

static file_xal_index_list fxil = {0, 0, NULL };

/* stuff for redirecting calls to set_acl() from set_perms()
 * for keep_backup() */
static const struct file_struct *backup_orig_file = NULL;
static const char null_string[] = "";
static const char *backup_orig_fname = null_string;
static const char *backup_dest_fname = null_string;
static rsync_xal backup_xal;

/* ------------------------------------------------------------------------- */

static void rsync_xal_free(rsync_xal *x)
{
        size_t i;

        for (i = 0; i < x->count; i++) {
                free(x->rxas[i].name);
                /* free(x->rxas[i].value); */
        }
        x->count = 0;
}

static int rsync_xal_compare_names(const void *x1, const void *x2)
{
        const rsync_xa *xa1;
        const rsync_xa *xa2;

        xa1 = x1;
        xa2 = x2;
        return strcmp(xa1->name, xa2->name);
}

static int rsync_xal_get(const char *fname, rsync_xal *x)
{
        ssize_t name_size;
        ssize_t datum_size;
        ssize_t left;
        char *name;
        size_t len;
        char *ptr;

        if (!namebuf) {
                namebuf_len = 100;
                namebuf = new_array(char, namebuf_len);
                datumbuf_len = 100;
                datumbuf = new_array(char, datumbuf_len);
                if (!namebuf || !datumbuf)
                        out_of_memory("rsync_xal_get");
        }

        name_size = sys_llistxattr(fname, namebuf, namebuf_len);
        if (name_size > (ssize_t)namebuf_len) {
                name_size = -1;
                errno = ERANGE;
        }
        if (name_size < 0) {
                if (errno == ENOTSUP)
                        return -1;
                if (errno == ERANGE) {
                        name_size = sys_llistxattr(fname, NULL, 0);
                        if (name_size < 0) {
                                rprintf(FERROR, "%s: rsync_xal_get: llistxattr: %s\n",
                                        fname, strerror(errno));
                                return -1;
                        }
                        namebuf = realloc_array(namebuf, char, name_size + 1);
                        if (!namebuf)
                                out_of_memory("rsync_xal_get");
                        namebuf_len = name_size;
                        name_size = sys_llistxattr(fname, namebuf, namebuf_len);
                        if (name_size < 0) {
                                rprintf(FERROR,
                                    "%s: rsync_xal_get: re-llistxattr failed: %s\n",
                                    fname, strerror(errno));
                                return -1;
                        }
                } else {
                        rprintf(FERROR,
                            "%s: rsync_xal_get: llistxattr failed: %s\n",
                            fname, strerror(errno));
                        return -1;
                }
        }
        rsync_xal_free(x);
        if (name_size == 0)
                return 0;
        for (left = name_size, name = namebuf; left > 0 ; left -= len, name += len) {
                len = strlen(name) + 1;

                if (x->count >= x->alloc) {
                        size_t new_alloc;
                        rsync_xa *new_rxas;

                        new_alloc = x->alloc < RSYNC_XAL_INITIAL ? RSYNC_XAL_INITIAL : x->alloc * 2;
                        new_rxas = realloc_array(x->rxas, rsync_xa, new_alloc);
                        if (!new_rxas)
                                out_of_memory("rsync_xal_get");
                        x->alloc = new_alloc;
                        x->rxas = new_rxas;
                }
                datum_size = sys_lgetxattr(fname, name, datumbuf, datumbuf_len);
                if (datum_size > (ssize_t)datumbuf_len) {
                        datum_size = -1;
                        errno = ERANGE;
                }
                if (datum_size < 0) {
                        if (errno == ENOTSUP)
                                return -1;
                        if (errno == ERANGE) {
                                datum_size = sys_lgetxattr(fname, name, NULL, 0);
                                if (datum_size < 0) {
                                        rprintf(FERROR,
                                            "%s: rsync_xal_get: lgetxattr %s failed: %s\n",
                                            fname, name, strerror(errno));
                                        return -1;
                                }
                                datumbuf = realloc_array(datumbuf, char, datum_size + 1);
                                if (!datumbuf)
                                        out_of_memory("rsync_xal_get");
                                datumbuf_len = datum_size;
                                datum_size = sys_lgetxattr(fname, name, datumbuf, datumbuf_len);
                                if (datum_size < 0) {
                                        rprintf(FERROR,
                                            "%s: rsync_xal_get: re-lgetxattr of %s failed: %s\n",
                                            name, fname, strerror(errno));
                                        return -1;
                                }
                        } else {
                                rprintf(FERROR,
                                    "%s: rsync_xal_get: lgetxattr %s failed: %s\n",
                                    fname, name, strerror(errno));
                                return -1;
                        }
                }
                ptr = new_array(char, len + datum_size);
                if (!ptr)
                        out_of_memory("rsync_xal_get");
                strcpy(ptr, name);
                if (datum_size)
                        memcpy(ptr + len, datumbuf, datum_size);
                x->rxas[x->count].name_len = len;
                x->rxas[x->count].name = ptr;
                x->rxas[x->count].datum_len = datum_size;
                x->rxas[x->count].datum = ptr + len;
                x->count++;
        }
        if (x->count > 1) {
                qsort(x->rxas, x->count, sizeof (rsync_xa), rsync_xal_compare_names);
        }
        return 0;
}


/* generate the xattr(s) for this flist entry;
 * xattr(s) are either sent or cleaned-up by send_xattr() below */

int make_xattr(UNUSED(const struct file_struct *file), const char *fname)
{
        rsync_xal_get(fname, &curr_rsync_xal);
        return 0; /* TODO:  This needs to return 1 if no xattrs changed! */
}

static ssize_t rsync_xal_find_matching(void)
{
        size_t i;
        size_t j;

        for (i = 0; i < rsync_xal_l.count; i++) {
                /* Wrong number of elements? */
                if (rsync_xal_l.rxals[i].count != curr_rsync_xal.count)
                        continue;
                /* any elements different? */
                for (j = 0; j < curr_rsync_xal.count; j++) {
                        if (rsync_xal_l.rxals[i].rxas[j].name_len != curr_rsync_xal.rxas[j].name_len
                         || rsync_xal_l.rxals[i].rxas[j].datum_len != curr_rsync_xal.rxas[j].datum_len
                         || strcmp(rsync_xal_l.rxals[i].rxas[j].name, curr_rsync_xal.rxas[j].name)
                         || memcmp(rsync_xal_l.rxals[i].rxas[j].datum, curr_rsync_xal.rxas[j].datum, curr_rsync_xal.rxas[j].datum_len))
                                break;
                }
                /* no differences found.  This is The One! */
                if (j == curr_rsync_xal.count)
                        break;
        }
        if (i < rsync_xal_l.count)
                return i;
        return (ssize_t)-1;
}

/* Store curr_rsync_xal on the end of rsync_xal_l */
static void rsync_xal_store(void)
{
        if (rsync_xal_l.count <= rsync_xal_l.alloc) {
                size_t new_alloc;
                void *new_xal;

                new_alloc = rsync_xal_l.count < RSYNC_XAL_LIST_INITIAL ? RSYNC_XAL_LIST_INITIAL : rsync_xal_l.count * 2;
                new_xal = realloc_array(rsync_xal_l.rxals, rsync_xal, new_alloc);
                if (!new_xal)
                        out_of_memory("rsync_xal_store");
                rsync_xal_l.alloc = new_alloc;
                rsync_xal_l.rxals = new_xal;
        }
        rsync_xal_l.rxals[rsync_xal_l.count] = curr_rsync_xal;
        rsync_xal_l.count++;
        curr_rsync_xal.count = 0;
        curr_rsync_xal.alloc = 0;
        curr_rsync_xal.rxas = NULL;
}

/* send the make_xattr()-generated xattr list for this flist entry,
 * or clean up after an flist entry that's not being sent (f == -1) */

void send_xattr(UNUSED(const struct file_struct *file), int f)
{
        ssize_t index;

        if (f == -1) {
                rsync_xal_free(&curr_rsync_xal);
                return;
        }
        index = rsync_xal_find_matching();
        if (index != -1) {
                write_byte(f, 'x');
                write_int(f, index);
                rsync_xal_free(&curr_rsync_xal);
        } else {
                rsync_xa *rxa;
                size_t count;

                count = curr_rsync_xal.count;
                write_byte(f, 'X');
                write_int(f, count);
                for (rxa = curr_rsync_xal.rxas; count--; rxa++) {
                        write_int(f, rxa->name_len);
                        write_int(f, rxa->datum_len);
                        write_buf(f, rxa->name, rxa->name_len);
                        write_buf(f, rxa->datum, rxa->datum_len);
                }
                rsync_xal_store();
        }
}


/* ------------------------------------------------------------------------- */
/* receive and build the rsync_xattr_lists */

void receive_xattr(struct file_struct *file, int f)
{
        char *fname;
        int tag;

        fname = f_name(file, NULL);
        tag = read_byte(f);
        if (tag != 'X' && tag != 'x') {
                rprintf(FERROR,
                    "%s: receive_xattr: unknown extended attribute type tag: %c\n",
                    fname, tag);
                exit_cleanup(RERR_STREAMIO);
        }

        if (fxil.alloc <= fxil.count) {
                void *new_ptr;
                size_t new_alloc;

                if (fxil.count <  RSYNC_XAL_LIST_INITIAL)
                        new_alloc = fxil.alloc + RSYNC_XAL_LIST_INITIAL;
                else
                        new_alloc = fxil.alloc * 2;
                new_ptr = realloc_array(fxil.filexalidxs, file_xal_index, new_alloc);
                if (!new_ptr)
                        out_of_memory("receive_xattr");
                if (verbose >= 3) {
                        rprintf(FINFO, "receive_xattr to %lu bytes, %s move\n",
                                (unsigned long)(new_alloc * sizeof (file_xal_index)),
                                fxil.filexalidxs == new_ptr ? "did not" : "did");
                }

                fxil.filexalidxs = new_ptr;
                fxil.alloc = new_alloc;
        }

        fxil.filexalidxs[fxil.count].file = file;
        if (tag == 'X') {
                size_t count;
                size_t i;

                fxil.filexalidxs[fxil.count].xalidx = rsync_xal_l.count;

                count = read_int(f);
                curr_rsync_xal.count = count;
                curr_rsync_xal.alloc = count;
                curr_rsync_xal.rxas = new_array(rsync_xa, count);
                if (!curr_rsync_xal.rxas)
                        out_of_memory("receive_xattr");
                for (i = 0; i < count; i++) {
                        size_t name_len;
                        size_t datum_len;
                        char *ptr;

                        name_len = read_int(f);
                        datum_len = read_int(f);
                        if (name_len + datum_len < name_len)
                                out_of_memory("receive_xattr"); /* overflow */
                        ptr = new_array(char, name_len + datum_len);
                        if (!ptr)
                                out_of_memory("receive_xattr");
                        read_buf(f, ptr, name_len);
                        read_buf(f, ptr + name_len, datum_len);
                        curr_rsync_xal.rxas[i].name_len = name_len;
                        curr_rsync_xal.rxas[i].datum_len = datum_len;
                        curr_rsync_xal.rxas[i].name = ptr;
                        curr_rsync_xal.rxas[i].datum = ptr + name_len;
                }
                rsync_xal_store();
        } else {
                size_t index;

                index = read_int(f);
                if (index >= rsync_xal_l.count) {
                        rprintf(FERROR, "%s: receive_xattr: xa index %lu out of range\n",
                                fname, (unsigned long)index);
                        exit_cleanup(RERR_STREAMIO);
                }
                fxil.filexalidxs[fxil.count].xalidx = index;
        }
        fxil.count++;
}

static int rsync_xal_set(const char *fname, rsync_xal *x)
{
        size_t i;
        int ret = 0;

        for (i = 0; i < x->count; i++) {
                int status = sys_lsetxattr(fname, x->rxas[i].name, x->rxas[i].datum, x->rxas[i].datum_len, 0);
                if (status < 0) {
                        rprintf(FERROR, "%s: rsync_xal_set: lsetxattr %s failed: %s\n",
                                fname, x->rxas[i].name, strerror(errno));
                        ret = -1;
                }
        }
        return ret;
}

/* for duplicating xattrs on backups when using backup_dir */

int dup_xattr(const char *orig, const char *bak)
{
        int ret;

        if (rsync_xal_get(orig, &backup_xal) < 0)
                ret = rsync_xal_set(bak, &backup_xal);
        else
                ret = 0;
        rsync_xal_free(&backup_xal);

        return ret;
}

void push_keep_backup_xattr(const struct file_struct *file, const char *orig, const char *dest)
{
        backup_orig_file = file;
        backup_orig_fname = orig;
        backup_dest_fname = dest;
        rsync_xal_get(orig, &backup_xal);
}

static int set_keep_backup_xal(void)
{
        return rsync_xal_set(backup_dest_fname, &backup_xal);
}

void cleanup_keep_backup_xattr(void)
{
        backup_orig_file = NULL;
        backup_orig_fname = null_string;
        backup_dest_fname = null_string;
        rsync_xal_free(&backup_xal);
}

static int file_xal_index_compare(const void *x1, const void *x2)
{
        const file_xal_index *xa1;
        const file_xal_index *xa2;

        xa1 = x1;
        xa2 = x2;
        return xa1->file == xa2->file ? 0 : xa1->file < xa2->file ? -1 : 1;
}

void sort_file_xattr_index_lists(void)
{
        qsort(fxil.filexalidxs, fxil.count, sizeof (file_xal_index), file_xal_index_compare);
}

static int find_file_xal_index(const struct file_struct *file)
{
        int low = 0, high = fxil.count;
        const struct file_struct *file_mid;

        if (!high--) {
                rprintf(FERROR, "find_file_xal_index: no entries\n");
                exit_cleanup(RERR_STREAMIO);
                return -1;
        }
        do {
                int mid = (high + low) / 2;
                file_mid = fxil.filexalidxs[mid].file;
                if (file_mid == file)
                        return fxil.filexalidxs[mid].xalidx;
                if (file_mid > file)
                        high = mid - 1;
                else
                        low = mid + 1;
        } while (low < high);
        if (low == high) {
                file_mid = fxil.filexalidxs[low].file;
                if (file_mid == file)
                        return fxil.filexalidxs[low].xalidx;
        }
        rprintf(FERROR,
                "find_file_xal_index: can't find entry for file in list\n");
        exit_cleanup(RERR_STREAMIO);
        return -1;
}

/* set extended attributes on rsync-ed or keep_backup-ed file */

int set_xattr(const char *fname, const struct file_struct *file)
{
        int xalidx;
        rsync_xal *x;

        if (dry_run)
                return 1; /* FIXME: --dry-run needs to compute this value */

        if (file == backup_orig_file) {
                if (!strcmp(fname, backup_dest_fname))
                        return set_keep_backup_xal();
        }
        xalidx = find_file_xal_index(file);
        x = &(rsync_xal_l.rxals[xalidx]);

        return rsync_xal_set(fname, x);
}

#endif /* SUPPORT_XATTRS */

---