dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / libadm / common / fulldevnm.c

/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"
/*LINTLIBRARY*/

#include <sys/types.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/vfstab.h>
#include <sys/lofi.h>
#include <sys/ramdisk.h>
#include <sys/fssnap_if.h>
#include "libadm.h"

/*
 * Globals:
 *      getfullrawname - returns a fully-qualified raw device name
 *      getfullblkname - returns a fully-qualified block device name
 *
 * These two routines take a device pathname and return corresponding
 * the raw or block device name.
 *
 * First the device name is fully qualified:
 *      If the device name does not start with a '/' or starts with
 *      './' then the current working directory is added to the beginning
 *      of the pathname.
 *
 *      If the device name starts with a '../' then all but the last
 *      sub-directory of the current working directory is added to the
 *      the beginning of the pathname.
 *
 * Second if the fully-qualified device name given is the raw/block
 * device that is being asked for then the fully-qualified device name is
 * returned.
 *
 * Third if an entry is found in /etc/vfstab which matches the given name
 * then the corresponding raw/block device is returned.  This allows
 * non-standard names to be converted (.i.e., block device "/dev/joe" can
 * be converted to raw device "/dev/fred", via this mechanism).
 *
 * Last standard names are converted.  Standard names are those
 * with a '/dsk/' for block or '/rdsk/' for raw sub-directory components
 * in the device name. Or, the filename component has an 'r' for raw or
 * no 'r' for block (e.g., rsd0a <=> sd0a).
 *
 * Caveat:
 * It is assumed that the block and raw devices have the
 * same device number, and this is used to verify the conversion
 * happened corretly.  If this happens not to be true, due to mapping
 * of minor numbers or sometheing, then entries can be put in the
 * the '/etc/vfstab' file to over-ride this checking.
 *
 *
 * Return Values:
 *      raw/block device name   - (depending on which routine is used)
 *      null string             - When the conversion failed
 *      null pointer            - malloc problems
 *
 * It is up to the user of these routines to free the memory, of
 * the device name or null string returned by these library routines,
 * when appropriate by the application.
 */
#define GET_BLK 0
#define GET_RAW 1

static int test_if_blk(char *, dev_t);
static int test_if_raw(char *, dev_t);
static char *getblkcomplete(char *, struct stat64 *);
static char *getrawcomplete(char *, struct stat64 *);

/*
 * getfullname() - Builds a fully qualified pathname.
 *                 This handles . and .. as well.
 *                 NOTE: This is different from realpath(3C) because
 *                       it does not follow links.
 */
static char *
getfullname(char *path)
{
        char    cwd[MAXPATHLEN];
        char    *c;
        char    *wa;
        size_t  len;

        if (*path == '/')
                return (strdup(path));

        if (getcwd(cwd, sizeof (cwd)) == NULL)
                return (strdup(""));

        /* handle . and .. */
        if (strncmp(path, "./", 2) == 0) {
                /* strip the ./ from the given path */
                path += 2;
        } else if (strncmp(path, "../", 3) == 0) {
                /* strip the last directory component from cwd */
                c = strrchr(cwd, '/');
                *c = '\0';

                /* strip the ../ from the given path */
                path += 3;
        }

        /*
         * Adding 2 takes care of slash and null terminator.
         */
        len = strlen(cwd) + strlen(path) + 2;
        if ((wa = malloc(len)) == NULL)
                return (NULL);

        (void) strcpy(wa, cwd);
        (void) strcat(wa, "/");
        (void) strcat(wa, path);

        return (wa);
}

/*
 * test the path/fname to see if is blk special
 */
static int
test_if_blk(char *new_path, dev_t raw_dev)
{
        struct stat64   buf;

        /* check if we got a char special file */
        if (stat64(new_path, &buf) != 0)
                return (0);

        if (!S_ISBLK(buf.st_mode))
                return (0);

        if (raw_dev != buf.st_rdev)
                return (0);

        return (1);
}

/*
 * test the path/fname to see if is char special
 */
static int
test_if_raw(char *new_path, dev_t blk_dev)
{
        struct stat64   buf;

        /* check if we got a char special file */
        if (stat64(new_path, &buf) != 0)
                return (0);

        if (!S_ISCHR(buf.st_mode))
                return (0);

        if (blk_dev != buf.st_rdev)
                return (0);

        return (1);
}

