busybox/e2fsprogs/e2fs_lib.c

/* vi: set sw=4 ts=4: */
/*
 * See README for additional information
 *
 * This file can be redistributed under the terms of the GNU Library General
 * Public License
 */

#include "libbb.h"
#include "e2fs_lib.h"

#define HAVE_EXT2_IOCTLS 1

#if INT_MAX == LONG_MAX
#define IF_LONG_IS_SAME(...) __VA_ARGS__
#define IF_LONG_IS_WIDER(...)
#else
#define IF_LONG_IS_SAME(...)
#define IF_LONG_IS_WIDER(...) __VA_ARGS__
#endif

static void close_silently(int fd)
{
	int e = errno;
	close(fd);
	errno = e;
}


/* Iterate a function on each entry of a directory */
int iterate_on_dir(const char *dir_name,
		int (*func)(const char *, struct dirent *, void *),
		void * private)
{
	DIR *dir;
	struct dirent *de, *dep;
	int max_len, len;

	max_len = PATH_MAX + sizeof(struct dirent);
	de = xmalloc(max_len+1);
	memset(de, 0, max_len+1);

	dir = opendir(dir_name);
	if (dir == NULL) {
		free(de);
		return -1;
	}
	while ((dep = readdir(dir))) {
		len = sizeof(struct dirent);
		if (len < dep->d_reclen)
			len = dep->d_reclen;
		if (len > max_len)
			len = max_len;
		memcpy(de, dep, len);
		func(dir_name, de, private);
	}
	closedir(dir);
	free(de);
	return 0;
}


/* Get/set a file version on an ext2 file system */
int fgetsetversion(const char *name, unsigned long *get_version, unsigned long set_version)
{
#if HAVE_EXT2_IOCTLS
	int fd, r;
	IF_LONG_IS_WIDER(int ver;)

	fd = open(name, O_NONBLOCK);
	if (fd == -1)
		return -1;
	if (!get_version) {
		IF_LONG_IS_WIDER(
			ver = (int) set_version;
			r = ioctl(fd, EXT2_IOC_SETVERSION, &ver);
		)
		IF_LONG_IS_SAME(
			r = ioctl(fd, EXT2_IOC_SETVERSION, (void*)&set_version);
		)
	} else {
		IF_LONG_IS_WIDER(
			r = ioctl(fd, EXT2_IOC_GETVERSION, &ver);
			*get_version = ver;
		)
		IF_LONG_IS_SAME(
			r = ioctl(fd, EXT2_IOC_GETVERSION, (void*)get_version);
		)
	}
	close_silently(fd);
	return r;
#else /* ! HAVE_EXT2_IOCTLS */
	errno = EOPNOTSUPP;
	return -1;
#endif /* ! HAVE_EXT2_IOCTLS */
}


/* Get/set a file flags on an ext2 file system */
int fgetsetflags(const char *name, unsigned long *get_flags, unsigned long set_flags)
{
#if HAVE_EXT2_IOCTLS
	struct stat buf;
	int fd, r;
	IF_LONG_IS_WIDER(int f;)

	if (stat(name, &buf) == 0 /* stat is ok */
	 && !S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode)
	) {
		goto notsupp;
	}
	fd = open(name, O_NONBLOCK); /* neither read nor write asked for */
	if (fd == -1)
		return -1;

	if (!get_flags) {
		IF_LONG_IS_WIDER(
			f = (int) set_flags;
			r = ioctl(fd, EXT2_IOC_SETFLAGS, &f);
		)
		IF_LONG_IS_SAME(
			r = ioctl(fd, EXT2_IOC_SETFLAGS, (void*)&set_flags);
		)
	} else {
		IF_LONG_IS_WIDER(
			r = ioctl(fd, EXT2_IOC_GETFLAGS, &f);
			*get_flags = f;
		)
		IF_LONG_IS_SAME(
			r = ioctl(fd, EXT2_IOC_GETFLAGS, (void*)get_flags);
		)
	}

	close_silently(fd);
	return r;
 notsupp:
#endif /* HAVE_EXT2_IOCTLS */
	errno = EOPNOTSUPP;
	return -1;
}


/* Print file attributes on an ext2 file system */
const uint32_t e2attr_flags_value[] = {
#ifdef ENABLE_COMPRESSION
	EXT2_COMPRBLK_FL,
	EXT2_DIRTY_FL,
	EXT2_NOCOMPR_FL,
	EXT2_ECOMPR_FL,
#endif
	EXT2_INDEX_FL,
	EXT2_SECRM_FL,
	EXT2_UNRM_FL,
	EXT2_SYNC_FL,
	EXT2_DIRSYNC_FL,
	EXT2_IMMUTABLE_FL,
	EXT2_APPEND_FL,
	EXT2_NODUMP_FL,
	EXT2_NOATIME_FL,
	EXT2_COMPR_FL,
	EXT3_JOURNAL_DATA_FL,
	EXT2_NOTAIL_FL,
	EXT2_TOPDIR_FL
};

