[dump.git] / restore / xattr.c

/*
 * Copyright (c) 1999-2004
 *	Stelian Pop <stelian@popies.net>, 1999-2004
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
static const char rcsid[] =
	"$Id: xattr.c,v 1.1 2005/05/02 15:10:47 stelian Exp $";
#endif /* not lint */

#include <config.h>
#include <compatlfs.h>
#include <compaterr.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <bsdcompat.h>
#include <protocols/dumprestore.h>
#include "restore.h"
#include "extern.h"
#include "pathnames.h"

/*
 * Data structures below taken from the kernel
 */

/* Maximum number of references to one attribute block */
#define EXT2_XATTR_REFCOUNT_MAX		1024

/* Name indexes */
#define EXT2_XATTR_INDEX_MAX			10
#define EXT2_XATTR_INDEX_USER			1
#define EXT2_XATTR_INDEX_POSIX_ACL_ACCESS	2
#define EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT	3
#define EXT2_XATTR_INDEX_TRUSTED		4
#define	EXT2_XATTR_INDEX_LUSTRE			5
#define EXT2_XATTR_INDEX_SECURITY	        6

struct ext2_xattr_header {
	u_int32_t	h_magic;	/* magic number for identification */
	u_int32_t	h_refcount;	/* reference count */
	u_int32_t	h_blocks;	/* number of disk blocks used */
	u_int32_t	h_hash;		/* hash value of all attributes */
	u_int32_t	h_reserved[4];	/* zero right now */
};

struct ext3_xattr_ibody_header {
	u_int32_t	h_magic;	/* magic number for identification */
};

struct ext2_xattr_entry {
	u_char		e_name_len;	/* length of name */
	u_char		e_name_index;	/* attribute name index */
	u_int16_t	e_value_offs;	/* offset in disk block of value */
	u_int32_t	e_value_block;	/* disk block attribute is stored on (n/i) */
	u_int32_t	e_value_size;	/* size of attribute value */
	u_int32_t	e_hash;		/* hash value of name and value */
	char		e_name[0];	/* attribute name */
};

#define EXT2_XATTR_PAD_BITS		2
#define EXT2_XATTR_PAD		(1<<EXT2_XATTR_PAD_BITS)
#define EXT2_XATTR_ROUND		(EXT2_XATTR_PAD-1)
#define EXT2_XATTR_LEN(name_len) \
	(((name_len) + EXT2_XATTR_ROUND + \
	sizeof(struct ext2_xattr_entry)) & ~EXT2_XATTR_ROUND)
#define EXT2_XATTR_NEXT(entry) \
	( (struct ext2_xattr_entry *)( \
	  (char *)(entry) + EXT2_XATTR_LEN((entry)->e_name_len)) )
#define EXT3_XATTR_SIZE(size) \
	(((size) + EXT2_XATTR_ROUND) & ~EXT2_XATTR_ROUND)

#define HDR(buffer) ((struct ext2_xattr_header *)(buffer))
#define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)

#define BFIRST(buffer) ENTRY(HDR(buffer)+1)
#define IFIRST(buffer) ENTRY(((struct ext3_xattr_ibody_header *)(buffer))+1)

