/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include        <stdio.h>
#include        <limits.h>
#include        <locale.h>
#include        <libintl.h>
#include        <sys/fstyp.h>
#include        <errno.h>
#include        <sys/vfstab.h>
#include        <sys/types.h>
#include        <sys/stat.h>
#include        <fcntl.h>
#include        <string.h>
#include        <libdiskmgt.h>
#include        "fslib.h"


static int match(char **opts, char *s);
static int has_Nflag(char *opts);

#define FSTYPE_MAX      8
#define ARGV_MAX        1024
#define VFS_PATH        "/usr/lib/fs"
#define ALT_PATH        "/etc/fs"

extern char     *default_fstype();
void    stat_snap(char *, char *, char *);
char    *special = NULL;  /*  device special name  */
char    *fstype = NULL;   /*  fstype name is filled in here  */
char    *cbasename;       /* name of command */
char    *newargv[ARGV_MAX];     /* args for the fstype specific command  */
char    vfstab[] = VFSTAB;
int     newargc = 2;

/*
 * TRANSLATION_NOTE - the usage strings in the c_usgstr[] of the
 * following structures should be given a translation; the call to gettext
 * is in the usage() function. The strings are the ones containing
 * "[-F FSType]".
 */

struct commands {
        char *c_basename;
        char *c_optstr;
        char *c_usgstr[4]; /* make sure as large as largest array size */
} cmd_data[] = {
        "clri", "F:o:?V",
        {
                "[-F FSType] [-V] special inumber ...",
                NULL
        },
        "mkfs", "F:o:mb:?V",
        {
                "[-F FSType] [-V] [-m] [-o specific_options] special ",
                "[operands]", NULL
        },
        "dcopy", "F:o:?V",
        {
                "[-F FSType] [-V] special inumber ...",
                NULL
        },
        "fsdb", "F:o:z:?V",
        {
                "[-F FSType] [-V] [-o specific_options] special",
                NULL
        },
        "fssnap", "F:dio:?V",
        {
                "[-F FSType] [-V] -o special_options  /mount/point",
                "-d [-F FSType] [-V] /mount/point | dev",
                "-i [-F FSType] [-V] [-o special-options] [/mount/point | dev]",
                NULL
        },
        "labelit", "F:o:?nV",
        {
                "[-F FSType] [-V] [-o specific_options] special [operands]",
                NULL
        },
        NULL, "F:o:?V",
        {
                "[-F FSType] [-V] [-o specific_options] special [operands]",
                NULL
        }
};
struct  commands *c_ptr;

static void usage(char *cmd, char **usg);
static void lookup(void);

