8354 sync regcomp(3C) with upstream (fix make catalog)

[unleashed/tickless.git] / usr / src / lib / libadm / common / dgrpent.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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright (c) 1997,1998,2002 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"        /* SVr4.0 1.1 */
/*LINTLIBRARY*/

/*
 * dgrpent.c
 *
 *  Contains functions that deal with the device-group table and are not for
 *  consumption by the general user population.
 *
 *  Functions defined:
 *      _opendgrptab()          Opens the device-group table for commands
 *      _setdgrptab()           Rewinds the open device table
 *      _enddgrptab()           Closes the open device table
 *      _getdgrptabent()        Gets the next entry in the device table
 *      _freedgrptabent()       Frees memory allocated to a device-table entry
 *      _getdgrprec()           Gets a specific record from the device table
 *      _dgrptabpath()          Gets the pathname of the device group file
 */

/*
 *  Header files
 *      <sys/types.h>   System data types
 *      <unistd.h>      Standard UNIX(r) definitions
 *      <stdio.h>       Standard I/O Definitions
 *      <string.h>      String handling definitions
 *      <ctype.h>       Character types and macros
 *      <errno.h>       Errorcode definitions
 *      <sys/stat.h>    File status information
 *      <devmgmt.h>     Global Device Management definitions
 *      "devtab.h"      Local device table definitions
 */

#include        <sys/types.h>
#include        <unistd.h>
#include        <stdio.h>
#include        <string.h>
#include        <ctype.h>
#include        <errno.h>
#include        <sys/stat.h>
#include        <devmgmt.h>
#include        "devtab.h"
#include        <stdlib.h>

/*
 *  Local definitions
 */


/*
 *  Static data definitions:
 *      leftoff         Addr of char to begin next parse using
 *                      getfld(), getattrval(), getquoted()
 *      recbufsz        The size of the buffer used for reading records
 *      recbuf          Addr of malloc() buffer for reading records
 *      recnum          Record number of next record to read
 *      xtndcnt         Number of times the buffer has been extended
 */

static  char            *leftoff = NULL;
static  int             recbufsz = 0;
static  char            *recbuf = NULL;
static  int             recnum = 0;
static  int             xtndcnt = 0;

/*
 *  void _setdgrptab()
 *
 *      This function rewinds the open device table so that the next
 *      _getdgrptabent() returns the first record in the device table.
 *
 *  Arguments:  None
 *
 *  Returns:  Void
 */

void
_setdgrptab(void)
{
        /*  If the device table file is open, rewind the file  */
        if (oam_dgroup) {
            rewind(oam_dgroup);
            recnum = 0;
        }
}

/*
 *  void _enddgrptab()
 *
 *      This function closes the open device table.  It resets the
 *      open device table external variable to NULL.
 *
 *  Arguments:  None
 *
 *  Returns:  Void
 */

void
_enddgrptab(void)
{
        /*  If the device table file is open, close it  */
        if (oam_dgroup) {
            (void) fclose(oam_dgroup);
            recnum = 0;
            oam_dgroup = NULL;
        }
}

/*
 *  char *getfld(ptr, delims)
 *      char   *ptr
 *      char   *delims
 *
 *  Notes:
 *    - Can't use "strtok()" because of its use of static data.  The caller
 *      may be using strtok() and we'll really mess them up.
 *    - The function returns NULL if it didn't find any token -- '\0' can't
 *      be a delimiter using this algorithm.
 */

static char *
getfld(
        char   *ptr,            /* String to parse */
        char   *delims)         /* List of delimiters */
{
        char   *p, *q;

        /*
         *  Figure out where to start.
         *  If given a pointer, use that.
         *  Otherwise, use where we left off.
         */

        p = ptr ? ptr : leftoff;


        /*
         *  If there's anything to parse, search the string for the first
         *  occurrence of any of the delimiters.  If one is found, change it
         *  to '\0' and remember the place to start for next time.  If not
         *  found, forget the restart address and prepare to return NULL
         */

        if (p) {
            while (*p && isspace((unsigned char)*p)) p++;
            if (*p) {
                q = p;
                while (*q && !strchr(delims, *q)) q++;
                if (*q) {
                    *q++ = '\0';
                    leftoff = q;
                } else leftoff = NULL;
            } else leftoff = p = NULL;
        }

        /*  Finished  */
        return (p);
}

