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(x) x
#define IF_LONG_IS_WIDER(x)
#else
#define IF_LONG_IS_SAME(x)
#define IF_LONG_IS_WIDER(x) x
#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 */
struct flags_name {
	unsigned long	flag;
	char		short_name;
	const char	*long_name;
};

static const struct flags_name flags_array[] = {
	{ EXT2_SECRM_FL, 's', "Secure_Deletion" },
	{ EXT2_UNRM_FL, 'u' , "Undelete" },
	{ EXT2_SYNC_FL, 'S', "Synchronous_Updates" },
	{ EXT2_DIRSYNC_FL, 'D', "Synchronous_Directory_Updates" },
	{ EXT2_IMMUTABLE_FL, 'i', "Immutable" },
	{ EXT2_APPEND_FL, 'a', "Append_Only" },
	{ EXT2_NODUMP_FL, 'd', "No_Dump" },
	{ EXT2_NOATIME_FL, 'A', "No_Atime" },
	{ EXT2_COMPR_FL, 'c', "Compression_Requested" },
#ifdef ENABLE_COMPRESSION
	{ EXT2_COMPRBLK_FL, 'B', "Compressed_File" },
	{ EXT2_DIRTY_FL, 'Z', "Compressed_Dirty_File" },
	{ EXT2_NOCOMPR_FL, 'X', "Compression_Raw_Access" },
	{ EXT2_ECOMPR_FL, 'E', "Compression_Error" },
#endif
	{ EXT3_JOURNAL_DATA_FL, 'j', "Journaled_Data" },
	{ EXT2_INDEX_FL, 'I', "Indexed_directory" },
	{ EXT2_NOTAIL_FL, 't', "No_Tailmerging" },
	{ EXT2_TOPDIR_FL, 'T', "Top_of_Directory_Hierarchies" },
	{ 0, '\0', NULL }
};

void print_flags(FILE *f, unsigned long flags, unsigned options)
{
	const struct flags_name *fp;

	if (options & PFOPT_LONG) {
		int first = 1;
		for (fp = flags_array; fp->short_name; fp++) {
			if (flags & fp->flag) {
				if (!first)
					fputs(", ", f);
				fputs(fp->long_name, f);
				first = 0;
			}
		}
		if (first)
			fputs("---", f);
	} else {
		for (fp = flags_array; fp->short_name; fp++) {
			char c = '-';
			if (flags & fp->flag)
				c = fp->short_name;
			fputc(c, f);
		}
	}
}
1	niro	532	/* 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(x) x
16			#define IF_LONG_IS_WIDER(x)
17			#else
18			#define IF_LONG_IS_SAME(x)
19			#define IF_LONG_IS_WIDER(x) x
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			struct flags_name {
145			unsigned long flag;
146			char short_name;
147			const char *long_name;
148			};
149
150			static const struct flags_name flags_array[] = {
151			{ EXT2_SECRM_FL, 's', "Secure_Deletion" },
152			{ EXT2_UNRM_FL, 'u' , "Undelete" },
153			{ EXT2_SYNC_FL, 'S', "Synchronous_Updates" },
154			{ EXT2_DIRSYNC_FL, 'D', "Synchronous_Directory_Updates" },
155			{ EXT2_IMMUTABLE_FL, 'i', "Immutable" },
156			{ EXT2_APPEND_FL, 'a', "Append_Only" },
157			{ EXT2_NODUMP_FL, 'd', "No_Dump" },
158			{ EXT2_NOATIME_FL, 'A', "No_Atime" },
159			{ EXT2_COMPR_FL, 'c', "Compression_Requested" },
160			#ifdef ENABLE_COMPRESSION
161			{ EXT2_COMPRBLK_FL, 'B', "Compressed_File" },
162			{ EXT2_DIRTY_FL, 'Z', "Compressed_Dirty_File" },
163			{ EXT2_NOCOMPR_FL, 'X', "Compression_Raw_Access" },
164			{ EXT2_ECOMPR_FL, 'E', "Compression_Error" },
165			#endif
166			{ EXT3_JOURNAL_DATA_FL, 'j', "Journaled_Data" },
167			{ EXT2_INDEX_FL, 'I', "Indexed_directory" },
168			{ EXT2_NOTAIL_FL, 't', "No_Tailmerging" },
169			{ EXT2_TOPDIR_FL, 'T', "Top_of_Directory_Hierarchies" },
170			{ 0, '\0', NULL }
171			};
172
173			void print_flags(FILE *f, unsigned long flags, unsigned options)
174			{
175			const struct flags_name *fp;
176
177			if (options & PFOPT_LONG) {
178			int first = 1;
179			for (fp = flags_array; fp->short_name; fp++) {
180			if (flags & fp->flag) {
181			if (!first)
182			fputs(", ", f);
183			fputs(fp->long_name, f);
184			first = 0;
185			}
186			}
187			if (first)
188			fputs("---", f);
189			} else {
190			for (fp = flags_array; fp->short_name; fp++) {
191			char c = '-';
192			if (flags & fp->flag)
193			c = fp->short_name;
194			fputc(c, f);
195			}
196			}
197			}