/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libintl.h>
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/mntent.h>
#include <sys/mnttab.h>
#include <sys/param.h>
#include <libzonecfg.h>
#include "zones_strings.h"
#include "instzones_lib.h"

#define MNTTAB  "/etc/mnttab"

#define MNTTAB_HUNK     32

static struct mnttab *mountTable;
static size_t mountTableSize = 0;
static boolean_t createdFlag = B_FALSE;

/*
 * Name         : z_createMountTable
 * Description  : Populate the mountTable Array with mnttab entries
 * Arguments    : void
 * Returns      : int
 *                0: The Mount Table was succesfully initialized
 *               -1: There was an error during initialisation
 */
int
z_createMountTable(void)
{
        FILE *fp;
        struct mnttab ent;
        struct mnttab *entp;

        if (createdFlag) {
                return (0);
        }

        fp = fopen(MNTTAB, "r");
        if (fp == NULL) {
                _z_program_error(ERR_OPEN_READ, MNTTAB, errno,
                    strerror(errno));
                return (-1);
        }

        /* Put the entries into the table */
        mountTable = NULL;
        mountTableSize = 0;
        createdFlag = B_TRUE;
        while (getmntent(fp, &ent) == 0) {
                if (mountTableSize % MNTTAB_HUNK == 0) {
                        mountTable = _z_realloc(mountTable,
                            (mountTableSize + MNTTAB_HUNK) * sizeof (ent));
                }
                entp = &mountTable[mountTableSize++];

                /*
                 * Zero out any fields we're not using.
                 */
                (void) memset(entp, 0, sizeof (*entp));

                if (ent.mnt_special != NULL)
                        entp->mnt_special = _z_strdup(ent.mnt_special);
                if (ent.mnt_mntopts != NULL)
                        entp->mnt_mntopts = _z_strdup(ent.mnt_mntopts);
                entp->mnt_mountp = _z_strdup(ent.mnt_mountp);
                entp->mnt_fstype = _z_strdup(ent.mnt_fstype);
        }

        (void) fclose(fp);
        return (0);
}

/*
 * Name         : findPathRWStatus
 * Description  : Check whether the given path is an mnttab entry
 * Arguments    : char * - The Path to be verified
 * Returns      : int
 *                -1: The Path is NOT present in the table (mnttab)
 *                 0: The Path is present in the table and is mounted read-only
 *                 1: The Path is present in the table and is mounted read-write
 */
static int
findPathRWStatus(const char *a_path)
{
        int i;

        for (i = 0; i < mountTableSize; i++) {
                if (strcmp(a_path, mountTable[i].mnt_mountp) == 0) {
                        if (hasmntopt(&mountTable[i], MNTOPT_RO) != NULL) {
                                return (0);
                        } else {
                                return (1);
                        }
                }
        }

        return (-1);
}


/*
 * Name         : z_isPathWritable
 * Description  : Check if the given path is in a writable area
 * Arguments    : char * - The Path to be verified
 * Returns      : int
 *                 0: The Path is under a read-only mount
 *                 1: The Path is under a read-write mount
 * NOTE         : This funcion automatically initialises
 *                the mountPoint table if needed.
 */
int
z_isPathWritable(const char *a_str)
{
        int i, result, slen;
        char a_path[MAXPATHLEN];

        if (!createdFlag) {
                if (z_createMountTable() != 0) {
                        return (1);
                }
        }

        (void) strlcpy(a_path, a_str, sizeof (a_path));
        slen = strlen(a_path);

        /*
         * This for loop traverses Path backwards, incrementally removing the
         * basename of Path and looking for the resultant directory in the
         * mnttab.  Once found, it returns the rw status of that file system.
         */
        for (i = slen; i > 0; i--) {
                if ((a_path[i] == '/') || (a_path[i] == '\0')) {
                        a_path[i] = '\0';
                        result = findPathRWStatus(a_path);
                        if (result != -1) {
                                return (result);
                        }
                }
        }

        return (1);
}

/*
 * Name         : z_destroyMountTable
 * Description  : Clear the entries in the mount table
 * Arguments    : void
 * Returns      : void
 */
void
z_destroyMountTable(void)
{
        int i;

        if (!createdFlag) {
                return;
        }

        if (mountTable == NULL) {
                return;
        }

        for (i = 0; i < mountTableSize; i++) {
                free(mountTable[i].mnt_mountp);
                free(mountTable[i].mnt_fstype);
                free(mountTable[i].mnt_special);
                free(mountTable[i].mnt_mntopts);
                assert(mountTable[i].mnt_time == NULL);
        }

        free(mountTable);
        mountTable = NULL;
        mountTableSize = 0;
        createdFlag = B_FALSE;
}

/*
 * Name         : z_resolve_lofs
 * Description  : Loop over potential loopback mounts and symlinks in a
 *                given path and resolve them all down to an absolute path.
 * Arguments    : char * - path to resolve.  path is in writable storage.
 *                size_t - length of path storage.
 * Returns      : void
 */
void
z_resolve_lofs(char *path, size_t pathlen)
{
        int len, arlen, i;
        const char *altroot;
        char tmppath[MAXPATHLEN];
        boolean_t outside_altroot;

        if ((len = resolvepath(path, tmppath, sizeof (tmppath))) == -1)
                return;

        tmppath[len] = '\0';
        (void) strlcpy(path, tmppath, pathlen);

        if (z_createMountTable() == -1)
                return;

        altroot = zonecfg_get_root();
        arlen = strlen(altroot);
        outside_altroot = B_FALSE;
        for (;;) {
                struct mnttab *mnp;

                /* Search in reverse order to find longest match */
                for (i = mountTableSize; i > 0; i--) {
                        mnp = &mountTable[i - 1];
                        if (mnp->mnt_fstype == NULL ||
                            mnp->mnt_mountp == NULL ||
                            mnp->mnt_special == NULL)
                                continue;
                        len = strlen(mnp->mnt_mountp);
                        if (strncmp(mnp->mnt_mountp, path, len) == 0 &&
                            (path[len] == '/' || path[len] == '\0'))
                                break;
                }
                if (i <= 0)
                        break;

                /* If it's not a lofs then we're done */
                if (strcmp(mnp->mnt_fstype, MNTTYPE_LOFS) != 0)
                        break;

                if (outside_altroot) {
                        char *cp;
                        int olen = sizeof (MNTOPT_RO) - 1;

                        /*
                         * If we run into a read-only mount outside of the
                         * alternate root environment, then the user doesn't
                         * want this path to be made read-write.
                         */
                        if (mnp->mnt_mntopts != NULL &&
                            (cp = strstr(mnp->mnt_mntopts, MNTOPT_RO)) !=
                            NULL &&
                            (cp == mnp->mnt_mntopts || cp[-1] == ',') &&
                            (cp[olen] == '\0' || cp[olen] == ',')) {
                                break;
                        }
                } else if (arlen > 0 &&
                    (strncmp(mnp->mnt_special, altroot, arlen) != 0 ||
                    (mnp->mnt_special[arlen] != '\0' &&
                    mnp->mnt_special[arlen] != '/'))) {
                        outside_altroot = B_TRUE;
                }
                /* use temporary buffer because new path might be longer */
                (void) snprintf(tmppath, sizeof (tmppath), "%s%s",
                    mnp->mnt_special, path + len);
                if ((len = resolvepath(tmppath, path, pathlen)) == -1)
                        break;
                path[len] = '\0';
        }
}