/* * 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. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #include <sys/types.h> #include <sys/param.h> #include <stdio.h> #include <errno.h> #include <stdlib.h> #include <string.h> #include <fmtmsg.h> #include <devmgmt.h> #include <devtab.h> #include <values.h> /* * Local definitions * TRUE Boolean TRUE value * FALSE Boolean FALSE value * TOKDELIMS Char string of delimiters for lists */ #ifndef TRUE #define TRUE ('t') #endif #ifndef FALSE #define FALSE 0 #endif #define TOKDELIMS ", \t\n" /* * Exit codes: * EX_OK Exit code for all went well * EX_ERROR Exit code for something failed * EX_TABLES A table couldn't be accessed * EX_NOALLOC Exit code for allocation failed */ #define EX_OK 0 #define EX_ERROR 1 #define EX_TABLES 2 #define EX_NOALLOC 3 /* * Messages: * M_USAGE Usage error * M_INVKEY Invalid key specified * M_ERROR Some strange error * M_UNABLE A list of devices is unavailable * M_DEVTAB Can't access device table (for reading) * M_RSVTAB Can't access device reservation table (for r/w) * M_NODEV A list of devices is invalid */ #define M_USAGE "usage: devreserv [key [devicelist [...]]]" #define M_INVKEY "Invalid key: %s" #define M_ERROR "Internal error, errno=%d" #define M_UNABLE "Cannot reserve devices" #define M_DEVTAB "Cannot open the device table: %s" #define M_RSVTAB "Cannot open the device-reservation table: %s" #define M_NODEV M_UNABLE /* * Local functions and static data * * buildreqlist() Builds the list of requested devices for devreserv() * freereqlist() Free space allocated to the list of requested devices * ndevsin() Get number of elements in a list * stdmsg(r,l,s,m) Standard message generation * r Recoverability flag * l Label * s Severity * m Message * * lbl Buffer for the label-component of a message * txt Buffer for the text-component of a message */ static char ***buildreqlist(); static void freereqlist(); static int ndevsin(); #define stdmsg(r, l, s, m) \ (void) fmtmsg(MM_PRINT | MM_UTIL | r, l, s, m, MM_NULLACT, MM_NULLTAG) static char lbl[MM_MXLABELLN+1]; static char txt[MM_MXTXTLN+1]; /* * devreserv [key [devlist [devlist [...]]]] * * This command reserves sets of devices known to the OA&M device * management system. It reserves a device from each of the device * lists presented to it, reserving them on the key (<key>). If no * device-lists are provided, the command lists those devices reserved * on the given key (<key>). If no key (<key>) is provided, the * command lists all devices currently reserved. * * Options: None * * Arguments: * key Key to lock the devices on * devlist A comma-, space-, or tab-list containing devices * (pathnames or aliases). For typical shells, space- * and tab-lists should be quoted or the separator should * be somehow escaped. * * Command Values: * EX_OK 0 Device(s) successfully allocated * EX_ERROR 1 A syntax or other error occurred * EX_TABLES 2 Either the device-table or the device- * reservation table couldn't be opened as needed * EX_NOALLOC 3 The device-reservation request couldn't be * fulfilled. */ int main(int argc, char *argv[]) { /* Automatics */ char ***reqlist; /* * to list of lists */ char **argp; /* Ptr to current argument */ char **alloclist; /* List of allocated devices */ char **pp; /* Temp ptr to char ptrs */ struct reservdev **rsvd; /* Ptr to list of rsvd devs */ struct reservdev **plk; /* Running ptr to locks */ char *p; /* Temp char ptr */ char *devtab; /* Device table pathname */ char *rsvtab; /* Dev-rsv tbl pathname */ int argcount; /* Number of args on cmd */ long lkey; /* Key for locking (long) */ int key; /* Key for locking */ int exitcode; /* Value to return */ int sev; /* Message severity */ int syntaxerr; /* Flag, TRUE if syntax error */ int c; /* Option character */ int i; /* Temp counter */ const char *errstr; /* * Initializations */ /* Build a message label */ if (p = strrchr(argv[0], '/')) p++; else p = argv[0]; (void) strlcat(strcpy(lbl, "UX:"), p, sizeof (lbl)); /* * Allow only the text component of messages to be written * (this will probably go away in SVR4.1) */ (void) putenv("MSGVERB=text"); /* * Parse the options from the command line */ opterr = 0; syntaxerr = FALSE; while ((c = getopt(argc, argv, "")) != EOF) switch (c) { default: syntaxerr = FALSE; break; } /* If there's (an obvious) syntax error, write a message and quit */ if (syntaxerr) { stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE); exit(EX_ERROR); } /* Argument initializations */ argcount = argc - optind; argp = &argv[optind]; /* * devreserv * * If euid == 0, write a list of all currently allocated devices. */ if (argcount == 0) { /* Get the list of reserved devices */ if (rsvd = reservdev()) { /* * Write the list of reserved devices with the key * that the device was locked on. The key should go * in column 16, but separate it from the alias with at * least one space */ exitcode = EX_OK; for (plk = rsvd; *plk; plk++) { if ((i = fputs((*plk)->devname, stdout)) >= 0) do { (void) fputc(' ', stdout); } while (++i < 16); (void) fprintf(stdout, "%ld\n", (*plk)->key); } } else { /* Problems getting the list of reserved devices */ if (((errno == EINVAL) || (errno == EACCES)) && (rsvtab = _rsvtabpath())) { (void) snprintf(txt, sizeof (txt), M_RSVTAB, rsvtab); exitcode = EX_TABLES; sev = MM_ERROR; } else { (void) sprintf(txt, M_ERROR, errno); exitcode = EX_ERROR; sev = MM_HALT; } stdmsg(MM_NRECOV, lbl, sev, txt); } /* Finished */ exit(exitcode); } /* * devreserv key * * Generate a list of the devices allocated on a specific key. */ if (argcount == 1) { /* Extract the key from the command */ lkey = strtonum(*argp, 1, MAXINT, &errstr); if (errstr != NULL) { /* <key> argument invalid */ (void) snprintf(txt, sizeof (txt), M_INVKEY, *argp); stdmsg(MM_NRECOV, lbl, MM_ERROR, txt); exitcode = EX_ERROR; } else { key = (int)lkey; /* Get the list of reserved devices ... */ if (rsvd = reservdev()) { /* * For each reserved device, write the alias * to stdout */ exitcode = EX_OK; for (plk = rsvd; *plk; plk++) { if ((*plk)->key == key) (void) puts((*plk)->devname); } } else { /* * Problems getting the list of reserved * devices */ if (((errno == EINVAL) || (errno == EACCES)) && (rsvtab = _rsvtabpath())) { (void) snprintf(txt, sizeof (txt), M_RSVTAB, rsvtab); exitcode = EX_TABLES; sev = MM_ERROR; } else { (void) sprintf(txt, M_ERROR, errno); exitcode = EX_ERROR; sev = MM_HALT; } stdmsg(MM_NRECOV, lbl, sev, txt); } } /* Finished */ exit(exitcode); } /* * devreserv key devlist [...] * * Reserve specific devices */ /* Open the device file (if there's one to be opened) */ if (!_opendevtab("r")) { if (devtab = _devtabpath()) { (void) snprintf(txt, sizeof (txt), M_DEVTAB, devtab); exitcode = EX_TABLES; sev = MM_ERROR; } else { (void) sprintf(txt, M_ERROR, errno); exitcode = EX_ERROR; sev = MM_HALT; } stdmsg(MM_NRECOV, lbl, sev, txt); exit(exitcode); } /* Extract the key from the command */ lkey = strtonum(*argp, 1, MAXINT, &errstr); if (errstr != NULL) { (void) snprintf(txt, sizeof (txt), M_INVKEY, *argp); stdmsg(MM_NRECOV, lbl, MM_ERROR, txt); exit(EX_ERROR); } key = (int)lkey; argp++; /* Build the device request list from the command arguments */ if (reqlist = buildreqlist(argp)) { /* Attempt to allocate the devices */ if (alloclist = devreserv(key, reqlist)) { /* * For each allocated device, write the alias to stdout * and free the space allocated for the string. */ for (pp = alloclist; *pp; pp++) { (void) puts(*pp); free(*pp); } /* Free the list of allocated devices */ free(alloclist); exitcode = EX_OK; } else { /* Device allocation failed */ if (errno == EAGAIN) { stdmsg(MM_NRECOV, lbl, MM_ERROR, M_UNABLE); exitcode = EX_NOALLOC; } else if (errno == ENODEV) { stdmsg(MM_NRECOV, lbl, MM_ERROR, M_NODEV); exitcode = EX_NOALLOC; } else { (void) sprintf(txt, M_ERROR, errno); stdmsg(MM_NRECOV, lbl, MM_HALT, txt); exitcode = EX_ERROR; } } freereqlist(reqlist); } /* Exit with the appropriate code */ return (exitcode); } /* * char ***buildreqlist(args) * char **args * * Build the list of lists of devices to request, as described by the * arguments on the command line. * * Arguments: * char **args The address of the first argument of the list of * lists of devices to allocate. (This list is * terminated with a (char *) NULL.) * * Returns: char *** * A pointer to a list containing addresses of lists of pointers to * character-strings, as expected by "devreserv()" * * Notes: * - Assuming that strtok() won't return "". If it does, the * parsing algorithm needs to be enhanced a bit to eliminate * these cases. */ static char *** buildreqlist(char **args) { /* Local automatic data */ char ***addrlist; /* Addr of space for ptrs to lists */ char ***ppp; /* Pointer to pointers to pointers */ char **pp; /* Pointer to pointers */ char **qq; /* Pointer to pointers */ int noerror; /* FLAG, TRUE if all's well */ int i; /* Counter */ int n; /* Another counter */ /* Count the number of lists we have to work with */ i = 1; for (pp = args; *pp; pp++) i++; /* If we can allocate space for the list of lists ... */ if (addrlist = malloc(i * sizeof (char **))) { /* Parse each list, putting that list in the list of lists */ ppp = addrlist; noerror = TRUE; for (pp = args; noerror && *pp; pp++) { n = ndevsin(*pp, TOKDELIMS); if (*ppp = malloc((n + 1) * sizeof (char *))) { qq = *ppp++; if (*qq++ = strtok(*pp, TOKDELIMS)) while (*qq++ = strtok(NULL, TOKDELIMS)) ; } else { noerror = FALSE; } } /* If there was an error, clean up the malloc()s we've made */ if (!noerror) { freereqlist(addrlist); addrlist = NULL; } } /* Return ptr to the list of addresses of lists (or NULL if none) */ return (addrlist); } /* * void freereqlist(list) * char ***list * * This function frees the space allocated to the list of lists * referenced by <list> * * Arguments: * char ***list Address of the list of lists * * Returns: void */ static void freereqlist(char ***list) { char ***ppp; if (list) { for (ppp = list; *ppp; ppp++) free(*ppp); free(list); } } /* * int ndevsin(list, delims) * char *list * char *delims * * This function determines how many tokens are in the list <list>. * The tokens are delimited by fields of characters in the string * <delims>. It returns the number of tokens in the list. * * Arguments: * char *list The <delims>list of tokens to scan * char *delims The list of delimiters that define the list * * Returns: int * The number of elements in the list. * * Notes: * - This function does not recognize "null" elements. For example, * a,b,,,,c,,d contains 4 elememts (if delims contains a ',') */ static int ndevsin(char *list, char *delims) { char *p; /* Running character pointer */ int count; /* Number of tokens seen so far */ int tokflag; /* TRUE if we're parsing a token */ count = 0; /* None seen yet */ tokflag = FALSE; /* Not in a token */ /* Scan the character-string containing the list of tokens */ for (p = list; *p; p++) { /* If a delimiter, we're not in a token */ if (strchr(delims, *p)) { tokflag = FALSE; } else if (!tokflag) { /* * Otherwise, if we weren't in a token, * we've found one */ tokflag = TRUE; count++; } } /* Return the number of elements in the list */ return (count); }