const char e2attr_flags_sname[] =
#ifdef ENABLE_COMPRESSION
	"BZXE"
#endif
	"I"
	"suSDiadAcjtT";

static const char e2attr_flags_lname[] =
#ifdef ENABLE_COMPRESSION
	"Compressed_File" "\0"
	"Compressed_Dirty_File" "\0"
	"Compression_Raw_Access" "\0"
	"Compression_Error" "\0"
#endif
	"Indexed_directory" "\0"
	"Secure_Deletion" "\0"
	"Undelete" "\0"
	"Synchronous_Updates" "\0"
	"Synchronous_Directory_Updates" "\0"
	"Immutable" "\0"
	"Append_Only" "\0"
	"No_Dump" "\0"
	"No_Atime" "\0"
	"Compression_Requested" "\0"
	"Journaled_Data" "\0"
	"No_Tailmerging" "\0"
	"Top_of_Directory_Hierarchies" "\0"
	/* Another trailing NUL is added by compiler */;

void print_e2flags(FILE *f, unsigned long flags, unsigned options)
{
	const uint32_t *fv;
	const char *fn;

	fv = e2attr_flags_value;
	if (options & PFOPT_LONG) {
		int first = 1;
		fn = e2attr_flags_lname;
		do {
			if (flags & *fv) {
				if (!first)
					fputs(", ", f);
				fputs(fn, f);
				first = 0;
			}
			fv++;
			fn += strlen(fn) + 1;
		} while (*fn);
		if (first)
			fputs("---", f);
	} else {
		fn = e2attr_flags_sname;
		do  {
			char c = '-';
			if (flags & *fv)
				c = *fn;
			fputc(c, f);
			fv++;
			fn++;
		} while (*fn);
	}
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* See README for additional information
4	*
5	* This file can be redistributed under the terms of the GNU Library General
6	* Public License
7	*/
8
9	#include "libbb.h"
10	#include "e2fs_lib.h"
11
12	#define HAVE_EXT2_IOCTLS 1
13
14	#if INT_MAX == LONG_MAX
15	#define IF_LONG_IS_SAME(...) __VA_ARGS__
16	#define IF_LONG_IS_WIDER(...)
17	#else
18	#define IF_LONG_IS_SAME(...)
19	#define IF_LONG_IS_WIDER(...) __VA_ARGS__
20	#endif
21
22	static void close_silently(int fd)
23	{
24	int e = errno;
25	close(fd);
26	errno = e;
27	}
28
29
30	/* Iterate a function on each entry of a directory */
31	int iterate_on_dir(const char *dir_name,
32	int (func)(const char , struct dirent , void ),
33	void * private)
34	{
35	DIR *dir;
36	struct dirent de, dep;
37	int max_len, len;
38
39	max_len = PATH_MAX + sizeof(struct dirent);
40	de = xmalloc(max_len+1);
41	memset(de, 0, max_len+1);
42
43	dir = opendir(dir_name);
44	if (dir == NULL) {
45	free(de);
46	return -1;
47	}
48	while ((dep = readdir(dir))) {
49	len = sizeof(struct dirent);
50	if (len < dep->d_reclen)
51	len = dep->d_reclen;
52	if (len > max_len)
53	len = max_len;
54	memcpy(de, dep, len);
55	func(dir_name, de, private);
56	}
57	closedir(dir);
58	free(de);
59	return 0;
60	}
61
62
63	/* Get/set a file version on an ext2 file system */
64	int fgetsetversion(const char name, unsigned long get_version, unsigned long set_version)
65	{
66	#if HAVE_EXT2_IOCTLS
67	int fd, r;
68	IF_LONG_IS_WIDER(int ver;)
69
70	fd = open(name, O_NONBLOCK);
71	if (fd == -1)
72	return -1;
73	if (!get_version) {
74	IF_LONG_IS_WIDER(
75	ver = (int) set_version;
76	r = ioctl(fd, EXT2_IOC_SETVERSION, &ver);
77	)
78	IF_LONG_IS_SAME(
79	r = ioctl(fd, EXT2_IOC_SETVERSION, (void*)&set_version);
80	)
81	} else {
82	IF_LONG_IS_WIDER(
83	r = ioctl(fd, EXT2_IOC_GETVERSION, &ver);
84	*get_version = ver;
85	)
86	IF_LONG_IS_SAME(
87	r = ioctl(fd, EXT2_IOC_GETVERSION, (void*)get_version);
88	)
89	}
90	close_silently(fd);
91	return r;
92	#else /* ! HAVE_EXT2_IOCTLS */
93	errno = EOPNOTSUPP;
94	return -1;
95	#endif /* ! HAVE_EXT2_IOCTLS */
96	}
97
98
99	/* Get/set a file flags on an ext2 file system */
100	int fgetsetflags(const char name, unsigned long get_flags, unsigned long set_flags)
101	{
102	#if HAVE_EXT2_IOCTLS
103	struct stat buf;
104	int fd, r;
105	IF_LONG_IS_WIDER(int f;)
106
107	if (stat(name, &buf) == 0 /* stat is ok */
108	&& !S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode)
109	) {
110	goto notsupp;
111	}
112	fd = open(name, O_NONBLOCK); /* neither read nor write asked for */
113	if (fd == -1)
114	return -1;
115
116	if (!get_flags) {
117	IF_LONG_IS_WIDER(
118	f = (int) set_flags;
119	r = ioctl(fd, EXT2_IOC_SETFLAGS, &f);
120	)
121	IF_LONG_IS_SAME(
122	r = ioctl(fd, EXT2_IOC_SETFLAGS, (void*)&set_flags);
123	)
124	} else {
125	IF_LONG_IS_WIDER(
126	r = ioctl(fd, EXT2_IOC_GETFLAGS, &f);
127	*get_flags = f;
128	)
129	IF_LONG_IS_SAME(
130	r = ioctl(fd, EXT2_IOC_GETFLAGS, (void*)get_flags);
131	)
132	}
133
134	close_silently(fd);
135	return r;
136	notsupp:
137	#endif /* HAVE_EXT2_IOCTLS */
138	errno = EOPNOTSUPP;
139	return -1;
140	}
141
142
143	/* Print file attributes on an ext2 file system */
144	const uint32_t e2attr_flags_value[] = {
145	#ifdef ENABLE_COMPRESSION
146	EXT2_COMPRBLK_FL,
147	EXT2_DIRTY_FL,
148	EXT2_NOCOMPR_FL,
149	EXT2_ECOMPR_FL,
150	#endif
151	EXT2_INDEX_FL,
152	EXT2_SECRM_FL,
153	EXT2_UNRM_FL,
154	EXT2_SYNC_FL,
155	EXT2_DIRSYNC_FL,
156	EXT2_IMMUTABLE_FL,
157	EXT2_APPEND_FL,
158	EXT2_NODUMP_FL,
159	EXT2_NOATIME_FL,
160	EXT2_COMPR_FL,
161	EXT3_JOURNAL_DATA_FL,
162	EXT2_NOTAIL_FL,
163	EXT2_TOPDIR_FL
164	};
165
166	const char e2attr_flags_sname[] =
167	#ifdef ENABLE_COMPRESSION
168	"BZXE"
169	#endif
170	"I"
171	"suSDiadAcjtT";
172
173	static const char e2attr_flags_lname[] =
174	#ifdef ENABLE_COMPRESSION
175	"Compressed_File" "\0"
176	"Compressed_Dirty_File" "\0"
177	"Compression_Raw_Access" "\0"
178	"Compression_Error" "\0"
179	#endif
180	"Indexed_directory" "\0"
181	"Secure_Deletion" "\0"
182	"Undelete" "\0"
183	"Synchronous_Updates" "\0"
184	"Synchronous_Directory_Updates" "\0"
185	"Immutable" "\0"
186	"Append_Only" "\0"
187	"No_Dump" "\0"
188	"No_Atime" "\0"
189	"Compression_Requested" "\0"
190	"Journaled_Data" "\0"
191	"No_Tailmerging" "\0"
192	"Top_of_Directory_Hierarchies" "\0"
193	/* Another trailing NUL is added by compiler */;
194
195	void print_e2flags(FILE *f, unsigned long flags, unsigned options)
196	{
197	const uint32_t *fv;
198	const char *fn;
199
200	fv = e2attr_flags_value;
201	if (options & PFOPT_LONG) {
202	int first = 1;
203	fn = e2attr_flags_lname;
204	do {
205	if (flags & *fv) {
206	if (!first)
207	fputs(", ", f);
208	fputs(fn, f);
209	first = 0;
210	}
211	fv++;
212	fn += strlen(fn) + 1;
213	} while (*fn);
214	if (first)
215	fputs("---", f);
216	} else {
217	fn = e2attr_flags_sname;
218	do {
219	char c = '-';
220	if (flags & *fv)
221	c = *fn;
222	fputc(c, f);
223	fv++;
224	fn++;
225	} while (*fn);
226	}
227	}