1 files changed, 190 insertions, 0 deletions
diff --git a/util-linux/e2p/feature.c b/util-linux/e2p/feature.c
new file mode 100644
index 000000000..ef11d93b7
--- /dev/null
+++ b/util-linux/e2p/feature.c
@@ -0,0 +1,190 @@
+/*
+ * feature.c --- convert between features and strings
+ * 
+ * Copyright (C) 1999  Theodore Ts'o <tytso@mit.edu>
+ * 
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ * 
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include "e2p.h"
+struct feature {
+        int             compat;
+        unsigned int    mask;
+        const char      *string;
+};
+static struct feature feature_list[] = {
+        {       E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_PREALLOC,
+                        "dir_prealloc" },
+        {       E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL,
+                        "has_journal" },
+        {       E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_IMAGIC_INODES,
+                        "imagic_inodes" },
+        {       E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_EXT_ATTR,
+                        "ext_attr" },
+        {       E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX,
+                        "dir_index" },
+        {       E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_RESIZE_INODE,
+                        "resize_inode" },
+        {       E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER,
+                        "sparse_super" },
+        {       E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_LARGE_FILE,
+                        "large_file" },
+        {       E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_COMPRESSION,
+                        "compression" },
+        {       E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_FILETYPE,
+                        "filetype" },
+        {       E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_RECOVER,
+                        "needs_recovery" },
+        {       E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_JOURNAL_DEV,
+                        "journal_dev" },
+        {       E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_EXTENTS,
+                        "extents" },
+        {       E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_META_BG,
+                        "meta_bg" },
+        {       0, 0, 0 },
+};
+const char *e2p_feature2string(int compat, unsigned int mask)
+{
+        struct feature  *f;
+        static char buf[20];
+        char    fchar;
+        int     fnum;
+        for (f = feature_list; f->string; f++) {
+                if ((compat == f->compat) &&
+                    (mask == f->mask))
+                        return f->string;
+        }
+        switch (compat) {
+        case  E2P_FEATURE_COMPAT:
+                fchar = 'C';
+                break;
+        case E2P_FEATURE_INCOMPAT:
+                fchar = 'I';
+                break;
+        case E2P_FEATURE_RO_INCOMPAT:
+                fchar = 'R';
+                break;
+        default:
+                fchar = '?';
+                break;
+        }
+        for (fnum = 0; mask >>= 1; fnum++);
+        sprintf(buf, "FEATURE_%c%d", fchar, fnum);
+        return buf;
+}
+int e2p_string2feature(char *string, int *compat_type, unsigned int *mask)
+{
+        struct feature  *f;
+        char            *eptr;
+        int             num;
+        for (f = feature_list; f->string; f++) {
+                if (!strcasecmp(string, f->string)) {
+                        *compat_type = f->compat;
+                        *mask = f->mask;
+                        return 0;
+                }
+        }
+        if (strncasecmp(string, "FEATURE_", 8))
+                return 1;
+        switch (string[8]) {
+        case 'c':
+        case 'C':
+                *compat_type = E2P_FEATURE_COMPAT;
+                break;
+        case 'i':
+        case 'I':
+                *compat_type = E2P_FEATURE_INCOMPAT;
+                break;
+        case 'r':
+        case 'R':
+                *compat_type = E2P_FEATURE_RO_INCOMPAT;
+                break;
+        default:
+                return 1;
+        }
+        if (string[9] == 0)
+                return 1;
+        num = strtol(string+9, &eptr, 10);
+        if (num > 32 || num < 0)
+                return 1;
+        if (*eptr)
+                return 1;
+        *mask = 1 << num;
+        return 0;
+}
+static char *skip_over_blanks(char *cp)
+{
+        while (*cp && isspace(*cp))
+                cp++;
+        return cp;
+}
+static char *skip_over_word(char *cp)
+{
+        while (*cp && !isspace(*cp) && *cp != ',')
+                cp++;
+        return cp;
+}
+/*
+ * Edit a feature set array as requested by the user.  The ok_array,
+ * if set, allows the application to limit what features the user is
+ * allowed to set or clear using this function.
+ */
+int e2p_edit_feature(const char *str, __u32 *compat_array, __u32 *ok_array)
+{
+        char    *cp, *buf, *next;
+        int     neg;
+        unsigned int    mask;
+        int             compat_type;
+        buf = malloc(strlen(str)+1);
+        if (!buf)
+                return 1;
+        strcpy(buf, str);
+        cp = buf;
+        while (cp && *cp) {
+                neg = 0;
+                cp = skip_over_blanks(cp);
+                next = skip_over_word(cp);
+                if (*next == 0)
+                        next = 0;
+                else
+                        *next = 0;
+                switch (*cp) {
+                case '-':
+                case '^':
+                        neg++;
+                case '+':
+                        cp++;
+                        break;
+                }
+                if (e2p_string2feature(cp, &compat_type, &mask))
+                        return 1;
+                if (ok_array && !(ok_array[compat_type] & mask))
+                        return 1;
+                if (neg)
+                        compat_array[compat_type] &= ~mask;
+                else
+                        compat_array[compat_type] |= mask;
+                cp = next ? next+1 : 0;
+        }
+        return 0;
+}

