17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 51ca93273Seota * Common Development and Distribution License (the "License"). 61ca93273Seota * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*0013e2d3SJerry Gilliam * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #include <stdio.h> 277c478bd9Sstevel@tonic-gate #include <stdlib.h> 281ca93273Seota #include <ctype.h> 297c478bd9Sstevel@tonic-gate #include <unistd.h> 307c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 317c478bd9Sstevel@tonic-gate #include <libintl.h> 327c478bd9Sstevel@tonic-gate #include <wait.h> 337c478bd9Sstevel@tonic-gate #include <string.h> 34*0013e2d3SJerry Gilliam #include <strings.h> 357c478bd9Sstevel@tonic-gate #include <errno.h> 367c478bd9Sstevel@tonic-gate #include <fcntl.h> 377c478bd9Sstevel@tonic-gate #include <signal.h> 387c478bd9Sstevel@tonic-gate #include <sys/buf.h> 397c478bd9Sstevel@tonic-gate #include <sys/stat.h> 407c478bd9Sstevel@tonic-gate #include <grp.h> 417c478bd9Sstevel@tonic-gate #include "addrem.h" 427c478bd9Sstevel@tonic-gate #include "errmsg.h" 437c478bd9Sstevel@tonic-gate #include "plcysubr.h" 447c478bd9Sstevel@tonic-gate 457c478bd9Sstevel@tonic-gate static char *add_rem_lock; /* lock file */ 467c478bd9Sstevel@tonic-gate static char *tmphold; /* temperary file for updating */ 4749e92448Svikram static int add_rem_lock_fd = -1; 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate static int get_cached_n_to_m_file(char *filename, char ***cache); 507c478bd9Sstevel@tonic-gate static int get_name_to_major_entry(int *major_no, char *driver_name, 517c478bd9Sstevel@tonic-gate char *file_name); 527c478bd9Sstevel@tonic-gate 531ca93273Seota static int is_blank(char *); 541ca93273Seota 557c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 567c478bd9Sstevel@tonic-gate void 577c478bd9Sstevel@tonic-gate log_minorperm_error(minorperm_err_t err, int key) 587c478bd9Sstevel@tonic-gate { 597c478bd9Sstevel@tonic-gate switch (err) { 607c478bd9Sstevel@tonic-gate case MP_FOPEN_ERR: 617c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 62*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 637c478bd9Sstevel@tonic-gate break; 647c478bd9Sstevel@tonic-gate case MP_FCLOSE_ERR: 657c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 66*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 677c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 687c478bd9Sstevel@tonic-gate break; 697c478bd9Sstevel@tonic-gate case MP_IGNORING_LINE_ERR: 707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 71*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 727c478bd9Sstevel@tonic-gate break; 737c478bd9Sstevel@tonic-gate case MP_ALLOC_ERR: 747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 75*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 767c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 777c478bd9Sstevel@tonic-gate break; 787c478bd9Sstevel@tonic-gate case MP_NVLIST_ERR: 797c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 80*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 817c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 827c478bd9Sstevel@tonic-gate break; 837c478bd9Sstevel@tonic-gate case MP_CANT_FIND_USER_ERR: 847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 85*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 867c478bd9Sstevel@tonic-gate break; 877c478bd9Sstevel@tonic-gate case MP_CANT_FIND_GROUP_ERR: 887c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 89*0013e2d3SJerry Gilliam MINOR_PERM_FILE); 907c478bd9Sstevel@tonic-gate break; 917c478bd9Sstevel@tonic-gate } 927c478bd9Sstevel@tonic-gate } 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate /* 957c478bd9Sstevel@tonic-gate * open file 967c478bd9Sstevel@tonic-gate * for each entry in list 977c478bd9Sstevel@tonic-gate * where list entries are separated by <list_separator> 987c478bd9Sstevel@tonic-gate * append entry : driver_name <entry_separator> entry 997c478bd9Sstevel@tonic-gate * close file 1007c478bd9Sstevel@tonic-gate * return error/noerr 1017c478bd9Sstevel@tonic-gate */ 1027c478bd9Sstevel@tonic-gate int 1037c478bd9Sstevel@tonic-gate append_to_file( 1047c478bd9Sstevel@tonic-gate char *driver_name, 1057c478bd9Sstevel@tonic-gate char *entry_list, 1067c478bd9Sstevel@tonic-gate char *filename, 1077c478bd9Sstevel@tonic-gate char list_separator, 108f4da9be0Scth char *entry_separator, 109f4da9be0Scth int quoted) 1107c478bd9Sstevel@tonic-gate { 1117c478bd9Sstevel@tonic-gate int i, len; 1127c478bd9Sstevel@tonic-gate int fpint; 1137c478bd9Sstevel@tonic-gate char *current_head, *previous_head; 1147c478bd9Sstevel@tonic-gate char *line, *one_entry; 1157c478bd9Sstevel@tonic-gate FILE *fp; 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate if ((fp = fopen(filename, "a")) == NULL) { 1187c478bd9Sstevel@tonic-gate perror(NULL); 1197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 1207c478bd9Sstevel@tonic-gate filename); 1217c478bd9Sstevel@tonic-gate return (ERROR); 1227c478bd9Sstevel@tonic-gate } 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate len = strlen(entry_list); 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate one_entry = calloc(len + 1, 1); 1277c478bd9Sstevel@tonic-gate if (one_entry == NULL) { 1287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), filename); 1297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 1307c478bd9Sstevel@tonic-gate (void) fclose(fp); 1317c478bd9Sstevel@tonic-gate return (ERROR); 1327c478bd9Sstevel@tonic-gate } 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate previous_head = entry_list; 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate line = calloc(strlen(driver_name) + len + 4, 1); 1377c478bd9Sstevel@tonic-gate if (line == NULL) { 1387c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 1397c478bd9Sstevel@tonic-gate (void) fclose(fp); 1407c478bd9Sstevel@tonic-gate err_exit(); 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate /* 1447c478bd9Sstevel@tonic-gate * get one entry at a time from list and append to <filename> file 1457c478bd9Sstevel@tonic-gate */ 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate do { 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate for (i = 0; i <= len; i++) 1507c478bd9Sstevel@tonic-gate one_entry[i] = 0; 1517c478bd9Sstevel@tonic-gate 1527c478bd9Sstevel@tonic-gate for (i = 0; i <= (int)strlen(line); i++) 1537c478bd9Sstevel@tonic-gate line[i] = 0; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate current_head = get_entry(previous_head, one_entry, 156f4da9be0Scth list_separator, quoted); 1577c478bd9Sstevel@tonic-gate previous_head = current_head; 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate (void) strcpy(line, driver_name); 1607c478bd9Sstevel@tonic-gate (void) strcat(line, entry_separator); 161f4da9be0Scth if (quoted) 162f4da9be0Scth (void) strcat(line, "\""); 1637c478bd9Sstevel@tonic-gate (void) strcat(line, one_entry); 164f4da9be0Scth if (quoted) 165f4da9be0Scth (void) strcat(line, "\""); 1667c478bd9Sstevel@tonic-gate (void) strcat(line, "\n"); 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate if ((fputs(line, fp)) == EOF) { 1697c478bd9Sstevel@tonic-gate perror(NULL); 1707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_UPDATE), 1717c478bd9Sstevel@tonic-gate filename); 1727c478bd9Sstevel@tonic-gate } 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate } while (*current_head != '\0'); 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate (void) fflush(fp); 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate fpint = fileno(fp); 1807c478bd9Sstevel@tonic-gate (void) fsync(fpint); 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate (void) fclose(fp); 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate free(one_entry); 1857c478bd9Sstevel@tonic-gate free(line); 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate return (NOERR); 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate /* 1927c478bd9Sstevel@tonic-gate * open file 1937c478bd9Sstevel@tonic-gate * read thru file, deleting all entries if first 1947c478bd9Sstevel@tonic-gate * entry = driver_name 1957c478bd9Sstevel@tonic-gate * close 1967c478bd9Sstevel@tonic-gate * if error, leave original file intact with message 1977c478bd9Sstevel@tonic-gate * assumption : drvconfig has been modified to work with clone 1987c478bd9Sstevel@tonic-gate * entries in /etc/minor_perm as driver:mummble NOT 1997c478bd9Sstevel@tonic-gate * clone:driver mummble 2007c478bd9Sstevel@tonic-gate * this implementation will NOT find clone entries 2017c478bd9Sstevel@tonic-gate * clone:driver mummble 2027c478bd9Sstevel@tonic-gate * match: 2037c478bd9Sstevel@tonic-gate * delete just the matching entry 2047c478bd9Sstevel@tonic-gate * 2057c478bd9Sstevel@tonic-gate */ 2067c478bd9Sstevel@tonic-gate int 2077c478bd9Sstevel@tonic-gate delete_entry( 2087c478bd9Sstevel@tonic-gate char *oldfile, 2097c478bd9Sstevel@tonic-gate char *driver_name, 2107c478bd9Sstevel@tonic-gate char *marker, 2117c478bd9Sstevel@tonic-gate char *match) 2127c478bd9Sstevel@tonic-gate { 2137c478bd9Sstevel@tonic-gate int rv, i; 2147c478bd9Sstevel@tonic-gate int status = NOERR; 2157c478bd9Sstevel@tonic-gate int drvr_found = 0; 2167c478bd9Sstevel@tonic-gate boolean_t nomatch = B_TRUE; 2171ca93273Seota char *newfile, *tptr, *cp, *dup; 2187c478bd9Sstevel@tonic-gate char line[MAX_DBFILE_ENTRY], drv[FILENAME_MAX + 1]; 2197c478bd9Sstevel@tonic-gate FILE *fp, *newfp; 2207c478bd9Sstevel@tonic-gate struct group *sysgrp; 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /* 2237c478bd9Sstevel@tonic-gate * check if match is specified and if it equals " " 2247c478bd9Sstevel@tonic-gate * this is a special case handling as we do a strstr(3STRING) 2257c478bd9Sstevel@tonic-gate * to match an entry. By default all entries are space separated 2267c478bd9Sstevel@tonic-gate * and without this check all entries of the file could get deleted. 2277c478bd9Sstevel@tonic-gate */ 2287c478bd9Sstevel@tonic-gate if (match && (*match == ' ' && strlen(match) == 1)) { 2297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_INT_UPDATE), oldfile); 2307c478bd9Sstevel@tonic-gate return (ERROR); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate if ((fp = fopen(oldfile, "r")) == NULL) { 2347c478bd9Sstevel@tonic-gate perror(NULL); 2357c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), oldfile); 2367c478bd9Sstevel@tonic-gate return (ERROR); 2377c478bd9Sstevel@tonic-gate } 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate /* 2407c478bd9Sstevel@tonic-gate * Build filename for temporary file 2417c478bd9Sstevel@tonic-gate */ 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate if ((tptr = calloc(strlen(oldfile) + strlen(XEND) + 1, 1)) == NULL) { 2447c478bd9Sstevel@tonic-gate perror(NULL); 2457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 2467c478bd9Sstevel@tonic-gate } 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate (void) strcpy(tptr, oldfile); 2497c478bd9Sstevel@tonic-gate (void) strcat(tptr, XEND); 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate /* 2527c478bd9Sstevel@tonic-gate * Set gid so we preserve group attribute. Ideally we wouldn't 2537c478bd9Sstevel@tonic-gate * assume a gid of "sys" but we can't undo the damage on already 2547c478bd9Sstevel@tonic-gate * installed systems unless we force the issue. 2557c478bd9Sstevel@tonic-gate */ 2567c478bd9Sstevel@tonic-gate if ((sysgrp = getgrnam("sys")) != NULL) { 2577c478bd9Sstevel@tonic-gate (void) setgid(sysgrp->gr_gid); 2587c478bd9Sstevel@tonic-gate } 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate newfile = mktemp(tptr); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate if ((newfp = fopen(newfile, "w")) == NULL) { 2637c478bd9Sstevel@tonic-gate perror(NULL); 2647c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 2657c478bd9Sstevel@tonic-gate newfile); 2667c478bd9Sstevel@tonic-gate return (ERROR); 2677c478bd9Sstevel@tonic-gate } 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate while ((fgets(line, sizeof (line), fp) != NULL) && status == NOERR) { 2701ca93273Seota /* copy the whole line into dup */ 2711ca93273Seota if ((dup = strdup(line)) == NULL) { 2721ca93273Seota perror(NULL); 2731ca93273Seota (void) fprintf(stderr, gettext(ERR_NO_MEM)); 2741ca93273Seota status = ERROR; 2751ca93273Seota break; 2761ca93273Seota } 2771ca93273Seota /* cut off comments starting with '#' */ 2781ca93273Seota if ((cp = strchr(dup, '#')) != NULL) 2791ca93273Seota *cp = '\0'; 2801ca93273Seota /* ignore comment or blank lines */ 2811ca93273Seota if (is_blank(dup)) { 2821ca93273Seota if (fputs(line, newfp) == EOF) { 2837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), 2847c478bd9Sstevel@tonic-gate oldfile); 2857c478bd9Sstevel@tonic-gate status = ERROR; 2867c478bd9Sstevel@tonic-gate } 2871ca93273Seota free(dup); 2887c478bd9Sstevel@tonic-gate continue; 2897c478bd9Sstevel@tonic-gate } 2901ca93273Seota 2911ca93273Seota /* get the driver name */ 2921ca93273Seota if (sscanf(dup, "%s", drv) != 1) { 2937c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 2947c478bd9Sstevel@tonic-gate oldfile, line); 2957c478bd9Sstevel@tonic-gate status = ERROR; 2961ca93273Seota free(dup); 2971ca93273Seota break; 2987c478bd9Sstevel@tonic-gate } 2991ca93273Seota free(dup); 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate for (i = strcspn(drv, marker); i < FILENAME_MAX; i++) { 3027c478bd9Sstevel@tonic-gate drv[i] = '\0'; 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate if (strcmp(driver_name, drv) != 0) { 3067c478bd9Sstevel@tonic-gate if ((fputs(line, newfp)) == EOF) { 3077c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), 3087c478bd9Sstevel@tonic-gate oldfile); 3097c478bd9Sstevel@tonic-gate status = ERROR; 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate } else { 3127c478bd9Sstevel@tonic-gate drvr_found++; 3137c478bd9Sstevel@tonic-gate if (match) { /* Just delete one entry */ 3147c478bd9Sstevel@tonic-gate /* for now delete just minor_perm and aliases */ 3157c478bd9Sstevel@tonic-gate if ((strcmp(oldfile, minor_perm) == 0) || 3167c478bd9Sstevel@tonic-gate (strcmp(oldfile, extra_privs) == 0) || 3177c478bd9Sstevel@tonic-gate (strcmp(oldfile, driver_aliases) == 0)) { 3187c478bd9Sstevel@tonic-gate if (strstr(line, match)) { 3197c478bd9Sstevel@tonic-gate nomatch = B_FALSE; 3207c478bd9Sstevel@tonic-gate } else { 3217c478bd9Sstevel@tonic-gate if ((fputs(line, newfp)) == 3227c478bd9Sstevel@tonic-gate EOF) { 3237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 3247c478bd9Sstevel@tonic-gate gettext(ERR_UPDATE), 3257c478bd9Sstevel@tonic-gate oldfile); 3267c478bd9Sstevel@tonic-gate status = ERROR; 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate if (nomatch != B_FALSE) 3297c478bd9Sstevel@tonic-gate nomatch = B_TRUE; 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate } 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate } /* end of else */ 3357c478bd9Sstevel@tonic-gate } /* end of while */ 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate (void) fclose(fp); 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate /* Make sure that the file is on disk */ 3407c478bd9Sstevel@tonic-gate if (fflush(newfp) != 0 || fsync(fileno(newfp)) != 0) 3417c478bd9Sstevel@tonic-gate status = ERROR; 3427c478bd9Sstevel@tonic-gate else 3437c478bd9Sstevel@tonic-gate rv = NOERR; 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate (void) fclose(newfp); 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate /* no matching driver found */ 3487c478bd9Sstevel@tonic-gate rv = NOERR; 3497c478bd9Sstevel@tonic-gate if (!drvr_found || 3507c478bd9Sstevel@tonic-gate (nomatch == B_TRUE)) { 3517c478bd9Sstevel@tonic-gate rv = NONE_FOUND; 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate /* 3557c478bd9Sstevel@tonic-gate * if error, leave original file, delete new file 3567c478bd9Sstevel@tonic-gate * if noerr, replace original file with new file 3577c478bd9Sstevel@tonic-gate */ 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate if (status == NOERR) { 3607c478bd9Sstevel@tonic-gate if (rename(oldfile, tmphold) == -1) { 3617c478bd9Sstevel@tonic-gate perror(NULL); 3627c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), oldfile); 3637c478bd9Sstevel@tonic-gate (void) unlink(newfile); 3647c478bd9Sstevel@tonic-gate return (ERROR); 3657c478bd9Sstevel@tonic-gate } else if (rename(newfile, oldfile) == -1) { 3667c478bd9Sstevel@tonic-gate perror(NULL); 3677c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), oldfile); 3687c478bd9Sstevel@tonic-gate (void) unlink(oldfile); 3697c478bd9Sstevel@tonic-gate (void) unlink(newfile); 3707c478bd9Sstevel@tonic-gate if (link(tmphold, oldfile) == -1) { 3717c478bd9Sstevel@tonic-gate perror(NULL); 3727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINK), 3737c478bd9Sstevel@tonic-gate oldfile, tmphold); 3747c478bd9Sstevel@tonic-gate } 3757c478bd9Sstevel@tonic-gate return (ERROR); 3767c478bd9Sstevel@tonic-gate } 3777c478bd9Sstevel@tonic-gate (void) unlink(tmphold); 3787c478bd9Sstevel@tonic-gate } else { 3797c478bd9Sstevel@tonic-gate /* 3807c478bd9Sstevel@tonic-gate * since there's an error, leave file alone; remove 3817c478bd9Sstevel@tonic-gate * new file 3827c478bd9Sstevel@tonic-gate */ 3837c478bd9Sstevel@tonic-gate if (unlink(newfile) == -1) { 3847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_RM), newfile); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate return (ERROR); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate return (rv); 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* 3947c478bd9Sstevel@tonic-gate * wrapper for call to get_name_to_major_entry(): given driver name, 3957c478bd9Sstevel@tonic-gate * retrieve major number. 3967c478bd9Sstevel@tonic-gate */ 3977c478bd9Sstevel@tonic-gate int 3987c478bd9Sstevel@tonic-gate get_major_no(char *driver_name, char *file_name) 3997c478bd9Sstevel@tonic-gate { 4007c478bd9Sstevel@tonic-gate int major = UNIQUE; 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate if (get_name_to_major_entry(&major, driver_name, file_name) == ERROR) 4037c478bd9Sstevel@tonic-gate return (ERROR); 4047c478bd9Sstevel@tonic-gate else 4057c478bd9Sstevel@tonic-gate return (major); 4067c478bd9Sstevel@tonic-gate } 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate /* 4097c478bd9Sstevel@tonic-gate * wrapper for call to get_name_to_major_entry(): given major number, 4107c478bd9Sstevel@tonic-gate * retrieve driver name. 4117c478bd9Sstevel@tonic-gate */ 4127c478bd9Sstevel@tonic-gate int 4137c478bd9Sstevel@tonic-gate get_driver_name(int major, char *file_name, char *buf) 4147c478bd9Sstevel@tonic-gate { 4157c478bd9Sstevel@tonic-gate if (major < 0) 4167c478bd9Sstevel@tonic-gate return (ERROR); 4177c478bd9Sstevel@tonic-gate return (get_name_to_major_entry(&major, buf, file_name)); 4187c478bd9Sstevel@tonic-gate } 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate 4217c478bd9Sstevel@tonic-gate /* 4227c478bd9Sstevel@tonic-gate * return pointer to cached name_to_major file - reads file into 4237c478bd9Sstevel@tonic-gate * cache if this has not already been done. Since there may be 4247c478bd9Sstevel@tonic-gate * requests for multiple name_to_major files (rem_name_to_major, 4257c478bd9Sstevel@tonic-gate * name_to_major), this routine keeps a list of cached files. 4267c478bd9Sstevel@tonic-gate */ 4277c478bd9Sstevel@tonic-gate static int 4287c478bd9Sstevel@tonic-gate get_cached_n_to_m_file(char *filename, char ***cache) 4297c478bd9Sstevel@tonic-gate { 4307c478bd9Sstevel@tonic-gate struct n_to_m_cache { 4317c478bd9Sstevel@tonic-gate char *file; 4327c478bd9Sstevel@tonic-gate char **cached_file; 4337c478bd9Sstevel@tonic-gate int size; 4347c478bd9Sstevel@tonic-gate struct n_to_m_cache *next; 4357c478bd9Sstevel@tonic-gate }; 4367c478bd9Sstevel@tonic-gate static struct n_to_m_cache *head = NULL; 4377c478bd9Sstevel@tonic-gate struct n_to_m_cache *ptr; 4387c478bd9Sstevel@tonic-gate FILE *fp; 4397c478bd9Sstevel@tonic-gate char drv[FILENAME_MAX + 1]; 4407c478bd9Sstevel@tonic-gate char entry[FILENAME_MAX + 1]; 4411ca93273Seota char line[MAX_N2M_ALIAS_LINE], *cp; 4427c478bd9Sstevel@tonic-gate int maj; 4437c478bd9Sstevel@tonic-gate int size = 0; 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate /* 4477c478bd9Sstevel@tonic-gate * see if the file is already cached - either 4487c478bd9Sstevel@tonic-gate * rem_name_to_major or name_to_major 4497c478bd9Sstevel@tonic-gate */ 4507c478bd9Sstevel@tonic-gate ptr = head; 4517c478bd9Sstevel@tonic-gate while (ptr != NULL) { 4527c478bd9Sstevel@tonic-gate if (strcmp(ptr->file, filename) == 0) 4537c478bd9Sstevel@tonic-gate break; 4547c478bd9Sstevel@tonic-gate ptr = ptr->next; 4557c478bd9Sstevel@tonic-gate } 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate if (ptr == NULL) { /* we need to cache the contents */ 4587c478bd9Sstevel@tonic-gate if ((fp = fopen(filename, "r")) == NULL) { 4597c478bd9Sstevel@tonic-gate perror(NULL); 4607c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_OPEN), 4617c478bd9Sstevel@tonic-gate filename); 4627c478bd9Sstevel@tonic-gate return (ERROR); 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != NULL) { 4661ca93273Seota /* cut off comments starting with '#' */ 4671ca93273Seota if ((cp = strchr(line, '#')) != NULL) 4681ca93273Seota *cp = '\0'; 4691ca93273Seota /* ignore comment or blank lines */ 4701ca93273Seota if (is_blank(line)) 4711ca93273Seota continue; 4721ca93273Seota /* sanity-check */ 4737c478bd9Sstevel@tonic-gate if (sscanf(line, "%s%s", drv, entry) != 2) { 4747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 4757c478bd9Sstevel@tonic-gate filename, line); 4767c478bd9Sstevel@tonic-gate continue; 4777c478bd9Sstevel@tonic-gate } 4787c478bd9Sstevel@tonic-gate maj = atoi(entry); 4797c478bd9Sstevel@tonic-gate if (maj > size) 4807c478bd9Sstevel@tonic-gate size = maj; 4817c478bd9Sstevel@tonic-gate } 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate /* allocate struct to cache the file */ 4847c478bd9Sstevel@tonic-gate ptr = (struct n_to_m_cache *)calloc(1, 4857c478bd9Sstevel@tonic-gate sizeof (struct n_to_m_cache)); 4867c478bd9Sstevel@tonic-gate if (ptr == NULL) { 4877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 4887c478bd9Sstevel@tonic-gate return (ERROR); 4897c478bd9Sstevel@tonic-gate } 4907c478bd9Sstevel@tonic-gate ptr->size = size + 1; 4917c478bd9Sstevel@tonic-gate /* allocate space to cache contents of file */ 4927c478bd9Sstevel@tonic-gate ptr->cached_file = (char **)calloc(ptr->size, sizeof (char *)); 4937c478bd9Sstevel@tonic-gate if (ptr->cached_file == NULL) { 4947c478bd9Sstevel@tonic-gate free(ptr); 4957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 4967c478bd9Sstevel@tonic-gate return (ERROR); 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate rewind(fp); 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate /* 5027c478bd9Sstevel@tonic-gate * now fill the cache 5037c478bd9Sstevel@tonic-gate * the cache is an array of char pointers indexed by major 5047c478bd9Sstevel@tonic-gate * number 5057c478bd9Sstevel@tonic-gate */ 5067c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != NULL) { 5071ca93273Seota /* cut off comments starting with '#' */ 5081ca93273Seota if ((cp = strchr(line, '#')) != NULL) 5091ca93273Seota *cp = '\0'; 5101ca93273Seota /* ignore comment or blank lines */ 5111ca93273Seota if (is_blank(line)) 5121ca93273Seota continue; 5131ca93273Seota /* sanity-check */ 5147c478bd9Sstevel@tonic-gate if (sscanf(line, "%s%s", drv, entry) != 2) { 5157c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 5167c478bd9Sstevel@tonic-gate filename, line); 5177c478bd9Sstevel@tonic-gate continue; 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate maj = atoi(entry); 5207c478bd9Sstevel@tonic-gate if ((ptr->cached_file[maj] = strdup(drv)) == NULL) { 5217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 5227c478bd9Sstevel@tonic-gate free(ptr->cached_file); 5237c478bd9Sstevel@tonic-gate free(ptr); 5247c478bd9Sstevel@tonic-gate return (ERROR); 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate (void) strcpy(ptr->cached_file[maj], drv); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate (void) fclose(fp); 5297c478bd9Sstevel@tonic-gate /* link the cache struct into the list of cached files */ 5307c478bd9Sstevel@tonic-gate ptr->file = strdup(filename); 5317c478bd9Sstevel@tonic-gate if (ptr->file == NULL) { 5327c478bd9Sstevel@tonic-gate for (maj = 0; maj <= ptr->size; maj++) 5337c478bd9Sstevel@tonic-gate free(ptr->cached_file[maj]); 5347c478bd9Sstevel@tonic-gate free(ptr->cached_file); 5357c478bd9Sstevel@tonic-gate free(ptr); 5367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 5377c478bd9Sstevel@tonic-gate return (ERROR); 5387c478bd9Sstevel@tonic-gate } 5397c478bd9Sstevel@tonic-gate ptr->next = head; 5407c478bd9Sstevel@tonic-gate head = ptr; 5417c478bd9Sstevel@tonic-gate } 5427c478bd9Sstevel@tonic-gate /* return value pointer to contents of file */ 5437c478bd9Sstevel@tonic-gate *cache = ptr->cached_file; 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate /* return size */ 5467c478bd9Sstevel@tonic-gate return (ptr->size); 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /* 5517c478bd9Sstevel@tonic-gate * Using get_cached_n_to_m_file(), retrieve maximum major number 5527c478bd9Sstevel@tonic-gate * found in the specificed file (name_to_major/rem_name_to_major). 5537c478bd9Sstevel@tonic-gate * 5547c478bd9Sstevel@tonic-gate * The return value is actually the size of the internal cache including 0. 5557c478bd9Sstevel@tonic-gate */ 5567c478bd9Sstevel@tonic-gate int 5577c478bd9Sstevel@tonic-gate get_max_major(char *file_name) 5587c478bd9Sstevel@tonic-gate { 5597c478bd9Sstevel@tonic-gate char **n_to_m_cache = NULL; 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate return (get_cached_n_to_m_file(file_name, &n_to_m_cache)); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate 5657c478bd9Sstevel@tonic-gate /* 5667c478bd9Sstevel@tonic-gate * searching name_to_major: if major_no == UNIQUE then the caller wants to 5677c478bd9Sstevel@tonic-gate * use the driver name as the key. Otherwise, the caller wants to use 5687c478bd9Sstevel@tonic-gate * the major number as a key. 5697c478bd9Sstevel@tonic-gate * 5707c478bd9Sstevel@tonic-gate * This routine caches the contents of the name_to_major file on 5717c478bd9Sstevel@tonic-gate * first call. And it could be generalized to deal with other 5727c478bd9Sstevel@tonic-gate * config files if necessary. 5737c478bd9Sstevel@tonic-gate */ 5747c478bd9Sstevel@tonic-gate static int 5757c478bd9Sstevel@tonic-gate get_name_to_major_entry(int *major_no, char *driver_name, char *file_name) 5767c478bd9Sstevel@tonic-gate { 5777c478bd9Sstevel@tonic-gate int maj; 5787c478bd9Sstevel@tonic-gate char **n_to_m_cache = NULL; 5797c478bd9Sstevel@tonic-gate int size = 0; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate int ret = NOT_UNIQUE; 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate /* 5847c478bd9Sstevel@tonic-gate * read the file in - we cache it in case caller wants to 5857c478bd9Sstevel@tonic-gate * do multiple lookups 5867c478bd9Sstevel@tonic-gate */ 5877c478bd9Sstevel@tonic-gate size = get_cached_n_to_m_file(file_name, &n_to_m_cache); 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate if (size == ERROR) 5907c478bd9Sstevel@tonic-gate return (ERROR); 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate /* search with driver name as key */ 5937c478bd9Sstevel@tonic-gate if (*major_no == UNIQUE) { 5947c478bd9Sstevel@tonic-gate for (maj = 0; maj < size; maj++) { 5957c478bd9Sstevel@tonic-gate if ((n_to_m_cache[maj] != NULL) && 5967c478bd9Sstevel@tonic-gate (strcmp(driver_name, n_to_m_cache[maj]) == 0)) { 5977c478bd9Sstevel@tonic-gate *major_no = maj; 5987c478bd9Sstevel@tonic-gate break; 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate } 6017c478bd9Sstevel@tonic-gate if (maj >= size) 6027c478bd9Sstevel@tonic-gate ret = UNIQUE; 6037c478bd9Sstevel@tonic-gate /* search with major number as key */ 6047c478bd9Sstevel@tonic-gate } else { 6057c478bd9Sstevel@tonic-gate /* 6067c478bd9Sstevel@tonic-gate * Bugid 1254588, drvconfig dump core after loading driver 6077c478bd9Sstevel@tonic-gate * with major number bigger than entries defined in 6087c478bd9Sstevel@tonic-gate * /etc/name_to_major. 6097c478bd9Sstevel@tonic-gate */ 6107c478bd9Sstevel@tonic-gate if (*major_no >= size) 6117c478bd9Sstevel@tonic-gate return (UNIQUE); 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate if (n_to_m_cache[*major_no] != NULL) { 6147c478bd9Sstevel@tonic-gate (void) strcpy(driver_name, n_to_m_cache[*major_no]); 6157c478bd9Sstevel@tonic-gate } else 6167c478bd9Sstevel@tonic-gate ret = UNIQUE; 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate return (ret); 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate /* 622f4da9be0Scth * Given pointer to begining of member 'n' in a space (or separator) 623f4da9be0Scth * separated list, return pointer to member 'n+1', and establish member 'n' 624f4da9be0Scth * in *current_entry. If unquote, then we skip a leading quote and treat 625f4da9be0Scth * the trailing quote as a separator (and skip). 6267c478bd9Sstevel@tonic-gate */ 6277c478bd9Sstevel@tonic-gate char * 6287c478bd9Sstevel@tonic-gate get_entry( 6297c478bd9Sstevel@tonic-gate char *prev_member, 6307c478bd9Sstevel@tonic-gate char *current_entry, 631f4da9be0Scth char separator, 632f4da9be0Scth int unquote) 6337c478bd9Sstevel@tonic-gate { 634f4da9be0Scth char *ptr; 635f4da9be0Scth int quoted = 0; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate ptr = prev_member; 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /* skip white space */ 6407c478bd9Sstevel@tonic-gate while (*ptr == '\t' || *ptr == ' ') 6417c478bd9Sstevel@tonic-gate ptr++; 6427c478bd9Sstevel@tonic-gate 643f4da9be0Scth /* if unquote skip leading quote */ 644f4da9be0Scth if (unquote && *ptr == '"') { 645f4da9be0Scth quoted++; 646f4da9be0Scth ptr++; 647f4da9be0Scth } 648f4da9be0Scth 649f4da9be0Scth /* read thru the current entry looking for end, separator, or unquote */ 650f4da9be0Scth while (*ptr && 651f4da9be0Scth (*ptr != separator) && 652f4da9be0Scth ((separator != ' ') || (*ptr != '\t')) && 653f4da9be0Scth (!quoted || (*ptr != '"'))) { 6547c478bd9Sstevel@tonic-gate *current_entry++ = *ptr++; 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate *current_entry = '\0'; 6577c478bd9Sstevel@tonic-gate 658f4da9be0Scth if (separator && (*ptr == separator)) 659f4da9be0Scth ptr++; /* skip over separator */ 660f4da9be0Scth if (quoted && (*ptr == '"')) 661f4da9be0Scth ptr++; /* skip over trailing quote */ 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate /* skip white space */ 6647c478bd9Sstevel@tonic-gate while (*ptr == '\t' || *ptr == ' ') { 6657c478bd9Sstevel@tonic-gate ptr++; 6667c478bd9Sstevel@tonic-gate } 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate return (ptr); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate void 6727c478bd9Sstevel@tonic-gate enter_lock(void) 6737c478bd9Sstevel@tonic-gate { 67449e92448Svikram struct flock lock; 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate /* 6777c478bd9Sstevel@tonic-gate * attempt to create the lock file 6787c478bd9Sstevel@tonic-gate */ 67949e92448Svikram add_rem_lock_fd = open(add_rem_lock, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR); 68049e92448Svikram if (add_rem_lock_fd < 0) { 68149e92448Svikram (void) fprintf(stderr, gettext(ERR_CREAT_LOCK), 68249e92448Svikram add_rem_lock, strerror(errno)); 68349e92448Svikram exit(1); 68449e92448Svikram } 68549e92448Svikram 68649e92448Svikram lock.l_type = F_WRLCK; 68749e92448Svikram lock.l_whence = SEEK_SET; 68849e92448Svikram lock.l_start = 0; 68949e92448Svikram lock.l_len = 0; 69049e92448Svikram 69149e92448Svikram /* Try for the lock but don't wait. */ 69249e92448Svikram if (fcntl(add_rem_lock_fd, F_SETLK, &lock) == -1) { 69349e92448Svikram if (errno == EACCES || errno == EAGAIN) { 6947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_PROG_IN_USE)); 6957c478bd9Sstevel@tonic-gate } else { 69649e92448Svikram (void) fprintf(stderr, gettext(ERR_LOCK), 69749e92448Svikram add_rem_lock, strerror(errno)); 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate exit(1); 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate void 7047c478bd9Sstevel@tonic-gate err_exit(void) 7057c478bd9Sstevel@tonic-gate { 7067c478bd9Sstevel@tonic-gate /* release memory allocated for moddir */ 7077c478bd9Sstevel@tonic-gate cleanup_moddir(); 7087c478bd9Sstevel@tonic-gate /* remove add_drv/rem_drv lock */ 7097c478bd9Sstevel@tonic-gate exit_unlock(); 7107c478bd9Sstevel@tonic-gate exit(1); 7117c478bd9Sstevel@tonic-gate } 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate void 7147c478bd9Sstevel@tonic-gate cleanup_moddir(void) 7157c478bd9Sstevel@tonic-gate { 7167c478bd9Sstevel@tonic-gate struct drvmod_dir *walk_ptr; 7177c478bd9Sstevel@tonic-gate struct drvmod_dir *free_ptr = moddir; 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate while (free_ptr != NULL) { 7207c478bd9Sstevel@tonic-gate walk_ptr = free_ptr->next; 7217c478bd9Sstevel@tonic-gate free(free_ptr); 7227c478bd9Sstevel@tonic-gate free_ptr = walk_ptr; 7237c478bd9Sstevel@tonic-gate } 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate void 7277c478bd9Sstevel@tonic-gate exit_unlock(void) 7287c478bd9Sstevel@tonic-gate { 72949e92448Svikram struct flock unlock; 7307c478bd9Sstevel@tonic-gate 73149e92448Svikram if (add_rem_lock_fd < 0) 73249e92448Svikram return; 73349e92448Svikram 73449e92448Svikram unlock.l_type = F_UNLCK; 73549e92448Svikram unlock.l_whence = SEEK_SET; 73649e92448Svikram unlock.l_start = 0; 73749e92448Svikram unlock.l_len = 0; 73849e92448Svikram 73949e92448Svikram if (fcntl(add_rem_lock_fd, F_SETLK, &unlock) == -1) { 74049e92448Svikram (void) fprintf(stderr, gettext(ERR_UNLOCK), 74149e92448Svikram add_rem_lock, strerror(errno)); 74249e92448Svikram } else { 74349e92448Svikram (void) close(add_rem_lock_fd); 74449e92448Svikram add_rem_lock_fd = -1; 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate } 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate /* 7497c478bd9Sstevel@tonic-gate * error adding driver; need to back out any changes to files. 7507c478bd9Sstevel@tonic-gate * check flag to see which files need entries removed 7517c478bd9Sstevel@tonic-gate * entry removal based on driver name 7527c478bd9Sstevel@tonic-gate */ 7537c478bd9Sstevel@tonic-gate void 7547c478bd9Sstevel@tonic-gate remove_entry( 7557c478bd9Sstevel@tonic-gate int c_flag, 7567c478bd9Sstevel@tonic-gate char *driver_name) 7577c478bd9Sstevel@tonic-gate { 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate if (c_flag & CLEAN_NAM_MAJ) { 7607c478bd9Sstevel@tonic-gate if (delete_entry(name_to_major, driver_name, " ", 7617c478bd9Sstevel@tonic-gate NULL) == ERROR) { 7627c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_CLEAN), 7637c478bd9Sstevel@tonic-gate name_to_major, driver_name); 7647c478bd9Sstevel@tonic-gate } 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate if (c_flag & CLEAN_DRV_ALIAS) { 7687c478bd9Sstevel@tonic-gate if (delete_entry(driver_aliases, driver_name, " ", 7697c478bd9Sstevel@tonic-gate NULL) == ERROR) { 7707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_DEL_ENTRY), 7717c478bd9Sstevel@tonic-gate driver_name, driver_aliases); 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate } 7747c478bd9Sstevel@tonic-gate 7757c478bd9Sstevel@tonic-gate if (c_flag & CLEAN_DRV_CLASSES) { 7767c478bd9Sstevel@tonic-gate if (delete_entry(driver_classes, driver_name, "\t", NULL) == 7777c478bd9Sstevel@tonic-gate ERROR) { 7787c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_DEL_ENTRY), 7797c478bd9Sstevel@tonic-gate driver_name, driver_classes); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate } 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate if (c_flag & CLEAN_MINOR_PERM) { 7847c478bd9Sstevel@tonic-gate if (delete_entry(minor_perm, driver_name, ":", NULL) == ERROR) { 7857c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_DEL_ENTRY), 7867c478bd9Sstevel@tonic-gate driver_name, minor_perm); 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate /* 7907c478bd9Sstevel@tonic-gate * There's no point in removing entries from files that don't 7917c478bd9Sstevel@tonic-gate * exist. Prevent error messages by checking for file existence 7927c478bd9Sstevel@tonic-gate * first. 7937c478bd9Sstevel@tonic-gate */ 7947c478bd9Sstevel@tonic-gate if ((c_flag & CLEAN_DEV_POLICY) != 0 && 7957c478bd9Sstevel@tonic-gate access(device_policy, F_OK) == 0) { 7967c478bd9Sstevel@tonic-gate if (delete_plcy_entry(device_policy, driver_name) == ERROR) { 7977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_DEL_ENTRY), 798*0013e2d3SJerry Gilliam driver_name, device_policy); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate if ((c_flag & CLEAN_DRV_PRIV) != 0 && 8027c478bd9Sstevel@tonic-gate access(extra_privs, F_OK) == 0) { 8037c478bd9Sstevel@tonic-gate if (delete_entry(extra_privs, driver_name, ":", NULL) == 8047c478bd9Sstevel@tonic-gate ERROR) { 8057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_DEL_ENTRY), 806*0013e2d3SJerry Gilliam driver_name, extra_privs); 8077c478bd9Sstevel@tonic-gate } 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate int 8127c478bd9Sstevel@tonic-gate check_perms_aliases( 8137c478bd9Sstevel@tonic-gate int m_flag, 8147c478bd9Sstevel@tonic-gate int i_flag) 8157c478bd9Sstevel@tonic-gate { 8167c478bd9Sstevel@tonic-gate /* 8177c478bd9Sstevel@tonic-gate * If neither i_flag nor m_flag are specified no need to check the 8187c478bd9Sstevel@tonic-gate * files for access permissions 8197c478bd9Sstevel@tonic-gate */ 8207c478bd9Sstevel@tonic-gate if (!m_flag && !i_flag) 8217c478bd9Sstevel@tonic-gate return (NOERR); 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate /* check minor_perm file : exits and is writable */ 8247c478bd9Sstevel@tonic-gate if (m_flag) { 8257c478bd9Sstevel@tonic-gate if (access(minor_perm, R_OK | W_OK)) { 8267c478bd9Sstevel@tonic-gate perror(NULL); 8277c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 8287c478bd9Sstevel@tonic-gate minor_perm); 8297c478bd9Sstevel@tonic-gate return (ERROR); 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate /* check driver_aliases file : exits and is writable */ 8347c478bd9Sstevel@tonic-gate if (i_flag) { 8357c478bd9Sstevel@tonic-gate if (access(driver_aliases, R_OK | W_OK)) { 8367c478bd9Sstevel@tonic-gate perror(NULL); 8377c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 8387c478bd9Sstevel@tonic-gate driver_aliases); 8397c478bd9Sstevel@tonic-gate return (ERROR); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate return (NOERR); 8447c478bd9Sstevel@tonic-gate } 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate int 8487c478bd9Sstevel@tonic-gate check_name_to_major(int mode) 8497c478bd9Sstevel@tonic-gate { 8507c478bd9Sstevel@tonic-gate /* check name_to_major file : exists and is writable */ 8517c478bd9Sstevel@tonic-gate if (access(name_to_major, mode)) { 8527c478bd9Sstevel@tonic-gate perror(NULL); 8537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 8547c478bd9Sstevel@tonic-gate name_to_major); 8557c478bd9Sstevel@tonic-gate return (ERROR); 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate return (NOERR); 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate 8627c478bd9Sstevel@tonic-gate /* 8637c478bd9Sstevel@tonic-gate * All this stuff is to support a server installing 8647c478bd9Sstevel@tonic-gate * drivers on diskless clients. When on the server 8657c478bd9Sstevel@tonic-gate * need to prepend the basedir 8667c478bd9Sstevel@tonic-gate */ 8677c478bd9Sstevel@tonic-gate int 8687c478bd9Sstevel@tonic-gate build_filenames(char *basedir) 8697c478bd9Sstevel@tonic-gate { 8707c478bd9Sstevel@tonic-gate int len; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate if (basedir == NULL) { 8737c478bd9Sstevel@tonic-gate driver_aliases = DRIVER_ALIAS; 8747c478bd9Sstevel@tonic-gate driver_classes = DRIVER_CLASSES; 8757c478bd9Sstevel@tonic-gate minor_perm = MINOR_PERM; 8767c478bd9Sstevel@tonic-gate name_to_major = NAM_TO_MAJ; 8777c478bd9Sstevel@tonic-gate rem_name_to_major = REM_NAM_TO_MAJ; 8787c478bd9Sstevel@tonic-gate add_rem_lock = ADD_REM_LOCK; 8797c478bd9Sstevel@tonic-gate tmphold = TMPHOLD; 8807c478bd9Sstevel@tonic-gate devfs_root = DEVFS_ROOT; 8817c478bd9Sstevel@tonic-gate device_policy = DEV_POLICY; 8827c478bd9Sstevel@tonic-gate extra_privs = EXTRA_PRIVS; 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate } else { 8857c478bd9Sstevel@tonic-gate len = strlen(basedir); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate driver_aliases = malloc(len + sizeof (DRIVER_ALIAS)); 8887c478bd9Sstevel@tonic-gate driver_classes = malloc(len + sizeof (DRIVER_CLASSES)); 8897c478bd9Sstevel@tonic-gate minor_perm = malloc(len + sizeof (MINOR_PERM)); 8907c478bd9Sstevel@tonic-gate name_to_major = malloc(len + sizeof (NAM_TO_MAJ)); 8917c478bd9Sstevel@tonic-gate rem_name_to_major = malloc(len + sizeof (REM_NAM_TO_MAJ)); 8927c478bd9Sstevel@tonic-gate add_rem_lock = malloc(len + sizeof (ADD_REM_LOCK)); 8937c478bd9Sstevel@tonic-gate tmphold = malloc(len + sizeof (TMPHOLD)); 8947c478bd9Sstevel@tonic-gate devfs_root = malloc(len + sizeof (DEVFS_ROOT)); 8957c478bd9Sstevel@tonic-gate device_policy = malloc(len + sizeof (DEV_POLICY)); 8967c478bd9Sstevel@tonic-gate extra_privs = malloc(len + sizeof (EXTRA_PRIVS)); 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate if ((driver_aliases == NULL) || 9007c478bd9Sstevel@tonic-gate (driver_classes == NULL) || 9017c478bd9Sstevel@tonic-gate (minor_perm == NULL) || 9027c478bd9Sstevel@tonic-gate (name_to_major == NULL) || 9037c478bd9Sstevel@tonic-gate (rem_name_to_major == NULL) || 9047c478bd9Sstevel@tonic-gate (add_rem_lock == NULL) || 9057c478bd9Sstevel@tonic-gate (tmphold == NULL) || 9067c478bd9Sstevel@tonic-gate (devfs_root == NULL) || 9077c478bd9Sstevel@tonic-gate (device_policy == NULL) || 9087c478bd9Sstevel@tonic-gate (extra_privs == NULL)) { 9097c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 9107c478bd9Sstevel@tonic-gate return (ERROR); 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate (void) sprintf(driver_aliases, "%s%s", basedir, DRIVER_ALIAS); 9147c478bd9Sstevel@tonic-gate (void) sprintf(driver_classes, "%s%s", basedir, DRIVER_CLASSES); 9157c478bd9Sstevel@tonic-gate (void) sprintf(minor_perm, "%s%s", basedir, MINOR_PERM); 9167c478bd9Sstevel@tonic-gate (void) sprintf(name_to_major, "%s%s", basedir, NAM_TO_MAJ); 9177c478bd9Sstevel@tonic-gate (void) sprintf(rem_name_to_major, "%s%s", basedir, 918*0013e2d3SJerry Gilliam REM_NAM_TO_MAJ); 9197c478bd9Sstevel@tonic-gate (void) sprintf(add_rem_lock, "%s%s", basedir, ADD_REM_LOCK); 9207c478bd9Sstevel@tonic-gate (void) sprintf(tmphold, "%s%s", basedir, TMPHOLD); 9217c478bd9Sstevel@tonic-gate (void) sprintf(devfs_root, "%s%s", basedir, DEVFS_ROOT); 9227c478bd9Sstevel@tonic-gate (void) sprintf(device_policy, "%s%s", basedir, DEV_POLICY); 9237c478bd9Sstevel@tonic-gate (void) sprintf(extra_privs, "%s%s", basedir, EXTRA_PRIVS); 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate return (NOERR); 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate static int 9307c478bd9Sstevel@tonic-gate exec_command(char *path, char *cmdline[MAX_CMD_LINE]) 9317c478bd9Sstevel@tonic-gate { 9327c478bd9Sstevel@tonic-gate pid_t pid; 9337c478bd9Sstevel@tonic-gate uint_t stat_loc; 9347c478bd9Sstevel@tonic-gate int waitstat; 9357c478bd9Sstevel@tonic-gate int exit_status; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate /* child */ 9387c478bd9Sstevel@tonic-gate if ((pid = fork()) == 0) { 9397c478bd9Sstevel@tonic-gate (void) execv(path, cmdline); 9407c478bd9Sstevel@tonic-gate perror(NULL); 9417c478bd9Sstevel@tonic-gate return (ERROR); 9427c478bd9Sstevel@tonic-gate } else if (pid == -1) { 9437c478bd9Sstevel@tonic-gate /* fork failed */ 9447c478bd9Sstevel@tonic-gate perror(NULL); 9457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_FORK_FAIL), cmdline); 9467c478bd9Sstevel@tonic-gate return (ERROR); 9477c478bd9Sstevel@tonic-gate } else { 9487c478bd9Sstevel@tonic-gate /* parent */ 9497c478bd9Sstevel@tonic-gate do { 9507c478bd9Sstevel@tonic-gate waitstat = waitpid(pid, (int *)&stat_loc, 0); 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate } while ((!WIFEXITED(stat_loc) && 953*0013e2d3SJerry Gilliam !WIFSIGNALED(stat_loc)) || (waitstat == 0)); 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate exit_status = WEXITSTATUS(stat_loc); 9567c478bd9Sstevel@tonic-gate 9577c478bd9Sstevel@tonic-gate return (exit_status); 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate /* 9627c478bd9Sstevel@tonic-gate * check that major_num doesn't exceed maximum on this machine 9637c478bd9Sstevel@tonic-gate * do this here to support add_drv on server for diskless clients 9647c478bd9Sstevel@tonic-gate */ 9657c478bd9Sstevel@tonic-gate int 9667c478bd9Sstevel@tonic-gate config_driver( 9677c478bd9Sstevel@tonic-gate char *driver_name, 9687c478bd9Sstevel@tonic-gate major_t major_num, 9697c478bd9Sstevel@tonic-gate char *aliases, 9707c478bd9Sstevel@tonic-gate char *classes, 9717c478bd9Sstevel@tonic-gate int cleanup_flag, 9727c478bd9Sstevel@tonic-gate int verbose_flag) 9737c478bd9Sstevel@tonic-gate { 9747c478bd9Sstevel@tonic-gate int max_dev; 9757c478bd9Sstevel@tonic-gate int n = 0; 9767c478bd9Sstevel@tonic-gate char *cmdline[MAX_CMD_LINE]; 9777c478bd9Sstevel@tonic-gate char maj_num[128]; 9787c478bd9Sstevel@tonic-gate char *previous; 9797c478bd9Sstevel@tonic-gate char *current; 9807c478bd9Sstevel@tonic-gate int exec_status; 9817c478bd9Sstevel@tonic-gate int len; 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate if (modctl(MODRESERVED, NULL, &max_dev) < 0) { 9847c478bd9Sstevel@tonic-gate perror(NULL); 9857c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_MAX_MAJOR)); 9867c478bd9Sstevel@tonic-gate return (ERROR); 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate if (major_num >= max_dev) { 9907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_MAX_EXCEEDS), 9917c478bd9Sstevel@tonic-gate major_num, max_dev); 9927c478bd9Sstevel@tonic-gate return (ERROR); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate /* bind major number and driver name */ 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate /* build command line */ 9987c478bd9Sstevel@tonic-gate cmdline[n++] = DRVCONFIG; 9997c478bd9Sstevel@tonic-gate if (verbose_flag) { 10007c478bd9Sstevel@tonic-gate cmdline[n++] = "-v"; 10017c478bd9Sstevel@tonic-gate } 10027c478bd9Sstevel@tonic-gate cmdline[n++] = "-b"; 10037c478bd9Sstevel@tonic-gate if (classes) { 10047c478bd9Sstevel@tonic-gate cmdline[n++] = "-c"; 10057c478bd9Sstevel@tonic-gate cmdline[n++] = classes; 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate cmdline[n++] = "-i"; 10087c478bd9Sstevel@tonic-gate cmdline[n++] = driver_name; 10097c478bd9Sstevel@tonic-gate cmdline[n++] = "-m"; 10107c478bd9Sstevel@tonic-gate (void) sprintf(maj_num, "%lu", major_num); 10117c478bd9Sstevel@tonic-gate cmdline[n++] = maj_num; 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate if (aliases != NULL) { 10147c478bd9Sstevel@tonic-gate len = strlen(aliases); 10157c478bd9Sstevel@tonic-gate previous = aliases; 10167c478bd9Sstevel@tonic-gate do { 10177c478bd9Sstevel@tonic-gate cmdline[n++] = "-a"; 10187c478bd9Sstevel@tonic-gate cmdline[n] = calloc(len + 1, 1); 10197c478bd9Sstevel@tonic-gate if (cmdline[n] == NULL) { 10207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10217c478bd9Sstevel@tonic-gate gettext(ERR_NO_MEM)); 10227c478bd9Sstevel@tonic-gate return (ERROR); 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate current = get_entry(previous, 1025f4da9be0Scth cmdline[n++], ' ', 0); 10267c478bd9Sstevel@tonic-gate previous = current; 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate } while (*current != '\0'); 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate } 10317c478bd9Sstevel@tonic-gate cmdline[n] = (char *)0; 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate exec_status = exec_command(DRVCONFIG_PATH, cmdline); 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate if (exec_status == NOERR) 10367c478bd9Sstevel@tonic-gate return (NOERR); 10377c478bd9Sstevel@tonic-gate perror(NULL); 10387c478bd9Sstevel@tonic-gate remove_entry(cleanup_flag, driver_name); 10397c478bd9Sstevel@tonic-gate return (ERROR); 10407c478bd9Sstevel@tonic-gate } 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate void 10437c478bd9Sstevel@tonic-gate load_driver(char *driver_name, int verbose_flag) 10447c478bd9Sstevel@tonic-gate { 10457c478bd9Sstevel@tonic-gate int n = 0; 10467c478bd9Sstevel@tonic-gate char *cmdline[MAX_CMD_LINE]; 10477c478bd9Sstevel@tonic-gate int exec_status; 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate /* build command line */ 10507c478bd9Sstevel@tonic-gate cmdline[n++] = DEVFSADM; 10517c478bd9Sstevel@tonic-gate if (verbose_flag) { 10527c478bd9Sstevel@tonic-gate cmdline[n++] = "-v"; 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate cmdline[n++] = "-i"; 10557c478bd9Sstevel@tonic-gate cmdline[n++] = driver_name; 10567c478bd9Sstevel@tonic-gate cmdline[n] = (char *)0; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate exec_status = exec_command(DEVFSADM_PATH, cmdline); 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate if (exec_status != NOERR) { 10617c478bd9Sstevel@tonic-gate /* no clean : name and major number are bound */ 10627c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CONFIG), 1063*0013e2d3SJerry Gilliam driver_name); 10647c478bd9Sstevel@tonic-gate } 10657c478bd9Sstevel@tonic-gate } 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate void 10687c478bd9Sstevel@tonic-gate get_modid(char *driver_name, int *mod) 10697c478bd9Sstevel@tonic-gate { 10707c478bd9Sstevel@tonic-gate struct modinfo modinfo; 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate modinfo.mi_id = -1; 10737c478bd9Sstevel@tonic-gate modinfo.mi_info = MI_INFO_ALL; 10747c478bd9Sstevel@tonic-gate do { 10757c478bd9Sstevel@tonic-gate /* 10767c478bd9Sstevel@tonic-gate * If we are at the end of the list of loaded modules 10777c478bd9Sstevel@tonic-gate * then set *mod = -1 and return 10787c478bd9Sstevel@tonic-gate */ 10797c478bd9Sstevel@tonic-gate if (modctl(MODINFO, 0, &modinfo) < 0) { 10807c478bd9Sstevel@tonic-gate *mod = -1; 10817c478bd9Sstevel@tonic-gate return; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate *mod = modinfo.mi_id; 10857c478bd9Sstevel@tonic-gate } while (strcmp(driver_name, modinfo.mi_name) != 0); 10867c478bd9Sstevel@tonic-gate } 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate int 10897c478bd9Sstevel@tonic-gate create_reconfig(char *basedir) 10907c478bd9Sstevel@tonic-gate { 10917c478bd9Sstevel@tonic-gate char reconfig_file[MAXPATHLEN + FILENAME_MAX + 1]; 10927c478bd9Sstevel@tonic-gate FILE *reconfig_fp; 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate if (basedir != NULL) { 10957c478bd9Sstevel@tonic-gate (void) strcpy(reconfig_file, basedir); 10967c478bd9Sstevel@tonic-gate (void) strcat(reconfig_file, RECONFIGURE); 10977c478bd9Sstevel@tonic-gate } else { 10987c478bd9Sstevel@tonic-gate (void) strcpy(reconfig_file, RECONFIGURE); 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate if ((reconfig_fp = fopen(reconfig_file, "a")) == NULL) 11017c478bd9Sstevel@tonic-gate return (ERROR); 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate (void) fclose(reconfig_fp); 11047c478bd9Sstevel@tonic-gate return (NOERR); 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate /* 11097c478bd9Sstevel@tonic-gate * update_minor_entry: 11107c478bd9Sstevel@tonic-gate * open file 11117c478bd9Sstevel@tonic-gate * for each entry in list 11127c478bd9Sstevel@tonic-gate * where list entries are separated by <list_separator> 11137c478bd9Sstevel@tonic-gate * modify entry : driver_name <entry_separator> entry 11147c478bd9Sstevel@tonic-gate * close file 11157c478bd9Sstevel@tonic-gate * 11167c478bd9Sstevel@tonic-gate * return error/noerr 11177c478bd9Sstevel@tonic-gate */ 11187c478bd9Sstevel@tonic-gate int 11197c478bd9Sstevel@tonic-gate update_minor_entry(char *driver_name, char *perm_list) 11207c478bd9Sstevel@tonic-gate { 11217c478bd9Sstevel@tonic-gate FILE *fp; 11227c478bd9Sstevel@tonic-gate FILE *newfp; 11237c478bd9Sstevel@tonic-gate struct group *sysgrp; 11247c478bd9Sstevel@tonic-gate int match = 0; 11251ca93273Seota char line[MAX_DBFILE_ENTRY], *cp, *dup; 11261ca93273Seota char drv[FILENAME_MAX + 1], *drv_minor; 11277c478bd9Sstevel@tonic-gate char minor[FILENAME_MAX + 1], perm[OPT_LEN + 1]; 11287c478bd9Sstevel@tonic-gate char own[OPT_LEN + 1], grp[OPT_LEN + 1]; 11297c478bd9Sstevel@tonic-gate int status = NOERR, i; 11307c478bd9Sstevel@tonic-gate char *newfile, *tptr; 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate if ((fp = fopen(minor_perm, "r")) == NULL) { 11337c478bd9Sstevel@tonic-gate perror(NULL); 11347c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 11357c478bd9Sstevel@tonic-gate minor_perm); 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate return (ERROR); 11387c478bd9Sstevel@tonic-gate } 11397c478bd9Sstevel@tonic-gate 11407c478bd9Sstevel@tonic-gate /* 11417c478bd9Sstevel@tonic-gate * Build filename for temporary file 11427c478bd9Sstevel@tonic-gate */ 11437c478bd9Sstevel@tonic-gate if ((tptr = calloc(strlen(minor_perm) + strlen(XEND) + 1, 1)) == NULL) { 11447c478bd9Sstevel@tonic-gate perror(NULL); 11457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate (void) strcpy(tptr, minor_perm); 11487c478bd9Sstevel@tonic-gate (void) strcat(tptr, XEND); 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate /* 11517c478bd9Sstevel@tonic-gate * Set gid so we preserve group attribute. Ideally we wouldn't 11527c478bd9Sstevel@tonic-gate * assume a gid of "sys" but we can't undo the damage on already 11537c478bd9Sstevel@tonic-gate * installed systems unless we force the issue. 11547c478bd9Sstevel@tonic-gate */ 11557c478bd9Sstevel@tonic-gate if ((sysgrp = getgrnam("sys")) != NULL) { 11567c478bd9Sstevel@tonic-gate (void) setgid(sysgrp->gr_gid); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate newfile = mktemp(tptr); 11607c478bd9Sstevel@tonic-gate if ((newfp = fopen(newfile, "w")) == NULL) { 11617c478bd9Sstevel@tonic-gate perror(NULL); 11627c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 11637c478bd9Sstevel@tonic-gate newfile); 11647c478bd9Sstevel@tonic-gate return (ERROR); 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate if (sscanf(perm_list, "%s%s%s%s", minor, perm, own, grp) != 4) { 11687c478bd9Sstevel@tonic-gate status = ERROR; 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate while ((fgets(line, sizeof (line), fp) != NULL) && status == NOERR) { 11721ca93273Seota /* copy the whole line into dup */ 11731ca93273Seota if ((dup = strdup(line)) == NULL) { 11741ca93273Seota perror(NULL); 11751ca93273Seota (void) fprintf(stderr, gettext(ERR_NO_MEM)); 11761ca93273Seota status = ERROR; 11771ca93273Seota break; 11781ca93273Seota } 11791ca93273Seota /* cut off comments starting with '#' */ 11801ca93273Seota if ((cp = strchr(dup, '#')) != NULL) 11811ca93273Seota *cp = '\0'; 11821ca93273Seota /* ignore comment or blank lines */ 11831ca93273Seota if (is_blank(dup)) { 11841ca93273Seota if (fputs(line, newfp) == EOF) { 11857c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), 11867c478bd9Sstevel@tonic-gate minor_perm); 11877c478bd9Sstevel@tonic-gate status = ERROR; 11887c478bd9Sstevel@tonic-gate } 11891ca93273Seota free(dup); 11907c478bd9Sstevel@tonic-gate continue; 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11931ca93273Seota /* get the driver name */ 11941ca93273Seota if (sscanf(dup, "%s", drv) != 1) { 11957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 11967c478bd9Sstevel@tonic-gate minor_perm, line); 11977c478bd9Sstevel@tonic-gate status = ERROR; 11981ca93273Seota free(dup); 11991ca93273Seota break; 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12021ca93273Seota /* 12031ca93273Seota * get the minor name; place the NULL character at the 12041ca93273Seota * end of the driver name, then make the drv_minor 12051ca93273Seota * point to the first character of the minor name. 12061ca93273Seota * the line missing ':' must be treated as a broken one. 12071ca93273Seota */ 12081ca93273Seota i = strcspn(drv, ":"); 12091ca93273Seota if (i == strlen(drv)) { 12107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 12117c478bd9Sstevel@tonic-gate minor_perm, line); 12127c478bd9Sstevel@tonic-gate status = ERROR; 12131ca93273Seota free(dup); 12141ca93273Seota break; 12157c478bd9Sstevel@tonic-gate } 12161ca93273Seota drv[i] = '\0'; 12171ca93273Seota drv_minor = &drv[strlen(drv) + 1]; 12187c478bd9Sstevel@tonic-gate 12191ca93273Seota /* 12201ca93273Seota * compare both of the driver name and the minor name. 12211ca93273Seota * then the new line should be written to the file if 12221ca93273Seota * both of them match 12231ca93273Seota */ 12247c478bd9Sstevel@tonic-gate if ((strcmp(drv, driver_name) == 0) && 12257c478bd9Sstevel@tonic-gate (strcmp(minor, drv_minor) == 0)) { 12261ca93273Seota /* if it has a comment, keep it */ 12271ca93273Seota if (cp != NULL) { 12281ca93273Seota cp++; /* skip a terminator */ 12291ca93273Seota (void) sprintf(line, "%s:%s %s %s %s #%s\n", 12301ca93273Seota drv, minor, perm, own, grp, cp); 12311ca93273Seota } else { 12321ca93273Seota (void) sprintf(line, "%s:%s %s %s %s\n", 12331ca93273Seota drv, minor, perm, own, grp); 12341ca93273Seota } 12357c478bd9Sstevel@tonic-gate match = 1; 12367c478bd9Sstevel@tonic-gate } 12371ca93273Seota free(dup); 12387c478bd9Sstevel@tonic-gate 12391ca93273Seota /* update the file */ 12407c478bd9Sstevel@tonic-gate if ((fputs(line, newfp)) == EOF) { 12417c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), 12427c478bd9Sstevel@tonic-gate minor_perm); 12437c478bd9Sstevel@tonic-gate status = ERROR; 12447c478bd9Sstevel@tonic-gate } 12457c478bd9Sstevel@tonic-gate } 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate if (!match) { 12487c478bd9Sstevel@tonic-gate (void) bzero(line, sizeof (&line[0])); 12497c478bd9Sstevel@tonic-gate (void) sprintf(line, "%s:%s %s %s %s\n", 12507c478bd9Sstevel@tonic-gate driver_name, minor, perm, own, grp); 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate /* add the new entry */ 12537c478bd9Sstevel@tonic-gate if ((fputs(line, newfp)) == EOF) { 12547c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), minor_perm); 12557c478bd9Sstevel@tonic-gate status = ERROR; 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate (void) fclose(fp); 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate if (fflush(newfp) != 0 || fsync(fileno(newfp)) != 0) 12627c478bd9Sstevel@tonic-gate status = ERROR; 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate (void) fclose(newfp); 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate /* 12677c478bd9Sstevel@tonic-gate * if error, leave original file, delete new file 12687c478bd9Sstevel@tonic-gate * if noerr, replace original file with new file 12697c478bd9Sstevel@tonic-gate */ 12707c478bd9Sstevel@tonic-gate if (status == NOERR) { 12717c478bd9Sstevel@tonic-gate if (rename(minor_perm, tmphold) == -1) { 12727c478bd9Sstevel@tonic-gate perror(NULL); 12737c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), minor_perm); 12747c478bd9Sstevel@tonic-gate (void) unlink(newfile); 12757c478bd9Sstevel@tonic-gate return (ERROR); 12767c478bd9Sstevel@tonic-gate } else if (rename(newfile, minor_perm) == -1) { 12777c478bd9Sstevel@tonic-gate perror(NULL); 12787c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_UPDATE), minor_perm); 12797c478bd9Sstevel@tonic-gate (void) unlink(minor_perm); 12807c478bd9Sstevel@tonic-gate (void) unlink(newfile); 12817c478bd9Sstevel@tonic-gate if (link(tmphold, minor_perm) == -1) { 12827c478bd9Sstevel@tonic-gate perror(NULL); 12837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINK), 12847c478bd9Sstevel@tonic-gate minor_perm, tmphold); 12857c478bd9Sstevel@tonic-gate } 12867c478bd9Sstevel@tonic-gate return (ERROR); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate (void) unlink(tmphold); 12897c478bd9Sstevel@tonic-gate } else { 12907c478bd9Sstevel@tonic-gate /* 12917c478bd9Sstevel@tonic-gate * since there's an error, leave file alone; remove 12927c478bd9Sstevel@tonic-gate * new file 12937c478bd9Sstevel@tonic-gate */ 12947c478bd9Sstevel@tonic-gate if (unlink(newfile) == -1) { 12957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_RM), newfile); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate return (ERROR); 12987c478bd9Sstevel@tonic-gate } 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate return (NOERR); 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate /* 13067c478bd9Sstevel@tonic-gate * list_entry: 13077c478bd9Sstevel@tonic-gate * open file 13087c478bd9Sstevel@tonic-gate * read thru file, listing all entries if first entry = driver_name 13097c478bd9Sstevel@tonic-gate * close 13107c478bd9Sstevel@tonic-gate */ 13117c478bd9Sstevel@tonic-gate void 13127c478bd9Sstevel@tonic-gate list_entry( 13137c478bd9Sstevel@tonic-gate char *oldfile, 13147c478bd9Sstevel@tonic-gate char *driver_name, 13157c478bd9Sstevel@tonic-gate char *marker) 13167c478bd9Sstevel@tonic-gate { 13177c478bd9Sstevel@tonic-gate FILE *fp; 13187c478bd9Sstevel@tonic-gate int i; 13191ca93273Seota char line[MAX_DBFILE_ENTRY], *cp; 13207c478bd9Sstevel@tonic-gate char drv[FILENAME_MAX + 1]; 13217c478bd9Sstevel@tonic-gate 13227c478bd9Sstevel@tonic-gate if ((fp = fopen(oldfile, "r")) == NULL) { 13237c478bd9Sstevel@tonic-gate perror(NULL); 13247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), oldfile); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate return; 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != NULL) { 13301ca93273Seota /* cut off comments starting with '#' */ 13311ca93273Seota if ((cp = strchr(line, '#')) != NULL) 13321ca93273Seota *cp = '\0'; 13331ca93273Seota /* ignore comment or blank lines */ 13341ca93273Seota if (is_blank(line)) 13357c478bd9Sstevel@tonic-gate continue; 13361ca93273Seota /* sanity-check */ 13377c478bd9Sstevel@tonic-gate if (sscanf(line, "%s", drv) != 1) { 13387c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 13397c478bd9Sstevel@tonic-gate oldfile, line); 13407c478bd9Sstevel@tonic-gate } 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate for (i = strcspn(drv, marker); i < FILENAME_MAX; i++) { 13437c478bd9Sstevel@tonic-gate drv[i] = '\0'; 13447c478bd9Sstevel@tonic-gate } 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate if (strcmp(driver_name, drv) == 0) { 13477c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "%s", line); 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate (void) fclose(fp); 13527c478bd9Sstevel@tonic-gate } 13537c478bd9Sstevel@tonic-gate 13541ca93273Seota static boolean_t 13551ca93273Seota is_token(char *tok) 13561ca93273Seota { 13571ca93273Seota /* 13581ca93273Seota * Check the token here. According to IEEE1275 Open Firmware Boot 13591ca93273Seota * Standard, the name is composed of 1 to 31 letters, 13601ca93273Seota * digits and punctuation characters from the set ",._+-", and 13611ca93273Seota * uppercase and lowercase characters are considered distinct. 13621ca93273Seota * (ie. token := [a-zA-Z0-9,._+-]+, length(token) <= 31) 13631ca93273Seota * However, since either the definition of driver or aliase names is 13641ca93273Seota * not known well, only '#' is avoided explicitly. (the kernel lexical 13651ca93273Seota * analyzer treats it as a start of a comment) 13661ca93273Seota */ 13671ca93273Seota for (/* nothing */; *tok != '\0'; tok++) 13681ca93273Seota if (*tok == '#' || iscntrl(*tok)) 13691ca93273Seota return (B_FALSE); 13701ca93273Seota 13711ca93273Seota return (B_TRUE); 13721ca93273Seota } 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate /* 13757c478bd9Sstevel@tonic-gate * check each entry in perm_list for: 13767c478bd9Sstevel@tonic-gate * 4 arguments 13777c478bd9Sstevel@tonic-gate * permission arg is in valid range 13787c478bd9Sstevel@tonic-gate * permlist entries separated by comma 13797c478bd9Sstevel@tonic-gate * return ERROR/NOERR 13807c478bd9Sstevel@tonic-gate */ 13817c478bd9Sstevel@tonic-gate int 13827c478bd9Sstevel@tonic-gate check_perm_opts(char *perm_list) 13837c478bd9Sstevel@tonic-gate { 13847c478bd9Sstevel@tonic-gate char *current_head; 13857c478bd9Sstevel@tonic-gate char *previous_head; 13867c478bd9Sstevel@tonic-gate char *one_entry; 13877c478bd9Sstevel@tonic-gate int i, len, scan_stat; 13887c478bd9Sstevel@tonic-gate char minor[FILENAME_MAX + 1]; 13897c478bd9Sstevel@tonic-gate char perm[OPT_LEN + 1]; 13907c478bd9Sstevel@tonic-gate char own[OPT_LEN + 1]; 13917c478bd9Sstevel@tonic-gate char grp[OPT_LEN + 1]; 13927c478bd9Sstevel@tonic-gate char dumb[OPT_LEN + 1]; 13937c478bd9Sstevel@tonic-gate int status = NOERR; 13947c478bd9Sstevel@tonic-gate int intperm; 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate len = strlen(perm_list); 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate if (len == 0) { 13997c478bd9Sstevel@tonic-gate return (ERROR); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate one_entry = calloc(len + 1, 1); 14037c478bd9Sstevel@tonic-gate if (one_entry == NULL) { 14047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 14057c478bd9Sstevel@tonic-gate return (ERROR); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate previous_head = perm_list; 14097c478bd9Sstevel@tonic-gate current_head = perm_list; 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate while (*current_head != '\0') { 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate for (i = 0; i <= len; i++) 14147c478bd9Sstevel@tonic-gate one_entry[i] = 0; 14157c478bd9Sstevel@tonic-gate 1416f4da9be0Scth current_head = get_entry(previous_head, one_entry, ',', 0); 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate previous_head = current_head; 14197c478bd9Sstevel@tonic-gate scan_stat = sscanf(one_entry, "%s%s%s%s%s", minor, perm, own, 14207c478bd9Sstevel@tonic-gate grp, dumb); 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate if (scan_stat < 4) { 14237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_MIS_TOK), 14247c478bd9Sstevel@tonic-gate "-m", one_entry); 14257c478bd9Sstevel@tonic-gate status = ERROR; 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate if (scan_stat > 4) { 14287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_TOO_MANY_ARGS), 14297c478bd9Sstevel@tonic-gate "-m", one_entry); 14307c478bd9Sstevel@tonic-gate status = ERROR; 14317c478bd9Sstevel@tonic-gate } 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate intperm = atoi(perm); 14347c478bd9Sstevel@tonic-gate if (intperm < 0000 || intperm > 4777) { 14357c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_MODE), perm); 14367c478bd9Sstevel@tonic-gate status = ERROR; 14377c478bd9Sstevel@tonic-gate } 14387c478bd9Sstevel@tonic-gate } 14397c478bd9Sstevel@tonic-gate 14407c478bd9Sstevel@tonic-gate free(one_entry); 14417c478bd9Sstevel@tonic-gate return (status); 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate /* 14467c478bd9Sstevel@tonic-gate * check each alias : 14477c478bd9Sstevel@tonic-gate * alias list members separated by white space 14487c478bd9Sstevel@tonic-gate * cannot exist as driver name in /etc/name_to_major 14497c478bd9Sstevel@tonic-gate * cannot exist as driver or alias name in /etc/driver_aliases 14507c478bd9Sstevel@tonic-gate */ 14517c478bd9Sstevel@tonic-gate int 14527c478bd9Sstevel@tonic-gate aliases_unique(char *aliases) 14537c478bd9Sstevel@tonic-gate { 14547c478bd9Sstevel@tonic-gate char *current_head; 14557c478bd9Sstevel@tonic-gate char *previous_head; 14567c478bd9Sstevel@tonic-gate char *one_entry; 14577c478bd9Sstevel@tonic-gate int i, len; 14587c478bd9Sstevel@tonic-gate int is_unique; 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate len = strlen(aliases); 14617c478bd9Sstevel@tonic-gate 14627c478bd9Sstevel@tonic-gate one_entry = calloc(len + 1, 1); 14637c478bd9Sstevel@tonic-gate if (one_entry == NULL) { 14647c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 14657c478bd9Sstevel@tonic-gate return (ERROR); 14667c478bd9Sstevel@tonic-gate } 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate previous_head = aliases; 14697c478bd9Sstevel@tonic-gate 14707c478bd9Sstevel@tonic-gate do { 14717c478bd9Sstevel@tonic-gate for (i = 0; i <= len; i++) 14727c478bd9Sstevel@tonic-gate one_entry[i] = 0; 14737c478bd9Sstevel@tonic-gate 1474f4da9be0Scth current_head = get_entry(previous_head, one_entry, ' ', 1); 14757c478bd9Sstevel@tonic-gate previous_head = current_head; 14767c478bd9Sstevel@tonic-gate 14777c478bd9Sstevel@tonic-gate if ((unique_driver_name(one_entry, name_to_major, 14787c478bd9Sstevel@tonic-gate &is_unique)) == ERROR) { 14797c478bd9Sstevel@tonic-gate free(one_entry); 14807c478bd9Sstevel@tonic-gate return (ERROR); 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate if (is_unique != UNIQUE) { 14847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_ALIAS_IN_NAM_MAJ), 14857c478bd9Sstevel@tonic-gate one_entry); 14867c478bd9Sstevel@tonic-gate free(one_entry); 14877c478bd9Sstevel@tonic-gate return (ERROR); 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate if (unique_drv_alias(one_entry) != NOERR) { 14917c478bd9Sstevel@tonic-gate free(one_entry); 14927c478bd9Sstevel@tonic-gate return (ERROR); 14937c478bd9Sstevel@tonic-gate } 14947c478bd9Sstevel@tonic-gate 14951ca93273Seota if (!is_token(one_entry)) { 14961ca93273Seota (void) fprintf(stderr, gettext(ERR_BAD_TOK), 14971ca93273Seota "-i", one_entry); 14981ca93273Seota free(one_entry); 14991ca93273Seota return (ERROR); 15001ca93273Seota } 15011ca93273Seota 15027c478bd9Sstevel@tonic-gate } while (*current_head != '\0'); 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate free(one_entry); 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate return (NOERR); 15077c478bd9Sstevel@tonic-gate 15087c478bd9Sstevel@tonic-gate } 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate 1511f4da9be0Scth /* 1512f4da9be0Scth * check each alias : 1513f4da9be0Scth * if path-oriented alias, path exists 1514f4da9be0Scth */ 1515f4da9be0Scth int 1516f4da9be0Scth aliases_paths_exist(char *aliases) 1517f4da9be0Scth { 1518f4da9be0Scth char *current_head; 1519f4da9be0Scth char *previous_head; 1520f4da9be0Scth char *one_entry; 1521f4da9be0Scth int i, len; 1522f4da9be0Scth char path[MAXPATHLEN]; 1523f4da9be0Scth struct stat buf; 1524f4da9be0Scth 1525f4da9be0Scth len = strlen(aliases); 1526f4da9be0Scth 1527f4da9be0Scth one_entry = calloc(len + 1, 1); 1528f4da9be0Scth if (one_entry == NULL) { 1529f4da9be0Scth (void) fprintf(stderr, gettext(ERR_NO_MEM)); 1530f4da9be0Scth return (ERROR); 1531f4da9be0Scth } 1532f4da9be0Scth 1533f4da9be0Scth previous_head = aliases; 1534f4da9be0Scth 1535f4da9be0Scth do { 1536f4da9be0Scth for (i = 0; i <= len; i++) 1537f4da9be0Scth one_entry[i] = 0; 1538f4da9be0Scth 1539f4da9be0Scth current_head = get_entry(previous_head, one_entry, ' ', 1); 1540f4da9be0Scth previous_head = current_head; 1541f4da9be0Scth 1542f4da9be0Scth /* if the alias is a path, ensure that the path exists */ 1543f4da9be0Scth if (*one_entry != '/') 1544f4da9be0Scth continue; 1545f4da9be0Scth (void) snprintf(path, sizeof (path), "/devices/%s", one_entry); 1546f4da9be0Scth if (stat(path, &buf) == 0) 1547f4da9be0Scth continue; 1548f4da9be0Scth 1549f4da9be0Scth /* no device at specified path-oriented alias path */ 1550f4da9be0Scth (void) fprintf(stderr, gettext(ERR_PATH_ORIENTED_ALIAS), 1551f4da9be0Scth one_entry); 1552f4da9be0Scth free(one_entry); 1553f4da9be0Scth return (ERROR); 1554f4da9be0Scth 1555f4da9be0Scth } while (*current_head != '\0'); 1556f4da9be0Scth 1557f4da9be0Scth free(one_entry); 1558f4da9be0Scth 1559f4da9be0Scth return (NOERR); 1560f4da9be0Scth } 1561f4da9be0Scth 1562f4da9be0Scth 15637c478bd9Sstevel@tonic-gate int 15647c478bd9Sstevel@tonic-gate update_driver_aliases( 15657c478bd9Sstevel@tonic-gate char *driver_name, 15667c478bd9Sstevel@tonic-gate char *aliases) 15677c478bd9Sstevel@tonic-gate { 15687c478bd9Sstevel@tonic-gate /* make call to update the aliases file */ 1569f4da9be0Scth return (append_to_file(driver_name, aliases, driver_aliases, 1570f4da9be0Scth ' ', " ", 1)); 15717c478bd9Sstevel@tonic-gate } 15727c478bd9Sstevel@tonic-gate 15737c478bd9Sstevel@tonic-gate 15747c478bd9Sstevel@tonic-gate int 15757c478bd9Sstevel@tonic-gate unique_drv_alias(char *drv_alias) 15767c478bd9Sstevel@tonic-gate { 15777c478bd9Sstevel@tonic-gate FILE *fp; 15787c478bd9Sstevel@tonic-gate char drv[FILENAME_MAX + 1]; 15791ca93273Seota char line[MAX_N2M_ALIAS_LINE + 1], *cp; 15807c478bd9Sstevel@tonic-gate char alias[FILENAME_MAX + 1]; 1581f4da9be0Scth char *a; 15827c478bd9Sstevel@tonic-gate int status = NOERR; 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate fp = fopen(driver_aliases, "r"); 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate if (fp != NULL) { 15877c478bd9Sstevel@tonic-gate while ((fgets(line, sizeof (line), fp) != 0) && 15887c478bd9Sstevel@tonic-gate status != ERROR) { 15891ca93273Seota /* cut off comments starting with '#' */ 15901ca93273Seota if ((cp = strchr(line, '#')) != NULL) 15911ca93273Seota *cp = '\0'; 15921ca93273Seota /* ignore comment or blank lines */ 15931ca93273Seota if (is_blank(line)) 15941ca93273Seota continue; 15951ca93273Seota /* sanity-check */ 15967c478bd9Sstevel@tonic-gate if (sscanf(line, "%s %s", drv, alias) != 2) 15977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 15987c478bd9Sstevel@tonic-gate driver_aliases, line); 15997c478bd9Sstevel@tonic-gate 1600f4da9be0Scth /* unquote for compare */ 1601f4da9be0Scth if ((*alias == '"') && 1602f4da9be0Scth (*(alias + strlen(alias) - 1) == '"')) { 1603f4da9be0Scth a = &alias[1]; 1604f4da9be0Scth alias[strlen(alias) - 1] = '\0'; 1605f4da9be0Scth } else 1606f4da9be0Scth a = alias; 1607f4da9be0Scth 16087c478bd9Sstevel@tonic-gate if ((strcmp(drv_alias, drv) == 0) || 1609f4da9be0Scth (strcmp(drv_alias, a) == 0)) { 16107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 16117c478bd9Sstevel@tonic-gate gettext(ERR_ALIAS_IN_USE), 16127c478bd9Sstevel@tonic-gate drv_alias); 16137c478bd9Sstevel@tonic-gate status = ERROR; 16147c478bd9Sstevel@tonic-gate } 16157c478bd9Sstevel@tonic-gate } 16167c478bd9Sstevel@tonic-gate (void) fclose(fp); 16177c478bd9Sstevel@tonic-gate return (status); 16187c478bd9Sstevel@tonic-gate } else { 16197c478bd9Sstevel@tonic-gate perror(NULL); 16207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_OPEN), driver_aliases); 16217c478bd9Sstevel@tonic-gate return (ERROR); 16227c478bd9Sstevel@tonic-gate } 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate 16267c478bd9Sstevel@tonic-gate /* 16277c478bd9Sstevel@tonic-gate * search for driver_name in first field of file file_name 16287c478bd9Sstevel@tonic-gate * searching name_to_major and driver_aliases: name separated from rest of 16297c478bd9Sstevel@tonic-gate * line by blank 16307c478bd9Sstevel@tonic-gate * if there return 16317c478bd9Sstevel@tonic-gate * else return 16327c478bd9Sstevel@tonic-gate */ 16337c478bd9Sstevel@tonic-gate int 16347c478bd9Sstevel@tonic-gate unique_driver_name(char *driver_name, char *file_name, 16357c478bd9Sstevel@tonic-gate int *is_unique) 16367c478bd9Sstevel@tonic-gate { 16377c478bd9Sstevel@tonic-gate int ret; 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate if ((ret = get_major_no(driver_name, file_name)) == ERROR) { 16407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), 16417c478bd9Sstevel@tonic-gate file_name); 16427c478bd9Sstevel@tonic-gate } else { 16437c478bd9Sstevel@tonic-gate /* XXX */ 16447c478bd9Sstevel@tonic-gate /* check alias file for name collision */ 16457c478bd9Sstevel@tonic-gate if (unique_drv_alias(driver_name) == ERROR) { 16467c478bd9Sstevel@tonic-gate ret = ERROR; 16477c478bd9Sstevel@tonic-gate } else { 16487c478bd9Sstevel@tonic-gate if (ret != UNIQUE) 16497c478bd9Sstevel@tonic-gate *is_unique = NOT_UNIQUE; 16507c478bd9Sstevel@tonic-gate else 16517c478bd9Sstevel@tonic-gate *is_unique = ret; 16527c478bd9Sstevel@tonic-gate ret = NOERR; 16537c478bd9Sstevel@tonic-gate } 16547c478bd9Sstevel@tonic-gate } 16557c478bd9Sstevel@tonic-gate return (ret); 16567c478bd9Sstevel@tonic-gate } 16577c478bd9Sstevel@tonic-gate 1658*0013e2d3SJerry Gilliam /* 1659*0013e2d3SJerry Gilliam * returns: 1660*0013e2d3SJerry Gilliam * SUCCESS - not an existing driver alias 1661*0013e2d3SJerry Gilliam * NOT_UNIQUE - matching driver alias exists 1662*0013e2d3SJerry Gilliam * ERROR - an error occurred 1663*0013e2d3SJerry Gilliam */ 1664*0013e2d3SJerry Gilliam int 1665*0013e2d3SJerry Gilliam check_duplicate_driver_alias(char *driver_name, char *drv_alias) 1666*0013e2d3SJerry Gilliam { 1667*0013e2d3SJerry Gilliam FILE *fp; 1668*0013e2d3SJerry Gilliam char drv[FILENAME_MAX + 1]; 1669*0013e2d3SJerry Gilliam char line[MAX_N2M_ALIAS_LINE + 1], *cp; 1670*0013e2d3SJerry Gilliam char alias[FILENAME_MAX + 1]; 1671*0013e2d3SJerry Gilliam char *a; 1672*0013e2d3SJerry Gilliam int status = SUCCESS; 1673*0013e2d3SJerry Gilliam 1674*0013e2d3SJerry Gilliam if ((fp = fopen(driver_aliases, "r")) == NULL) { 1675*0013e2d3SJerry Gilliam perror(NULL); 1676*0013e2d3SJerry Gilliam (void) fprintf(stderr, gettext(ERR_CANT_OPEN), driver_aliases); 1677*0013e2d3SJerry Gilliam return (ERROR); 1678*0013e2d3SJerry Gilliam } 1679*0013e2d3SJerry Gilliam 1680*0013e2d3SJerry Gilliam while (fgets(line, sizeof (line), fp) != 0) { 1681*0013e2d3SJerry Gilliam /* cut off comments starting with '#' */ 1682*0013e2d3SJerry Gilliam if ((cp = strchr(line, '#')) != NULL) 1683*0013e2d3SJerry Gilliam *cp = '\0'; 1684*0013e2d3SJerry Gilliam /* ignore comment or blank lines */ 1685*0013e2d3SJerry Gilliam if (is_blank(line)) 1686*0013e2d3SJerry Gilliam continue; 1687*0013e2d3SJerry Gilliam /* sanity-check */ 1688*0013e2d3SJerry Gilliam if (sscanf(line, "%s %s", drv, alias) != 2) 1689*0013e2d3SJerry Gilliam (void) fprintf(stderr, gettext(ERR_BAD_LINE), 1690*0013e2d3SJerry Gilliam driver_aliases, line); 1691*0013e2d3SJerry Gilliam 1692*0013e2d3SJerry Gilliam /* unquote for compare */ 1693*0013e2d3SJerry Gilliam if ((*alias == '"') && 1694*0013e2d3SJerry Gilliam (*(alias + strlen(alias) - 1) == '"')) { 1695*0013e2d3SJerry Gilliam a = &alias[1]; 1696*0013e2d3SJerry Gilliam alias[strlen(alias) - 1] = '\0'; 1697*0013e2d3SJerry Gilliam } else 1698*0013e2d3SJerry Gilliam a = alias; 1699*0013e2d3SJerry Gilliam 1700*0013e2d3SJerry Gilliam if ((strcmp(drv_alias, a) == 0) && 1701*0013e2d3SJerry Gilliam (strcmp(drv, driver_name) == 0)) { 1702*0013e2d3SJerry Gilliam status = NOT_UNIQUE; 1703*0013e2d3SJerry Gilliam } 1704*0013e2d3SJerry Gilliam 1705*0013e2d3SJerry Gilliam if ((strcmp(drv_alias, drv) == 0) || 1706*0013e2d3SJerry Gilliam ((strcmp(drv_alias, a) == 0) && 1707*0013e2d3SJerry Gilliam (strcmp(drv, driver_name) != 0))) { 1708*0013e2d3SJerry Gilliam (void) fprintf(stderr, 1709*0013e2d3SJerry Gilliam gettext(ERR_ALIAS_IN_USE), 1710*0013e2d3SJerry Gilliam drv_alias); 1711*0013e2d3SJerry Gilliam status = ERROR; 1712*0013e2d3SJerry Gilliam goto done; 1713*0013e2d3SJerry Gilliam } 1714*0013e2d3SJerry Gilliam } 1715*0013e2d3SJerry Gilliam 1716*0013e2d3SJerry Gilliam done: 1717*0013e2d3SJerry Gilliam (void) fclose(fp); 1718*0013e2d3SJerry Gilliam return (status); 1719*0013e2d3SJerry Gilliam } 1720*0013e2d3SJerry Gilliam 1721*0013e2d3SJerry Gilliam int 1722*0013e2d3SJerry Gilliam trim_duplicate_aliases(char *driver_name, char *aliases, char **aliases2p) 1723*0013e2d3SJerry Gilliam { 1724*0013e2d3SJerry Gilliam char *current_head; 1725*0013e2d3SJerry Gilliam char *previous_head; 1726*0013e2d3SJerry Gilliam char *one_entry; 1727*0013e2d3SJerry Gilliam char *aliases2; 1728*0013e2d3SJerry Gilliam int rv, len; 1729*0013e2d3SJerry Gilliam int n = 0; 1730*0013e2d3SJerry Gilliam 1731*0013e2d3SJerry Gilliam *aliases2p = NULL; 1732*0013e2d3SJerry Gilliam len = strlen(aliases) + 1; 1733*0013e2d3SJerry Gilliam 1734*0013e2d3SJerry Gilliam one_entry = calloc(len, 1); 1735*0013e2d3SJerry Gilliam aliases2 = calloc(len, 1); 1736*0013e2d3SJerry Gilliam if (one_entry == NULL || aliases2 == NULL) { 1737*0013e2d3SJerry Gilliam (void) fprintf(stderr, gettext(ERR_NO_MEM)); 1738*0013e2d3SJerry Gilliam return (ERROR); 1739*0013e2d3SJerry Gilliam } 1740*0013e2d3SJerry Gilliam 1741*0013e2d3SJerry Gilliam previous_head = aliases; 1742*0013e2d3SJerry Gilliam 1743*0013e2d3SJerry Gilliam do { 1744*0013e2d3SJerry Gilliam (void) bzero(one_entry, len); 1745*0013e2d3SJerry Gilliam current_head = get_entry(previous_head, one_entry, ' ', 1); 1746*0013e2d3SJerry Gilliam previous_head = current_head; 1747*0013e2d3SJerry Gilliam 1748*0013e2d3SJerry Gilliam rv = check_duplicate_driver_alias(driver_name, one_entry); 1749*0013e2d3SJerry Gilliam switch (rv) { 1750*0013e2d3SJerry Gilliam case SUCCESS: 1751*0013e2d3SJerry Gilliam /* not an existing driver alias: add it */ 1752*0013e2d3SJerry Gilliam if (n > 0) { 1753*0013e2d3SJerry Gilliam if (strlcat(aliases2, " ", len) >= len) 1754*0013e2d3SJerry Gilliam goto err; 1755*0013e2d3SJerry Gilliam } 1756*0013e2d3SJerry Gilliam if (strlcat(aliases2, one_entry, len) >= len) 1757*0013e2d3SJerry Gilliam goto err; 1758*0013e2d3SJerry Gilliam n++; 1759*0013e2d3SJerry Gilliam break; 1760*0013e2d3SJerry Gilliam case NOT_UNIQUE: 1761*0013e2d3SJerry Gilliam /* matching driver alias exists: do not add it */ 1762*0013e2d3SJerry Gilliam break; 1763*0013e2d3SJerry Gilliam case ERROR: 1764*0013e2d3SJerry Gilliam /* error reading the alias file */ 1765*0013e2d3SJerry Gilliam goto err; 1766*0013e2d3SJerry Gilliam default: 1767*0013e2d3SJerry Gilliam goto err; 1768*0013e2d3SJerry Gilliam } 1769*0013e2d3SJerry Gilliam 1770*0013e2d3SJerry Gilliam if (!is_token(one_entry)) { 1771*0013e2d3SJerry Gilliam (void) fprintf(stderr, gettext(ERR_BAD_TOK), 1772*0013e2d3SJerry Gilliam "-i", one_entry); 1773*0013e2d3SJerry Gilliam goto err; 1774*0013e2d3SJerry Gilliam } 1775*0013e2d3SJerry Gilliam } while (*current_head != '\0'); 1776*0013e2d3SJerry Gilliam 1777*0013e2d3SJerry Gilliam /* 1778*0013e2d3SJerry Gilliam * If all the aliases listed are already 1779*0013e2d3SJerry Gilliam * present we actually have none to do. 1780*0013e2d3SJerry Gilliam */ 1781*0013e2d3SJerry Gilliam if (n == 0) { 1782*0013e2d3SJerry Gilliam free(aliases2); 1783*0013e2d3SJerry Gilliam } else { 1784*0013e2d3SJerry Gilliam *aliases2p = aliases2; 1785*0013e2d3SJerry Gilliam } 1786*0013e2d3SJerry Gilliam free(one_entry); 1787*0013e2d3SJerry Gilliam return (NOERR); 1788*0013e2d3SJerry Gilliam 1789*0013e2d3SJerry Gilliam err: 1790*0013e2d3SJerry Gilliam free(aliases2); 1791*0013e2d3SJerry Gilliam free(one_entry); 1792*0013e2d3SJerry Gilliam return (ERROR); 1793*0013e2d3SJerry Gilliam } 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate int 17967c478bd9Sstevel@tonic-gate check_space_within_quote(char *str) 17977c478bd9Sstevel@tonic-gate { 17987c478bd9Sstevel@tonic-gate register int i; 17997c478bd9Sstevel@tonic-gate register int len; 18007c478bd9Sstevel@tonic-gate int quoted = 0; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate len = strlen(str); 18037c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++, str++) { 18047c478bd9Sstevel@tonic-gate if (*str == '"') { 18057c478bd9Sstevel@tonic-gate if (quoted == 0) 18067c478bd9Sstevel@tonic-gate quoted++; 18077c478bd9Sstevel@tonic-gate else 18087c478bd9Sstevel@tonic-gate quoted--; 18097c478bd9Sstevel@tonic-gate } else if (*str == ' ' && quoted) 18107c478bd9Sstevel@tonic-gate return (ERROR); 18117c478bd9Sstevel@tonic-gate } 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate return (0); 18147c478bd9Sstevel@tonic-gate } 18157c478bd9Sstevel@tonic-gate 18167c478bd9Sstevel@tonic-gate 18177c478bd9Sstevel@tonic-gate /* 18187c478bd9Sstevel@tonic-gate * get major number 18197c478bd9Sstevel@tonic-gate * write driver_name major_num to name_to_major file 18207c478bd9Sstevel@tonic-gate * major_num returned in major_num 18217c478bd9Sstevel@tonic-gate * return success/failure 18227c478bd9Sstevel@tonic-gate */ 18237c478bd9Sstevel@tonic-gate int 18247c478bd9Sstevel@tonic-gate update_name_to_major(char *driver_name, major_t *major_num, int server) 18257c478bd9Sstevel@tonic-gate { 18267c478bd9Sstevel@tonic-gate char major[MAX_STR_MAJOR + 1]; 18277c478bd9Sstevel@tonic-gate struct stat buf; 18287c478bd9Sstevel@tonic-gate char *num_list; 18297c478bd9Sstevel@tonic-gate char drv_majnum_str[MAX_STR_MAJOR + 1]; 18307c478bd9Sstevel@tonic-gate int new_maj = -1; 18317c478bd9Sstevel@tonic-gate int i, tmp = 0, is_unique, have_rem_n2m = 0; 18327c478bd9Sstevel@tonic-gate int max_dev = 0; 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate /* 18357c478bd9Sstevel@tonic-gate * if driver_name already in rem_name_to_major 18367c478bd9Sstevel@tonic-gate * delete entry from rem_nam_to_major 18377c478bd9Sstevel@tonic-gate * put entry into name_to_major 18387c478bd9Sstevel@tonic-gate */ 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate if (stat(rem_name_to_major, &buf) == 0) { 18417c478bd9Sstevel@tonic-gate have_rem_n2m = 1; 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate if (have_rem_n2m) { 18457c478bd9Sstevel@tonic-gate if ((is_unique = get_major_no(driver_name, rem_name_to_major)) 18467c478bd9Sstevel@tonic-gate == ERROR) 18477c478bd9Sstevel@tonic-gate return (ERROR); 18487c478bd9Sstevel@tonic-gate 18497c478bd9Sstevel@tonic-gate /* 18507c478bd9Sstevel@tonic-gate * found a match in rem_name_to_major 18517c478bd9Sstevel@tonic-gate */ 18527c478bd9Sstevel@tonic-gate if (is_unique != UNIQUE) { 18537c478bd9Sstevel@tonic-gate char scratch[FILENAME_MAX]; 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate /* 18567c478bd9Sstevel@tonic-gate * If there is a match in /etc/rem_name_to_major then 18577c478bd9Sstevel@tonic-gate * be paranoid: is that major number already in 18587c478bd9Sstevel@tonic-gate * /etc/name_to_major (potentially under another name)? 18597c478bd9Sstevel@tonic-gate */ 18607c478bd9Sstevel@tonic-gate if (get_driver_name(is_unique, name_to_major, 18617c478bd9Sstevel@tonic-gate scratch) != UNIQUE) { 18627c478bd9Sstevel@tonic-gate /* 18637c478bd9Sstevel@tonic-gate * nuke the rem_name_to_major entry-- it 18647c478bd9Sstevel@tonic-gate * isn't helpful. 18657c478bd9Sstevel@tonic-gate */ 18667c478bd9Sstevel@tonic-gate (void) delete_entry(rem_name_to_major, 18677c478bd9Sstevel@tonic-gate driver_name, " ", NULL); 18687c478bd9Sstevel@tonic-gate } else { 18697c478bd9Sstevel@tonic-gate (void) snprintf(major, sizeof (major), 18707c478bd9Sstevel@tonic-gate "%d", is_unique); 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate if (append_to_file(driver_name, major, 1873f4da9be0Scth name_to_major, ' ', " ", 0) == ERROR) { 18747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 18757c478bd9Sstevel@tonic-gate gettext(ERR_NO_UPDATE), 18767c478bd9Sstevel@tonic-gate name_to_major); 18777c478bd9Sstevel@tonic-gate return (ERROR); 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate if (delete_entry(rem_name_to_major, 18817c478bd9Sstevel@tonic-gate driver_name, " ", NULL) == ERROR) { 18827c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 18837c478bd9Sstevel@tonic-gate gettext(ERR_DEL_ENTRY), driver_name, 18847c478bd9Sstevel@tonic-gate rem_name_to_major); 18857c478bd9Sstevel@tonic-gate return (ERROR); 18867c478bd9Sstevel@tonic-gate } 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate /* found matching entry : no errors */ 18897c478bd9Sstevel@tonic-gate *major_num = is_unique; 18907c478bd9Sstevel@tonic-gate return (NOERR); 18917c478bd9Sstevel@tonic-gate } 18927c478bd9Sstevel@tonic-gate } 18937c478bd9Sstevel@tonic-gate } 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate /* 18967c478bd9Sstevel@tonic-gate * Bugid: 1264079 18977c478bd9Sstevel@tonic-gate * In a server case (with -b option), we can't use modctl() to find 18987c478bd9Sstevel@tonic-gate * the maximum major number, we need to dig thru client's 18997c478bd9Sstevel@tonic-gate * /etc/name_to_major and /etc/rem_name_to_major for the max_dev. 19007c478bd9Sstevel@tonic-gate * 19017c478bd9Sstevel@tonic-gate * if (server) 19027c478bd9Sstevel@tonic-gate * get maximum major number thru (rem_)name_to_major file on client 19037c478bd9Sstevel@tonic-gate * else 19047c478bd9Sstevel@tonic-gate * get maximum major number allowable on current system using modctl 19057c478bd9Sstevel@tonic-gate */ 19067c478bd9Sstevel@tonic-gate if (server) { 19077c478bd9Sstevel@tonic-gate max_dev = 0; 19087c478bd9Sstevel@tonic-gate tmp = 0; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate max_dev = get_max_major(name_to_major); 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate /* If rem_name_to_major exists, we need to check it too */ 19137c478bd9Sstevel@tonic-gate if (have_rem_n2m) { 19147c478bd9Sstevel@tonic-gate tmp = get_max_major(rem_name_to_major); 19157c478bd9Sstevel@tonic-gate 19167c478bd9Sstevel@tonic-gate /* 19177c478bd9Sstevel@tonic-gate * If name_to_major is missing, we can get max_dev from 19187c478bd9Sstevel@tonic-gate * /etc/rem_name_to_major. If both missing, bail out! 19197c478bd9Sstevel@tonic-gate */ 19207c478bd9Sstevel@tonic-gate if ((max_dev == ERROR) && (tmp == ERROR)) { 19217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 1922*0013e2d3SJerry Gilliam gettext(ERR_CANT_ACCESS_FILE), 1923*0013e2d3SJerry Gilliam name_to_major); 19247c478bd9Sstevel@tonic-gate return (ERROR); 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate /* guard against bigger maj_num in rem_name_to_major */ 19287c478bd9Sstevel@tonic-gate if (tmp > max_dev) 19297c478bd9Sstevel@tonic-gate max_dev = tmp; 19307c478bd9Sstevel@tonic-gate } else { 19317c478bd9Sstevel@tonic-gate /* 19327c478bd9Sstevel@tonic-gate * If we can't get major from name_to_major file 19337c478bd9Sstevel@tonic-gate * and there is no /etc/rem_name_to_major file, 19347c478bd9Sstevel@tonic-gate * then we don't have a max_dev, bail out quick! 19357c478bd9Sstevel@tonic-gate */ 19367c478bd9Sstevel@tonic-gate if (max_dev == ERROR) 19377c478bd9Sstevel@tonic-gate return (ERROR); 19387c478bd9Sstevel@tonic-gate } 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate /* 19417c478bd9Sstevel@tonic-gate * In case there is no more slack in current name_to_major 19427c478bd9Sstevel@tonic-gate * table, provide at least 1 extra entry so the add_drv can 19437c478bd9Sstevel@tonic-gate * succeed. Since only one add_drv process is allowed at one 19447c478bd9Sstevel@tonic-gate * time, and hence max_dev will be re-calculated each time 19457c478bd9Sstevel@tonic-gate * add_drv is ran, we don't need to worry about adding more 19467c478bd9Sstevel@tonic-gate * than 1 extra slot for max_dev. 19477c478bd9Sstevel@tonic-gate */ 19487c478bd9Sstevel@tonic-gate max_dev++; 19497c478bd9Sstevel@tonic-gate 19507c478bd9Sstevel@tonic-gate } else { 19517c478bd9Sstevel@tonic-gate if (modctl(MODRESERVED, NULL, &max_dev) < 0) { 19527c478bd9Sstevel@tonic-gate perror(NULL); 19537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_MAX_MAJOR)); 19547c478bd9Sstevel@tonic-gate return (ERROR); 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate } 19577c478bd9Sstevel@tonic-gate 19587c478bd9Sstevel@tonic-gate /* 19597c478bd9Sstevel@tonic-gate * max_dev is really how many slots the kernel has allocated for 19607c478bd9Sstevel@tonic-gate * devices... [0 , maxdev-1], not the largest available device num. 19617c478bd9Sstevel@tonic-gate */ 19627c478bd9Sstevel@tonic-gate if ((num_list = calloc(max_dev, 1)) == NULL) { 19637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 19647c478bd9Sstevel@tonic-gate return (ERROR); 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate /* 19687c478bd9Sstevel@tonic-gate * Populate the num_list array 19697c478bd9Sstevel@tonic-gate */ 19707c478bd9Sstevel@tonic-gate if (fill_n2m_array(name_to_major, &num_list, &max_dev) != 0) { 19717c478bd9Sstevel@tonic-gate return (ERROR); 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate if (have_rem_n2m) { 19747c478bd9Sstevel@tonic-gate if (fill_n2m_array(rem_name_to_major, &num_list, &max_dev) != 0) 19757c478bd9Sstevel@tonic-gate return (ERROR); 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate 19787c478bd9Sstevel@tonic-gate /* find first free major number */ 19797c478bd9Sstevel@tonic-gate for (i = 0; i < max_dev; i++) { 19807c478bd9Sstevel@tonic-gate if (num_list[i] != 1) { 19817c478bd9Sstevel@tonic-gate new_maj = i; 19827c478bd9Sstevel@tonic-gate break; 19837c478bd9Sstevel@tonic-gate } 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 19867c478bd9Sstevel@tonic-gate if (new_maj == -1) { 19877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_FREE_MAJOR)); 19887c478bd9Sstevel@tonic-gate return (ERROR); 19897c478bd9Sstevel@tonic-gate } 19907c478bd9Sstevel@tonic-gate 19917c478bd9Sstevel@tonic-gate (void) sprintf(drv_majnum_str, "%d", new_maj); 19927c478bd9Sstevel@tonic-gate if (do_the_update(driver_name, drv_majnum_str) == ERROR) { 19937c478bd9Sstevel@tonic-gate return (ERROR); 19947c478bd9Sstevel@tonic-gate } 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate *major_num = new_maj; 19977c478bd9Sstevel@tonic-gate return (NOERR); 19987c478bd9Sstevel@tonic-gate } 19997c478bd9Sstevel@tonic-gate 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate int 20027c478bd9Sstevel@tonic-gate fill_n2m_array(char *filename, char **array, int *nelems) 20037c478bd9Sstevel@tonic-gate { 20047c478bd9Sstevel@tonic-gate FILE *fp; 20051ca93273Seota char line[MAX_N2M_ALIAS_LINE + 1], *cp; 20067c478bd9Sstevel@tonic-gate char drv[FILENAME_MAX + 1]; 20077c478bd9Sstevel@tonic-gate u_longlong_t dnum; 20087c478bd9Sstevel@tonic-gate major_t drv_majnum; 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate /* 20117c478bd9Sstevel@tonic-gate * Read through the file, marking each major number found 20127c478bd9Sstevel@tonic-gate * order is not relevant 20137c478bd9Sstevel@tonic-gate */ 20147c478bd9Sstevel@tonic-gate if ((fp = fopen(filename, "r")) == NULL) { 20157c478bd9Sstevel@tonic-gate perror(NULL); 20167c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_CANT_ACCESS_FILE), filename); 20177c478bd9Sstevel@tonic-gate return (ERROR); 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != 0) { 20211ca93273Seota /* cut off comments starting with '#' */ 20221ca93273Seota if ((cp = strchr(line, '#')) != NULL) 20231ca93273Seota *cp = '\0'; 20241ca93273Seota /* ignore comment or blank lines */ 20251ca93273Seota if (is_blank(line)) 20261ca93273Seota continue; 20271ca93273Seota /* sanity-check */ 20287c478bd9Sstevel@tonic-gate if (sscanf(line, "%s %llu", drv, &dnum) != 2) { 20297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_BAD_LINE), 20307c478bd9Sstevel@tonic-gate filename, line); 20317c478bd9Sstevel@tonic-gate (void) fclose(fp); 20327c478bd9Sstevel@tonic-gate return (ERROR); 20337c478bd9Sstevel@tonic-gate } 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate if (dnum > L_MAXMAJ32) { 20367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_MAJ_TOOBIG), drv, 20377c478bd9Sstevel@tonic-gate dnum, filename, L_MAXMAJ32); 20387c478bd9Sstevel@tonic-gate continue; 20397c478bd9Sstevel@tonic-gate } 20407c478bd9Sstevel@tonic-gate /* 20417c478bd9Sstevel@tonic-gate * cast down to a major_t; we can be sure this is safe because 20427c478bd9Sstevel@tonic-gate * of the above range-check. 20437c478bd9Sstevel@tonic-gate */ 20447c478bd9Sstevel@tonic-gate drv_majnum = (major_t)dnum; 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate if (drv_majnum >= *nelems) { 20477c478bd9Sstevel@tonic-gate /* 20487c478bd9Sstevel@tonic-gate * Allocate some more space, up to drv_majnum + 1 so 20497c478bd9Sstevel@tonic-gate * we can accomodate 0 through drv_majnum. 20507c478bd9Sstevel@tonic-gate * 20517c478bd9Sstevel@tonic-gate * Note that in the failure case, we leak all of the 20527c478bd9Sstevel@tonic-gate * old contents of array. It's ok, since we just 20537c478bd9Sstevel@tonic-gate * wind up exiting immediately anyway. 20547c478bd9Sstevel@tonic-gate */ 20557c478bd9Sstevel@tonic-gate *nelems = drv_majnum + 1; 20567c478bd9Sstevel@tonic-gate *array = realloc(*array, *nelems); 20577c478bd9Sstevel@tonic-gate if (*array == NULL) { 20587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(ERR_NO_MEM)); 20597c478bd9Sstevel@tonic-gate return (ERROR); 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate (*array)[drv_majnum] = 1; 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate (void) fclose(fp); 20667c478bd9Sstevel@tonic-gate return (0); 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate int 20717c478bd9Sstevel@tonic-gate do_the_update(char *driver_name, char *major_number) 20727c478bd9Sstevel@tonic-gate { 20737c478bd9Sstevel@tonic-gate return (append_to_file(driver_name, major_number, name_to_major, 2074f4da9be0Scth ' ', " ", 0)); 20757c478bd9Sstevel@tonic-gate } 20761ca93273Seota 20771ca93273Seota /* 20781ca93273Seota * is_blank() returns 1 (true) if a line specified is composed of 20791ca93273Seota * whitespace characters only. otherwise, it returns 0 (false). 20801ca93273Seota * 20811ca93273Seota * Note. the argument (line) must be null-terminated. 20821ca93273Seota */ 20831ca93273Seota static int 20841ca93273Seota is_blank(char *line) 20851ca93273Seota { 20861ca93273Seota for (/* nothing */; *line != '\0'; line++) 20871ca93273Seota if (!isspace(*line)) 20881ca93273Seota return (0); 20891ca93273Seota return (1); 20901ca93273Seota } 2091