#define FIRST_ENTRY(buffer) \
	((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
		IFIRST(buffer) : \
		BFIRST(buffer))

/*
 * On-block xattr value offsets start at the beginning of the block, but
 * on-inode xattr value offsets start after the initial header 
 * (ext3_xattr_ibody_header).
 */
#define VALUE_OFFSET(buffer, entry) \
	(((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
		(entry)->e_value_offs + sizeof(struct ext3_xattr_ibody_header) : \
		(entry)->e_value_offs))
	
/*
 * xattr syscalls do not exist yet in libc, get our own copy here,
 * taken from libattr.
 */
#if defined (__i386__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		227
# define __NR_lgetxattr		230
# define __NR_llistxattr	233
#elif defined (__sparc__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		170
# define __NR_lgetxattr		173
# define __NR_llistxattr	179
#elif defined (__ia64__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		1218
# define __NR_lgetxattr		1221
# define __NR_llistxattr	1224
#elif defined (__powerpc__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		210
# define __NR_lgetxattr		213
# define __NR_llistxattr	216
#elif defined (__x86_64__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		189
# define __NR_lgetxattr		192
# define __NR_llistxattr	195
#elif defined (__s390__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		225
# define __NR_lgetxattr		228
# define __NR_llistxattr	231
#elif defined (__arm__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_SYSCALL_BASE 0x900000
# define __NR_lsetxattr		(__NR_SYSCALL_BASE+227)
# define __NR_lgetxattr		(__NR_SYSCALL_BASE+230)
# define __NR_llistxattr	(__NR_SYSCALL_BASE+233)
#elif defined (__mips64__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_Linux 5000
# define __NR_lsetxattr		(__NR_Linux + 218)
# define __NR_lgetxattr		(__NR_Linux + 221)
# define __NR_llistxattr	(__NR_Linux + 224)
#elif defined (__mips__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_Linux 4000
# define __NR_lsetxattr		(__NR_Linux + 225)
# define __NR_lgetxattr		(__NR_Linux + 228)
# define __NR_llistxattr	(__NR_Linux + 231)
#elif defined (__alpha__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		383
# define __NR_lgetxattr		386
# define __NR_llistxattr	389
#elif defined (__mc68000__)
# define HAVE_XATTR_SYSCALLS 1
# define __NR_lsetxattr		224
# define __NR_lgetxattr		227
# define __NR_llistxattr	230
#else
# warning "Extended attribute syscalls undefined for this architecture"
# define HAVE_XATTR_SYSCALLS 0
#endif

#if HAVE_XATTR_SYSCALLS
# define SYSCALL(args...)	syscall(args)
#else
# define SYSCALL(args...)	( errno = ENOSYS, -1 )
#endif

static int lsetxattr __P((const char *, const char *, void *, size_t, int));
static ssize_t lgetxattr __P((const char *, const char *, void *, size_t));
static ssize_t llistxattr __P((const char *, char *, size_t));
static int xattr_cb_list __P((char *, char *, int, void *));
static int xattr_cb_set __P((char *, char *, int, void *));
static int xattr_cb_compare __P((char *, char *, int, void *));
static int xattr_verify __P((char *));
static int xattr_count __P((char *, int *));
static int xattr_walk __P((char *, int (*)(char *, char *, int, void *), void *));

static int
lsetxattr(const char *path, const char *name, void *value, size_t size, int flags)
{
	return SYSCALL(__NR_lsetxattr, path, name, value, size, flags);
}

static ssize_t
lgetxattr(const char *path, const char *name, void *value, size_t size)
{
	return SYSCALL(__NR_lgetxattr, path, name, value, size);
}

static ssize_t
llistxattr(const char *path, char *list, size_t size)
{
	return SYSCALL(__NR_llistxattr, path, list, size);
}

/*
 * Dump code starts here :)
 */

static int
xattr_cb_list(char *name, char *value, int valuelen, void *private)
{
	value[valuelen] = '\0';
	printf("EA: %s:%s\n", name, value);

	return GOOD;
}

static int
xattr_cb_set(char *name, char *value, int valuelen, void *private)
{
	char *path = (char *)private;

	if (lsetxattr(path, name, value, valuelen, 0) < 0) {
		warn("lsetxattr %s failed", path);
		return FAIL;
	}
	return GOOD;
}

static int
xattr_cb_compare(char *name, char *value, int valuelen, void *private)
{
	char *path = (char *)private;
	char valuef[XATTR_MAXSIZE];
	int valuesz;

	valuesz = lgetxattr(path, name, valuef, XATTR_MAXSIZE);
	if (valuesz < 0) {
		warn("%s: lgetxattr failed\n", path);
		return FAIL;
	}

	if (valuesz != valuelen) {
		fprintf(stderr, "%s: EA %s value changed\n", path, value);
		return FAIL;
	}

	if (memcmp(value, valuef, valuelen)) {
		fprintf(stderr, "%s: EA %s value changed\n", path, value);
		return FAIL;
	}

	return GOOD;
}

static int
xattr_verify(char *buffer)
{
	struct ext2_xattr_entry *entry;
	char *end;

	end = buffer + XATTR_MAXSIZE;

	if (Bcvt)
		swabst("4i", (u_char *)buffer);

	if (HDR(buffer)->h_magic != EXT2_XATTR_MAGIC &&
	    HDR(buffer)->h_magic != EXT2_XATTR_MAGIC2) {
		fprintf(stderr, "error in EA block 1\n");
		fprintf(stderr, "magic = %x\n", HDR(buffer)->h_magic);
		
		return FAIL;
	}

	/* check the on-disk data structure */
	entry = FIRST_ENTRY(buffer);
	if (Bcvt) 
		swabst("2b1s3i", (u_char *)entry);
	while (!IS_LAST_ENTRY(entry)) {
		struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);

		if ((char *)next >= end) {
			fprintf(stderr, "error in EA block\n");
			return FAIL;
		}
		entry = next;
		if (Bcvt) 
			swabst("2b1s3i", (u_char *)entry);
	}
	return GOOD;
}

static int
xattr_count(char *buffer, int *count)
{
	struct ext2_xattr_entry *entry;
	int result = 0;

	/* list the attribute names */
	for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
	     entry = EXT2_XATTR_NEXT(entry))
		result++;

	*count = result;
	return GOOD;
}