/*
 *  char *getnextrec()
 *
 *      This function gets the next record from the input stream "oam_dgroup"
 *      and puts it in the device-group table record buffer (whose address is
 *      in "recbuf").  If the buffer is not allocated or is too small to
 *      accommodate the record, the function allocates more space to the
 *      buffer.
 *
 *  Arguments:  None
 *
 *  Returns:  char *
 *      The address of the buffer containing the record.
 *
 *  Static Data Referenced:
 *      recbuf          Address of the buffer containing records read from the
 *                      device table file
 *      recbufsz        Current size of the record buffer
 *      xtndcnt         Number of times the record buffer has been extended
 *      oam_dgroup      Device-group table stream, expected to be open for (at
 *                      least) reading
 *
 *  Notes:
 *    - The string returned in the buffer <buf> ALWAYS end in a '\n' (newline)
 *      character followed by a '\0' (null).
 */

static char *
getnextrec(void)
{
        /* Automatic data */
        char            *recp;          /* Value to return */
        char            *p;             /* Temp pointer */
        int             done;           /* TRUE if we're finished */
        int             reclen;         /* Number of chars in record */


        /* If there's no buffer for records, try to get one */
        if (!recbuf) {
            if (recbuf = malloc(DGRP_BUFSIZ)) {
                recbufsz = DGRP_BUFSIZ;
                xtndcnt = 0;
            } else return (NULL);
        }


        /* Get the next record */
        recp = fgets(recbuf, recbufsz, oam_dgroup);
        done = FALSE;

        /* While we've something to return and we're not finished ... */
        while (recp && !done) {

            /* If our return string isn't a null-string ... */
            if ((reclen = (int)strlen(recp)) != 0) {

                /* If we have a complete record, we're finished */
                if (*(recp+reclen-1) == '\n') done = TRUE;
                else while (!done) {

                /*
                 * Need to complete the record.  A complete record is one
                 * which is terminated by a new-line character
                 */

                    /* If the buffer is full, expand it and continue reading */
                    if (reclen == recbufsz-1) {

                        /* Have we reached our maximum extension count? */
                        if (xtndcnt < XTND_MAXCNT) {

                            /* Expand the record buffer */
                            if (p = realloc(recbuf,
                                (size_t)(recbufsz+DGRP_BUFINC))) {

                                /* Update buffer information */
                                xtndcnt++;
                                recbuf = p;
                                recbufsz += DGRP_BUFINC;

                            } else {

                                /* Expansion failed */
                                recp = NULL;
                                done = TRUE;
                            }

                        } else {

                            /* Maximum extend count exceeded.  Insane table */
                            recp = NULL;
                            done = TRUE;
                        }

                    }

                    /* Complete the record */
                    if (!done) {

                        /* Read stuff into the expanded space */
                        if (fgets(recbuf+reclen, recbufsz-reclen, oam_dgroup)) {
                            reclen = (int)strlen(recbuf);
                            recp = recbuf;
                            if (*(recp+reclen-1) == '\n') done = TRUE;
                        } else {
                            /* Read failed, corrupt record? */
                            recp = NULL;
                            done = TRUE;
                        }
                    }

                }   /* End incomplete record handling */

            } else {

                /* Read a null string?  (corrupt table) */
                recp = NULL;
                done = TRUE;
            }

        }   /* while (recp && !done) */

        /* Return what we've got (if anything) */
        return (recp);
}

/*
 *  char *_dgrptabpath()
 *
 *      Get the pathname of the device-group table file
 *
 *  Arguments:  None
 *
 *  Returns:  char *
 *      Returns the pathname to the device group table of (char *) NULL if
 *      there was a problem getting the memory needed to contain the
 *      pathname.
 *
 *  Algorithm:
 *      1.  If OAM_DGRP is defined in the environment and is not
 *          defined as "", it returns the value of that environment
 *          variable.
 *      2.  Otherwise, use the devault pathname (as defined by the
 *          environment variable DGRP_PATH in <devmgmt.h>.
 */