int
main(int argc, char *argv[])
{
        char    *ptr;
        char    full_path[PATH_MAX];
        char    *vfs_path = VFS_PATH;
        char    *alt_path = ALT_PATH;
        int     i;
        int     j;
        int     verbose = 0;            /* set if -V is specified */
        int     F_flg = 0;
        int     mflag = 0;
        int     Nflag = 0;
        char    *oopts = NULL;
        char    *tmpopts = NULL;        /* used for in use checking */
        int     iflag = 0;
        int     usgflag = 0;
        int     arg;                    /* argument from getopt() */
        char    *msg;
        int     error;
        extern  char *optarg;           /* getopt specific */
        extern  int optind;
        extern  int opterr;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif

        (void) textdomain(TEXT_DOMAIN);

        cbasename = ptr = argv[0];
        while (*ptr) {
                if (*ptr++ == '/')
                        cbasename = ptr;
        }


        if (argc == 1) {
                for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
                    (strcmp(c_ptr->c_basename, cbasename) != 0)); c_ptr++)
                ;
                usage(cbasename, c_ptr->c_usgstr);
                exit(2);
        }

        for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
            (strcmp(c_ptr->c_basename, cbasename) != 0));  c_ptr++)
                ;
        while ((arg = getopt(argc, argv, c_ptr->c_optstr)) != -1) {
                        switch (arg) {
                        case 'V':       /* echo complete command line */
                                verbose = 1;
                                break;
                        case 'F':       /* FSType specified */
                                F_flg++;
                                fstype = optarg;
                                break;
                        case 'o':       /* FSType specific arguments */
                                newargv[newargc++] = "-o";
                                newargv[newargc++] = optarg;
                                oopts = optarg;
                                if (!Nflag) {
                                        tmpopts = optarg;
                                        Nflag = has_Nflag(tmpopts);
                                }
                                break;
                        case '?':       /* print usage message */
                                newargv[newargc++] = "-?";
                                usgflag = 1;
                                break;
                        case 'm':       /* FSType specific arguments */
                                mflag = 1;
                                newargv[newargc] = (char *)malloc(3);
                                sprintf(newargv[newargc++], "-%c", arg);
                                if (optarg)
                                        newargv[newargc++] = optarg;
                                break;
                        case 'i': /* fssnap only */
                                iflag = 1;
                                /*FALLTHROUGH*/
                        default:
                                newargv[newargc] = (char *)malloc(3);
                                sprintf(newargv[newargc++], "-%c", arg);
                                if (optarg)
                                        newargv[newargc++] = optarg;
                                break;
                        }
                        optarg = NULL;
        }
        if (F_flg > 1) {
                (void) fprintf(stderr,
                    gettext("%s: more than one FSType specified\n"),
                    cbasename);
                usage(cbasename, c_ptr->c_usgstr);
                exit(2);
        }
        if (fstype != NULL) {
                if (strlen(fstype) > FSTYPE_MAX) {
                        (void) fprintf(stderr,
                            gettext("%s: FSType %s exceeds %d characters\n"),
                            cbasename, fstype, FSTYPE_MAX);
                        exit(2);
                }
        }

        /*  perform a lookup if fstype is not specified  */
        special = argv[optind];
        optind++;

        /* handle -i (fssnap command only) */
        if (iflag) {
                int diff = argc - optind;
                /*
                 * There is no reason to ever call a file system specific
                 * version since its all in kstats.
                 */
                if (diff > 0) /* gave more than one mountpoint or device */
                        usage(cbasename, c_ptr->c_usgstr);
                stat_snap(cbasename, diff == 0 ? argv[argc-1] : NULL, oopts);
                exit(0);
        }

        if ((special == NULL) && (!usgflag)) {
                (void) fprintf(stderr, gettext("%s: special not specified\n"),
                    cbasename);
                usage(cbasename, c_ptr->c_usgstr);
                exit(2);
        }

        if ((fstype == NULL) && (usgflag))
                usage(cbasename, c_ptr->c_usgstr);
        if (fstype == NULL)
                lookup();
        if (fstype == NULL) {
                (void) fprintf(stderr,
                    gettext("%s: FSType cannot be identified\n"), cbasename);
                usage(cbasename, c_ptr->c_usgstr);
                exit(2);
        }
        newargv[newargc++] = special;
        for (; optind < argc; optind++)
                newargv[newargc++] = argv[optind];

        /*  build the full pathname of the fstype dependent command  */
        sprintf(full_path, "%s/%s/%s", vfs_path, fstype, cbasename);

        newargv[1] = cbasename;

        if (verbose) {
                printf("%s -F %s ", cbasename, fstype);
                for (i = 2; newargv[i]; i++)
                        printf("%s ", newargv[i]);
                printf("\n");
                exit(0);
        }

        /*
         * Prior to executing the command for mkfs check for device in use.
         * If the mflag is set, user wants to see command that created
         * an already existing filesystem. Do not check for in use in this
         * case. If Nflag is set user wants to see what the parameters
         * would be to create the filesystem. Do not check for in use in
         * this case.
         */
        if (strcmp(cbasename, "mkfs") == 0 && !mflag && !Nflag) {
                if (dm_inuse(special, &msg, DM_WHO_MKFS, &error) ||
                    error) {
                        if (error != 0) {
                                (void) fprintf(stderr, gettext("Error occurred"
                                    " with device in use checking: %s\n"),
                                    strerror(error));
                        } else {
                                (void) fprintf(stderr, "%s", msg);
                                free(msg);
                                exit(2);
                        }
                }
        }

        /*
         *  Execute the FSType specific command.
         */
        execv(full_path, &newargv[1]);
        if ((errno == ENOENT) || (errno == EACCES)) {
                /*  build the alternate pathname */
                sprintf(full_path, "%s/%s/%s", alt_path, fstype, cbasename);
                if (verbose) {
                        printf("%s -F %s ", cbasename, fstype);
                        for (i = 2; newargv[i]; i++)
                                printf("%s ", newargv[i]);
                        printf("\n");
                        exit(0);
                }
                execv(full_path, &newargv[1]);
        }
        if (errno == ENOEXEC) {
                newargv[0] = "sh";
                newargv[1] = full_path;
                execv("/sbin/sh", &newargv[0]);
        }
        if (errno != ENOENT) {
                perror(cbasename);
                (void) fprintf(stderr, gettext("%s: cannot execute %s\n"),
                    cbasename, full_path);
                exit(2);
        }

        if (sysfs(GETFSIND, fstype) == (-1)) {
                (void) fprintf(stderr,
                    gettext("%s: FSType %s not installed in the kernel\n"),
                    cbasename, fstype);
                exit(2);
        }
        (void) fprintf(stderr,
            gettext("%s: Operation not applicable for FSType %s \n"),
            cbasename, fstype);
        return (2);
}

