libinstzones/common/zones_lofs.c

/*
 * 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';
    }
}