/* * 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) 1996-1998 by Sun Microsystems, Inc. * All Rights reserved. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /*LINTLIBRARY*/ /* * devtab.c * * Contains functions that deal with the device table and are not for * consumption by the general user population. * * Functions defined: * _opendevtab() Opens the device table for commands * _setdevtab() Rewinds the open device table * _enddevtab() Closes the open device table * _getdevtabent() Gets the next entry in the device table * _freedevtabent() Frees memory allocated to a device-table entry * _getdevrec() Gets a specific record from the device table * _devtabpath() Get the pathname of the device table file * _validalias() Is a value a valid alias? */ /* * Header files * * <sys/sysmacros.h> System macro definitions * <sys/types.h> System data types * <sys/mkdev.h> Device Macros * <unistd.h> System Symbolic Constants * <stdio.h> Standard I/O definitions * <string.h> String handling definitions * <ctype.h> Character types and macros * <errno.h> Error codes * <sys/stat.h> File status information * <devmgmt.h> Global Device Management definitions * "devtab.h" Local Device Management definitions */ #include <sys/sysmacros.h> #include <sys/types.h> #ifndef SUNOS41 #include <sys/mkdev.h> #endif #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> /* * Static data definitions: * dtabrecnum Record number of the current record (0 to n-1) * 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 * xtndcnt Number of malloc()/realloc() calls on record buffer */ static int xtndcnt = 0; static char *recbuf = NULL; static int recbufsz = 0; static char *leftoff = NULL; static int dtabrecnum = 0; /* * int samedev(x, y) * struct stat x, y * * Compares pertinent information in a stat() structure * to see if the two structures describe the same device. * If the file modes are the same and they have the same * file system and i-node (i.e. they're links) or they * are block or character devices and have the same major * and minor device numbers (i.e. "mknod"s for the same * device), it's the same device. * * Returns: int * TRUE if the two structures describe the same device * FALSE otherwise */ static int samedev(struct stat64 x, struct stat64 y) { int same; /* If the devices are of the same type ... */ if ((x.st_mode & 0170000) == (y.st_mode & 0170000)) { /* * If they are described by the same inode on the same device, * the two devices are the same. Otherwise, if the devices are * character-special or block-special devices, try to match by * device type and major and minor device numbers. */ if ((x.st_dev == y.st_dev) && (x.st_ino == y.st_ino)) same = TRUE; else if (((x.st_mode & 0170000) == 0020000) || ((x.st_mode & 0170000) == 0060000)) { if ((major(x.st_rdev) == major(y.st_rdev)) && (minor(x.st_rdev) == minor(y.st_rdev))) same = TRUE; else same = FALSE; } else same = FALSE; } else same = FALSE; return (same); } /* * void _setdevtab() * * This function rewinds the open device table so that the next * _getdevtabent() returns the first record in the device table. * * Arguments: None * * Returns: Void */ void _setdevtab(void) { /* If the device table file is open, rewind the file */ if (oam_devtab != NULL) { rewind(oam_devtab); dtabrecnum = 0; } } /* * void _enddevtab() * * This function closes the open device table. It resets the * open device table external variable to NULL. * * Arguments: None * * Returns: Void */ void _enddevtab(void) { /* If the device table file is open, close it */ if (oam_devtab != NULL) { (void) fclose(oam_devtab); oam_devtab = NULL; dtabrecnum = 0; } } /* * 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 */ { int done; /* TRUE if we're finished */ char *p, *q; /* Temp pointers */ /* * 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. * Don't terminate on "escaped" characters. */ if (p) { /* Anything to do ?? */ q = p; /* Where to begin */ done = FALSE; /* We're not done yet */ while (*q && !done) { /* Any more chars */ if (*q == '\\') { /* Escaped ? */ if (*(++q)) q++; /* Skip escaped char */ } else /* Not escaped */ if (!strchr(delims, *q)) q++; /* Skip non-delim */ else done = TRUE; /* Otherwise, done */ } if (*q) { /* Terminator found? */ *q++ = '\0'; /* Null-terminate token */ leftoff = q; /* Remember restart pt. */ } else leftoff = p = NULL; /* Nothin found or left */ } /* Finished */ return (p); /* Return ptr to token */ } /* * char *getquoted(ptr) * char *ptr; * * This function extracts a quoted string from the string pointed * to by <ptr>, or, if <ptr> is NULL, wherever we left off * last time. * * Arguments: * char *ptr Pointer to the character-string to parse, or * (char *) NULL if we're to pick up where we * [getquoted(), getfld(), and getattrval()] left off. * * Returns: char * * The address of malloc()ed space that contains the possibly quoted * string. * * Notes: * - This code only works if it can assume that the last character in * the string it's parsing is a '\n', something that is guarenteed * by the getnextrec() function. */ static char * getquoted(char *ptr) { /* Automatic data */ char *rtn; /* Value to return */ char *p, *q; /* Temps */ /* Figure out where to start off */ p = ptr ? ptr : leftoff; /* If there's anything to parse and it's a quoted string ... */ if ((p) && (*p == '"') && (p = getfld(p+1, "\""))) { /* Copy string for the caller */ if (rtn = malloc(strlen(p)+1)) { /* Malloc() space */ q = rtn; /* Set up temp ptr */ do { if (*p == '\\') p++; /* Skip escape */ *q++ = *p; /* Copy char */ } while (*p++); /* While there's chars */ } else leftoff = rtn = NULL; } else leftoff = rtn = NULL; /* Fini */ return (rtn); } /* * struct attrval *getattrval(ptr) * char *ptr * * This function extracts the next attr=val pair from <ptr> or wherever * getfld() left off... * * Arguments: * char *ptr The string to parse, or (char *) NULL if we're to * begin wherever we left off last time. * * Returns: struct attrval * * The address of a malloc()ed structure containing the attribute and the * value of the attr=val pair extracted. */ static struct attrval * getattrval(char *ptr) { /* Automatic data */ struct attrval *rtn; /* Ptr to struct to return */ char *p, *q; /* Temp pointers */ /* Use what's given to us or wherever we left off */ p = ptr ? ptr : leftoff; /* If there's anything to parse, extract the next attr=val pair */ if (p) { /* Eat white space */ while (*p && isspace((unsigned char)*p)) p++; /* Extract the attribute name, if any */ if (*p && getfld(p, "=")) { /* Allocate space for the structure we're building */ if (rtn = malloc(sizeof (struct attrval))) { /* Allocate space for the attribute name */ if (rtn->attr = malloc(strlen(p)+1)) { /* Copy the attribute name into alloc'd space */ q = rtn->attr; /* Set up temp ptr */ do { if (*p == '\\') p++; /* Skip escape */ *q++ = *p; /* Copy char */ } while (*p++); /* While more */ /* Extract the value */ if (!(rtn->val = getquoted(NULL))) { /* Error getting value, free resources */ free(rtn->attr); free(rtn); leftoff = NULL; rtn = NULL; } } else { /* Error getting space for attribute, free resources */ free(rtn); leftoff = NULL; rtn = NULL; } } else { /* No space for attr struct */ leftoff = NULL; rtn = NULL; } } else { /* No attribute name */ leftoff = NULL; rtn = NULL; } } else { /* Nothing to parse */ leftoff = NULL; rtn = NULL; } /* Done */ return (rtn); } /* * char *getnextrec() * * This function gets the next record from the input stream "oam_devtab" * and puts it in the device-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_devtab Device 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(DTAB_BUFSIZ)) { recbufsz = DTAB_BUFSIZ; xtndcnt = 0; } else return (NULL); } /* Get the next record */ recp = fgets(recbuf, recbufsz, oam_devtab); 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') && ((reclen == 1) || (*(recp+reclen-2) != '\\'))) done = TRUE; else while (!done) { /* * Need to complete the record. A complete record is * one which is terminated by an unescaped 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+DTAB_BUFINC)) { /* Update buffer information */ xtndcnt++; recbuf = p; recbufsz += DTAB_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_devtab)) { reclen = (int)strlen(recbuf); recp = recbuf; if ((*(recp+reclen-1) == '\n') && ((reclen == 1) || (*(recp+reclen-2) != '\\'))) 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 *_devtabpath() * * Get the pathname of the device table * * Arguments: None * * Returns: char * * Returns the pathname to the device table of NULL if * there was a problem getting the memory needed to contain the * pathname. * * Algorithm: * 1. If OAM_DEVTAB is defined in the environment and is not * defined as "", it returns the value of that environment * variable. * 2. Otherwise, use the value of the environment variable DTAB_PATH. */ char * _devtabpath(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_DEVTAB)) != NULL) && (*path)) { if (rtnval = malloc(strlen(path)+1)) (void) strcpy(rtnval, path); } else { #endif /* * Use the standard device table. */ if (rtnval = malloc(strlen(DTAB_PATH)+1)) (void) strcpy(rtnval, DTAB_PATH); #ifdef DEBUG } #endif /* Finished */ return (rtnval); } /* * int _opendevtab(mode) * char *mode * * The _opendevtab() function opens a device 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 it successfully opens the device table file, FALSE otherwise */ int _opendevtab(char *mode) { /* * Automatic data */ char *devtabname; /* Ptr to the device table name */ int rtnval; /* Value to return */ rtnval = TRUE; if (devtabname = _devtabpath()) { if (oam_devtab) (void) fclose(oam_devtab); if (oam_devtab = fopen(devtabname, mode)) dtabrecnum = 0; /* :-) */ else rtnval = FALSE; /* :-( */ } else rtnval = FALSE; /* :-( */ return (rtnval); } /* * int _validalias(alias) * char *alias * * Determine if <alias> is a valid alias. Returns TRUE if it is * a valid alias, FALSE otherwise. * * Arguments: * alias Value to check out * * Returns: int * TRUE if <alias> is a valid alias, FALSE otherwise. */ int _validalias(char *alias) /* Alias to validate */ { /* Automatic data */ char *p; /* Temp pointer */ size_t len; /* Length of <alias> */ int rtn; /* Value to return */ /* Assume the worst */ rtn = FALSE; /* * A valid alias contains 0 < i <= 14 characters. The first * must be alphanumeric or "@$_." and the rest must be alphanumeric * or "@#$_+-." */ /* Check length */ if ((alias != NULL) && ((len = strlen(alias)) > 0) && (len <= 14)) { /* Check the first character */ p = alias; if (isalnum((unsigned char)*p) || strchr("@$_.", *p)) { /* Check the rest of the characters */ for (p++; *p && (isalnum((unsigned char)*p) || strchr("@#$_-+.", *p)); p++) ; if (!(*p)) rtn = TRUE; } } /* Return indicator... */ return (rtn); } /* int _validalias() */ /* * struct devtabent *_getdevtabent() * * This function returns the next entry in the device table. * If no device table is open, it opens the standard device table * and returns the first record in the table. * * Arguments: None. * * Returns: struct devtabent * * Pointer to the next record in the device table, or * (struct devtabent *) 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 devtabent * _getdevtabent(void) { /* Automatic data */ struct devtabent *ent; /* Ptr to dev table entry structure */ struct attrval *attr; /* Ptr to struct for attr/val pair */ struct attrval *t; /* Tmp ptr to attr/val struct */ char *record; /* Ptr to the record just read */ char *p, *q; /* Tmp char ptrs */ int done; /* TRUE if we've built an entry */ /* Open the device table if it's not already open */ if (oam_devtab == NULL) { if (!_opendevtab("r")) return (NULL); } /* Get space for the structure we're returning */ if (!(ent = malloc(sizeof (struct devtabent)))) { return (NULL); } done = FALSE; while (!done && (record = getnextrec())) { /* Save record number in structure */ ent->entryno = dtabrecnum++; /* Comment record? If so, just save the value and we're through */ if (strchr("#\n", *record) || isspace((unsigned char)*record)) { ent->comment = TRUE; done = TRUE; if (ent->attrstr = malloc(strlen(record)+1)) { q = ent->attrstr; p = record; do { if (*p == '\\') p++; *q++ = *p; } while (*p++); } else { free(ent); ent = NULL; } } else { /* Record is a data record. Parse it. */ ent->comment = FALSE; ent->attrstr = NULL; /* For now */ /* Extract the device alias */ if (p = getfld(record, ":")) { if (*p) { if (ent->alias = malloc(strlen(p)+1)) { q = ent->alias; do { if (*p == '\\') p++; *q++ = *p; } while (*p++); } } else ent->alias = NULL; /* Extract the character-device name */ if ((p = getfld(NULL, ":")) == NULL) { if (ent->alias) free(ent->alias); } else { if (*p) { if (ent->cdevice = malloc(strlen(p)+1)) { q = ent->cdevice; do { if (*p == '\\') p++; *q++ = *p; } while (*p++); } } else ent->cdevice = NULL; /* Extract the block-device name */ if (!(p = getfld(NULL, ":"))) { if (ent->alias) free(ent->alias); if (ent->cdevice) free(ent->cdevice); } else { if (*p) { if (ent->bdevice = malloc(strlen(p)+1)) { q = ent->bdevice; do { if (*p == '\\') p++; *q++ = *p; } while (*p++); } } else ent->bdevice = NULL; /* Extract the pathname */ if ((p = getfld(NULL, ":\n")) == NULL) { if (ent->alias) free(ent->alias); if (ent->cdevice) free(ent->cdevice); if (ent->bdevice) free(ent->bdevice); } else { if (*p) { if (ent->pathname = malloc(strlen(p)+1)) { q = ent->pathname; do { if (*p == '\\') p++; *q++ = *p; } while (*p++); } } else ent->pathname = NULL; /* Found a valid record */ done = TRUE; /* * Extract attributes, build a linked list of * 'em (may be none) */ if (attr = getattrval(NULL)) { ent->attrlist = attr; t = attr; while (attr = getattrval(NULL)) { t->next = attr; t = attr; } t->next = NULL; } else ent->attrlist = NULL; } /* pathname extracted */ } /* bdevice extracted */ } /* cdevice extracted */ } /* alias extracted */ } } /* !done && record read */ /* If no entry was read, free space allocated to the structure */ if (!done) { free(ent); ent = NULL; } return (ent); } /* * void _freedevtabent(devtabent) * struct devtabent *devtabent; * * This function frees space allocated to a device table entry. * * Arguments: * struct devtabent *devtabent The structure whose space is to be * freed. * * Returns: void */ void _freedevtabent(struct devtabent *ent) { /* * Automatic data */ struct attrval *p; /* Structure being freed */ struct attrval *q; /* Next structure to free */ if (!ent->comment) { /* * Free the attribute list. For each item in the attribute * list, * 1. Free the attribute name (always defined), * 2. Free the value (if any -- it's not defined if we're * changing an existing attribute), * 3. Free the space allocated to the structure. */ q = ent->attrlist; if (q) do { p = q; q = p->next; free(p->attr); if (p->val) free(p->val); free(p); } while (q); /* Free the standard fields (alias, cdevice, bdevice, pathname) */ if (ent->alias) free(ent->alias); if (ent->cdevice) free(ent->cdevice); if (ent->bdevice) free(ent->bdevice); if (ent->pathname) free(ent->pathname); } /* Free the attribute string */ if (ent->attrstr) free(ent->attrstr); /* Free the space allocated to the structure */ free(ent); } /* * struct devtabent *_getdevrec(device) * char *device * * Thie _getdevrec() function returns a pointer to a structure that * contains the information in the device-table entry that describes * the device <device>. * * The device <device> can be a device alias, a pathname contained in * the entry as the "cdevice", "bdevice", or "pathname" attribute, * or a pathname to a device described using the "cdevice", "bdevice", * or "pathname" attribute (depending on whether the pathname references * a character-special file, block-special file, or something else, * respectively. * * Arguments: * char *device A character-string describing the device whose record * is to be retrieved from the device table. * * Returns: struct devtabent * * A pointer to a structure describing the device. * * Notes: * - Someday, add a cache so that repeated requests for the same record * don't require going to the filesystem. (Maybe -- this might belong * in devattr()...) */ struct devtabent * _getdevrec(char *device) /* The device to search for */ { /* * Automatic data */ struct stat64 devstatbuf; /* Stat struct, <device> */ struct stat64 tblstatbuf; /* Stat struct, tbl entry */ struct devtabent *devrec; /* Pointer to current record */ int found; /* TRUE if record found */ int olderrno; /* Old value of errno */ /* * Search the device table looking for the requested device */ _setdevtab(); olderrno = errno; found = FALSE; if ((device != NULL) && !_validalias(device)) { while (!found && (devrec = _getdevtabent())) { if (!devrec->comment) { if (devrec->cdevice) if (strcmp(device, devrec->cdevice) == 0) found = TRUE; if (devrec->bdevice) if (strcmp(device, devrec->bdevice) == 0) found = TRUE; if (devrec->pathname) if (strcmp(device, devrec->pathname) == 0) found = TRUE; } else _freedevtabent(devrec); } /* * If the device <device> wasn't named explicitly in the device * table, compare it against like entries by comparing file- * system, major device number, and minor device number */ if (!found) { _setdevtab(); /* Status the file <device>. If fails, invalid device */ if (stat64(device, &devstatbuf) != 0) errno = ENODEV; else { /* * If <device> is a block-special device. See if it is * in the table by matching its file-system indicator * and major/minor device numbers against the * file-system and major/minor device numbers of the * "bdevice" entries. */ if ((devstatbuf.st_mode & 0170000) == 0020000) { while (!found && (devrec = _getdevtabent())) { if (!devrec->comment && (devrec->cdevice != NULL)) if (stat64(devrec->cdevice, &tblstatbuf) == 0) { if (samedev(tblstatbuf, devstatbuf)) found = TRUE; } else { /* Ignore stat() errs */ errno = olderrno; } if (!found) _freedevtabent(devrec); } } /* * If <device> is a block-special device. See if it is * in the table by matching its file-system indicator * and major/minor device numbers against the * file-system and major/minor device numbers of the * "bdevice" entries. */ else if ((devstatbuf.st_mode & 0170000) == 0060000) { while (!found && (devrec = _getdevtabent())) { if (!devrec->comment && (devrec->bdevice != NULL)) if (stat64(devrec->bdevice, &tblstatbuf) == 0) { if (samedev(tblstatbuf, devstatbuf)) found = TRUE; } else { /* Ignore stat() errs */ errno = olderrno; } if (!found) _freedevtabent(devrec); } } /* * If <device> is neither a block-special or character- * special device. See if it is in the table by * matching its file-system indicator and major/minor * device numbers against the file-system and * major/minor device numbers of the "pathname" entries. */ else { while (!found && (devrec = _getdevtabent())) { if (!devrec->comment && (devrec->pathname != NULL)) if (stat64(devrec->pathname, &tblstatbuf) == 0) { if (samedev(tblstatbuf, devstatbuf)) found = TRUE; } else { /* Ignore stat() errs */ errno = olderrno; } if (!found) _freedevtabent(devrec); } } if (!found) { devrec = NULL; errno = ENODEV; } } /* End case where stat() on the <device> succeeded */ } /* End case handling pathname not explicitly in device table */ } /* End case handling <device> as a fully-qualified pathname */ /* * Otherwise the device <device> is an alias. * Search the table for a record that has as the "alias" attribute * the value <device>. */ else { while (!found && (devrec = _getdevtabent())) { if (!devrec->comment && (device != NULL) && strcmp(device, devrec->alias) == 0) found = TRUE; else _freedevtabent(devrec); } if (!found) { devrec = NULL; errno = ENODEV; } } /* Fini */ return (devrec); }