diff --git a/util-linux/e2p/feature.c b/util-linux/e2p/feature.c new file mode 100644 index 000000000..ef11d93b7 --- /dev/null +++ b/util-linux/e2p/feature.c
@@ -0,0 +1,190 @@
	1	/*
	2	* feature.c --- convert between features and strings
	3	*
	4	* Copyright (C) 1999 Theodore Ts'o <tytso@mit.edu>
	5	*
	6	* This file can be redistributed under the terms of the GNU Library General
	7	* Public License
	8	*
	9	*/
	10
	11	#include <stdio.h>
	12	#include <stdlib.h>
	13	#include <string.h>
	14	#include <ctype.h>
	15	#include <errno.h>
	16
	17	#include "e2p.h"
	18
	19	struct feature {
	20	int compat;
	21	unsigned int mask;
	22	const char *string;
	23	};
	24
	25	static struct feature feature_list[] = {
	26	{ E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_PREALLOC,
	27	"dir_prealloc" },
	28	{ E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL,
	29	"has_journal" },
	30	{ E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_IMAGIC_INODES,
	31	"imagic_inodes" },
	32	{ E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_EXT_ATTR,
	33	"ext_attr" },
	34	{ E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX,
	35	"dir_index" },
	36	{ E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_RESIZE_INODE,
	37	"resize_inode" },
	38	{ E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER,
	39	"sparse_super" },
	40	{ E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_LARGE_FILE,
	41	"large_file" },
	42	{ E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_COMPRESSION,
	43	"compression" },
	44	{ E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_FILETYPE,
	45	"filetype" },
	46	{ E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_RECOVER,
	47	"needs_recovery" },
	48	{ E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_JOURNAL_DEV,
	49	"journal_dev" },
	50	{ E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_EXTENTS,
	51	"extents" },
	52	{ E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_META_BG,
	53	"meta_bg" },
	54	{ 0, 0, 0 },
	55	};
	56
	57	const char *e2p_feature2string(int compat, unsigned int mask)
	58	{
	59	struct feature *f;
	60	static char buf[20];
	61	char fchar;
	62	int fnum;
	63
	64	for (f = feature_list; f->string; f++) {
	65	if ((compat == f->compat) &&
	66	(mask == f->mask))
	67	return f->string;
	68	}
	69	switch (compat) {
	70	case E2P_FEATURE_COMPAT:
	71	fchar = 'C';
	72	break;
	73	case E2P_FEATURE_INCOMPAT:
	74	fchar = 'I';
	75	break;
	76	case E2P_FEATURE_RO_INCOMPAT:
	77	fchar = 'R';
	78	break;
	79	default:
	80	fchar = '?';
	81	break;
	82	}
	83	for (fnum = 0; mask >>= 1; fnum++);
	84	sprintf(buf, "FEATURE_%c%d", fchar, fnum);
	85	return buf;
	86	}
	87
	88	int e2p_string2feature(char string, int compat_type, unsigned int *mask)
	89	{
	90	struct feature *f;
	91	char *eptr;
	92	int num;
	93
	94	for (f = feature_list; f->string; f++) {
	95	if (!strcasecmp(string, f->string)) {
	96	*compat_type = f->compat;
	97	*mask = f->mask;
	98	return 0;
	99	}
	100	}
	101	if (strncasecmp(string, "FEATURE_", 8))
	102	return 1;
	103
	104	switch (string[8]) {
	105	case 'c':
	106	case 'C':
	107	*compat_type = E2P_FEATURE_COMPAT;
	108	break;
	109	case 'i':
	110	case 'I':
	111	*compat_type = E2P_FEATURE_INCOMPAT;
	112	break;
	113	case 'r':
	114	case 'R':
	115	*compat_type = E2P_FEATURE_RO_INCOMPAT;
	116	break;
	117	default:
	118	return 1;
	119	}
	120	if (string[9] == 0)
	121	return 1;
	122	num = strtol(string+9, &eptr, 10);
	123	if (num > 32 \|\| num < 0)
	124	return 1;
	125	if (*eptr)
	126	return 1;
	127	*mask = 1 << num;
	128	return 0;
	129	}
	130
	131	static char skip_over_blanks(char cp)
	132	{
	133	while (cp && isspace(cp))
	134	cp++;
	135	return cp;
	136	}
	137
	138	static char skip_over_word(char cp)
	139	{
	140	while (cp && !isspace(cp) && *cp != ',')
	141	cp++;
	142	return cp;
	143	}
	144
	145	/*
	146	* Edit a feature set array as requested by the user. The ok_array,
	147	* if set, allows the application to limit what features the user is
	148	* allowed to set or clear using this function.
	149	*/
	150	int e2p_edit_feature(const char str, __u32 compat_array, __u32 *ok_array)
	151	{
	152	char cp, buf, *next;
	153	int neg;
	154	unsigned int mask;
	155	int compat_type;
	156
	157	buf = malloc(strlen(str)+1);
	158	if (!buf)
	159	return 1;
	160	strcpy(buf, str);
	161	cp = buf;
	162	while (cp && *cp) {
	163	neg = 0;
	164	cp = skip_over_blanks(cp);
	165	next = skip_over_word(cp);
	166	if (*next == 0)
	167	next = 0;
	168	else
	169	*next = 0;
	170	switch (*cp) {
	171	case '-':
	172	case '^':
	173	neg++;
	174	case '+':
	175	cp++;
	176	break;
	177	}
	178	if (e2p_string2feature(cp, &compat_type, &mask))
	179	return 1;
	180	if (ok_array && !(ok_array[compat_type] & mask))
	181	return 1;
	182	if (neg)
	183	compat_array[compat_type] &= ~mask;
	184	else
	185	compat_array[compat_type] \|= mask;
	186	cp = next ? next+1 : 0;
	187	}
	188	return 0;
	189	}
	190