static int
xattr_walk(char *buffer, int (*xattr_cb)(char *, char *, int, void *), void *private)
{
	struct ext2_xattr_entry *entry;

	/* list the attribute names */
	for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
	     entry = EXT2_XATTR_NEXT(entry)) {
	     	char name[XATTR_MAXSIZE], value[XATTR_MAXSIZE];
		int off;

		switch (entry->e_name_index) {
		case EXT2_XATTR_INDEX_USER:
			strcpy(name, "user.");
			break;
		case EXT2_XATTR_INDEX_POSIX_ACL_ACCESS:
		case EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT:
			strcpy(name, "system.");
			break;
		case EXT2_XATTR_INDEX_TRUSTED:
			strcpy(name, "trusted.");
			break;
		case EXT2_XATTR_INDEX_LUSTRE:
			strcpy(name, "lustre.");
			break;
		case EXT2_XATTR_INDEX_SECURITY:
			strcpy(name, "security.");
			break;
		default:
			fprintf(stderr, "Unknown EA index\n");
			return FAIL;
		}

		off = strlen(name);
		memcpy(name + off, entry->e_name, entry->e_name_len);
		name[off + entry->e_name_len] = '\0';


		memcpy(value, buffer + VALUE_OFFSET(buffer, entry), entry->e_value_size);

		if (xattr_cb(name, value, entry->e_value_size, private) != GOOD)
			return FAIL;
	}

	return GOOD;
}

int
xattr_compare(char *path, char *buffer)
{
	int countf, countt;
	char *names = NULL, *end_names, *name;

	countf = llistxattr(path, NULL, 0);
	if (countf < 0) {
		warn("%s: llistxattr failed", path);
		return FAIL;
	}

	names = malloc(countf + 1);
	if (!names) {
		warn("%s: llistxattr failed", path);
		return FAIL;
	}

	countf = llistxattr(path, names, countf);
	if (countf < 0) {
		warn("%s: llistxattr failed", path);
		free(names);
		return FAIL;
	}

	names[countf] = '\0';
	end_names = names + countf;

	countf = 0;
	for (name = names; name != end_names; name = strchr(name, '\0') + 1) {
		if (!*name)
			continue;
		countf++;
	}

	free(names);

	if (buffer) {
		if (xattr_verify(buffer) == FAIL)
			return FAIL;

		if (xattr_count(buffer, &countt) == FAIL)
			return FAIL;
	}
	else
		countt = 0;

	if (countf != countt) {
		fprintf(stderr, "%s: EA count changed from %d to %d\n", path, countt, countf);
		return FAIL;
	}

	if (!buffer)
		return GOOD;

	return xattr_walk(buffer, xattr_cb_compare, path);
}