char *
_dgrptabpath(void)
{

        /* Automatic data */
#ifdef  DEBUG
        char            *path;          /* Ptr to path in environment */
#endif
        char            *rtnval;                /* Ptr to value to return */


        /*
         * If compiled with -DDEBUG=1,
         * look for the pathname in the environment
         */

#ifdef  DEBUG
        if (((path = getenv(OAM_DGROUP)) != NULL) && (*path)) {
            if (rtnval = malloc(strlen(path)+1))
                (void) strcpy(rtnval, path);
        } else {
#endif
        /*
         * Use the default name.
         */

            if (rtnval = malloc(strlen(DGRP_PATH)+1))
                (void) strcpy(rtnval, DGRP_PATH);

#ifdef  DEBUG
        }
#endif

        /* Finished */
        return (rtnval);
}

/*
 *  int _opendgrptab(mode)
 *      char   *mode
 *
 *      The _opendgrptab() function opens a device-group table for a command.
 *
 *  Arguments:
 *      mode    The open mode to use to open the file.  (i.e. "r" for
 *              reading, "w" for writing.  See FOPEN(BA_OS) in SVID.)
 *
 *  Returns:  int
 *      TRUE if successful, FALSE otherwise
 */

int
_opendgrptab(char *mode)
{
        /* Automatic data */
        char   *dgrptabname;    /* Ptr to the device-group table name */
        int     rtnval;         /* Value to return */

        rtnval = TRUE;
        if (dgrptabname = _dgrptabpath()) {
            if (oam_dgroup) (void) fclose(oam_dgroup);
            if (oam_dgroup = fopen(dgrptabname, mode)) {
                xtndcnt = 0;
                recnum = 0;
            } else rtnval = FALSE;  /* :-( */
        } else rtnval = FALSE;    /* :-( */
        return (rtnval);
}

/*
 *  struct dgrptabent *_getdgrptabent()
 *
 *      This function returns the next entry in the device-group table.
 *      If no device-group table is open, it opens the standard device-group
 *      table and returns the first record in the table.
 *
 *  Arguments:  None.
 *
 *  Returns:  struct dgrptabent *
 *      Pointer to the next record in the device-group table, or
 *      (struct dgrptabent *) NULL if it was unable to open the file or there
 *      are no more records to read.  "errno" reflects the situation.  If
 *      errno is not changed and the function returns NULL, there are no more
 *      records to read.  If errno is set, it indicates the error.
 *
 *  Notes:
 *    - The caller should set "errno" to 0 before calling this function.
 */