/*
 * complete getblkrawname() for blk->raw to handle volmgt devices
 */

static char *
getblkcomplete(char *cp, struct stat64 *dat)
{
        char            *dp;
        char            *new_path;
        char            c;

        /* ok, so we either have a bad device or a floppy */

        /* try the rfd# form */
        if ((dp = strstr(cp, "/rfd")) != NULL) {
                if ((new_path = malloc(strlen(cp))) == NULL)
                        return (NULL);

                c = *++dp;                      /* save the 'r' */
                *dp = '\0';                     /* replace it with a null */
                (void) strcpy(new_path, cp);    /* save first part of it */
                *dp++ = c;                      /* give the 'r' back */
                (void) strcat(new_path, dp);    /* copy, skipping the 'r' */

                if (test_if_blk(new_path, dat->st_rdev))
                        return (new_path);

                free(new_path);
                return (strdup(""));
        }

        /* try the rdiskette form */
        if ((dp = strstr(cp, "/rdiskette")) != NULL) {
                if ((new_path = malloc(strlen(cp))) == NULL)
                        return (NULL);

                c = *++dp;                      /* save the 'r' */
                *dp = '\0';                     /* replace it with a null */
                (void) strcpy(new_path, cp);    /* save first part of it */
                *dp++ = c;                      /* give the 'r' back */
                (void) strcat(new_path, dp);    /* copy, skipping the 'r' */

                if (test_if_blk(new_path, dat->st_rdev))
                        return (new_path);

                free(new_path);
                return (strdup(""));
        }

        /* no match found */
        return (strdup(""));
}

/*
 * complete getfullrawname() for raw->blk to handle volmgt devices
 */

static char *
getrawcomplete(char *cp, struct stat64 *dat)
{
        char            *dp;
        char            *new_path;
        char            c;

        /* ok, so we either have a bad device or a floppy */

        /* try the fd# form */
        if ((dp = strstr(cp, "/fd")) != NULL) {
                /* malloc path for new_path to hold raw */
                if ((new_path = malloc(strlen(cp)+2)) == NULL)
                        return (NULL);

                c = *++dp;                      /* save the 'f' */
                *dp = '\0';                     /* replace it with a null */
                (void) strcpy(new_path, cp);    /* save first part of it */
                *dp = c;                        /* put the 'f' back */
                (void) strcat(new_path, "r");   /* insert an 'r' */
                (void) strcat(new_path, dp);    /* copy the rest */

                if (test_if_raw(new_path, dat->st_rdev))
                        return (new_path);

                free(new_path);
        }

        /* try the diskette form */
        if ((dp = strstr(cp, "/diskette")) != NULL) {
                /* malloc path for new_path to hold raw */
                if ((new_path = malloc(strlen(cp)+2)) == NULL)
                        return (NULL);

                c = *++dp;                      /* save at 'd' */
                *dp = '\0';                     /* replace it with a null */
                (void) strcpy(new_path, cp);    /* save first part */
                *dp = c;                        /* put the 'd' back */
                (void) strcat(new_path, "r");   /* insert an 'r' */
                (void) strcat(new_path, dp);    /* copy the rest */

                if (test_if_raw(new_path, dat->st_rdev))
                        return (new_path);

                free(new_path);
                return (strdup(""));
        }

        /* failed to build raw name, return null string */
        return (strdup(""));



}

static char *
getvfsspecial(char *path, int raw_special)
{
        FILE            *fp;
        struct vfstab   vp;
        struct vfstab   ref_vp;

        if ((fp = fopen("/etc/vfstab", "r")) == NULL)
                return (NULL);

        (void) memset(&ref_vp, 0, sizeof (struct vfstab));

        if (raw_special)
                ref_vp.vfs_special = path;
        else
                ref_vp.vfs_fsckdev = path;

        if (getvfsany(fp, &vp, &ref_vp)) {
                (void) fclose(fp);
                return (NULL);
        }

        (void) fclose(fp);

        if (raw_special)
                return (vp.vfs_fsckdev);

        return (vp.vfs_special);
}