static void
usage(char *cmd, char **usg)
{
        int i;
        (void) fprintf(stderr, gettext("Usage:\n"));
        for (i = 0; usg[i] != NULL; i++)
                (void) fprintf(stderr, "%s %s\n", gettext(cmd),
                    gettext(usg[i]));
        exit(2);
}


/*
 *  This looks up the /etc/vfstab entry given the device 'special'.
 *  It is called when the fstype is not specified on the command line.
 *
 *  The following global variables are used:
 *      special, fstype
 */

static void
lookup(void)
{
        FILE    *fd;
        int     ret;
        struct vfstab   vget, vref;

        if ((fd = fopen(vfstab, "r")) == NULL) {
                (void) fprintf(stderr, gettext("%s: cannot open vfstab\n"),
                    cbasename);
                exit(1);
        }
        vfsnull(&vref);
        vref.vfs_special = special;
        ret = getvfsany(fd, &vget, &vref);
        if (ret == -1) {
                rewind(fd);
                vfsnull(&vref);
                vref.vfs_fsckdev = special;
                ret = getvfsany(fd, &vget, &vref);
        }
        fclose(fd);

        switch (ret) {
        case -1:
                fstype = default_fstype(special);
                break;
        case 0:
                fstype = vget.vfs_fstype;
                break;
        case VFS_TOOLONG:
                (void) fprintf(stderr,
                    gettext("%s: line in vfstab exceeds %d characters\n"),
                    cbasename, VFS_LINE_MAX-2);
                exit(1);
                break;
        case VFS_TOOFEW:
                (void) fprintf(stderr,
                    gettext("%s: line in vfstab has too few entries\n"),
                    cbasename);
                exit(1);
                break;
        }
}

void
stat_snap(char *cmd, char *mountpoint, char *opts)
{
        int fd; /* check mount point if given */
        int en;
        char *errstr;

        if (mountpoint) {
                if ((fd = open(mountpoint, O_RDONLY)) < 0) {
                        en = errno;
                        errstr = strerror(errno);
                        if (errstr == NULL)
                                errstr = gettext("Unknown error");

                        (void) fprintf(stderr,
                            gettext("%s: %s: error %d: %s\n"),
                            cmd, mountpoint, en, errstr);

                        exit(2);
                }
                close(fd);
        }
        fssnap_show_status(mountpoint, opts, 1, (opts ? 0 : 1));
}
static int
has_Nflag(char *opts)
{
        while (opts != NULL && *opts != '\0') {
                if (match(&opts, "N")) {
                        return (1);
                }
                if (!opts)
                        break;
                if (*opts == ',')
                        opts ++;
                if (*opts == ' ')
                        opts ++;
        }
        return (0);
}
/*
 * Parses the -o [fs specific options string] to search for the UFS -N flag.
 * Return the opts string pointing to the next position in the string if
 * match is not found. A delimiter of , or ' ' can be used depending on the
 * caller, newfs or mkfs.
 */
static int
match(char **opts, char *s)
{
        char *cs;
        char *tmp_str;

        cs = *opts;

        while (*cs++ == *s) {
                if (*s++ == '\0') {
                        goto true;
                }
        }
        if (*s != '\0') {
                /*
                 * If we cannot find the delimiter it means we
                 * have hit the end of the string.
                 */
                tmp_str = strchr(*opts, ',');
                if (!tmp_str)
                        tmp_str = strchr(*opts, ' ');

                *opts = tmp_str;
                return (0);
        }
true:
        cs--;
        *opts = cs;
        return (1);
}