int
xattr_extract(char *path, char *buffer)
{
	if (dflag) {
		fprintf(stderr, "xattr_extract(%s)\n", path);
		xattr_walk(buffer, xattr_cb_list, NULL);
	}

	if (xattr_verify(buffer) == FAIL)
		return FAIL;

	return xattr_walk(buffer, xattr_cb_set, path);
}
Commit	Line	Data
cca7148b SP	1	/*
	2	* Copyright (c) 1999-2004
	3	* Stelian Pop <stelian@popies.net>, 1999-2004
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. Neither the name of the University nor the names of its contributors
	14	* may be used to endorse or promote products derived from this software
	15	* without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	27	* SUCH DAMAGE.
	28	*/
	29
	30	#ifndef lint
	31	static const char rcsid[] =
	32	"$Id: xattr.c,v 1.1 2005/05/02 15:10:47 stelian Exp $";
	33	#endif /* not lint */
	34
	35	#include <config.h>
	36	#include <compatlfs.h>
	37	#include <compaterr.h>
	38	#include <sys/types.h>
	39	#include <stdio.h>
	40	#include <stdlib.h>
	41	#include <string.h>
	42	#include <unistd.h>
	43	#include <errno.h>
	44	#include <bsdcompat.h>
	45	#include <protocols/dumprestore.h>
	46	#include "restore.h"
	47	#include "extern.h"
	48	#include "pathnames.h"
	49
	50	/*
	51	* Data structures below taken from the kernel
	52	*/
	53
	54	/* Maximum number of references to one attribute block */
	55	#define EXT2_XATTR_REFCOUNT_MAX 1024
	56
	57	/* Name indexes */
	58	#define EXT2_XATTR_INDEX_MAX 10
	59	#define EXT2_XATTR_INDEX_USER 1
	60	#define EXT2_XATTR_INDEX_POSIX_ACL_ACCESS 2
	61	#define EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT 3
	62	#define EXT2_XATTR_INDEX_TRUSTED 4
	63	#define EXT2_XATTR_INDEX_LUSTRE 5
	64	#define EXT2_XATTR_INDEX_SECURITY 6
