put small subset of e2fsprogs back in the tree:

lsattr, chattr, fsck. Old e2fsprogs tree is in
e2fsprogs/old_e2fsprogs/*.

15 files changed, 1285 insertions, 0 deletions

diff --git a/e2fsprogs/old_e2fsprogs/e2p/Kbuild b/e2fsprogs/old_e2fsprogs/e2p/Kbuild
new file mode 100644
index 000000000..c0ff824e3
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/Kbuild
@@ -0,0 +1,15 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under the GPL v2, see the file LICENSE in this tarball.
+
+NEEDED-$(CONFIG_CHATTR) = y
+NEEDED-$(CONFIG_LSATTR) = y
+NEEDED-$(CONFIG_MKE2FS) = y
+NEEDED-$(CONFIG_TUNE2FS) = y
+
+lib-y:=
+lib-$(NEEDED-y) += fgetsetflags.o fgetsetversion.o pf.o iod.o mntopts.o \
+           feature.o ls.o uuid.o pe.o ostype.o ps.o hashstr.o \
+           parse_num.o
diff --git a/e2fsprogs/old_e2fsprogs/e2p/e2p.h b/e2fsprogs/old_e2fsprogs/e2p/e2p.h
new file mode 100644
index 000000000..2a2367b9f
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/e2p.h
@@ -0,0 +1,64 @@
+/* vi: set sw=4 ts=4: */
+#include "busybox.h"
+#include <sys/types.h>          /* Needed by dirent.h on netbsd */
+#include <stdio.h>
+#include <dirent.h>
+
+#include "../ext2fs/ext2_fs.h"
+
+#define E2P_FEATURE_COMPAT      0
+#define E2P_FEATURE_INCOMPAT    1
+#define E2P_FEATURE_RO_INCOMPAT 2
+#ifndef EXT3_FEATURE_INCOMPAT_EXTENTS
+#define EXT3_FEATURE_INCOMPAT_EXTENTS           0x0040
+#endif
+
+/* `options' for print_flags() */
+
+#define PFOPT_LONG  1 /* Must be 1 for compatibility with `int long_format'. */
+
+/*int fgetversion (const char * name, unsigned long * version);*/
+/*int fsetversion (const char * name, unsigned long version);*/
+int fgetsetversion(const char * name, unsigned long * get_version, unsigned long set_version);
+#define fgetversion(name, version) fgetsetversion(name, version, 0)
+#define fsetversion(name, version) fgetsetversion(name, NULL, version)
+
+/*int fgetflags (const char * name, unsigned long * flags);*/
+/*int fsetflags (const char * name, unsigned long flags);*/
+int fgetsetflags(const char * name, unsigned long * get_flags, unsigned long set_flags);
+#define fgetflags(name, flags) fgetsetflags(name, flags, 0)
+#define fsetflags(name, flags) fgetsetflags(name, NULL, flags)
+
+int getflags (int fd, unsigned long * flags);
+int getversion (int fd, unsigned long * version);
+int iterate_on_dir (const char * dir_name,
+                    int (*func) (const char *, struct dirent *, void *),
+                    void * private);
+/*void list_super(struct ext2_super_block * s);*/
+void list_super2(struct ext2_super_block * s, FILE *f);
+#define list_super(s) list_super2(s, stdout)
+void print_fs_errors (FILE * f, unsigned short errors);
+void print_flags (FILE * f, unsigned long flags, unsigned options);
+void print_fs_state (FILE * f, unsigned short state);
+int setflags (int fd, unsigned long flags);
+int setversion (int fd, unsigned long version);
+
+const char *e2p_feature2string(int compat, unsigned int mask);
+int e2p_string2feature(char *string, int *compat, unsigned int *mask);
+int e2p_edit_feature(const char *str, __u32 *compat_array, __u32 *ok_array);
+
+int e2p_is_null_uuid(void *uu);
+void e2p_uuid_to_str(void *uu, char *out);
+const char *e2p_uuid2str(void *uu);
+
+const char *e2p_hash2string(int num);
+int e2p_string2hash(char *string);
+
+const char *e2p_mntopt2string(unsigned int mask);
+int e2p_string2mntopt(char *string, unsigned int *mask);
+int e2p_edit_mntopts(const char *str, __u32 *mntopts, __u32 ok);
+
+unsigned long parse_num_blocks(const char *arg, int log_block_size);
+
+char *e2p_os2string(int os_type);
+int e2p_string2os(char *str);
diff --git a/e2fsprogs/old_e2fsprogs/e2p/feature.c b/e2fsprogs/old_e2fsprogs/e2p/feature.c
new file mode 100644
index 000000000..b45754f97
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/feature.c
@@ -0,0 +1,187 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * 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 const 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)
+{
+        const 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)
+{
+        const 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 inline char *skip_over_blanks(char *cp)
+{
+        while (*cp && isspace(*cp))
+                cp++;
+        return cp;
+}
+
+static inline 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 = xstrdup(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/e2fsprogs/old_e2fsprogs/e2p/fgetsetflags.c b/e2fsprogs/old_e2fsprogs/e2p/fgetsetflags.c
new file mode 100644
index 000000000..008b79850
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/fgetsetflags.c
@@ -0,0 +1,70 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * fgetflags.c          - Get a file flags on an ext2 file system
+ * fsetflags.c          - Set a file flags on an ext2 file system
+ *
+ * Copyright (C) 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                           Laboratoire MASI, Institut Blaise Pascal
+ *                           Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 93/10/30     - Creation
+ */
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_EXT2_IOCTLS
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#endif
+
+#include "e2p.h"
+
+#ifdef O_LARGEFILE
+#define OPEN_FLAGS (O_RDONLY|O_NONBLOCK|O_LARGEFILE)
+#else
+#define OPEN_FLAGS (O_RDONLY|O_NONBLOCK)
+#endif
+
+int fgetsetflags (const char * name, unsigned long * get_flags, unsigned long set_flags)
+{
+#ifdef HAVE_EXT2_IOCTLS
+        struct stat buf;
+        int fd, r, f, save_errno = 0;
+
+        if (!stat(name, &buf) &&
+            !S_ISREG(buf.st_mode) && !S_ISDIR(buf.st_mode)) {
+                goto notsupp;
+        }
+        fd = open (name, OPEN_FLAGS);
+        if (fd == -1)
+                return -1;
+        if (!get_flags) {
+                f = (int) set_flags;
+                r = ioctl (fd, EXT2_IOC_SETFLAGS, &f);
+        } else {
+                r = ioctl (fd, EXT2_IOC_GETFLAGS, &f);
+                *get_flags = f;
+        }
+        if (r == -1)
+                save_errno = errno;
+        close (fd);
+        if (save_errno)
+                errno = save_errno;
+        return r;
+notsupp:
+#endif /* HAVE_EXT2_IOCTLS */
+        errno = EOPNOTSUPP;
+        return -1;
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/fgetsetversion.c b/e2fsprogs/old_e2fsprogs/e2p/fgetsetversion.c
new file mode 100644
index 000000000..8d79054d6
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/fgetsetversion.c
@@ -0,0 +1,70 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * fgetversion.c        - Get a file version on an ext2 file system
+ * fsetversion.c        - Set a file version on an ext2 file system
+ *
+ *
+ * Copyright (C) 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                           Laboratoire MASI, Institut Blaise Pascal
+ *                           Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 93/10/30     - Creation
+ */
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include "e2p.h"
+
+#ifdef O_LARGEFILE
+#define OPEN_FLAGS (O_RDONLY|O_NONBLOCK|O_LARGEFILE)
+#else
+#define OPEN_FLAGS (O_RDONLY|O_NONBLOCK)
+#endif
+
+/*
+   To do fsetversion:     unsigned long *ptr_version must be set to NULL.
+                      and unsigned long version must be set to a value
+   To do fgetversion:     unsigned long *ptr_version must NOT be set to NULL
+                      and unsigned long version is ignored.
+        TITO.
+*/
+
+int fgetsetversion (const char * name, unsigned long * get_version, unsigned long set_version)
+{
+#ifdef HAVE_EXT2_IOCTLS
+        int fd, r, ver, save_errno = 0;
+
+        fd = open (name, OPEN_FLAGS);
+        if (fd == -1)
+                return -1;
+        if (!get_version) {
+                ver = (int) set_version;
+                r = ioctl (fd, EXT2_IOC_SETVERSION, &ver);
+        } else {
+                r = ioctl (fd, EXT2_IOC_GETVERSION, &ver);
+                *get_version = ver;
+        }
+        if (r == -1)
+                save_errno = errno;
+        close (fd);
+        if (save_errno)
+                errno = save_errno;
+        return r;
+#else /* ! HAVE_EXT2_IOCTLS */
+        errno = EOPNOTSUPP;
+        return -1;
+#endif /* ! HAVE_EXT2_IOCTLS */
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/hashstr.c b/e2fsprogs/old_e2fsprogs/e2p/hashstr.c
new file mode 100644
index 000000000..697ffadc3
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/hashstr.c
@@ -0,0 +1,70 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * 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 hash {
+        int num;
+        const char *string;
+};
+
+static const struct hash hash_list[] = {
+        { EXT2_HASH_LEGACY,   "legacy" },
+        { EXT2_HASH_HALF_MD4, "half_md4" },
+        { EXT2_HASH_TEA,      "tea" },
+        { 0, 0 },
+};
+
+const char *e2p_hash2string(int num)
+{
+        const struct hash *p;
+        static char buf[20];
+
+        for (p = hash_list; p->string; p++) {
+                if (num == p->num)
+                        return p->string;
+        }
+        sprintf(buf, "HASHALG_%d", num);
+        return buf;
+}
+
+/*
+ * Returns the hash algorithm, or -1 on error
+ */
+int e2p_string2hash(char *string)
+{
+        const struct hash *p;
+        char *eptr;
+        int num;
+
+        for (p = hash_list; p->string; p++) {
+                if (!strcasecmp(string, p->string)) {
+                        return p->num;
+                }
+        }
+        if (strncasecmp(string, "HASHALG_", 8))
+                return -1;
+
+        if (string[8] == 0)
+                return -1;
+        num = strtol(string+8, &eptr, 10);
+        if (num > 255 || num < 0)
+                return -1;
+        if (*eptr)
+                return -1;
+        return num;
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/iod.c b/e2fsprogs/old_e2fsprogs/e2p/iod.c
new file mode 100644
index 000000000..23ab8d5b5
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/iod.c
@@ -0,0 +1,52 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * iod.c                - Iterate a function on each entry of a directory
+ *
+ * Copyright (C) 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                           Laboratoire MASI, Institut Blaise Pascal
+ *                           Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 93/10/30     - Creation
+ */
+
+#include "e2p.h"
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+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);
+        }
+        free(de);
+        closedir(dir);
+        return 0;
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/ls.c b/e2fsprogs/old_e2fsprogs/e2p/ls.c
new file mode 100644
index 000000000..9d29db6af
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/ls.c
@@ -0,0 +1,273 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ls.c                 - List the contents of an ext2fs superblock
+ *
+ * Copyright (C) 1992, 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                                 Laboratoire MASI, Institut Blaise Pascal
+ *                                 Universite Pierre et Marie Curie (Paris VI)
+ *
+ * Copyright (C) 1995, 1996, 1997  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 <sys/types.h>
+#include <string.h>
+#include <grp.h>
+#include <pwd.h>
+#include <time.h>
+
+#include "e2p.h"
+
+static void print_user(unsigned short uid, FILE *f)
+{
+        struct passwd *pw = getpwuid(uid);
+        fprintf(f, "%u (user %s)\n", uid,
+                        (pw == NULL ? "unknown" : pw->pw_name));
+}
+
+static void print_group(unsigned short gid, FILE *f)
+{
+        struct group *gr = getgrgid(gid);
+        fprintf(f, "%u (group %s)\n", gid,
+                        (gr == NULL ? "unknown" : gr->gr_name));
+}
+
+#define MONTH_INT (86400 * 30)
+#define WEEK_INT (86400 * 7)
+#define DAY_INT (86400)
+#define HOUR_INT (60 * 60)
+#define MINUTE_INT (60)
+
+static const char *interval_string(unsigned int secs)
+{
+        static char buf[256], tmp[80];
+        int             hr, min, num;
+
+        buf[0] = 0;
+
+        if (secs == 0)
+                return "<none>";
+
+        if (secs >= MONTH_INT) {
+                num = secs / MONTH_INT;
+                secs -= num*MONTH_INT;
+                sprintf(buf, "%d month%s", num, (num>1) ? "s" : "");
+        }
+        if (secs >= WEEK_INT) {
+                num = secs / WEEK_INT;
+                secs -= num*WEEK_INT;
+                sprintf(tmp, "%s%d week%s", buf[0] ? ", " : "",
+                        num, (num>1) ? "s" : "");
+                strcat(buf, tmp);
+        }
+        if (secs >= DAY_INT) {
+                num = secs / DAY_INT;
+                secs -= num*DAY_INT;
+                sprintf(tmp, "%s%d day%s", buf[0] ? ", " : "",
+                        num, (num>1) ? "s" : "");
+                strcat(buf, tmp);
+        }
+        if (secs > 0) {
+                hr = secs / HOUR_INT;
+                secs -= hr*HOUR_INT;
+                min = secs / MINUTE_INT;
+                secs -= min*MINUTE_INT;
+                sprintf(tmp, "%s%d:%02d:%02d", buf[0] ? ", " : "",
+                        hr, min, secs);
+                strcat(buf, tmp);
+        }
+        return buf;
+}
+
+static void print_features(struct ext2_super_block * s, FILE *f)
+{
+#ifdef EXT2_DYNAMIC_REV
+        int     i, j, printed=0;
+        __u32   *mask = &s->s_feature_compat, m;
+
+        fprintf(f, "Filesystem features:     ");
+        for (i=0; i <3; i++,mask++) {
+                for (j=0,m=1; j < 32; j++, m<<=1) {
+                        if (*mask & m) {
+                                fprintf(f, " %s", e2p_feature2string(i, m));
+                                printed++;
+                        }
+                }
+        }
+        if (printed == 0)
+                fprintf(f, " (none)");
+        fprintf(f, "\n");
+#endif
+}
+
+static void print_mntopts(struct ext2_super_block * s, FILE *f)
+{
+#ifdef EXT2_DYNAMIC_REV
+        int     i, printed=0;
+        __u32   mask = s->s_default_mount_opts, m;
+
+        fprintf(f, "Default mount options:   ");
+        if (mask & EXT3_DEFM_JMODE) {
+                fprintf(f, " %s", e2p_mntopt2string(mask & EXT3_DEFM_JMODE));
+                printed++;
+        }
+        for (i=0,m=1; i < 32; i++, m<<=1) {
+                if (m & EXT3_DEFM_JMODE)
+                        continue;
+                if (mask & m) {
+                        fprintf(f, " %s", e2p_mntopt2string(m));
+                        printed++;
+                }
+        }
+        if (printed == 0)
+                fprintf(f, " (none)");
+        fprintf(f, "\n");
+#endif
+}
+
+
+#ifndef EXT2_INODE_SIZE
+#define EXT2_INODE_SIZE(s) sizeof(struct ext2_inode)
+#endif
+
+#ifndef EXT2_GOOD_OLD_REV
+#define EXT2_GOOD_OLD_REV 0
+#endif
+
+void list_super2(struct ext2_super_block * sb, FILE *f)
+{
+        int inode_blocks_per_group;
+        char buf[80], *str;
+        time_t  tm;
+
+        inode_blocks_per_group = (((sb->s_inodes_per_group *
+                                    EXT2_INODE_SIZE(sb)) +
+                                   EXT2_BLOCK_SIZE(sb) - 1) /
+                                  EXT2_BLOCK_SIZE(sb));
+        if (sb->s_volume_name[0]) {
+                memset(buf, 0, sizeof(buf));
+                strncpy(buf, sb->s_volume_name, sizeof(sb->s_volume_name));
+        } else
+                strcpy(buf, "<none>");
+        fprintf(f, "Filesystem volume name:   %s\n", buf);
+        if (sb->s_last_mounted[0]) {
+                memset(buf, 0, sizeof(buf));
+                strncpy(buf, sb->s_last_mounted, sizeof(sb->s_last_mounted));
+        } else
+                strcpy(buf, "<not available>");
+        fprintf(f,
+                "Last mounted on:          %s\n"
+                "Filesystem UUID:          %s\n"
+                "Filesystem magic number:  0x%04X\n"
+                "Filesystem revision #:    %d",
+                buf, e2p_uuid2str(sb->s_uuid), sb->s_magic, sb->s_rev_level);
+        if (sb->s_rev_level == EXT2_GOOD_OLD_REV) {
+                fprintf(f, " (original)\n");
+#ifdef EXT2_DYNAMIC_REV
+        } else if (sb->s_rev_level == EXT2_DYNAMIC_REV) {
+                fprintf(f, " (dynamic)\n");
+#endif
+        } else
+                fprintf(f, " (unknown)\n");
+        print_features(sb, f);
+        print_mntopts(sb, f);
+        fprintf(f, "Filesystem state:        ");
+        print_fs_state (f, sb->s_state);
+        fprintf(f, "\nErrors behavior:          ");
+        print_fs_errors(f, sb->s_errors);
+        str = e2p_os2string(sb->s_creator_os);
+        fprintf(f,
+                "\n"
+                "Filesystem OS type:       %s\n"
+                "Inode count:              %u\n"
+                "Block count:              %u\n"
+                "Reserved block count:     %u\n"
+                "Free blocks:              %u\n"
+                "Free inodes:              %u\n"
+                "First block:              %u\n"
+                "Block size:               %u\n"
+                "Fragment size:            %u\n",
+                str, sb->s_inodes_count, sb->s_blocks_count, sb->s_r_blocks_count,
+                sb->s_free_blocks_count, sb->s_free_inodes_count,
+                sb->s_first_data_block, EXT2_BLOCK_SIZE(sb), EXT2_FRAG_SIZE(sb));
+        free(str);
+        if (sb->s_reserved_gdt_blocks)
+                fprintf(f, "Reserved GDT blocks:      %u\n",
+                        sb->s_reserved_gdt_blocks);
+        fprintf(f,
+                "Blocks per group:         %u\n"
+                "Fragments per group:      %u\n"
+                "Inodes per group:         %u\n"
+                "Inode blocks per group:   %u\n",
+                sb->s_blocks_per_group, sb->s_frags_per_group,
+                sb->s_inodes_per_group, inode_blocks_per_group);
+        if (sb->s_first_meta_bg)
+                fprintf(f, "First meta block group:   %u\n",
+                        sb->s_first_meta_bg);
+        if (sb->s_mkfs_time) {
+                tm = sb->s_mkfs_time;
+                fprintf(f, "Filesystem created:       %s", ctime(&tm));
+        }
+        tm = sb->s_mtime;
+        fprintf(f, "Last mount time:          %s",
+                sb->s_mtime ? ctime(&tm) : "n/a\n");
+        tm = sb->s_wtime;
+        fprintf(f,
+                "Last write time:          %s"
+                "Mount count:              %u\n"
+                "Maximum mount count:      %d\n",
+                ctime(&tm), sb->s_mnt_count, sb->s_max_mnt_count);
+        tm = sb->s_lastcheck;
+        fprintf(f,
+                "Last checked:             %s"
+                "Check interval:           %u (%s)\n",
+                ctime(&tm),
+                sb->s_checkinterval, interval_string(sb->s_checkinterval));
+        if (sb->s_checkinterval)
+        {
+                time_t next;
+
+                next = sb->s_lastcheck + sb->s_checkinterval;
+                fprintf(f, "Next check after:         %s", ctime(&next));
+        }
+        fprintf(f, "Reserved blocks uid:      ");
+        print_user(sb->s_def_resuid, f);
+        fprintf(f, "Reserved blocks gid:      ");
+        print_group(sb->s_def_resgid, f);
+        if (sb->s_rev_level >= EXT2_DYNAMIC_REV) {
+                fprintf(f,
+                        "First inode:              %d\n"
+                        "Inode size:              %d\n",
+                        sb->s_first_ino, sb->s_inode_size);
+        }
+        if (!e2p_is_null_uuid(sb->s_journal_uuid))
+                fprintf(f, "Journal UUID:             %s\n",
+                        e2p_uuid2str(sb->s_journal_uuid));
+        if (sb->s_journal_inum)
+                fprintf(f, "Journal inode:            %u\n",
+                        sb->s_journal_inum);
+        if (sb->s_journal_dev)
+                fprintf(f, "Journal device:               0x%04x\n",
+                        sb->s_journal_dev);
+        if (sb->s_last_orphan)
+                fprintf(f, "First orphan inode:       %u\n",
+                        sb->s_last_orphan);
+        if ((sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
+            sb->s_def_hash_version)
+                fprintf(f, "Default directory hash:   %s\n",
+                        e2p_hash2string(sb->s_def_hash_version));
+        if (!e2p_is_null_uuid(sb->s_hash_seed))
+                fprintf(f, "Directory Hash Seed:      %s\n",
+                        e2p_uuid2str(sb->s_hash_seed));
+        if (sb->s_jnl_backup_type) {
+                fprintf(f, "Journal backup:           ");
+                if (sb->s_jnl_backup_type == 1)
+                        fprintf(f, "inode blocks\n");
+                else
+                        fprintf(f, "type %u\n", sb->s_jnl_backup_type);
+        }
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/mntopts.c b/e2fsprogs/old_e2fsprogs/e2p/mntopts.c
new file mode 100644
index 000000000..17c26c480
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/mntopts.c
@@ -0,0 +1,134 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * mountopts.c --- convert between default mount options and strings
+ *
+ * Copyright (C) 2002  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 mntopt {
+        unsigned int    mask;
+        const char      *string;
+};
+
+static const struct mntopt mntopt_list[] = {
+        { EXT2_DEFM_DEBUG,      "debug" },
+        { EXT2_DEFM_BSDGROUPS,  "bsdgroups" },
+        { EXT2_DEFM_XATTR_USER, "user_xattr" },
+        { EXT2_DEFM_ACL,        "acl" },
+        { EXT2_DEFM_UID16,      "uid16" },
+        { EXT3_DEFM_JMODE_DATA, "journal_data" },
+        { EXT3_DEFM_JMODE_ORDERED, "journal_data_ordered" },
+        { EXT3_DEFM_JMODE_WBACK, "journal_data_writeback" },
+        { 0, 0 },
+};
+
+const char *e2p_mntopt2string(unsigned int mask)
+{
+        const struct mntopt  *f;
+        static char buf[20];
+        int     fnum;
+
+        for (f = mntopt_list; f->string; f++) {
+                if (mask == f->mask)
+                        return f->string;
+        }
+        for (fnum = 0; mask >>= 1; fnum++);
+        sprintf(buf, "MNTOPT_%d", fnum);
+        return buf;
+}
+
+int e2p_string2mntopt(char *string, unsigned int *mask)
+{
+        const struct mntopt  *f;
+        char            *eptr;
+        int             num;
+
+        for (f = mntopt_list; f->string; f++) {
+                if (!strcasecmp(string, f->string)) {
+                        *mask = f->mask;
+                        return 0;
+                }
+        }
+        if (strncasecmp(string, "MNTOPT_", 8))
+                return 1;
+
+        if (string[8] == 0)
+                return 1;
+        num = strtol(string+8, &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 mntopt set array as requested by the user.  The ok
+ * parameter, if non-zero, allows the application to limit what
+ * mntopts the user is allowed to set or clear using this function.
+ */
+int e2p_edit_mntopts(const char *str, __u32 *mntopts, __u32 ok)
+{
+        char    *cp, *buf, *next;
+        int     neg;
+        unsigned int    mask;
+
+        buf = xstrdup(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_string2mntopt(cp, &mask))
+                        return 1;
+                if (ok && !(ok & mask))
+                        return 1;
+                if (mask & EXT3_DEFM_JMODE)
+                        *mntopts &= ~EXT3_DEFM_JMODE;
+                if (neg)
+                        *mntopts &= ~mask;
+                else
+                        *mntopts |= mask;
+                cp = next ? next+1 : 0;
+        }
+        return 0;
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/ostype.c b/e2fsprogs/old_e2fsprogs/e2p/ostype.c
new file mode 100644
index 000000000..0e111d408
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/ostype.c
@@ -0,0 +1,74 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * getostype.c          - Get the Filesystem OS type
+ *
+ * Copyright (C) 2004,2005  Theodore Ts'o <tytso@mit.edu>
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+#include "e2p.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char * const os_tab[] =
+        { "Linux",
+          "Hurd",
+          "Masix",
+          "FreeBSD",
+          "Lites",
+          0 };
+
+/*
+ * Convert an os_type to a string
+ */
+char *e2p_os2string(int os_type)
+{
+        const char *os;
+        char *ret;
+
+        if (os_type <= EXT2_OS_LITES)
+                os = os_tab[os_type];
+        else
+                os = "(unknown os)";
+
+        ret = xstrdup(os);
+        return ret;
+}
+
+/*
+ * Convert an os_type to a string
+ */
+int e2p_string2os(char *str)
+{
+        const char * const *cpp;
+        int i = 0;
+
+        for (cpp = os_tab; *cpp; cpp++, i++) {
+                if (!strcasecmp(str, *cpp))
+                        return i;
+        }
+        return -1;
+}
+
+#ifdef TEST_PROGRAM
+int main(int argc, char **argv)
+{
+        char    *s;
+        int     i, os;
+
+        for (i=0; i <= EXT2_OS_LITES; i++) {
+                s = e2p_os2string(i);
+                os = e2p_string2os(s);
+                printf("%d: %s (%d)\n", i, s, os);
+                if (i != os) {
+                        fprintf(stderr, "Failure!\n");
+                        exit(1);
+                }
+        }
+        exit(0);
+}
+#endif
+
+
diff --git a/e2fsprogs/old_e2fsprogs/e2p/parse_num.c b/e2fsprogs/old_e2fsprogs/e2p/parse_num.c
new file mode 100644
index 000000000..6db076f9c
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/parse_num.c
@@ -0,0 +1,65 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * parse_num.c          - Parse the number of blocks
+ *
+ * Copyright (C) 2004,2005  Theodore Ts'o <tytso@mit.edu>
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+#include "e2p.h"
+
+#include <stdlib.h>
+
+unsigned long parse_num_blocks(const char *arg, int log_block_size)
+{
+        char *p;
+        unsigned long long num;
+
+        num = strtoull(arg, &p, 0);
+
+        if (p[0] && p[1])
+                return 0;
+
+        switch (*p) {           /* Using fall-through logic */
+        case 'T': case 't':
+                num <<= 10;
+        case 'G': case 'g':
+                num <<= 10;
+        case 'M': case 'm':
+                num <<= 10;
+        case 'K': case 'k':
+                num >>= log_block_size;
+                break;
+        case 's':
+                num >>= 1;
+                break;
+        case '\0':
+                break;
+        default:
+                return 0;
+        }
+        return num;
+}
+
+#ifdef DEBUG
+#include <unistd.h>
+#include <stdio.h>
+
+main(int argc, char **argv)
+{
+        unsigned long num;
+        int log_block_size = 0;
+
+        if (argc != 2) {
+                fprintf(stderr, "Usage: %s arg\n", argv[0]);
+                exit(1);
+        }
+
+        num = parse_num_blocks(argv[1], log_block_size);
+
+        printf("Parsed number: %lu\n", num);
+        exit(0);
+}
+#endif
diff --git a/e2fsprogs/old_e2fsprogs/e2p/pe.c b/e2fsprogs/old_e2fsprogs/e2p/pe.c
new file mode 100644
index 000000000..835274b54
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/pe.c
@@ -0,0 +1,32 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * pe.c                 - Print a second extended filesystem errors behavior
+ *
+ * Copyright (C) 1992, 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                                 Laboratoire MASI, Institut Blaise Pascal
+ *                                 Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 94/01/09     - Creation
+ */
+
+#include <stdio.h>
+
+#include "e2p.h"
+
+void print_fs_errors(FILE *f, unsigned short errors)
+{
+        char *disp = NULL;
+        switch (errors) {
+        case EXT2_ERRORS_CONTINUE: disp = "Continue"; break;
+        case EXT2_ERRORS_RO:       disp = "Remount read-only"; break;
+        case EXT2_ERRORS_PANIC:    disp = "Panic"; break;
+        default:                   disp = "Unknown (continue)";
+        }
+        fprintf(f, disp);
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/pf.c b/e2fsprogs/old_e2fsprogs/e2p/pf.c
new file mode 100644
index 000000000..55d4bc487
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/pf.c
@@ -0,0 +1,74 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * pf.c                 - Print file attributes on an ext2 file system
+ *
+ * Copyright (C) 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                           Laboratoire MASI, Institut Blaise Pascal
+ *                           Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 93/10/30     - Creation
+ */
+
+#include <stdio.h>
+
+#include "e2p.h"
+
+struct flags_name {
+        unsigned long   flag;
+        const 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_direcctory" },
+        { EXT2_NOTAIL_FL, "t", "No_Tailmerging" },
+        { EXT2_TOPDIR_FL, "T", "Top_of_Directory_Hierarchies" },
+        { 0, NULL, NULL }
+};
+
+void print_flags (FILE * f, unsigned long flags, unsigned options)
+{
+        int long_opt = (options & PFOPT_LONG);
+        const struct flags_name *fp;
+        int     first = 1;
+
+        for (fp = flags_array; fp->flag != 0; fp++) {
+                if (flags & fp->flag) {
+                        if (long_opt) {
+                                if (first)
+                                        first = 0;
+                                else
+                                        fputs(", ", f);
+                                fputs(fp->long_name, f);
+                        } else
+                                fputs(fp->short_name, f);
+                } else {
+                        if (!long_opt)
+                                fputs("-", f);
+                }
+        }
+        if (long_opt && first)
+                fputs("---", f);
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/ps.c b/e2fsprogs/old_e2fsprogs/e2p/ps.c
new file mode 100644
index 000000000..a6b4099db
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/ps.c
@@ -0,0 +1,27 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ps.c                 - Print filesystem state
+ *
+ * Copyright (C) 1993, 1994  Remy Card <card@masi.ibp.fr>
+ *                           Laboratoire MASI, Institut Blaise Pascal
+ *                           Universite Pierre et Marie Curie (Paris VI)
+ *
+ * This file can be redistributed under the terms of the GNU Library General
+ * Public License
+ */
+
+/*
+ * History:
+ * 93/12/22     - Creation
+ */
+
+#include <stdio.h>
+
+#include "e2p.h"
+
+void print_fs_state(FILE *f, unsigned short state)
+{
+        fprintf(f, (state & EXT2_VALID_FS ? " clean" : " not clean"));
+        if (state & EXT2_ERROR_FS)
+                fprintf(f, " with errors");
+}
diff --git a/e2fsprogs/old_e2fsprogs/e2p/uuid.c b/e2fsprogs/old_e2fsprogs/e2p/uuid.c
new file mode 100644
index 000000000..474d64a5a
--- /dev/null
+++ b/e2fsprogs/old_e2fsprogs/e2p/uuid.c
@@ -0,0 +1,78 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * uuid.c -- utility routines for manipulating UUID's.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "../ext2fs/ext2_types.h"
+
+#include "e2p.h"
+
+struct uuid {
+        __u32   time_low;
+        __u16   time_mid;
+        __u16   time_hi_and_version;
+        __u16   clock_seq;
+        __u8    node[6];
+};
+
+/* Returns 1 if the uuid is the NULL uuid */
+int e2p_is_null_uuid(void *uu)
+{
+        __u8    *cp;
+        int     i;
+
+        for (i=0, cp = uu; i < 16; i++)
+                if (*cp)
+                        return 0;
+        return 1;
+}
+
+static void e2p_unpack_uuid(void *in, struct uuid *uu)
+{
+        __u8    *ptr = in;
+        __u32   tmp;
+
+        tmp = *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        uu->time_low = tmp;
+
+        tmp = *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        uu->time_mid = tmp;
+
+        tmp = *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        uu->time_hi_and_version = tmp;
+
+        tmp = *ptr++;
+        tmp = (tmp << 8) | *ptr++;
+        uu->clock_seq = tmp;
+
+        memcpy(uu->node, ptr, 6);
+}
+
+void e2p_uuid_to_str(void *uu, char *out)
+{
+        struct uuid uuid;
+
+        e2p_unpack_uuid(uu, &uuid);
+        sprintf(out,
+                "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                uuid.time_low, uuid.time_mid, uuid.time_hi_and_version,
+                uuid.clock_seq >> 8, uuid.clock_seq & 0xFF,
+                uuid.node[0], uuid.node[1], uuid.node[2],
+                uuid.node[3], uuid.node[4], uuid.node[5]);
+}
+
+const char *e2p_uuid2str(void *uu)
+{
+        static char buf[80];
+        if (e2p_is_null_uuid(uu))
+                return "<none>";
+        e2p_uuid_to_str(uu, buf);
+        return buf;
+}