1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*
23 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*    Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28/*      All Rights Reserved   */
29
30
31#pragma ident	"%Z%%M%	%I%	%E% SMI"
32
33#include	<sys/types.h>
34#include	<sys/param.h>
35#include	<stdio.h>
36#include	<errno.h>
37#include	<stdlib.h>
38#include	<string.h>
39#include	<fmtmsg.h>
40#include	<devmgmt.h>
41#include	<devtab.h>
42#include	<values.h>
43
44
45/*
46 *  Local definitions
47 *	TRUE		Boolean TRUE value
48 *	FALSE		Boolean FALSE value
49 *	TOKDELIMS	Char string of delimiters for lists
50 */
51
52#ifndef		TRUE
53#define		TRUE		('t')
54#endif
55
56#ifndef		FALSE
57#define		FALSE		0
58#endif
59
60#define		TOKDELIMS	", \t\n"
61
62
63/*
64 *  Exit codes:
65 *	EX_OK		Exit code for all went well
66 *	EX_ERROR	Exit code for something failed
67 *	EX_TABLES	A table couldn't be accessed
68 *	EX_NOALLOC	Exit code for allocation failed
69 */
70
71#define		EX_OK		0
72#define		EX_ERROR	1
73#define		EX_TABLES	2
74#define		EX_NOALLOC	3
75
76/*
77 *  Messages:
78 *	M_USAGE		Usage error
79 *	M_INVKEY	Invalid key specified
80 *	M_ERROR		Some strange error
81 *	M_UNABLE	A list of devices is unavailable
82 *	M_DEVTAB	Can't access device table (for reading)
83 *	M_RSVTAB	Can't access device reservation table (for r/w)
84 *	M_NODEV		A list of devices is invalid
85 */
86
87#define	M_USAGE		"usage: devreserv [key [devicelist [...]]]"
88#define	M_INVKEY	"Invalid key: %s"
89#define	M_ERROR		"Internal error, errno=%d"
90#define	M_UNABLE	"Cannot reserve devices"
91#define	M_DEVTAB	"Cannot open the device table: %s"
92#define	M_RSVTAB	"Cannot open the device-reservation table: %s"
93#define	M_NODEV		M_UNABLE
94
95
96/*
97 *  Local functions and static data
98 *
99 *	buildreqlist()	Builds the list of requested devices for devreserv()
100 *	freereqlist()	Free space allocated to the list of requested devices
101 *	ndevsin()	Get number of elements in a list
102 *	stdmsg(r,l,s,m)	Standard message generation
103 *			r	Recoverability flag
104 *			l	Label
105 *			s	Severity
106 *			m	Message
107 *
108 *	lbl		Buffer for the label-component of a message
109 *	txt		Buffer for the text-component of a message
110 */
111
112static char  ***buildreqlist();
113static void	freereqlist();
114static int	ndevsin();
115
116#define	stdmsg(r,l,s,m)	(void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,m,MM_NULLACT,MM_NULLTAG)
117
118static	char	lbl[MM_MXLABELLN+1];
119static	char	txt[MM_MXTXTLN+1];
120
121/*
122 *  devreserv [key [devlist [devlist [...]]]]
123 *
124 *	This command reserves sets of devices known to the OA&M device
125 *	management system.  It reserves a device from each of the device
126 *	lists presented to it, reserving them on the key (<key>).  If no
127 *	device-lists are provided, the command lists those devices reserved
128 *	on the given key (<key>).  If no key (<key>) is provided, the
129 *	command lists all devices currently reserved.
130 *
131 *  Options:  None
132 *
133 *  Arguments:
134 *	key		Key to lock the devices on
135 *	devlist		A comma-, space-, or tab-list containing devices
136 *			(pathnames or aliases).  For typical shells, space-
137 *			and tab-lists should be quoted or the separator should
138 *			be somehow escaped.
139 *
140 *  Command Values:
141 *	EX_OK		0	Device(s) successfully allocated
142 *	EX_ERROR	1	A syntax or other error occurred
143 *	EX_TABLES	2	Either the device-table or the device-
144 *				reservation table couldn't be opened as needed
145 *	EX_NOALLOC	3	The device-reservation request couldn't be
146 *				fulfilled.
147 */
148
149int
150main(int argc, char *argv[])
151{
152
153	/* Automatics */
154	char		     ***reqlist;	/* * to list of lists */
155	char		      **argp;		/* Ptr to current argument */
156	char		      **alloclist;	/* List of allocated devices */
157	char		      **pp;		/* Temp ptr to char ptrs */
158	struct reservdev      **rsvd;		/* Ptr to list of rsvd devs */
159	struct reservdev      **plk;		/* Running ptr to locks */
160	char		       *p;		/* Temp char ptr */
161	char		       *devtab;		/* Device table pathname */
162	char		       *rsvtab;		/* Dev-rsv tbl pathname */
163	int			argcount;	/* Number of args on cmd */
164	long			lkey;		/* Key for locking (long) */
165	int			key;		/* Key for locking */
166	int			exitcode;	/* Value to return */
167	int			sev;		/* Message severity */
168	int			syntaxerr;	/* Flag, TRUE if syntax error */
169	int			c;		/* Option character */
170	int			i;		/* Temp counter */
171
172
173	/*
174	 * Initializations
175	 */
176
177	/* Build a message label */
178	if (p = strrchr(argv[0], '/')) p++;
179	else p = argv[0];
180	(void) strlcat(strcpy(lbl, "UX:"), p, sizeof(lbl));
181
182
183	/*
184	 * Allow only the text component of messages to be written
185	 * (this will probably go away in SVR4.1)
186	 */
187
188	(void) putenv("MSGVERB=text");
189
190
191	/*
192	 * Parse the options from the command line
193	 */
194
195	opterr = 0;
196	syntaxerr = FALSE;
197	while ((c = getopt(argc, argv, "")) != EOF) switch(c) {
198	default:
199	    syntaxerr = FALSE;
200	    break;
201	}
202
203	/* If there's (an obvious) syntax error, write a message and quit */
204	if (syntaxerr) {
205	    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
206	    exit(EX_ERROR);
207	}
208
209	/* Argument initializations */
210	argcount = argc - optind;
211	argp = &argv[optind];
212
213
214	/*
215	 *  devreserv
216	 *
217	 *  	If euid == 0, write a list of all currently allocated devices.
218	 */
219
220	if (argcount == 0) {
221
222	    /* Get the list of reserved devices */
223	    if (rsvd = reservdev()) {
224
225		/* Write the list of reserved devices with the key
226		 * that the device was locked on.  The key should go
227		 * in column 16, but separate it from the alias with at
228		 * least one space */
229
230		exitcode = EX_OK;
231		for (plk = rsvd ; *plk ; plk++) {
232		    if ((i = fputs((*plk)->devname, stdout)) >= 0) do
233			(void) fputc(' ', stdout);
234		    while (++i < 16);
235		    (void) fprintf(stdout, "%ld\n", (*plk)->key);
236		}
237
238	    } else {
239
240		/* Problems getting the list of reserved devices */
241		if (((errno == EINVAL) || (errno == EACCES)) && (rsvtab = _rsvtabpath())) {
242		    (void) snprintf(txt, sizeof(txt), M_RSVTAB, rsvtab);
243		    exitcode = EX_TABLES;
244		    sev = MM_ERROR;
245		} else {
246		    (void) sprintf(txt, M_ERROR, errno);
247		    exitcode = EX_ERROR;
248		    sev = MM_HALT;
249		}
250		stdmsg(MM_NRECOV, lbl, sev, txt);
251	    }
252
253	    /* Finished */
254	    exit(exitcode);
255	}
256
257
258	/*
259	 *  devreserv key
260	 *
261	 *  	Generate a list of the devices allocated on a specific key.
262	 */
263
264	if (argcount == 1) {
265
266	    /* Extract the key from the command */
267	    lkey = strtol(*argp, &p, 10);
268	    if (*p || (lkey <= 0) || (lkey > MAXINT)) {
269
270		/* <key> argument invalid */
271		(void) snprintf(txt, sizeof(txt), M_INVKEY, *argp);
272		stdmsg(MM_NRECOV, lbl, MM_ERROR, txt);
273		exitcode = EX_ERROR;
274
275	    } else {
276
277		key = (int) lkey;
278
279		/* Get the list of reserved devices ... */
280		if (rsvd = reservdev()) {
281
282		    /* For each reserved device, write the alias to stdout */
283		    exitcode = EX_OK;
284		    for (plk = rsvd ; *plk ; plk++) {
285			if ((*plk)->key == key) (void) puts((*plk)->devname);
286		    }
287
288		} else {
289
290		    /* Problems getting the list of reserved devices */
291		    if (((errno == EINVAL) || (errno == EACCES)) && (rsvtab = _rsvtabpath())) {
292			(void) snprintf(txt, sizeof(txt), M_RSVTAB, rsvtab);
293			exitcode = EX_TABLES;
294			sev = MM_ERROR;
295		    } else {
296			(void) sprintf(txt, M_ERROR, errno);
297			exitcode = EX_ERROR;
298			sev = MM_HALT;
299		    }
300		    stdmsg(MM_NRECOV, lbl, sev, txt);
301		}
302	    }
303
304	    /* Finished */
305	    exit(exitcode);
306	}
307
308
309	/*
310	 *  devreserv key devlist [...]
311	 *
312	 *	Reserve specific devices
313	 */
314
315	/* Open the device file (if there's one to be opened) */
316	if (!_opendevtab("r")) {
317	    if (devtab = _devtabpath()) {
318		(void) snprintf(txt, sizeof(txt), M_DEVTAB, devtab);
319		exitcode = EX_TABLES;
320		sev = MM_ERROR;
321	    } else {
322		(void) sprintf(txt, M_ERROR, errno);
323		exitcode = EX_ERROR;
324		sev = MM_HALT;
325	    }
326	    stdmsg(MM_NRECOV, lbl, sev, txt);
327	    exit(exitcode);
328	}
329
330	/* Extract the key from the command */
331	lkey = strtol(*argp, &p, 10);
332	if (*p || (lkey <= 0) || (lkey > MAXINT)) {
333	    (void) snprintf(txt, sizeof(txt), M_INVKEY, *argp);
334	    stdmsg(MM_NRECOV, lbl, MM_ERROR, txt);
335	    exit(EX_ERROR);
336	}
337
338	key = (int) lkey;
339	argp++;
340
341	/* Build the device request list from the command arguments */
342	if (reqlist = buildreqlist(argp)) {
343
344	    /* Attempt to allocate the devices */
345	    if (alloclist = devreserv(key, reqlist)) {
346
347		/*
348		 * For each allocated device, write the alias to stdout
349		 * and free the space allocated for the string.
350		 */
351
352		for (pp = alloclist; *pp; pp++) {
353		    (void) puts(*pp);
354		    free(*pp);
355		}
356
357		/* Free the list of allocated devices */
358		free((char *) alloclist);
359		exitcode = EX_OK;
360	    }
361	    else {
362		/* Device allocation failed */
363		if (errno == EAGAIN) {
364		    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_UNABLE);
365		    exitcode = EX_NOALLOC;
366		} else if (errno == ENODEV) {
367		    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_NODEV);
368		    exitcode = EX_NOALLOC;
369		} else {
370		    (void) sprintf(txt, M_ERROR, errno);
371		    stdmsg(MM_NRECOV, lbl, MM_HALT, txt);
372		    exitcode = EX_ERROR;
373		}
374	    }
375	    freereqlist(reqlist);
376	}
377
378
379	/* Exit with the appropriate code */
380	return(exitcode);
381}
382
383/*
384 * char ***buildreqlist(args)
385 *	char   **args
386 *
387 *	Build the list of lists of devices to request, as described by the
388 *	arguments on the command line.
389 *
390 *  Arguments:
391 *	char **args	The address of the first argument of the list of
392 *			lists of devices to allocate.   (This list is
393 *			terminated with a (char *) NULL.)
394 *
395 *  Returns:  char ***
396 *	A pointer to a list containing addresses of lists of pointers to
397 *	character-strings, as expected by "devreserv()"
398 *
399 *  Notes:
400 *    -	Assuming that strtok() won't return "".  If it does, the
401 *	parsing algorithm needs to be enhanced a bit to eliminate
402 *	these cases.
403 */
404
405static char ***
406buildreqlist(args)
407	char  **args;
408{
409	/* Local automatic data */
410	char	     ***addrlist;	/* Addr of space for ptrs to lists */
411	char	     ***ppp;		/* Pointer to pointers to pointers */
412	char	      **pp;		/* Pointer to pointers */
413	char	      **qq;		/* Pointer to pointers */
414	int		noerror;	/* FLAG, TRUE if all's well */
415	int		i;		/* Counter */
416	int		n;		/* Another counter */
417
418
419	/* Count the number of lists we have to work with */
420	i = 1;
421	for (pp = args ; *pp ; pp++) i++;
422
423
424	/* If we can allocate space for the list of lists ... */
425	if (addrlist = (char ***) malloc(i*sizeof(char **))) {
426
427	    /* Parse each list, putting that list in the list of lists */
428	    ppp = addrlist;
429	    noerror = TRUE;
430	    for (pp = args ; noerror && *pp ; pp++) {
431		n = ndevsin(*pp, TOKDELIMS);
432		if (*ppp = (char **) malloc((n+1)*sizeof(char *))) {
433		     qq = *ppp++;
434		     if (*qq++ = strtok(*pp, TOKDELIMS))
435			 while (*qq++ = strtok((char *) NULL, TOKDELIMS));
436		} else noerror = FALSE;
437	    }
438
439	    /* If there was an error, clean up the malloc()s we've made */
440	    if (!noerror) {
441		freereqlist(addrlist);
442		addrlist = (char ***) NULL;
443	    }
444	}
445
446	/* Return ptr to the list of addresses of lists (or NULL if none) */
447	return(addrlist);
448}
449
450/*
451 *  void freereqlist(list)
452 *	char ***list
453 *
454 *	This function frees the space allocated to the list of lists
455 *	referenced by <list>
456 *
457 *  Arguments:
458 *	char ***list	Address of the list of lists
459 *
460 *  Returns:  void
461 */
462
463static void
464freereqlist(list)
465	char ***list;
466{
467	char ***ppp;
468	if (list) {
469	    for (ppp = list ; *ppp ; ppp++) free((char *) *ppp);
470	    free((char *) list);
471	}
472}
473
474/*
475 * int ndevsin(list, delims)
476 *	char   *list
477 *	char   *delims
478 *
479 *	This function determines how many tokens are in the list <list>.
480 *	The tokens are delimited by fields of characters in the string
481 *	<delims>.  It returns the number of tokens in the list.
482 *
483 *  Arguments:
484 *	char *list	The <delims>list of tokens to scan
485 *	char *delims	The list of delimiters that define the list
486 *
487 *  Returns: int
488 *	The number of elements in the list.
489 *
490 *  Notes:
491 *    -	This function does not recognize "null" elements.  For example,
492 *	a,b,,,,c,,d contains 4 elememts (if delims contains a ',')
493 */
494
495static int
496ndevsin(list, delims)
497	char   *list;			/* List to scan */
498	char   *delims;			/* Delimiters */
499{
500	char   *p;			/* Running character pointer */
501	int	count;			/* Number of tokens seen so far */
502	int	tokflag;		/* TRUE if we're parsing a token */
503
504	count = 0;			/* None seen yet */
505	tokflag = FALSE;		/* Not in a token */
506
507	/* Scan the character-string containing the list of tokens */
508	for (p = list ; *p ; p++) {
509
510	    /* If a delimiter, we're not in a token */
511	    if (strchr(delims, *p)) tokflag = FALSE;
512
513	    /* Otherwise, if we weren't in a token, we've found one */
514	    else if (!tokflag) {
515		tokflag = TRUE;
516		count++;
517	    }
518	}
519
520	/* Return the number of elements in the list */
521	return(count);
522}
523