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 
112 static char  ***buildreqlist();
113 static void	freereqlist();
114 static 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 
118 static	char	lbl[MM_MXLABELLN+1];
119 static	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 
149 int
main(int argc,char * argv[])150 main(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 
405 static char ***
buildreqlist(args)406 buildreqlist(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 
463 static void
freereqlist(list)464 freereqlist(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 
495 static int
ndevsin(list,delims)496 ndevsin(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