65
66	struct ext2_xattr_header {
67	u_int32_t h_magic; /* magic number for identification */
68	u_int32_t h_refcount; /* reference count */
69	u_int32_t h_blocks; /* number of disk blocks used */
70	u_int32_t h_hash; /* hash value of all attributes */
71	u_int32_t h_reserved[4]; /* zero right now */
72	};
73
74	struct ext3_xattr_ibody_header {
75	u_int32_t h_magic; /* magic number for identification */
76	};
77
78	struct ext2_xattr_entry {
79	u_char e_name_len; /* length of name */
80	u_char e_name_index; /* attribute name index */
81	u_int16_t e_value_offs; /* offset in disk block of value */
82	u_int32_t e_value_block; /* disk block attribute is stored on (n/i) */
83	u_int32_t e_value_size; /* size of attribute value */
84	u_int32_t e_hash; /* hash value of name and value */
85	char e_name[0]; /* attribute name */
86	};
87
88	#define EXT2_XATTR_PAD_BITS 2
89	#define EXT2_XATTR_PAD (1<<EXT2_XATTR_PAD_BITS)
90	#define EXT2_XATTR_ROUND (EXT2_XATTR_PAD-1)
91	#define EXT2_XATTR_LEN(name_len) \
92	(((name_len) + EXT2_XATTR_ROUND + \
93	sizeof(struct ext2_xattr_entry)) & ~EXT2_XATTR_ROUND)
94	#define EXT2_XATTR_NEXT(entry) \
95	( (struct ext2_xattr_entry *)( \
96	(char *)(entry) + EXT2_XATTR_LEN((entry)->e_name_len)) )
97	#define EXT3_XATTR_SIZE(size) \
98	(((size) + EXT2_XATTR_ROUND) & ~EXT2_XATTR_ROUND)
99
100	#define HDR(buffer) ((struct ext2_xattr_header *)(buffer))
101	#define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
102	#define IS_LAST_ENTRY(entry) ((__u32 )(entry) == 0)
103
104	#define BFIRST(buffer) ENTRY(HDR(buffer)+1)
105	#define IFIRST(buffer) ENTRY(((struct ext3_xattr_ibody_header *)(buffer))+1)
106
107	#define FIRST_ENTRY(buffer) \
108	((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
109	IFIRST(buffer) : \
110	BFIRST(buffer))
111
112	/*
113	* On-block xattr value offsets start at the beginning of the block, but
114	* on-inode xattr value offsets start after the initial header
115	* (ext3_xattr_ibody_header).
116	*/
117	#define VALUE_OFFSET(buffer, entry) \
118	(((HDR(buffer)->h_magic == EXT2_XATTR_MAGIC2) ? \
119	(entry)->e_value_offs + sizeof(struct ext3_xattr_ibody_header) : \
120	(entry)->e_value_offs))
121
122	/*
123	* xattr syscalls do not exist yet in libc, get our own copy here,
124	* taken from libattr.
125	*/
126	#if defined (__i386__)
127	# define HAVE_XATTR_SYSCALLS 1
128	# define __NR_lsetxattr 227
129	# define __NR_lgetxattr 230
130	# define __NR_llistxattr 233
131	#elif defined (__sparc__)
132	# define HAVE_XATTR_SYSCALLS 1
133	# define __NR_lsetxattr 170
134	# define __NR_lgetxattr 173
135	# define __NR_llistxattr 179
136	#elif defined (__ia64__)
137	# define HAVE_XATTR_SYSCALLS 1
138	# define __NR_lsetxattr 1218
139	# define __NR_lgetxattr 1221
140	# define __NR_llistxattr 1224
141	#elif defined (__powerpc__)
142	# define HAVE_XATTR_SYSCALLS 1
143	# define __NR_lsetxattr 210
144	# define __NR_lgetxattr 213
145	# define __NR_llistxattr 216
146	#elif defined (__x86_64__)
147	# define HAVE_XATTR_SYSCALLS 1
148	# define __NR_lsetxattr 189
149	# define __NR_lgetxattr 192
150	# define __NR_llistxattr 195
151	#elif defined (__s390__)
152	# define HAVE_XATTR_SYSCALLS 1
153	# define __NR_lsetxattr 225
154	# define __NR_lgetxattr 228
155	# define __NR_llistxattr 231
156	#elif defined (__arm__)
157	# define HAVE_XATTR_SYSCALLS 1
158	# define __NR_SYSCALL_BASE 0x900000
159	# define __NR_lsetxattr (__NR_SYSCALL_BASE+227)
160	# define __NR_lgetxattr (__NR_SYSCALL_BASE+230)
161	# define __NR_llistxattr (__NR_SYSCALL_BASE+233)
162	#elif defined (__mips64__)
163	# define HAVE_XATTR_SYSCALLS 1
164	# define __NR_Linux 5000
165	# define __NR_lsetxattr (__NR_Linux + 218)
166	# define __NR_lgetxattr (__NR_Linux + 221)
167	# define __NR_llistxattr (__NR_Linux + 224)
168	#elif defined (__mips__)
169	# define HAVE_XATTR_SYSCALLS 1
170	# define __NR_Linux 4000
171	# define __NR_lsetxattr (__NR_Linux + 225)
172	# define __NR_lgetxattr (__NR_Linux + 228)
173	# define __NR_llistxattr (__NR_Linux + 231)
174	#elif defined (__alpha__)
175	# define HAVE_XATTR_SYSCALLS 1
176	# define __NR_lsetxattr 383
177	# define __NR_lgetxattr 386
178	# define __NR_llistxattr 389
179	#elif defined (__mc68000__)
180	# define HAVE_XATTR_SYSCALLS 1
181	# define __NR_lsetxattr 224
182	# define __NR_lgetxattr 227
183	# define __NR_llistxattr 230
184	#else
185	# warning "Extended attribute syscalls undefined for this architecture"
186	# define HAVE_XATTR_SYSCALLS 0
187	#endif
188
189	#if HAVE_XATTR_SYSCALLS
190	# define SYSCALL(args...) syscall(args)
191	#else
192	# define SYSCALL(args...) ( errno = ENOSYS, -1 )
193	#endif
194
195	static int lsetxattr __P((const char , const char , void *, size_t, int));
196	static ssize_t lgetxattr __P((const char , const char , void *, size_t));
197	static ssize_t llistxattr __P((const char , char , size_t));
198	static int xattr_cb_list __P((char , char , int, void *));
199	static int xattr_cb_set __P((char , char , int, void *));
200	static int xattr_cb_compare __P((char , char , int, void *));
201	static int xattr_verify __P((char *));
202	static int xattr_count __P((char , int ));
203	static int xattr_walk __P((char , int ()(char , char , int, void ), void ));
204
205	static int
206	lsetxattr(const char path, const char name, void *value, size_t size, int flags)
207	{
208	return SYSCALL(__NR_lsetxattr, path, name, value, size, flags);
209	}
210
211	static ssize_t
212	lgetxattr(const char path, const char name, void *value, size_t size)
213	{
214	return SYSCALL(__NR_lgetxattr, path, name, value, size);
215	}
216
217	static ssize_t
218	llistxattr(const char path, char list, size_t size)
219	{
220	return SYSCALL(__NR_llistxattr, path, list, size);
221	}
222
223	/*
224	* Dump code starts here :)
225	*/
226
227	static int
228	xattr_cb_list(char name, char value, int valuelen, void *private)
229	{
230	value[valuelen] = '\0';
231	printf("EA: %s:%s\n", name, value);
232
233	return GOOD;
234	}
235
236	static int
237	xattr_cb_set(char name, char value, int valuelen, void *private)
238	{
239	char path = (char )private;
240
241	if (lsetxattr(path, name, value, valuelen, 0) < 0) {
242	warn("lsetxattr %s failed", path);
243	return FAIL;
244	}
245	return GOOD;
246	}
247
248	static int
249	xattr_cb_compare(char name, char value, int valuelen, void *private)
250	{
251	char path = (char )private;
252	char valuef[XATTR_MAXSIZE];
253	int valuesz;
254
255	valuesz = lgetxattr(path, name, valuef, XATTR_MAXSIZE);
256	if (valuesz < 0) {
257	warn("%s: lgetxattr failed\n", path);
258	return FAIL;
259	}
260
261	if (valuesz != valuelen) {
262	fprintf(stderr, "%s: EA %s value changed\n", path, value);
263	return FAIL;
264	}
265
266	if (memcmp(value, valuef, valuelen)) {
267	fprintf(stderr, "%s: EA %s value changed\n", path, value);
268	return FAIL;
269	}
270
271	return GOOD;
272	}
273
274	static int
275	xattr_verify(char *buffer)
276	{
277	struct ext2_xattr_entry *entry;
278	char *end;
279
280	end = buffer + XATTR_MAXSIZE;
281
282	if (Bcvt)
283	swabst("4i", (u_char *)buffer);
284
285	if (HDR(buffer)->h_magic != EXT2_XATTR_MAGIC &&
286	HDR(buffer)->h_magic != EXT2_XATTR_MAGIC2) {
287	fprintf(stderr, "error in EA block 1\n");
288	fprintf(stderr, "magic = %x\n", HDR(buffer)->h_magic);
289
290	return FAIL;
291	}
292
293	/* check the on-disk data structure */
294	entry = FIRST_ENTRY(buffer);
295	if (Bcvt)
296	swabst("2b1s3i", (u_char *)entry);
297	while (!IS_LAST_ENTRY(entry)) {
298	struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
299
300	if ((char *)next >= end) {
301	fprintf(stderr, "error in EA block\n");
302	return FAIL;
303	}
304	entry = next;
305	if (Bcvt)
306	swabst("2b1s3i", (u_char *)entry);
307	}
308	return GOOD;
309	}
310
311	static int
312	xattr_count(char buffer, int count)
313	{
314	struct ext2_xattr_entry *entry;
315	int result = 0;
316
317	/* list the attribute names */
318	for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
319	entry = EXT2_XATTR_NEXT(entry))
320	result++;
321
322	*count = result;
323	return GOOD;
324	}
325
326	static int
327	xattr_walk(char buffer, int (xattr_cb)(char , char , int, void ), void private)
328	{
329	struct ext2_xattr_entry *entry;
330
331	/* list the attribute names */
332	for (entry = FIRST_ENTRY(buffer); !IS_LAST_ENTRY(entry);
333	entry = EXT2_XATTR_NEXT(entry)) {
334	char name[XATTR_MAXSIZE], value[XATTR_MAXSIZE];
335	int off;
336
337	switch (entry->e_name_index) {
338	case EXT2_XATTR_INDEX_USER:
339	strcpy(name, "user.");
340	break;
341	case EXT2_XATTR_INDEX_POSIX_ACL_ACCESS:
342	case EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT:
343	strcpy(name, "system.");
344	break;
345	case EXT2_XATTR_INDEX_TRUSTED:
346	strcpy(name, "trusted.");
347	break;
348	case EXT2_XATTR_INDEX_LUSTRE:
349	strcpy(name, "lustre.");
350	break;
351	case EXT2_XATTR_INDEX_SECURITY:
352	strcpy(name, "security.");
353	break;
354	default:
355	fprintf(stderr, "Unknown EA index\n");
356	return FAIL;
357	}
358
359	off = strlen(name);
360	memcpy(name + off, entry->e_name, entry->e_name_len);
361	name[off + entry->e_name_len] = '\0';
362
363
364	memcpy(value, buffer + VALUE_OFFSET(buffer, entry), entry->e_value_size);
365
366	if (xattr_cb(name, value, entry->e_value_size, private) != GOOD)
367	return FAIL;
368	}
369
370	return GOOD;
371	}
372
373	int
374	xattr_compare(char path, char buffer)
375	{
376	int countf, countt;
377	char names = NULL, end_names, *name;
378
379	countf = llistxattr(path, NULL, 0);
380	if (countf < 0) {
381	warn("%s: llistxattr failed", path);
382	return FAIL;
383	}
384
385	names = malloc(countf + 1);
386	if (!names) {
387	warn("%s: llistxattr failed", path);
388	return FAIL;
389	}
390
391	countf = llistxattr(path, names, countf);
392	if (countf < 0) {
393	warn("%s: llistxattr failed", path);
394	free(names);
395	return FAIL;
396	}
397
398	names[countf] = '\0';
399	end_names = names + countf;
400
401	countf = 0;
402	for (name = names; name != end_names; name = strchr(name, '\0') + 1) {
403	if (!*name)
404	continue;
405	countf++;
406	}
407
408	free(names);
409
410	if (buffer) {
411	if (xattr_verify(buffer) == FAIL)
412	return FAIL;
413
414	if (xattr_count(buffer, &countt) == FAIL)
415	return FAIL;
416	}
417	else
418	countt = 0;
419
420	if (countf != countt) {
421	fprintf(stderr, "%s: EA count changed from %d to %d\n", path, countt, countf);
422	return FAIL;
423	}
424
425	if (!buffer)
426	return GOOD;
427
428	return xattr_walk(buffer, xattr_cb_compare, path);
429	}
430
431	int
432	xattr_extract(char path, char buffer)
433	{
434	if (dflag) {
435	fprintf(stderr, "xattr_extract(%s)\n", path);
436	xattr_walk(buffer, xattr_cb_list, NULL);
437	}
438
439	if (xattr_verify(buffer) == FAIL)
440	return FAIL;
441
442	return xattr_walk(buffer, xattr_cb_set, path);
443	}
444