struct dgrptabent *
_getdgrptabent(void)
{
        /*  Automatic data  */
        struct dgrptabent       *ent;           /* Dev table entry structure */
        struct member           *q, *r;         /* Tmps for member structs */
        char                    *record;                /* Record just read */
        char                    *p;             /* Tmp char ptr */
        int                     done;           /* TRUE if built an entry */


        /*  Open the device-group table if it's not already open */
        if (!oam_dgroup)
            if (!_opendgrptab("r"))
                return (NULL);


        /*  Get space for the structure we're returning  */
        if (!(ent = malloc(sizeof (struct dgrptabent)))) {
            return (NULL);
        }

        done = FALSE;
        while (!done && (record = getnextrec())) {

            /* Is this a comment record or a data record */
            if (strchr("#\n", *record) ||
                        isspace((unsigned char)*record)) {

                /*
                 *  Record is a comment record
                 */
                ent->comment = TRUE;
                ent->entryno = recnum++;

                /* Alloc space for the comment and save pointer in struct */
                if (ent->dataspace = malloc(strlen(record)+1)) {
                    (void) strcpy(ent->dataspace, record);
                } else {
                    free(ent);
                    ent = NULL;
                }
                done = TRUE;

            } else {

                /*
                 *  Record is a data record
                 */
                ent->comment = FALSE;

                /* Extract the device-group name */
                if (p = getfld(record, ":")) {

                /* Record is a proper record */
                    done = TRUE;
                    ent->entryno = recnum++;

                    /* Copy device group name into malloc()ed space */
                    if (!(ent->name = malloc(strlen(p)+1))) {

                        free(ent);
                        return (NULL);
                    }
                    (void) strcpy(ent->name, p);

                        /*
                         * Extract the membership from the membership list
                         */

                    /* Get the 1st member */
                    ent->dataspace = NULL;
                    while (((p = getfld(NULL, ",\n")) != NULL) && !(*p))
                        ;
                    if (p) {
                        if (!(q = malloc(sizeof (struct member)))) {

                            free(ent->name);
                            free(ent);
                            return (NULL);
                        }
                        if (!(q->name = malloc(strlen(p)+1))) {
                            free(q);
                            free(ent->name);
                            free((char *)ent);
                            return (NULL);
                        }
                        (void) strcpy(q->name, p);
                        ent->membership = q;
                        q->next = NULL;

                        /* Get the rest of the members */
                        while (p = getfld(NULL, ",\n"))
                            if (*p) {
                                if (!(r = malloc(sizeof (struct member)))) {
                                    for (q = ent->membership; q; q = r) {
                                        free(q->name);
                                        r = q->next;
                                        free(q);
                                    }
                                    free(ent->name);
                                    free(ent);
                                    return (NULL);
                                }
                                if (!(r->name = malloc(strlen(p)+1))) {
                                    free(r);
                                    for (q = ent->membership; q; q = r) {
                                        free(q->name);
                                        r = q->next;
                                        free(q);
                                    }
                                    free(ent->name);
                                    free(ent);
                                    return (NULL);
                                }

                                q->next = r;
                                (void) strcpy(r->name, p);
                                r->next = NULL;
                                q = r;
                            }

                    } else {
                        /* No members */
                        ent->membership = NULL;
                    }

                }   /* record contains a group name */

            }   /* record is a data record */

        }   /* while (!done && there's more records) */


        /*  An entry read?  If not, free alloc'd space and return NULL */
        if (!done) {
            free(ent);
            ent = NULL;
        }

        /* Finis */
        return (ent);
}

/*
 *  void _freedgrptabent(dgrptabent)
 *      struct dgrptabent       *dgrptabent;
 *
 *      This function frees space allocated to a device table entry.
 *
 *  Arguments:
 *      struct dgrptabent *dgrptabent   The structure whose space is to be
 *                                      freed.
 *
 *  Returns:  void
 */

void
_freedgrptabent(struct dgrptabent *ent) /* Structure to free */
{
        /*
         * Automatic data
         */

        struct member  *p;              /* Structure being freed */
        struct member  *q;              /* Next structure to free */

        /*
         *  Free the space allocated to the membership structure.
         */

        if (!ent->comment) {
            if ((q = ent->membership) != NULL) do {
                p = q;
                q = p->next;
                if (p->name) free(p->name);
                free(p);
            } while (q);

            /* Free the device group name */
            if (ent->name) free(ent->name);
        }

        /* Free the membership string */
        if (ent->dataspace) free(ent->dataspace);
}

/*
 *  struct dgrptabent *_getdgrprec(dgroup)
 *      char *dgroup
 *
 *      Thie _getdgrprec() function returns a pointer to a structure that
 *      contains the information in the device-group table entry that describes
 *      the device-group <dgroup>.
 *
 *  Arguments:
 *      char *dgroup    A character-string describing the device-group whose
 *                      record is to be retrieved from the device-group table.
 *
 *  Returns:  struct dgrptabent *
 *      A pointer to a structure describing the device group.
 */

struct dgrptabent *
_getdgrprec(char *dgroup)               /* dgroup to search for */
{
        /*
         *  Automatic data
         */

        struct dgrptabent       *dgrprec;       /* Pointer to current record */
        int                     found;          /* FLAG, TRUE if found */


        /*
         *  Search the device-group table looking for the requested
         *  device group
         */

        _setdgrptab();
        errno = 0;
        found = FALSE;
        while (!found && (dgrprec = _getdgrptabent())) {
            if (!dgrprec->comment && strcmp(dgroup, dgrprec->name) == 0)
                found = TRUE;
            else _freedgrptabent(dgrprec);
        }

        /*  Set up return codes if we've failed  */
        if (!found) {
            if (errno == 0) errno = EINVAL;
            dgrprec = NULL;
        }

        /*  Finis  */
        return (dgrprec);
}