xref: /illumos-gate/usr/src/cmd/modload/drvsubr.c (revision b2d74f53)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 /*
26  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 /*
30  * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
31  */
32 
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <ctype.h>
36 #include <unistd.h>
37 #include <sys/sysmacros.h>
38 #include <libintl.h>
39 #include <wait.h>
40 #include <string.h>
41 #include <strings.h>
42 #include <errno.h>
43 #include <fcntl.h>
44 #include <signal.h>
45 #include <sys/buf.h>
46 #include <sys/stat.h>
47 #include <grp.h>
48 #include "addrem.h"
49 #include "errmsg.h"
50 #include "plcysubr.h"
51 
52 /*
53  * Macros to produce a quoted string containing the value of a
54  * preprocessor macro. For example, if SIZE is defined to be 256,
55  * VAL2STR(SIZE) is "256". This is used to construct format
56  * strings for scanf-family functions below.
57  * Note: For format string use, the argument to VAL2STR() must
58  * be a numeric constant that is one less than the size of the
59  * corresponding data buffer.
60  */
61 #define	VAL2STR_QUOTE(x)	#x
62 #define	VAL2STR(x)		VAL2STR_QUOTE(x)
63 
64 /*
65  * Convenience macro to determine if a character is a quote
66  */
67 #define	isquote(c)	(((c) == '"') || ((c) == '\''))
68 
69 char *driver_aliases;
70 char *driver_classes;
71 char *device_policy;
72 char *extra_privs;
73 char *devfs_root;
74 char *minor_perm;
75 struct drvmod_dir *moddir;
76 char *name_to_major;
77 char *rem_name_to_major;
78 
79 static char *add_rem_lock;	/* lock file */
80 static int  add_rem_lock_fd = -1;
81 
82 static int get_cached_n_to_m_file(char *filename, char ***cache);
83 static int get_name_to_major_entry(int *major_no, char *driver_name,
84     char *file_name);
85 
86 static int is_blank(char *);
87 
88 /*ARGSUSED*/
89 void
log_minorperm_error(minorperm_err_t err,int key)90 log_minorperm_error(minorperm_err_t err, int key)
91 {
92 	switch (err) {
93 	case MP_FOPEN_ERR:
94 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
95 		    MINOR_PERM_FILE);
96 		break;
97 	case MP_FCLOSE_ERR:
98 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
99 		    MINOR_PERM_FILE);
100 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
101 		break;
102 	case MP_IGNORING_LINE_ERR:
103 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
104 		    MINOR_PERM_FILE);
105 		break;
106 	case MP_ALLOC_ERR:
107 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
108 		    MINOR_PERM_FILE);
109 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
110 		break;
111 	case MP_NVLIST_ERR:
112 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
113 		    MINOR_PERM_FILE);
114 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
115 		break;
116 	case MP_CANT_FIND_USER_ERR:
117 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
118 		    MINOR_PERM_FILE);
119 		break;
120 	case MP_CANT_FIND_GROUP_ERR:
121 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
122 		    MINOR_PERM_FILE);
123 		break;
124 	}
125 }
126 
127 /*
128  *  open file
129  * for each entry in list
130  *	where list entries are separated by <list_separator>
131  *	append entry : driver_name <entry_separator> entry
132  * close file
133  * return error/noerr
134  */
135 int
append_to_file(char * driver_name,char * entry_list,char * filename,char list_separator,char * entry_separator,int quoted)136 append_to_file(
137 	char *driver_name,
138 	char *entry_list,
139 	char *filename,
140 	char list_separator,
141 	char *entry_separator,
142 	int quoted)
143 {
144 	int	len, line_len;
145 	int	fpint;
146 	char	*current_head, *previous_head;
147 	char	*line, *one_entry;
148 	FILE	*fp;
149 
150 	if ((fp = fopen(filename, "a")) == NULL) {
151 		perror(NULL);
152 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
153 		    filename);
154 		return (ERROR);
155 	}
156 
157 	len = strlen(entry_list);
158 
159 	one_entry = calloc(len + 1, 1);
160 	if (one_entry == NULL) {
161 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE), filename);
162 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
163 		(void) fclose(fp);
164 		return (ERROR);
165 	}
166 
167 	previous_head = entry_list;
168 
169 	line_len = strlen(driver_name) + len + 4;
170 	if (quoted)
171 		line_len += 2;
172 
173 	line = calloc(line_len, 1);
174 	if (line == NULL) {
175 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
176 		(void) fclose(fp);
177 		err_exit();
178 	}
179 
180 	/*
181 	 * get one entry at a time from list and append to <filename> file
182 	 */
183 
184 	do {
185 		bzero(one_entry, len + 1);
186 		bzero(line, line_len);
187 
188 		current_head = get_entry(previous_head, one_entry,
189 		    list_separator, quoted);
190 		previous_head = current_head;
191 
192 		(void) snprintf(line, line_len,
193 		    quoted ? "%s%s\"%s\"\n" : "%s%s%s\n",
194 		    driver_name, entry_separator, one_entry);
195 
196 		if ((fputs(line, fp)) == EOF) {
197 			perror(NULL);
198 			(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
199 			    filename);
200 		}
201 
202 	} while (*current_head != '\0');
203 
204 
205 	(void) fflush(fp);
206 
207 	fpint = fileno(fp);
208 	(void) fsync(fpint);
209 
210 	(void) fclose(fp);
211 
212 	free(one_entry);
213 	free(line);
214 
215 	return (NOERR);
216 }
217 
218 /*
219  *  open file
220  * for each entry in list
221  *	where list entries are separated by <list_separator>
222  *	append entry : driver_name <entry_separator> entry
223  * close file
224  * return error/noerr
225  */
226 int
append_to_minor_perm(char * driver_name,char * entry_list,char * filename)227 append_to_minor_perm(
228 	char *driver_name,
229 	char *entry_list,
230 	char *filename)
231 {
232 	int	len, line_len;
233 	int	fpint;
234 	char	*current_head, *previous_head;
235 	char	*line, *one_entry;
236 	FILE	*fp;
237 
238 	if ((fp = fopen(filename, "a")) == NULL) {
239 		perror(NULL);
240 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
241 		    filename);
242 		return (ERROR);
243 	}
244 
245 	len = strlen(entry_list);
246 
247 	one_entry = calloc(len + 1, 1);
248 	if (one_entry == NULL) {
249 		(void) fprintf(stderr, gettext(ERR_NO_UPDATE), filename);
250 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
251 		(void) fclose(fp);
252 		return (ERROR);
253 	}
254 
255 	previous_head = entry_list;
256 
257 	line_len = strlen(driver_name) + len + 4;
258 	line = calloc(line_len, 1);
259 	if (line == NULL) {
260 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
261 		(void) fclose(fp);
262 		err_exit();
263 	}
264 
265 	/*
266 	 * get one entry at a time from list and append to <filename> file
267 	 */
268 	do {
269 		bzero(one_entry, len + 1);
270 		bzero(line, line_len);
271 
272 		current_head = get_perm_entry(previous_head, one_entry);
273 		previous_head = current_head;
274 
275 		(void) snprintf(line, line_len, "%s:%s\n",
276 		    driver_name, one_entry);
277 
278 		if ((fputs(line, fp)) == EOF) {
279 			perror(NULL);
280 			(void) fprintf(stderr, gettext(ERR_NO_UPDATE),
281 			    filename);
282 		}
283 
284 	} while (*current_head != '\0');
285 
286 
287 	(void) fflush(fp);
288 
289 	fpint = fileno(fp);
290 	(void) fsync(fpint);
291 
292 	(void) fclose(fp);
293 
294 	free(one_entry);
295 	free(line);
296 
297 	return (NOERR);
298 }
299 
300 /*
301  * Require exact match to delete a driver alias/permission entry.
302  * Note line argument does not remain unchanged.  Return 1 if matched.
303  */
304 static int
match_entry(char * line,char * match)305 match_entry(char *line, char *match)
306 {
307 	char	*token, *p;
308 	int	n;
309 
310 	/* skip any leading white space */
311 	while (*line && isspace(*line))
312 		line++;
313 	/*
314 	 * Find separator for driver name, either space or colon
315 	 *	minor_perm: <driver>:<perm>
316 	 *	driver_aliases: <driver> <alias>
317 	 *	extra_privs: <driver>:<priv>
318 	 */
319 	if ((token = strpbrk(line, " :\t")) == NULL)
320 		return (0);
321 	token++;
322 	/* skip leading white space and quotes */
323 	while (*token && (isspace(*token) || isquote(*token)))
324 		token++;
325 	/* strip trailing newline, white space and quotes */
326 	n = strlen(token);
327 	p = token + n-1;
328 	while (n > 0 && (*p == '\n' || isspace(*p) || isquote(*p))) {
329 		*p-- = 0;
330 		n--;
331 	}
332 	if (n == 0)
333 		return (0);
334 	return (strcmp(token, match) == 0);
335 }
336 
337 /*
338  *  open file
339  * read thru file, deleting all entries if first
340  *    entry = driver_name
341  * close
342  * if error, leave original file intact with message
343  * assumption : drvconfig has been modified to work with clone
344  *  entries in /etc/minor_perm as driver:mummble NOT
345  *  clone:driver mummble
346  * this implementation will NOT find clone entries
347  * clone:driver mummble
348  * match:
349  *	delete just the matching entry
350  *
351  */
352 int
delete_entry(char * oldfile,char * driver_name,char * marker,char * match)353 delete_entry(
354 	char *oldfile,
355 	char *driver_name,
356 	char *marker,
357 	char *match)
358 {
359 	int		rv, i;
360 	int		status = NOERR;
361 	int		drvr_found = 0;
362 	boolean_t	nomatch = B_TRUE;
363 	char		newfile[MAXPATHLEN];
364 	char		*cp;
365 	char		line[MAX_DBFILE_ENTRY];
366 	char		drv[FILENAME_MAX + 1];
367 	FILE		*fp, *newfp;
368 	struct group	*sysgrp;
369 	int		newfd;
370 	char		*copy;		/* same size as line */
371 	char		*match2 = NULL;	/* match with quotes cleaned up */
372 
373 	/*
374 	 * if match is specified, sanity check it and clean it
375 	 * up by removing surrounding quotes as we require
376 	 * an exact match.
377 	 */
378 	if (match) {
379 		cp = match;
380 		while (*cp && (isspace(*cp)))
381 			cp++;
382 		i = strlen(cp);
383 		if (i > 0) {
384 			if ((match2 = strdup(cp)) == NULL) {
385 				perror(NULL);
386 				(void) fprintf(stderr, gettext(ERR_NO_MEM));
387 				return (ERROR);
388 			}
389 			i = strlen(match2) - 1;
390 			while (i >= 0 && (isspace(match2[i]))) {
391 				match2[i] = 0;
392 				i--;
393 			}
394 		}
395 		if (match2 == NULL || (strlen(match2) == 0)) {
396 			(void) fprintf(stderr,
397 			    gettext(ERR_INT_UPDATE), oldfile);
398 			return (ERROR);
399 		}
400 	}
401 
402 	if ((fp = fopen(oldfile, "r")) == NULL) {
403 		perror(NULL);
404 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), oldfile);
405 		return (ERROR);
406 	}
407 
408 	/* Space for defensive copy of input line */
409 	if ((copy = calloc(sizeof (line), 1)) == NULL) {
410 		perror(NULL);
411 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
412 		return (ERROR);
413 	}
414 
415 	/* Build filename for temporary file */
416 	(void) snprintf(newfile, sizeof (newfile), "%s%s", oldfile, ".hold");
417 
418 	/*
419 	 * Set gid so we preserve group attribute.  Ideally we wouldn't
420 	 * assume a gid of "sys" but we can't undo the damage on already
421 	 * installed systems unless we force the issue.
422 	 */
423 	if ((sysgrp = getgrnam("sys")) != NULL) {
424 		(void) setgid(sysgrp->gr_gid);
425 	}
426 
427 	if ((newfd = open(newfile, O_WRONLY | O_CREAT | O_EXCL, 0644)) < 0) {
428 		if (errno == EEXIST) {
429 			(void) fprintf(stderr, gettext(ERR_FILE_EXISTS),
430 			    newfile);
431 			return (ERROR);
432 		} else {
433 			(void) fprintf(stderr, gettext(ERR_CREAT_LOCK),
434 			    newfile);
435 			return (ERROR);
436 		}
437 	}
438 
439 	if ((newfp = fdopen(newfd, "w")) == NULL) {
440 		perror(NULL);
441 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
442 		    newfile);
443 		(void) close(newfd);
444 		return (ERROR);
445 	}
446 
447 	while ((fgets(line, sizeof (line), fp) != NULL) && status == NOERR) {
448 		/* copy the whole line */
449 		if (strlcpy(copy, line, sizeof (line)) >= sizeof (line)) {
450 			(void) fprintf(stderr, gettext(ERR_UPDATE), oldfile);
451 			status = ERROR;
452 			break;
453 		}
454 		/* cut off comments starting with '#' */
455 		if ((cp = strchr(copy, '#')) != NULL)
456 			*cp = '\0';
457 		/* ignore comment or blank lines */
458 		if (is_blank(copy)) {
459 			if (fputs(line, newfp) == EOF) {
460 				(void) fprintf(stderr, gettext(ERR_UPDATE),
461 				    oldfile);
462 				status = ERROR;
463 			}
464 			continue;
465 		}
466 
467 		/* get the driver name */
468 		if (sscanf(copy, "%" VAL2STR(FILENAME_MAX) "s", drv) != 1) {
469 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
470 			    oldfile, line);
471 			status = ERROR;
472 			break;
473 		}
474 
475 		for (i = strcspn(drv, marker); i < FILENAME_MAX; i++) {
476 			drv[i] =  '\0';
477 		}
478 
479 		if (strcmp(driver_name, drv) != 0) {
480 			if ((fputs(line, newfp)) == EOF) {
481 				(void) fprintf(stderr, gettext(ERR_UPDATE),
482 				    oldfile);
483 				status = ERROR;
484 			}
485 		} else {
486 			drvr_found++;
487 			if (match2) {	/* Just delete one entry */
488 				/* for now delete just minor_perm and aliases */
489 				if ((strcmp(oldfile, minor_perm) == 0) ||
490 				    (strcmp(oldfile, extra_privs) == 0) ||
491 				    (strcmp(oldfile, driver_aliases) == 0)) {
492 
493 					/* make defensive copy */
494 					if (strlcpy(copy, line, sizeof (line))
495 					    >= sizeof (line)) {
496 						(void) fprintf(stderr,
497 						    gettext(ERR_UPDATE),
498 						    oldfile);
499 						status = ERROR;
500 						break;
501 					}
502 					if (match_entry(copy, match2)) {
503 						nomatch = B_FALSE;
504 					} else {
505 						if ((fputs(line, newfp)) ==
506 						    EOF) {
507 							(void) fprintf(stderr,
508 							    gettext(ERR_UPDATE),
509 							    oldfile);
510 							status = ERROR;
511 						}
512 						if (nomatch != B_FALSE)
513 							nomatch = B_TRUE;
514 					}
515 				}
516 			}
517 
518 		} /* end of else */
519 	} /* end of while */
520 
521 	(void) fclose(fp);
522 	free(copy);
523 	if (match2)
524 		free(match2);
525 
526 	/* Make sure that the file is on disk */
527 	if (fflush(newfp) != 0 || fsync(fileno(newfp)) != 0)
528 		status = ERROR;
529 	else
530 		rv = NOERR;
531 
532 	(void) fclose(newfp);
533 
534 	/* no matching driver found */
535 	rv = NOERR;
536 	if (!drvr_found ||
537 	    (nomatch == B_TRUE)) {
538 		rv = NONE_FOUND;
539 	}
540 
541 	/*
542 	 * if error, leave original file, delete new file
543 	 * if noerr, replace original file with new file
544 	 */
545 
546 	if (status == NOERR) {
547 		if (rename(newfile, oldfile) == -1) {
548 			perror(NULL);
549 			(void) fprintf(stderr, gettext(ERR_UPDATE), oldfile);
550 			(void) unlink(newfile);
551 			return (ERROR);
552 		}
553 	} else {
554 		/*
555 		 * since there's an error, leave file alone; remove
556 		 * new file
557 		 */
558 		if (unlink(newfile) == -1) {
559 			(void) fprintf(stderr, gettext(ERR_CANT_RM), newfile);
560 		}
561 		return (ERROR);
562 	}
563 
564 	return (rv);
565 }
566 
567 
568 /*
569  * wrapper for call to get_name_to_major_entry(): given driver name,
570  * retrieve major number.
571  */
572 int
get_major_no(char * driver_name,char * file_name)573 get_major_no(char *driver_name, char *file_name)
574 {
575 	int major = UNIQUE;
576 
577 	if (get_name_to_major_entry(&major, driver_name, file_name) == ERROR)
578 		return (ERROR);
579 	else
580 		return (major);
581 }
582 
583 /*
584  * wrapper for call to get_name_to_major_entry(): given major number,
585  * retrieve driver name.
586  */
587 int
get_driver_name(int major,char * file_name,char * buf)588 get_driver_name(int major, char *file_name, char *buf)
589 {
590 	if (major < 0)
591 		return (ERROR);
592 	return (get_name_to_major_entry(&major, buf, file_name));
593 }
594 
595 
596 /*
597  * return pointer to cached name_to_major file - reads file into
598  * cache if this has not already been done.  Since there may be
599  * requests for multiple name_to_major files (rem_name_to_major,
600  * name_to_major), this routine keeps a list of cached files.
601  */
602 static int
get_cached_n_to_m_file(char * filename,char *** cache)603 get_cached_n_to_m_file(char *filename, char ***cache)
604 {
605 	struct n_to_m_cache {
606 		char *file;
607 		char **cached_file;
608 		int size;
609 		struct n_to_m_cache *next;
610 	};
611 	static struct n_to_m_cache *head = NULL;
612 	struct n_to_m_cache *ptr;
613 	FILE *fp;
614 	char drv[FILENAME_MAX + 1];
615 	char entry[FILENAME_MAX + 1];
616 	char line[MAX_N2M_ALIAS_LINE], *cp;
617 	int maj;
618 	int size = 0;
619 
620 
621 	/*
622 	 * see if the file is already cached - either
623 	 * rem_name_to_major or name_to_major
624 	 */
625 	ptr = head;
626 	while (ptr != NULL) {
627 		if (strcmp(ptr->file, filename) == 0)
628 			break;
629 		ptr = ptr->next;
630 	}
631 
632 	if (ptr == NULL) {	/* we need to cache the contents */
633 		if ((fp = fopen(filename, "r")) == NULL) {
634 			perror(NULL);
635 			(void) fprintf(stderr, gettext(ERR_CANT_OPEN),
636 			    filename);
637 			return (ERROR);
638 		}
639 
640 		while (fgets(line, sizeof (line), fp) != NULL) {
641 			/* cut off comments starting with '#' */
642 			if ((cp = strchr(line, '#')) != NULL)
643 				*cp = '\0';
644 			/* ignore comment or blank lines */
645 			if (is_blank(line))
646 				continue;
647 			/* sanity-check */
648 			if (sscanf(line,
649 			    "%" VAL2STR(FILENAME_MAX) "s"	/* drv */
650 			    "%" VAL2STR(FILENAME_MAX) "s",	/* entry */
651 			    drv, entry) != 2) {
652 				(void) fprintf(stderr, gettext(ERR_BAD_LINE),
653 				    filename, line);
654 				continue;
655 			}
656 			maj = atoi(entry);
657 			if (maj > size)
658 				size = maj;
659 		}
660 
661 		/* allocate struct to cache the file */
662 		ptr = (struct n_to_m_cache *)calloc(1,
663 		    sizeof (struct n_to_m_cache));
664 		if (ptr == NULL) {
665 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
666 			return (ERROR);
667 		}
668 		ptr->size = size + 1;
669 		/* allocate space to cache contents of file */
670 		ptr->cached_file = (char **)calloc(ptr->size, sizeof (char *));
671 		if (ptr->cached_file == NULL) {
672 			free(ptr);
673 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
674 			return (ERROR);
675 		}
676 
677 		rewind(fp);
678 
679 		/*
680 		 * now fill the cache
681 		 * the cache is an array of char pointers indexed by major
682 		 * number
683 		 */
684 		while (fgets(line, sizeof (line), fp) != NULL) {
685 			/* cut off comments starting with '#' */
686 			if ((cp = strchr(line, '#')) != NULL)
687 				*cp = '\0';
688 			/* ignore comment or blank lines */
689 			if (is_blank(line))
690 				continue;
691 			/* sanity-check */
692 			if (sscanf(line,
693 			    "%" VAL2STR(FILENAME_MAX) "s"	/* drv */
694 			    "%" VAL2STR(FILENAME_MAX) "s",	/* entry */
695 			    drv, entry) != 2) {
696 				(void) fprintf(stderr, gettext(ERR_BAD_LINE),
697 				    filename, line);
698 				continue;
699 			}
700 			maj = atoi(entry);
701 			if ((ptr->cached_file[maj] = strdup(drv)) == NULL) {
702 				(void) fprintf(stderr, gettext(ERR_NO_MEM));
703 				free(ptr->cached_file);
704 				free(ptr);
705 				return (ERROR);
706 			}
707 			(void) strcpy(ptr->cached_file[maj], drv);
708 		}
709 		(void) fclose(fp);
710 		/* link the cache struct into the list of cached files */
711 		ptr->file = strdup(filename);
712 		if (ptr->file == NULL) {
713 			for (maj = 0; maj <= ptr->size; maj++)
714 				free(ptr->cached_file[maj]);
715 			free(ptr->cached_file);
716 			free(ptr);
717 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
718 			return (ERROR);
719 		}
720 		ptr->next = head;
721 		head = ptr;
722 	}
723 	/* return value pointer to contents of file */
724 	*cache = ptr->cached_file;
725 
726 	/* return size */
727 	return (ptr->size);
728 }
729 
730 
731 /*
732  * Using get_cached_n_to_m_file(), retrieve maximum major number
733  * found in the specificed file (name_to_major/rem_name_to_major).
734  *
735  * The return value is actually the size of the internal cache including 0.
736  */
737 int
get_max_major(char * file_name)738 get_max_major(char *file_name)
739 {
740 	char **n_to_m_cache = NULL;
741 
742 	return (get_cached_n_to_m_file(file_name, &n_to_m_cache));
743 }
744 
745 
746 /*
747  * searching name_to_major: if major_no == UNIQUE then the caller wants to
748  * use the driver name as the key.  Otherwise, the caller wants to use
749  * the major number as a key.
750  *
751  * This routine caches the contents of the name_to_major file on
752  * first call.  And it could be generalized to deal with other
753  * config files if necessary.
754  */
755 static int
get_name_to_major_entry(int * major_no,char * driver_name,char * file_name)756 get_name_to_major_entry(int *major_no, char *driver_name, char *file_name)
757 {
758 	int maj;
759 	char **n_to_m_cache = NULL;
760 	int size = 0;
761 
762 	int ret = NOT_UNIQUE;
763 
764 	/*
765 	 * read the file in - we cache it in case caller wants to
766 	 * do multiple lookups
767 	 */
768 	size = get_cached_n_to_m_file(file_name, &n_to_m_cache);
769 
770 	if (size == ERROR)
771 		return (ERROR);
772 
773 	/* search with driver name as key */
774 	if (*major_no == UNIQUE) {
775 		for (maj = 0; maj < size; maj++) {
776 			if ((n_to_m_cache[maj] != NULL) &&
777 			    (strcmp(driver_name, n_to_m_cache[maj]) == 0)) {
778 				*major_no = maj;
779 				break;
780 			}
781 		}
782 		if (maj >= size)
783 			ret = UNIQUE;
784 	/* search with major number as key */
785 	} else {
786 		/*
787 		 * Bugid 1254588, drvconfig dump core after loading driver
788 		 * with major number bigger than entries defined in
789 		 * /etc/name_to_major.
790 		 */
791 		if (*major_no >= size)
792 			return (UNIQUE);
793 
794 		if (n_to_m_cache[*major_no] != NULL) {
795 			(void) strcpy(driver_name, n_to_m_cache[*major_no]);
796 		} else
797 			ret = UNIQUE;
798 	}
799 	return (ret);
800 }
801 
802 /*
803  * Given pointer to begining of member 'n' in a space (or separator)
804  * separated list, return pointer to member 'n+1', and establish member 'n'
805  * in *current_entry.  If unquote, then we skip a leading quote and treat
806  * the trailing quote as a separator (and skip).
807  */
808 char *
get_entry(char * prev_member,char * current_entry,char separator,int unquote)809 get_entry(
810 	char *prev_member,
811 	char *current_entry,
812 	char separator,
813 	int  unquote)
814 {
815 	char	*ptr;
816 	int	quoted = 0;
817 
818 	ptr = prev_member;
819 
820 	/* skip white space */
821 	while (isspace(*ptr))
822 		ptr++;
823 
824 	/* if unquote skip leading quote */
825 	if (unquote && *ptr == '"') {
826 		quoted++;
827 		ptr++;
828 	}
829 
830 	/* read thru the current entry looking for end, separator, or unquote */
831 	while (*ptr &&
832 	    (*ptr != separator) && (!isspace(*ptr)) &&
833 	    (!quoted || (*ptr != '"'))) {
834 		*current_entry++ = *ptr++;
835 	}
836 	*current_entry = '\0';
837 
838 	if (separator && (*ptr == separator))
839 		ptr++;	/* skip over separator */
840 	if (quoted && (*ptr == '"'))
841 		ptr++;	/* skip over trailing quote */
842 
843 	/* skip white space */
844 	while (isspace(*ptr))
845 		ptr++;
846 
847 	return (ptr);
848 }
849 
850 /*
851  * A parser specific to the add_drv "-m permission" syntax:
852  *
853  *	-m '<minor-name> <permissions> <owner> <group>', ...
854  *
855  * One entry is parsed starting at prev_member and returned
856  * in the string pointed at by current_entry.  A pointer
857  * to the entry following is returned.
858  */
859 char *
get_perm_entry(char * prev_member,char * current_entry)860 get_perm_entry(
861 	char *prev_member,
862 	char *current_entry)
863 {
864 	char	*ptr;
865 	int	nfields = 0;
866 	int	maxfields = 4;		/* fields in a permissions format */
867 
868 	ptr = prev_member;
869 	while (isspace(*ptr))
870 		ptr++;
871 
872 	while (*ptr) {
873 		/* comma allowed in minor name token only */
874 		if (*ptr == ',' && nfields > 0) {
875 			break;
876 		} else if (isspace(*ptr)) {
877 			*current_entry++ = *ptr++;
878 			while (isspace(*ptr))
879 				ptr++;
880 			if (++nfields == maxfields)
881 				break;
882 		} else
883 			*current_entry++ = *ptr++;
884 	}
885 	*current_entry = '\0';
886 
887 	while (isspace(*ptr))
888 		ptr++;
889 	if (*ptr == ',') {
890 		ptr++;	/* skip over optional trailing comma */
891 	}
892 	while (isspace(*ptr))
893 		ptr++;
894 
895 	return (ptr);
896 }
897 
898 void
enter_lock(void)899 enter_lock(void)
900 {
901 	struct flock lock;
902 
903 	/*
904 	 * Attempt to create the lock file.  Open the file itself,
905 	 * and not a symlink to some other file.
906 	 */
907 	add_rem_lock_fd = open(add_rem_lock,
908 	    O_CREAT|O_RDWR|O_NOFOLLOW|O_NOLINKS, S_IRUSR|S_IWUSR);
909 	if (add_rem_lock_fd < 0) {
910 		(void) fprintf(stderr, gettext(ERR_CREAT_LOCK),
911 		    add_rem_lock, strerror(errno));
912 		exit(1);
913 	}
914 
915 	lock.l_type = F_WRLCK;
916 	lock.l_whence = SEEK_SET;
917 	lock.l_start = 0;
918 	lock.l_len = 0;
919 
920 	/* Try for the lock but don't wait. */
921 	if (fcntl(add_rem_lock_fd, F_SETLK, &lock) == -1) {
922 		if (errno == EACCES || errno == EAGAIN) {
923 			(void) fprintf(stderr, gettext(ERR_PROG_IN_USE));
924 		} else {
925 			(void) fprintf(stderr, gettext(ERR_LOCK),
926 			    add_rem_lock, strerror(errno));
927 		}
928 		exit(1);
929 	}
930 }
931 
932 void
err_exit(void)933 err_exit(void)
934 {
935 	/* release memory allocated for moddir */
936 	cleanup_moddir();
937 	/* remove add_drv/rem_drv lock */
938 	exit_unlock();
939 	exit(1);
940 }
941 
942 void
cleanup_moddir(void)943 cleanup_moddir(void)
944 {
945 	struct drvmod_dir *walk_ptr;
946 	struct drvmod_dir *free_ptr = moddir;
947 
948 	while (free_ptr != NULL) {
949 		walk_ptr = free_ptr->next;
950 		free(free_ptr);
951 		free_ptr = walk_ptr;
952 	}
953 }
954 
955 void
exit_unlock(void)956 exit_unlock(void)
957 {
958 	struct flock unlock;
959 
960 	if (add_rem_lock_fd < 0)
961 		return;
962 
963 	unlock.l_type = F_UNLCK;
964 	unlock.l_whence = SEEK_SET;
965 	unlock.l_start = 0;
966 	unlock.l_len = 0;
967 
968 	if (fcntl(add_rem_lock_fd, F_SETLK, &unlock) == -1) {
969 		(void) fprintf(stderr, gettext(ERR_UNLOCK),
970 		    add_rem_lock, strerror(errno));
971 	} else {
972 		(void) close(add_rem_lock_fd);
973 		add_rem_lock_fd = -1;
974 	}
975 }
976 
977 /*
978  * error adding driver; need to back out any changes to files.
979  * check flag to see which files need entries removed
980  * entry removal based on driver name
981  */
982 void
remove_entry(int c_flag,char * driver_name)983 remove_entry(
984 	int c_flag,
985 	char *driver_name)
986 {
987 
988 	if (c_flag & CLEAN_NAM_MAJ) {
989 		if (delete_entry(name_to_major, driver_name, " ",
990 		    NULL) == ERROR) {
991 			(void) fprintf(stderr, gettext(ERR_NO_CLEAN),
992 			    name_to_major, driver_name);
993 		}
994 	}
995 
996 	if (c_flag & CLEAN_DRV_ALIAS) {
997 		if (delete_entry(driver_aliases, driver_name, " ",
998 		    NULL) == ERROR) {
999 			(void) fprintf(stderr, gettext(ERR_DEL_ENTRY),
1000 			    driver_name, driver_aliases);
1001 		}
1002 	}
1003 
1004 	if (c_flag & CLEAN_DRV_CLASSES) {
1005 		if (delete_entry(driver_classes, driver_name, "\t", NULL) ==
1006 		    ERROR) {
1007 			(void) fprintf(stderr, gettext(ERR_DEL_ENTRY),
1008 			    driver_name, driver_classes);
1009 		}
1010 	}
1011 
1012 	if (c_flag & CLEAN_MINOR_PERM) {
1013 		if (delete_entry(minor_perm, driver_name, ":", NULL) == ERROR) {
1014 			(void) fprintf(stderr, gettext(ERR_DEL_ENTRY),
1015 			    driver_name, minor_perm);
1016 		}
1017 	}
1018 	/*
1019 	 * There's no point in removing entries from files that don't
1020 	 * exist.  Prevent error messages by checking for file existence
1021 	 * first.
1022 	 */
1023 	if ((c_flag & CLEAN_DEV_POLICY) != 0 &&
1024 	    access(device_policy, F_OK) == 0) {
1025 		if (delete_plcy_entry(device_policy, driver_name) == ERROR) {
1026 			(void) fprintf(stderr, gettext(ERR_DEL_ENTRY),
1027 			    driver_name, device_policy);
1028 		}
1029 	}
1030 	if ((c_flag & CLEAN_DRV_PRIV) != 0 &&
1031 	    access(extra_privs, F_OK) == 0) {
1032 		if (delete_entry(extra_privs, driver_name, ":", NULL) ==
1033 		    ERROR) {
1034 			(void) fprintf(stderr, gettext(ERR_DEL_ENTRY),
1035 			    driver_name, extra_privs);
1036 		}
1037 	}
1038 }
1039 
1040 int
check_perms_aliases(int m_flag,int i_flag)1041 check_perms_aliases(
1042 	int m_flag,
1043 	int i_flag)
1044 {
1045 	/*
1046 	 * If neither i_flag nor m_flag are specified no need to check the
1047 	 * files for access permissions
1048 	 */
1049 	if (!m_flag && !i_flag)
1050 		return (NOERR);
1051 
1052 	/* check minor_perm file : exits and is writable */
1053 	if (m_flag) {
1054 		if (access(minor_perm, R_OK | W_OK)) {
1055 			perror(NULL);
1056 			(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1057 			    minor_perm);
1058 			return (ERROR);
1059 		}
1060 	}
1061 
1062 	/* check driver_aliases file : exits and is writable */
1063 	if (i_flag) {
1064 		if (access(driver_aliases, R_OK | W_OK)) {
1065 			perror(NULL);
1066 			(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1067 			    driver_aliases);
1068 			return (ERROR);
1069 		}
1070 	}
1071 
1072 	return (NOERR);
1073 }
1074 
1075 
1076 int
check_name_to_major(int mode)1077 check_name_to_major(int mode)
1078 {
1079 	/* check name_to_major file : exists and is writable */
1080 	if (access(name_to_major, mode)) {
1081 		perror(NULL);
1082 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1083 		    name_to_major);
1084 		return (ERROR);
1085 	}
1086 
1087 	return (NOERR);
1088 }
1089 
1090 
1091 /*
1092  * All this stuff is to support a server installing
1093  * drivers on diskless clients.  When on the server
1094  * need to prepend the basedir
1095  */
1096 int
build_filenames(char * basedir)1097 build_filenames(char *basedir)
1098 {
1099 	int	len;
1100 	int	driver_aliases_len;
1101 	int	driver_classes_len;
1102 	int	minor_perm_len;
1103 	int	name_to_major_len;
1104 	int	rem_name_to_major_len;
1105 	int	add_rem_lock_len;
1106 	int	devfs_root_len;
1107 	int	device_policy_len;
1108 	int	extra_privs_len;
1109 
1110 	if (basedir == NULL) {
1111 		driver_aliases = DRIVER_ALIAS;
1112 		driver_classes = DRIVER_CLASSES;
1113 		minor_perm = MINOR_PERM;
1114 		name_to_major = NAM_TO_MAJ;
1115 		rem_name_to_major = REM_NAM_TO_MAJ;
1116 		add_rem_lock = ADD_REM_LOCK;
1117 		devfs_root = DEVFS_ROOT;
1118 		device_policy = DEV_POLICY;
1119 		extra_privs = EXTRA_PRIVS;
1120 
1121 	} else {
1122 		len = strlen(basedir) + 1;
1123 
1124 		driver_aliases_len = len + sizeof (DRIVER_ALIAS);
1125 		driver_classes_len = len + sizeof (DRIVER_CLASSES);
1126 		minor_perm_len = len + sizeof (MINOR_PERM);
1127 		name_to_major_len = len + sizeof (NAM_TO_MAJ);
1128 		rem_name_to_major_len = len + sizeof (REM_NAM_TO_MAJ);
1129 		add_rem_lock_len = len + sizeof (ADD_REM_LOCK);
1130 		devfs_root_len = len + sizeof (DEVFS_ROOT);
1131 		device_policy_len = len + sizeof (DEV_POLICY);
1132 		extra_privs_len = len + sizeof (EXTRA_PRIVS);
1133 
1134 		driver_aliases = malloc(driver_aliases_len);
1135 		driver_classes = malloc(driver_classes_len);
1136 		minor_perm = malloc(minor_perm_len);
1137 		name_to_major = malloc(name_to_major_len);
1138 		rem_name_to_major = malloc(rem_name_to_major_len);
1139 		add_rem_lock = malloc(add_rem_lock_len);
1140 		devfs_root = malloc(devfs_root_len);
1141 		device_policy = malloc(device_policy_len);
1142 		extra_privs = malloc(extra_privs_len);
1143 
1144 		if ((driver_aliases == NULL) ||
1145 		    (driver_classes == NULL) ||
1146 		    (minor_perm == NULL) ||
1147 		    (name_to_major == NULL) ||
1148 		    (rem_name_to_major == NULL) ||
1149 		    (add_rem_lock == NULL) ||
1150 		    (devfs_root == NULL) ||
1151 		    (device_policy == NULL) ||
1152 		    (extra_privs == NULL)) {
1153 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
1154 			return (ERROR);
1155 		}
1156 
1157 		(void) snprintf(driver_aliases, driver_aliases_len,
1158 		    "%s%s", basedir, DRIVER_ALIAS);
1159 		(void) snprintf(driver_classes, driver_classes_len,
1160 		    "%s%s", basedir, DRIVER_CLASSES);
1161 		(void) snprintf(minor_perm, minor_perm_len,
1162 		    "%s%s", basedir, MINOR_PERM);
1163 		(void) snprintf(name_to_major, name_to_major_len,
1164 		    "%s%s", basedir, NAM_TO_MAJ);
1165 		(void) snprintf(rem_name_to_major, rem_name_to_major_len,
1166 		    "%s%s", basedir, REM_NAM_TO_MAJ);
1167 		(void) snprintf(add_rem_lock, add_rem_lock_len,
1168 		    "%s%s", basedir, ADD_REM_LOCK);
1169 		(void) snprintf(devfs_root, devfs_root_len,
1170 		    "%s%s", basedir, DEVFS_ROOT);
1171 		(void) snprintf(device_policy, device_policy_len,
1172 		    "%s%s", basedir, DEV_POLICY);
1173 		(void) snprintf(extra_privs, extra_privs_len,
1174 		    "%s%s", basedir, EXTRA_PRIVS);
1175 	}
1176 
1177 	return (NOERR);
1178 }
1179 
1180 static int
exec_command(char * path,char * cmdline[MAX_CMD_LINE])1181 exec_command(char *path, char *cmdline[MAX_CMD_LINE])
1182 {
1183 	pid_t pid;
1184 	uint_t stat_loc;
1185 	int waitstat;
1186 	int exit_status;
1187 
1188 	/* child */
1189 	if ((pid = fork()) == 0) {
1190 		(void) execv(path, cmdline);
1191 		perror(NULL);
1192 		return (ERROR);
1193 	} else if (pid == -1) {
1194 		/* fork failed */
1195 		perror(NULL);
1196 		(void) fprintf(stderr, gettext(ERR_FORK_FAIL), cmdline);
1197 		return (ERROR);
1198 	} else {
1199 		/* parent */
1200 		do {
1201 			waitstat = waitpid(pid, (int *)&stat_loc, 0);
1202 
1203 		} while ((!WIFEXITED(stat_loc) &&
1204 		    !WIFSIGNALED(stat_loc)) || (waitstat == 0));
1205 
1206 		exit_status = WEXITSTATUS(stat_loc);
1207 
1208 		return (exit_status);
1209 	}
1210 }
1211 
1212 /*
1213  * Exec devfsadm to perform driver config/unconfig operation,
1214  * adding or removing aliases.
1215  */
1216 static int
exec_devfsadm(boolean_t config,char * driver_name,major_t major_num,char * aliases,char * classes,int config_flags)1217 exec_devfsadm(
1218 	boolean_t config,
1219 	char *driver_name,
1220 	major_t major_num,
1221 	char *aliases,
1222 	char *classes,
1223 	int config_flags)
1224 {
1225 	int n = 0;
1226 	char *cmdline[MAX_CMD_LINE];
1227 	char maj_num[128];
1228 	int rv;
1229 
1230 	/* build command line */
1231 	cmdline[n++] = DRVCONFIG;
1232 	if (config == B_FALSE) {
1233 		cmdline[n++] = "-u";		/* unconfigure */
1234 		if (config_flags & CONFIG_DRV_FORCE)
1235 			cmdline[n++] = "-f";	/* force if currently in use */
1236 	}
1237 	if (config_flags & CONFIG_DRV_VERBOSE) {
1238 		cmdline[n++] = "-v";
1239 	}
1240 	cmdline[n++] = "-b";
1241 	if (classes) {
1242 		cmdline[n++] = "-c";
1243 		cmdline[n++] = classes;
1244 	}
1245 	cmdline[n++] = "-i";
1246 	cmdline[n++] = driver_name;
1247 	cmdline[n++] = "-m";
1248 	(void) snprintf(maj_num, sizeof (maj_num), "%lu", major_num);
1249 	cmdline[n++] = maj_num;
1250 	if (config_flags & CONFIG_DRV_UPDATE_ONLY)
1251 		cmdline[n++] = "-x";
1252 
1253 	if (aliases != NULL) {
1254 		char *buf, *p;
1255 		size_t len;
1256 		int n_start = n;
1257 
1258 		len = strlen(aliases);
1259 
1260 		p = buf = calloc(len + 1, 1);
1261 		if (buf == NULL) {
1262 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
1263 			return (ERROR);
1264 		}
1265 
1266 		while (*aliases != '\0') {
1267 			while (n < MAX_CMD_LINE - 3 && *aliases != '\0') {
1268 				cmdline[n++] = "-a";
1269 				aliases = get_entry(aliases, p, ' ', 0);
1270 				cmdline[n++] = p;
1271 				p += strlen(p) + 1;
1272 			}
1273 			cmdline[n] = NULL;
1274 			rv = exec_command(DRVCONFIG_PATH, cmdline);
1275 			if (rv != NOERR)
1276 				break;
1277 			n = n_start;
1278 		}
1279 		free(buf);
1280 		return (rv == NOERR ? NOERR : ERROR);
1281 	}
1282 	cmdline[n] = NULL;
1283 
1284 	rv = exec_command(DRVCONFIG_PATH, cmdline);
1285 	if (rv == NOERR)
1286 		return (NOERR);
1287 	return (ERROR);
1288 }
1289 
1290 int
unconfig_driver(char * driver_name,major_t major_num,char * aliases,int config_flags)1291 unconfig_driver(
1292 	char *driver_name,
1293 	major_t major_num,
1294 	char *aliases,
1295 	int config_flags)
1296 {
1297 	return (exec_devfsadm(B_FALSE, driver_name, major_num,
1298 	    aliases, NULL, config_flags));
1299 }
1300 
1301 /*
1302  * check that major_num doesn't exceed maximum on this machine
1303  * do this here to support add_drv on server for diskless clients
1304  */
1305 int
config_driver(char * driver_name,major_t major_num,char * aliases,char * classes,int cleanup_flag,int config_flags)1306 config_driver(
1307 	char *driver_name,
1308 	major_t major_num,
1309 	char *aliases,
1310 	char *classes,
1311 	int cleanup_flag,
1312 	int config_flags)
1313 {
1314 	int	max_dev;
1315 	int	rv;
1316 
1317 	if (modctl(MODRESERVED, NULL, &max_dev) < 0) {
1318 		perror(NULL);
1319 		(void) fprintf(stderr, gettext(ERR_MAX_MAJOR));
1320 		return (ERROR);
1321 	}
1322 
1323 	if (major_num >= max_dev) {
1324 		(void) fprintf(stderr, gettext(ERR_MAX_EXCEEDS),
1325 		    major_num, max_dev);
1326 		return (ERROR);
1327 	}
1328 
1329 	/* bind major number and driver name */
1330 	rv = exec_devfsadm(B_TRUE, driver_name, major_num,
1331 	    aliases, classes, config_flags);
1332 
1333 	if (rv == NOERR)
1334 		return (NOERR);
1335 	perror(NULL);
1336 	remove_entry(cleanup_flag, driver_name);
1337 	return (ERROR);
1338 }
1339 
1340 void
load_driver(char * driver_name,int verbose_flag)1341 load_driver(char *driver_name, int verbose_flag)
1342 {
1343 	int n = 0;
1344 	char *cmdline[MAX_CMD_LINE];
1345 	int exec_status;
1346 
1347 	/* build command line */
1348 	cmdline[n++] = DEVFSADM;
1349 	if (verbose_flag) {
1350 		cmdline[n++] = "-v";
1351 	}
1352 	cmdline[n++] = "-i";
1353 	cmdline[n++] = driver_name;
1354 	cmdline[n] = (char *)0;
1355 
1356 	exec_status = exec_command(DEVFSADM_PATH, cmdline);
1357 
1358 	if (exec_status != NOERR) {
1359 		/* no clean : name and major number are bound */
1360 		(void) fprintf(stderr, gettext(ERR_CONFIG), driver_name);
1361 	}
1362 }
1363 
1364 void
get_modid(char * driver_name,int * mod)1365 get_modid(char *driver_name, int *mod)
1366 {
1367 	struct modinfo	modinfo;
1368 
1369 	modinfo.mi_id = -1;
1370 	modinfo.mi_info = MI_INFO_ALL;
1371 	do {
1372 		/*
1373 		 * If we are at the end of the list of loaded modules
1374 		 * then set *mod = -1 and return
1375 		 */
1376 		if (modctl(MODINFO, 0, &modinfo) < 0) {
1377 			*mod = -1;
1378 			return;
1379 		}
1380 
1381 		*mod = modinfo.mi_id;
1382 	} while (strcmp(driver_name, modinfo.mi_name) != 0);
1383 }
1384 
1385 int
create_reconfig(char * basedir)1386 create_reconfig(char *basedir)
1387 {
1388 	char reconfig_file[MAXPATHLEN + FILENAME_MAX + 1];
1389 	FILE *reconfig_fp;
1390 
1391 	if (basedir != NULL) {
1392 		(void) strcpy(reconfig_file, basedir);
1393 		(void) strcat(reconfig_file, RECONFIGURE);
1394 	} else {
1395 		(void) strcpy(reconfig_file, RECONFIGURE);
1396 	}
1397 	if ((reconfig_fp = fopen(reconfig_file, "a")) == NULL)
1398 		return (ERROR);
1399 
1400 	(void) fclose(reconfig_fp);
1401 	return (NOERR);
1402 }
1403 
1404 
1405 /*
1406  * update_minor_entry:
1407  *	open file
1408  *	for each entry in list
1409  *		where list entries are separated by <list_separator>
1410  *		modify entry : driver_name <entry_separator> entry
1411  *	close file
1412  *
1413  *	return error/noerr
1414  */
1415 int
update_minor_entry(char * driver_name,char * perm_list)1416 update_minor_entry(char *driver_name, char *perm_list)
1417 {
1418 	FILE	*fp;
1419 	FILE	*newfp;
1420 	int	match = 0;
1421 	char	line[MAX_DBFILE_ENTRY];
1422 	char	drv[FILENAME_MAX + 1];
1423 	char	minor[FILENAME_MAX + 1];
1424 	char	perm[OPT_LEN + 1];
1425 	char	own[OPT_LEN + 1];
1426 	char	grp[OPT_LEN + 1];
1427 	int	status = NOERR, i;
1428 	char	newfile[MAXPATHLEN];
1429 	char	*cp, *dup, *drv_minor;
1430 	struct group	*sysgrp;
1431 	int		newfd;
1432 
1433 	if ((fp = fopen(minor_perm, "r")) == NULL) {
1434 		perror(NULL);
1435 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1436 		    minor_perm);
1437 
1438 		return (ERROR);
1439 	}
1440 
1441 	/* Build filename for temporary file */
1442 	(void) snprintf(newfile, sizeof (newfile), "%s%s", minor_perm, ".hold");
1443 
1444 	/*
1445 	 * Set gid so we preserve group attribute.  Ideally we wouldn't
1446 	 * assume a gid of "sys" but we can't undo the damage on already
1447 	 * installed systems unless we force the issue.
1448 	 */
1449 	if ((sysgrp = getgrnam("sys")) != NULL) {
1450 		(void) setgid(sysgrp->gr_gid);
1451 	}
1452 
1453 	if ((newfd = open(newfile, O_WRONLY | O_CREAT | O_EXCL, 0644)) < 0) {
1454 		if (errno == EEXIST) {
1455 			(void) fprintf(stderr, gettext(ERR_FILE_EXISTS),
1456 			    newfile);
1457 			return (ERROR);
1458 		} else {
1459 			(void) fprintf(stderr, gettext(ERR_CREAT_LOCK),
1460 			    newfile);
1461 			return (ERROR);
1462 		}
1463 	}
1464 
1465 	if ((newfp = fdopen(newfd, "w")) == NULL) {
1466 		perror(NULL);
1467 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1468 		    newfile);
1469 		(void) close(newfd);
1470 		return (ERROR);
1471 	}
1472 
1473 	if (sscanf(perm_list,
1474 	    "%" VAL2STR(FILENAME_MAX) "s"	/* minor */
1475 	    "%" VAL2STR(OPT_LEN) "s"		/* perm */
1476 	    "%" VAL2STR(OPT_LEN) "s"		/* own */
1477 	    "%" VAL2STR(OPT_LEN) "s",		/* grp */
1478 	    minor, perm, own, grp) != 4) {
1479 		status = ERROR;
1480 	}
1481 
1482 	while ((fgets(line, sizeof (line), fp) != NULL) && status == NOERR) {
1483 		/* copy the whole line into dup */
1484 		if ((dup = strdup(line)) == NULL) {
1485 			perror(NULL);
1486 			(void) fprintf(stderr, gettext(ERR_NO_MEM));
1487 			status = ERROR;
1488 			break;
1489 		}
1490 		/* cut off comments starting with '#' */
1491 		if ((cp = strchr(dup, '#')) != NULL)
1492 			*cp = '\0';
1493 		/* ignore comment or blank lines */
1494 		if (is_blank(dup)) {
1495 			if (fputs(line, newfp) == EOF) {
1496 				(void) fprintf(stderr, gettext(ERR_UPDATE),
1497 				    minor_perm);
1498 				status = ERROR;
1499 			}
1500 			free(dup);
1501 			continue;
1502 		}
1503 
1504 		/* get the driver name */
1505 		if (sscanf(dup, "%" VAL2STR(FILENAME_MAX) "s", drv) != 1) {
1506 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
1507 			    minor_perm, line);
1508 			status = ERROR;
1509 			free(dup);
1510 			break;
1511 		}
1512 
1513 		/*
1514 		 * get the minor name; place the NULL character at the
1515 		 * end of the driver name, then make the drv_minor
1516 		 * point to the first character of the minor name.
1517 		 * the line missing ':' must be treated as a broken one.
1518 		 */
1519 		i = strcspn(drv, ":");
1520 		if (i == strlen(drv)) {
1521 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
1522 			    minor_perm, line);
1523 			status = ERROR;
1524 			free(dup);
1525 			break;
1526 		}
1527 		drv[i] =  '\0';
1528 		drv_minor = &drv[strlen(drv) + 1];
1529 
1530 		/*
1531 		 * compare both of the driver name and the minor name.
1532 		 * then the new line should be written to the file if
1533 		 * both of them match
1534 		 */
1535 		if ((strcmp(drv, driver_name) == 0) &&
1536 		    (strcmp(minor, drv_minor) == 0)) {
1537 			/* if it has a comment, keep it */
1538 			if (cp != NULL) {
1539 				cp++; /* skip a terminator */
1540 				(void) snprintf(line, sizeof (line),
1541 				    "%s:%s %s %s %s #%s\n",
1542 				    drv, minor, perm, own, grp, cp);
1543 			} else {
1544 				(void) snprintf(line, sizeof (line),
1545 				    "%s:%s %s %s %s\n",
1546 				    drv, minor, perm, own, grp);
1547 			}
1548 			match = 1;
1549 		}
1550 		free(dup);
1551 
1552 		/* update the file */
1553 		if ((fputs(line, newfp)) == EOF) {
1554 			(void) fprintf(stderr, gettext(ERR_UPDATE),
1555 			    minor_perm);
1556 			status = ERROR;
1557 		}
1558 	}
1559 
1560 	if (!match) {
1561 		(void) bzero(line, sizeof (line));
1562 		(void) snprintf(line, sizeof (line),
1563 		    "%s:%s %s %s %s\n",
1564 		    driver_name, minor, perm, own, grp);
1565 
1566 		/* add the new entry */
1567 		if ((fputs(line, newfp)) == EOF) {
1568 			(void) fprintf(stderr, gettext(ERR_UPDATE), minor_perm);
1569 			status = ERROR;
1570 		}
1571 	}
1572 
1573 	(void) fclose(fp);
1574 
1575 	if (fflush(newfp) != 0 || fsync(fileno(newfp)) != 0)
1576 		status = ERROR;
1577 
1578 	(void) fclose(newfp);
1579 
1580 	/*
1581 	 * if error, leave original file, delete new file
1582 	 * if noerr, replace original file with new file
1583 	 */
1584 	if (status == NOERR) {
1585 		if (rename(newfile, minor_perm) == -1) {
1586 			perror(NULL);
1587 			(void) fprintf(stderr, gettext(ERR_UPDATE), minor_perm);
1588 			(void) unlink(newfile);
1589 			return (ERROR);
1590 		}
1591 	} else {
1592 		/*
1593 		 * since there's an error, leave file alone; remove
1594 		 * new file
1595 		 */
1596 		if (unlink(newfile) == -1) {
1597 			(void) fprintf(stderr, gettext(ERR_CANT_RM), newfile);
1598 		}
1599 		return (ERROR);
1600 	}
1601 
1602 	return (NOERR);
1603 
1604 }
1605 
1606 
1607 /*
1608  * list_entry:
1609  *	open file
1610  *	read thru file, listing all entries if first entry = driver_name
1611  *	close
1612  */
1613 void
list_entry(char * oldfile,char * driver_name,char * marker)1614 list_entry(
1615 	char *oldfile,
1616 	char *driver_name,
1617 	char *marker)
1618 {
1619 	FILE	*fp;
1620 	int	i;
1621 	char	line[MAX_DBFILE_ENTRY], *cp;
1622 	char	drv[FILENAME_MAX + 1];
1623 
1624 	if ((fp = fopen(oldfile, "r")) == NULL) {
1625 		perror(NULL);
1626 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), oldfile);
1627 
1628 		return;
1629 	}
1630 
1631 	while (fgets(line, sizeof (line), fp) != NULL) {
1632 		/* cut off comments starting with '#' */
1633 		if ((cp = strchr(line, '#')) != NULL)
1634 			*cp = '\0';
1635 		/* ignore comment or blank lines */
1636 		if (is_blank(line))
1637 			continue;
1638 		/* sanity-check */
1639 		if (sscanf(line, "%" VAL2STR(FILENAME_MAX) "s", drv) != 1) {
1640 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
1641 			    oldfile, line);
1642 		}
1643 
1644 		for (i = strcspn(drv, marker); i < FILENAME_MAX; i++) {
1645 			drv[i] =  '\0';
1646 		}
1647 
1648 		if (strcmp(driver_name, drv) == 0) {
1649 			(void) fprintf(stdout, "%s", line);
1650 		}
1651 	}
1652 
1653 	(void) fclose(fp);
1654 }
1655 
1656 static boolean_t
is_token(char * tok)1657 is_token(char *tok)
1658 {
1659 	/*
1660 	 * Check the token here. According to IEEE1275 Open Firmware Boot
1661 	 * Standard, the name is composed of 1 to 31 letters,
1662 	 * digits and punctuation characters from the set ",._+-", and
1663 	 * uppercase and lowercase characters are considered distinct.
1664 	 * (ie. token := [a-zA-Z0-9,._+-]+, length(token) <= 31)
1665 	 * However, since either the definition of driver or aliase names is
1666 	 * not known well, only '#' is avoided explicitly. (the kernel lexical
1667 	 * analyzer treats it as a start of a comment)
1668 	 */
1669 	for (/* nothing */; *tok != '\0'; tok++)
1670 		if (*tok == '#' || iscntrl(*tok))
1671 			return (B_FALSE);
1672 
1673 	return (B_TRUE);
1674 }
1675 
1676 /*
1677  * check each entry in perm_list for:
1678  *	4 arguments
1679  *	permission arg is in valid range
1680  * permlist entries separated by comma
1681  * return ERROR/NOERR
1682  */
1683 int
check_perm_opts(char * perm_list)1684 check_perm_opts(char *perm_list)
1685 {
1686 	char *current_head;
1687 	char *previous_head;
1688 	char *one_entry;
1689 	int len, scan_stat;
1690 	char minor[FILENAME_MAX + 1];
1691 	char perm[OPT_LEN + 1];
1692 	char own[OPT_LEN + 1];
1693 	char grp[OPT_LEN + 1];
1694 	char dumb[OPT_LEN + 1];
1695 	int status = NOERR;
1696 	int intperm;
1697 
1698 	if ((len = strlen(perm_list)) == 0)
1699 		return (ERROR);
1700 
1701 	if ((one_entry = calloc(len + 1, 1)) == NULL) {
1702 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
1703 		return (ERROR);
1704 	}
1705 
1706 	previous_head = perm_list;
1707 	current_head = perm_list;
1708 
1709 	while (*current_head != '\0') {
1710 		bzero(one_entry, len + 1);
1711 		current_head = get_perm_entry(previous_head, one_entry);
1712 
1713 		previous_head = current_head;
1714 		scan_stat = sscanf(one_entry,
1715 		    "%" VAL2STR(FILENAME_MAX) "s"	/* minor */
1716 		    "%" VAL2STR(OPT_LEN) "s"		/* perm */
1717 		    "%" VAL2STR(OPT_LEN) "s"		/* own */
1718 		    "%" VAL2STR(OPT_LEN) "s"		/* grp */
1719 		    "%" VAL2STR(OPT_LEN) "s",		/* dumb */
1720 		    minor, perm, own, grp, dumb);
1721 
1722 		if (scan_stat < 4) {
1723 			(void) fprintf(stderr, gettext(ERR_MIS_TOK),
1724 			    "-m", one_entry);
1725 			status = ERROR;
1726 		}
1727 		if (scan_stat > 4) {
1728 			(void) fprintf(stderr, gettext(ERR_TOO_MANY_ARGS),
1729 			    "-m", one_entry);
1730 			status = ERROR;
1731 		}
1732 
1733 		intperm = atoi(perm);
1734 		if (intperm < 0000 || intperm > 4777) {
1735 			(void) fprintf(stderr, gettext(ERR_BAD_MODE), perm);
1736 			status = ERROR;
1737 		}
1738 	}
1739 
1740 	free(one_entry);
1741 	return (status);
1742 }
1743 
1744 
1745 /*
1746  * check each alias :
1747  *	alias list members separated by white space
1748  *	cannot exist as driver name in /etc/name_to_major
1749  *	cannot exist as driver or alias name in /etc/driver_aliases
1750  */
1751 int
aliases_unique(char * aliases)1752 aliases_unique(char *aliases)
1753 {
1754 	char *current_head;
1755 	char *previous_head;
1756 	char *one_entry;
1757 	int len;
1758 	int is_unique;
1759 	int err;
1760 
1761 	len = strlen(aliases);
1762 
1763 	one_entry = calloc(len + 1, 1);
1764 	if (one_entry == NULL) {
1765 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
1766 		return (ERROR);
1767 	}
1768 
1769 	previous_head = aliases;
1770 
1771 	do {
1772 		bzero(one_entry, len+1);
1773 		current_head = get_entry(previous_head, one_entry, ' ', 1);
1774 		previous_head = current_head;
1775 
1776 		if ((unique_driver_name(one_entry, name_to_major,
1777 		    &is_unique)) == ERROR)
1778 			goto err_out;
1779 
1780 		if (is_unique != UNIQUE) {
1781 			(void) fprintf(stderr, gettext(ERR_ALIAS_IN_NAM_MAJ),
1782 			    one_entry);
1783 			goto err_out;
1784 		}
1785 
1786 		if ((err = unique_drv_alias(one_entry)) != UNIQUE) {
1787 			if (err == NOT_UNIQUE) {
1788 				(void) fprintf(stderr,
1789 				    gettext(ERR_ALIAS_IN_USE), one_entry);
1790 			}
1791 			goto err_out;
1792 		}
1793 
1794 		if (!is_token(one_entry)) {
1795 			(void) fprintf(stderr, gettext(ERR_BAD_TOK),
1796 			    "-i", one_entry);
1797 			goto err_out;
1798 		}
1799 
1800 	} while (*current_head != '\0');
1801 
1802 	free(one_entry);
1803 	return (NOERR);
1804 
1805 err_out:
1806 	free(one_entry);
1807 	return (ERROR);
1808 }
1809 
1810 /*
1811  * verify each alias :
1812  *	alias list members separated by white space and quoted
1813  *	exist as alias name in /etc/driver_aliases
1814  */
1815 int
aliases_exist(char * aliases)1816 aliases_exist(char *aliases)
1817 {
1818 	char *current_head;
1819 	char *previous_head;
1820 	char *one_entry;
1821 	int len;
1822 
1823 	len = strlen(aliases);
1824 
1825 	one_entry = calloc(len + 1, 1);
1826 	if (one_entry == NULL) {
1827 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
1828 		return (ERROR);
1829 	}
1830 
1831 	previous_head = aliases;
1832 
1833 	do {
1834 		bzero(one_entry, len+1);
1835 		current_head = get_entry(previous_head, one_entry, ' ', 1);
1836 		previous_head = current_head;
1837 
1838 		if (unique_drv_alias(one_entry) != NOT_UNIQUE)
1839 			goto err_out;
1840 
1841 		if (!is_token(one_entry)) {
1842 			(void) fprintf(stderr, gettext(ERR_BAD_TOK),
1843 			    "-i", one_entry);
1844 			goto err_out;
1845 		}
1846 
1847 	} while (*current_head != '\0');
1848 
1849 	free(one_entry);
1850 	return (NOERR);
1851 
1852 err_out:
1853 	free(one_entry);
1854 	return (ERROR);
1855 }
1856 
1857 
1858 /*
1859  * check each alias :
1860  *	if path-oriented alias, path exists
1861  */
1862 int
aliases_paths_exist(char * aliases)1863 aliases_paths_exist(char *aliases)
1864 {
1865 	char *current_head;
1866 	char *previous_head;
1867 	char *one_entry;
1868 	int i, len;
1869 	char path[MAXPATHLEN];
1870 	struct stat buf;
1871 
1872 	len = strlen(aliases);
1873 
1874 	one_entry = calloc(len + 1, 1);
1875 	if (one_entry == NULL) {
1876 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
1877 		return (ERROR);
1878 	}
1879 
1880 	previous_head = aliases;
1881 
1882 	do {
1883 		for (i = 0; i <= len; i++)
1884 			one_entry[i] = 0;
1885 
1886 		current_head = get_entry(previous_head, one_entry, ' ', 1);
1887 		previous_head = current_head;
1888 
1889 		/* if the alias is a path, ensure that the path exists */
1890 		if (*one_entry != '/')
1891 			continue;
1892 		(void) snprintf(path, sizeof (path), "/devices/%s", one_entry);
1893 		if (stat(path, &buf) == 0)
1894 			continue;
1895 
1896 		/* no device at specified path-oriented alias path */
1897 		(void) fprintf(stderr, gettext(ERR_PATH_ORIENTED_ALIAS),
1898 		    one_entry);
1899 		free(one_entry);
1900 		return (ERROR);
1901 
1902 	} while (*current_head != '\0');
1903 
1904 	free(one_entry);
1905 
1906 	return (NOERR);
1907 }
1908 
1909 
1910 int
update_driver_aliases(char * driver_name,char * aliases)1911 update_driver_aliases(
1912 	char *driver_name,
1913 	char *aliases)
1914 {
1915 	/* make call to update the aliases file */
1916 	return (append_to_file(driver_name, aliases, driver_aliases,
1917 	    ' ', " ", 1));
1918 }
1919 
1920 
1921 /*
1922  * Return:
1923  *	ERROR in case of memory or read error
1924  *	UNIQUE if there is no existing match to the supplied alias
1925  *	NOT_UNIQUE if there is a match
1926  * An error message is emitted in the case of ERROR,
1927  * up to the caller otherwise.
1928  */
1929 int
unique_drv_alias(char * drv_alias)1930 unique_drv_alias(char *drv_alias)
1931 {
1932 	FILE *fp;
1933 	char drv[FILENAME_MAX + 1];
1934 	char line[MAX_N2M_ALIAS_LINE + 1], *cp;
1935 	char alias[FILENAME_MAX + 1];
1936 	char *a;
1937 	int status = UNIQUE;
1938 
1939 	fp = fopen(driver_aliases, "r");
1940 
1941 	if (fp != NULL) {
1942 		while ((fgets(line, sizeof (line), fp) != 0) &&
1943 		    status == UNIQUE) {
1944 			/* cut off comments starting with '#' */
1945 			if ((cp = strchr(line, '#')) != NULL)
1946 				*cp = '\0';
1947 			/* ignore comment or blank lines */
1948 			if (is_blank(line))
1949 				continue;
1950 			/* sanity-check */
1951 			if (sscanf(line,
1952 			    "%" VAL2STR(FILENAME_MAX) "s"	/* drv */
1953 			    "%" VAL2STR(FILENAME_MAX) "s",	/* alias */
1954 			    drv, alias) != 2)
1955 				(void) fprintf(stderr, gettext(ERR_BAD_LINE),
1956 				    driver_aliases, line);
1957 
1958 			/* unquote for compare */
1959 			if ((*alias == '"') &&
1960 			    (*(alias + strlen(alias) - 1) == '"')) {
1961 				a = &alias[1];
1962 				alias[strlen(alias) - 1] = '\0';
1963 			} else
1964 				a = alias;
1965 
1966 			if ((strcmp(drv_alias, drv) == 0) ||
1967 			    (strcmp(drv_alias, a) == 0)) {
1968 				status = NOT_UNIQUE;
1969 				break;
1970 			}
1971 		}
1972 		(void) fclose(fp);
1973 		return (status);
1974 	} else {
1975 		perror(NULL);
1976 		(void) fprintf(stderr, gettext(ERR_CANT_OPEN), driver_aliases);
1977 		return (ERROR);
1978 	}
1979 }
1980 
1981 
1982 /*
1983  * search for driver_name in first field of file file_name
1984  * searching name_to_major and driver_aliases: name separated
1985  * from the remainder of the line by white space.
1986  */
1987 int
unique_driver_name(char * driver_name,char * file_name,int * is_unique)1988 unique_driver_name(char *driver_name, char *file_name, int *is_unique)
1989 {
1990 	int ret, err;
1991 
1992 	if ((ret = get_major_no(driver_name, file_name)) == ERROR) {
1993 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE),
1994 		    file_name);
1995 	} else {
1996 		/* check alias file for name collision */
1997 		if ((err = unique_drv_alias(driver_name)) != UNIQUE) {
1998 			if (err == NOT_UNIQUE) {
1999 				(void) fprintf(stderr,
2000 				    gettext(ERR_ALIAS_IN_USE),
2001 				    driver_name);
2002 			}
2003 			ret = ERROR;
2004 		} else {
2005 			if (ret != UNIQUE)
2006 				*is_unique = NOT_UNIQUE;
2007 			else
2008 				*is_unique = ret;
2009 			ret = NOERR;
2010 		}
2011 	}
2012 	return (ret);
2013 }
2014 
2015 /*
2016  * returns:
2017  *	SUCCESS - not an existing driver alias
2018  *	NOT_UNIQUE - matching driver alias exists
2019  *	ERROR - an error occurred
2020  */
2021 int
check_duplicate_driver_alias(char * driver_name,char * drv_alias)2022 check_duplicate_driver_alias(char *driver_name, char *drv_alias)
2023 {
2024 	FILE *fp;
2025 	char drv[FILENAME_MAX + 1];
2026 	char line[MAX_N2M_ALIAS_LINE + 1], *cp;
2027 	char alias[FILENAME_MAX + 1];
2028 	char *a;
2029 	int status = SUCCESS;
2030 
2031 	if ((fp = fopen(driver_aliases, "r")) == NULL) {
2032 		perror(NULL);
2033 		(void) fprintf(stderr, gettext(ERR_CANT_OPEN), driver_aliases);
2034 		return (ERROR);
2035 	}
2036 
2037 	while (fgets(line, sizeof (line), fp) != 0) {
2038 		/* cut off comments starting with '#' */
2039 		if ((cp = strchr(line, '#')) != NULL)
2040 			*cp = '\0';
2041 		/* ignore comment or blank lines */
2042 		if (is_blank(line))
2043 			continue;
2044 		/* sanity-check */
2045 		if (sscanf(line,
2046 		    "%" VAL2STR(FILENAME_MAX) "s"	/* drv */
2047 		    "%" VAL2STR(FILENAME_MAX) "s",	/* alias */
2048 		    drv, alias) != 2)
2049 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
2050 			    driver_aliases, line);
2051 
2052 		/* unquote for compare */
2053 		if ((*alias == '"') &&
2054 		    (*(alias + strlen(alias) - 1) == '"')) {
2055 			a = &alias[1];
2056 			alias[strlen(alias) - 1] = '\0';
2057 		} else
2058 			a = alias;
2059 
2060 		if ((strcmp(drv_alias, a) == 0) &&
2061 		    (strcmp(drv, driver_name) == 0)) {
2062 			status = NOT_UNIQUE;
2063 		}
2064 
2065 		if ((strcmp(drv_alias, drv) == 0) ||
2066 		    ((strcmp(drv_alias, a) == 0) &&
2067 		    (strcmp(drv, driver_name) != 0))) {
2068 			(void) fprintf(stderr,
2069 			    gettext(ERR_ALIAS_IN_USE),
2070 			    drv_alias);
2071 			status = ERROR;
2072 			goto done;
2073 		}
2074 	}
2075 
2076 done:
2077 	(void) fclose(fp);
2078 	return (status);
2079 }
2080 
2081 int
trim_duplicate_aliases(char * driver_name,char * aliases,char ** aliases2p)2082 trim_duplicate_aliases(char *driver_name, char *aliases, char **aliases2p)
2083 {
2084 	char *current_head;
2085 	char *previous_head;
2086 	char *one_entry;
2087 	char *aliases2;
2088 	int rv, len;
2089 	int n = 0;
2090 
2091 	*aliases2p = NULL;
2092 	len = strlen(aliases) + 1;
2093 
2094 	one_entry = calloc(len, 1);
2095 	aliases2 = calloc(len, 1);
2096 	if (one_entry == NULL || aliases2 == NULL) {
2097 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
2098 		return (ERROR);
2099 	}
2100 
2101 	previous_head = aliases;
2102 
2103 	do {
2104 		(void) bzero(one_entry, len);
2105 		current_head = get_entry(previous_head, one_entry, ' ', 1);
2106 		previous_head = current_head;
2107 
2108 		rv = check_duplicate_driver_alias(driver_name, one_entry);
2109 		switch (rv) {
2110 		case SUCCESS:
2111 			/* not an existing driver alias: add it */
2112 			if (n > 0) {
2113 				if (strlcat(aliases2, " ", len) >= len)
2114 					goto err;
2115 			}
2116 			if (strlcat(aliases2, one_entry, len) >= len)
2117 				goto err;
2118 			n++;
2119 			break;
2120 		case NOT_UNIQUE:
2121 			/* matching driver alias exists: do not add it */
2122 			break;
2123 		case ERROR:
2124 			/* error reading the alias file */
2125 			goto err;
2126 		default:
2127 			goto err;
2128 		}
2129 
2130 		if (!is_token(one_entry)) {
2131 			(void) fprintf(stderr, gettext(ERR_BAD_TOK),
2132 			    "-i", one_entry);
2133 			goto err;
2134 		}
2135 	} while (*current_head != '\0');
2136 
2137 	/*
2138 	 * If all the aliases listed are already
2139 	 * present we actually have none to do.
2140 	 */
2141 	if (n == 0) {
2142 		free(aliases2);
2143 	} else {
2144 		*aliases2p = aliases2;
2145 	}
2146 	free(one_entry);
2147 	return (NOERR);
2148 
2149 err:
2150 	free(aliases2);
2151 	free(one_entry);
2152 	return (ERROR);
2153 }
2154 
2155 int
check_space_within_quote(char * str)2156 check_space_within_quote(char *str)
2157 {
2158 	register int i;
2159 	register int len;
2160 	int quoted = 0;
2161 
2162 	len = strlen(str);
2163 	for (i = 0; i < len; i++, str++) {
2164 		if (*str == '"') {
2165 			if (quoted == 0)
2166 				quoted++;
2167 			else
2168 				quoted--;
2169 		} else if (*str == ' ' && quoted)
2170 			return (ERROR);
2171 	}
2172 
2173 	return (0);
2174 }
2175 
2176 
2177 /*
2178  * get major number
2179  * write driver_name major_num to name_to_major file
2180  * major_num returned in major_num
2181  * return success/failure
2182  */
2183 int
update_name_to_major(char * driver_name,major_t * major_num,int server)2184 update_name_to_major(char *driver_name, major_t *major_num, int server)
2185 {
2186 	char major[MAX_STR_MAJOR + 1];
2187 	struct stat buf;
2188 	char *num_list;
2189 	char drv_majnum_str[MAX_STR_MAJOR + 1];
2190 	int new_maj = -1;
2191 	int i, tmp = 0, is_unique, have_rem_n2m = 0;
2192 	int max_dev = 0;
2193 
2194 	/*
2195 	 * if driver_name already in rem_name_to_major
2196 	 *	delete entry from rem_nam_to_major
2197 	 *	put entry into name_to_major
2198 	 */
2199 
2200 	if (stat(rem_name_to_major, &buf) == 0) {
2201 		have_rem_n2m = 1;
2202 	}
2203 
2204 	if (have_rem_n2m) {
2205 		if ((is_unique = get_major_no(driver_name, rem_name_to_major))
2206 		    == ERROR)
2207 			return (ERROR);
2208 
2209 		/*
2210 		 * found a match in rem_name_to_major
2211 		 */
2212 		if (is_unique != UNIQUE) {
2213 			char scratch[FILENAME_MAX];
2214 
2215 			/*
2216 			 * If there is a match in /etc/rem_name_to_major then
2217 			 * be paranoid: is that major number already in
2218 			 * /etc/name_to_major (potentially under another name)?
2219 			 */
2220 			if (get_driver_name(is_unique, name_to_major,
2221 			    scratch) != UNIQUE) {
2222 				/*
2223 				 * nuke the rem_name_to_major entry-- it
2224 				 * isn't helpful.
2225 				 */
2226 				(void) delete_entry(rem_name_to_major,
2227 				    driver_name, " ", NULL);
2228 			} else {
2229 				(void) snprintf(major, sizeof (major),
2230 				    "%d", is_unique);
2231 
2232 				if (append_to_file(driver_name, major,
2233 				    name_to_major, ' ', " ", 0) == ERROR) {
2234 					(void) fprintf(stderr,
2235 					    gettext(ERR_NO_UPDATE),
2236 					    name_to_major);
2237 					return (ERROR);
2238 				}
2239 
2240 				if (delete_entry(rem_name_to_major,
2241 				    driver_name, " ", NULL) == ERROR) {
2242 					(void) fprintf(stderr,
2243 					    gettext(ERR_DEL_ENTRY), driver_name,
2244 					    rem_name_to_major);
2245 					return (ERROR);
2246 				}
2247 
2248 				/* found matching entry : no errors */
2249 				*major_num = is_unique;
2250 				return (NOERR);
2251 			}
2252 		}
2253 	}
2254 
2255 	/*
2256 	 * Bugid: 1264079
2257 	 * In a server case (with -b option), we can't use modctl() to find
2258 	 *    the maximum major number, we need to dig thru client's
2259 	 *    /etc/name_to_major and /etc/rem_name_to_major for the max_dev.
2260 	 *
2261 	 * if (server)
2262 	 *    get maximum major number thru (rem_)name_to_major file on client
2263 	 * else
2264 	 *    get maximum major number allowable on current system using modctl
2265 	 */
2266 	if (server) {
2267 		max_dev = 0;
2268 		tmp = 0;
2269 
2270 		max_dev = get_max_major(name_to_major);
2271 
2272 		/* If rem_name_to_major exists, we need to check it too */
2273 		if (have_rem_n2m) {
2274 			tmp = get_max_major(rem_name_to_major);
2275 
2276 			/*
2277 			 * If name_to_major is missing, we can get max_dev from
2278 			 * /etc/rem_name_to_major.  If both missing, bail out!
2279 			 */
2280 			if ((max_dev == ERROR) && (tmp == ERROR)) {
2281 				(void) fprintf(stderr,
2282 				    gettext(ERR_CANT_ACCESS_FILE),
2283 				    name_to_major);
2284 				return (ERROR);
2285 			}
2286 
2287 			/* guard against bigger maj_num in rem_name_to_major */
2288 			if (tmp > max_dev)
2289 				max_dev = tmp;
2290 		} else {
2291 			/*
2292 			 * If we can't get major from name_to_major file
2293 			 * and there is no /etc/rem_name_to_major file,
2294 			 * then we don't have a max_dev, bail out quick!
2295 			 */
2296 			if (max_dev == ERROR)
2297 				return (ERROR);
2298 		}
2299 
2300 		/*
2301 		 * In case there is no more slack in current name_to_major
2302 		 * table, provide at least 1 extra entry so the add_drv can
2303 		 * succeed.  Since only one add_drv process is allowed at one
2304 		 * time, and hence max_dev will be re-calculated each time
2305 		 * add_drv is ran, we don't need to worry about adding more
2306 		 * than 1 extra slot for max_dev.
2307 		 */
2308 		max_dev++;
2309 
2310 	} else {
2311 		if (modctl(MODRESERVED, NULL, &max_dev) < 0) {
2312 			perror(NULL);
2313 			(void) fprintf(stderr, gettext(ERR_MAX_MAJOR));
2314 			return (ERROR);
2315 		}
2316 	}
2317 
2318 	/*
2319 	 * max_dev is really how many slots the kernel has allocated for
2320 	 * devices... [0 , maxdev-1], not the largest available device num.
2321 	 */
2322 	if ((num_list = calloc(max_dev, 1)) == NULL) {
2323 		(void) fprintf(stderr, gettext(ERR_NO_MEM));
2324 		return (ERROR);
2325 	}
2326 
2327 	/*
2328 	 * Populate the num_list array
2329 	 */
2330 	if (fill_n2m_array(name_to_major, &num_list, &max_dev) != 0) {
2331 		return (ERROR);
2332 	}
2333 	if (have_rem_n2m) {
2334 		if (fill_n2m_array(rem_name_to_major, &num_list, &max_dev) != 0)
2335 			return (ERROR);
2336 	}
2337 
2338 	/*
2339 	 * Find the first free major number.
2340 	 *
2341 	 * Note that we begin searching from 1, as drivers have developer the
2342 	 * erroneous assumption that a dev_t of 0 is invalid, and since we no
2343 	 * longer include system devices in the base files, a major number of
2344 	 * 0 may now be given to arbitrary devices.
2345 	 */
2346 	for (i = 1; i < max_dev; i++) {
2347 		if (num_list[i] != 1) {
2348 			new_maj = i;
2349 			break;
2350 		}
2351 	}
2352 
2353 	if (new_maj == -1) {
2354 		(void) fprintf(stderr, gettext(ERR_NO_FREE_MAJOR));
2355 		return (ERROR);
2356 	}
2357 
2358 	(void) snprintf(drv_majnum_str, sizeof (drv_majnum_str),
2359 	    "%d", new_maj);
2360 	if (do_the_update(driver_name, drv_majnum_str) == ERROR) {
2361 		return (ERROR);
2362 	}
2363 
2364 	*major_num = new_maj;
2365 	return (NOERR);
2366 }
2367 
2368 
2369 int
fill_n2m_array(char * filename,char ** array,int * nelems)2370 fill_n2m_array(char *filename, char **array, int *nelems)
2371 {
2372 	FILE *fp;
2373 	char line[MAX_N2M_ALIAS_LINE + 1], *cp;
2374 	char drv[FILENAME_MAX + 1];
2375 	u_longlong_t dnum;
2376 	major_t drv_majnum;
2377 
2378 	/*
2379 	 * Read through the file, marking each major number found
2380 	 * order is not relevant
2381 	 */
2382 	if ((fp = fopen(filename, "r")) == NULL) {
2383 		perror(NULL);
2384 		(void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), filename);
2385 		return (ERROR);
2386 	}
2387 
2388 	while (fgets(line, sizeof (line), fp) != 0) {
2389 		/* cut off comments starting with '#' */
2390 		if ((cp = strchr(line, '#')) != NULL)
2391 			*cp = '\0';
2392 		/* ignore comment or blank lines */
2393 		if (is_blank(line))
2394 			continue;
2395 		/* sanity-check */
2396 		if (sscanf(line,
2397 		    "%" VAL2STR(FILENAME_MAX) "s %llu", drv, &dnum) != 2) {
2398 			(void) fprintf(stderr, gettext(ERR_BAD_LINE),
2399 			    filename, line);
2400 			(void) fclose(fp);
2401 			return (ERROR);
2402 		}
2403 
2404 		if (dnum > L_MAXMAJ32) {
2405 			(void) fprintf(stderr, gettext(ERR_MAJ_TOOBIG), drv,
2406 			    dnum, filename, L_MAXMAJ32);
2407 			continue;
2408 		}
2409 		/*
2410 		 * cast down to a major_t; we can be sure this is safe because
2411 		 * of the above range-check.
2412 		 */
2413 		drv_majnum = (major_t)dnum;
2414 
2415 		if (drv_majnum >= *nelems) {
2416 			/*
2417 			 * Allocate some more space, up to drv_majnum + 1 so
2418 			 * we can accomodate 0 through drv_majnum.
2419 			 *
2420 			 * Note that in the failure case, we leak all of the
2421 			 * old contents of array.  It's ok, since we just
2422 			 * wind up exiting immediately anyway.
2423 			 */
2424 			*nelems = drv_majnum + 1;
2425 			*array = realloc(*array, *nelems);
2426 			if (*array == NULL) {
2427 				(void) fprintf(stderr, gettext(ERR_NO_MEM));
2428 				return (ERROR);
2429 			}
2430 		}
2431 		(*array)[drv_majnum] = 1;
2432 	}
2433 
2434 	(void) fclose(fp);
2435 	return (0);
2436 }
2437 
2438 
2439 int
do_the_update(char * driver_name,char * major_number)2440 do_the_update(char *driver_name, char *major_number)
2441 {
2442 	return (append_to_file(driver_name, major_number, name_to_major,
2443 	    ' ', " ", 0));
2444 }
2445 
2446 /*
2447  * is_blank() returns 1 (true) if a line specified is composed of
2448  * whitespace characters only. otherwise, it returns 0 (false).
2449  *
2450  * Note. the argument (line) must be null-terminated.
2451  */
2452 static int
is_blank(char * line)2453 is_blank(char *line)
2454 {
2455 	for (/* nothing */; *line != '\0'; line++)
2456 		if (!isspace(*line))
2457 			return (0);
2458 	return (1);
2459 }
2460