/*
 * change the device name to a block device name
 */
char *
getfullblkname(char *cp)
{
        struct stat64   buf;
        char            *dp;
        char            *new_path;
        dev_t           raw_dev;

        if (cp == NULL)
                return (strdup(""));

        /*
         * Create a fully qualified name.
         */
        if ((cp = getfullname(cp)) == NULL)
                return (NULL);

        if (*cp == '\0')
                return (cp);

        if (stat64(cp, &buf) != 0) {
                free(cp);
                return (strdup(""));
        }

        if (S_ISBLK(buf.st_mode))
                return (cp);

        if (!S_ISCHR(buf.st_mode)) {
                free(cp);
                return (strdup(""));
        }

        if ((dp = getvfsspecial(cp, GET_BLK)) != NULL) {
                free(cp);
                return (strdup(dp));
        }

        raw_dev = buf.st_rdev;

        /*
         * We have a raw device name, go find the block name.
         */
        if ((dp = strstr(cp, "/rdsk/")) == NULL &&
            (dp = strstr(cp, "/" LOFI_CHAR_NAME "/")) == NULL &&
            (dp = strstr(cp, "/" RD_CHAR_NAME "/")) == NULL &&
            (dp = strstr(cp, "/" SNAP_CHAR_NAME "/")) == NULL &&
            (dp = strrchr(cp, '/')) == NULL) {
                /* this is not really possible */
                free(cp);
                return (strdup(""));
        }
        dp++;
        if (*dp != 'r') {
                dp = getblkcomplete(cp, &buf);
                free(cp);
                return (dp);
        }
        if ((new_path = malloc(strlen(cp))) == NULL) {
                free(cp);
                return (NULL);
        }
        (void) strncpy(new_path, cp, dp - cp);

        /* fill in the rest of the unraw name */
        (void) strcpy(new_path + (dp - cp), dp + 1);

        if (test_if_blk(new_path, raw_dev)) {
                free(cp);
                /* block name was found, return it here */
                return (new_path);
        }
        free(new_path);

        dp = getblkcomplete(cp, &buf);
        free(cp);
        return (dp);
}

/*
 * change the device name to a raw devname
 */
char *
getfullrawname(char *cp)
{
        struct stat64   buf;
        char            *dp;
        char            *new_path;
        dev_t           blk_dev;

        if (cp == NULL)
                return (strdup(""));

        /*
         * Create a fully qualified name.
         */
        if ((cp = getfullname(cp)) == NULL)
                return (NULL);

        if (*cp == '\0')
                return (cp);

        if (stat64(cp, &buf) != 0) {
                free(cp);
                return (strdup(""));
        }

        if (S_ISCHR(buf.st_mode))
                return (cp);

        if (!S_ISBLK(buf.st_mode)) {
                free(cp);
                return (strdup(""));
        }

        blk_dev = buf.st_rdev;

        if ((dp = getvfsspecial(cp, GET_RAW)) != NULL) {
                free(cp);
                return (strdup(dp));
        }

        /*
         * We have a block device name, go find the raw name.
         */
        if ((dp = strstr(cp, "/dsk/")) == NULL &&
            (dp = strstr(cp, "/" LOFI_BLOCK_NAME "/")) == NULL &&
            (dp = strstr(cp, "/" RD_BLOCK_NAME "/")) == NULL &&
            (dp = strstr(cp, "/" SNAP_BLOCK_NAME "/")) == NULL &&
            (dp = strrchr(cp, '/')) == NULL) {
                /* this is not really possible */
                free(cp);
                return (strdup(""));
        }
        dp++;

        if ((new_path = malloc(strlen(cp)+2)) == NULL) {
                free(cp);
                return (NULL);
        }
        (void) strncpy(new_path, cp, dp - cp);
        /* fill in the rest of the raw name */
        new_path[dp - cp] = 'r';
        (void) strcpy(new_path + (dp - cp) + 1, dp);

        if (test_if_raw(new_path, blk_dev)) {
                free(cp);
                return (new_path);
        }
        free(new_path);

        dp = getrawcomplete(cp, &buf);
        free(cp);
        return (dp);
}