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
545916cd2Sjpk * Common Development and Distribution License (the "License").
645916cd2Sjpk * 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 */
2145916cd2Sjpk
227c478bd9Sstevel@tonic-gate /*
237e3e5701SJan Parcel * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
247c478bd9Sstevel@tonic-gate * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate */
267c478bd9Sstevel@tonic-gate
277c478bd9Sstevel@tonic-gate /*
287c478bd9Sstevel@tonic-gate * scan /dev directory for mountable objects and construct device_allocate
297c478bd9Sstevel@tonic-gate * file for allocate....
307c478bd9Sstevel@tonic-gate *
317c478bd9Sstevel@tonic-gate * devices are:
327c478bd9Sstevel@tonic-gate * tape (cartridge)
337c478bd9Sstevel@tonic-gate * /dev/rst*
347c478bd9Sstevel@tonic-gate * /dev/nrst*
357c478bd9Sstevel@tonic-gate * /dev/rmt/...
367c478bd9Sstevel@tonic-gate * audio
377c478bd9Sstevel@tonic-gate * /dev/audio
387c478bd9Sstevel@tonic-gate * /dev/audioctl
397c478bd9Sstevel@tonic-gate * /dev/sound/...
407c478bd9Sstevel@tonic-gate * floppy
417c478bd9Sstevel@tonic-gate * /dev/diskette
427c478bd9Sstevel@tonic-gate * /dev/fd*
437c478bd9Sstevel@tonic-gate * /dev/rdiskette
447c478bd9Sstevel@tonic-gate * /dev/rfd*
457c478bd9Sstevel@tonic-gate * CD
467c478bd9Sstevel@tonic-gate * /dev/sr*
477c478bd9Sstevel@tonic-gate * /dev/nsr*
487c478bd9Sstevel@tonic-gate * /dev/dsk/c?t?d0s?
497c478bd9Sstevel@tonic-gate * /dev/rdsk/c?t?d0s?
5045916cd2Sjpk *
517c478bd9Sstevel@tonic-gate */
527c478bd9Sstevel@tonic-gate
5345916cd2Sjpk #include <errno.h>
5445916cd2Sjpk #include <fcntl.h>
557c478bd9Sstevel@tonic-gate #include <sys/types.h> /* for stat(2), etc. */
567c478bd9Sstevel@tonic-gate #include <sys/stat.h>
577c478bd9Sstevel@tonic-gate #include <dirent.h> /* for readdir(3), etc. */
587c478bd9Sstevel@tonic-gate #include <unistd.h> /* for readlink(2) */
5945916cd2Sjpk #include <stropts.h>
607c478bd9Sstevel@tonic-gate #include <string.h> /* for strcpy(3), etc. */
617c478bd9Sstevel@tonic-gate #include <strings.h> /* for bcopy(3C), etc. */
627c478bd9Sstevel@tonic-gate #include <stdio.h> /* for perror(3) */
637c478bd9Sstevel@tonic-gate #include <stdlib.h> /* for atoi(3) */
6445916cd2Sjpk #include <sys/dkio.h>
657c478bd9Sstevel@tonic-gate #include <locale.h>
667c478bd9Sstevel@tonic-gate #include <libintl.h>
6745916cd2Sjpk #include <libdevinfo.h>
6845916cd2Sjpk #include <secdb.h>
69f875b4ebSrica #include <deflt.h>
707c478bd9Sstevel@tonic-gate #include <auth_attr.h>
717c478bd9Sstevel@tonic-gate #include <auth_list.h>
7245916cd2Sjpk #include <bsm/devices.h>
7345916cd2Sjpk #include <bsm/devalloc.h>
7445916cd2Sjpk #include <tsol/label.h>
757c478bd9Sstevel@tonic-gate
767c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN
777c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD"
787c478bd9Sstevel@tonic-gate #endif
797c478bd9Sstevel@tonic-gate
8045916cd2Sjpk #define MKDEVALLOC "mkdevalloc"
8145916cd2Sjpk #define MKDEVMAPS "mkdevmaps"
8245916cd2Sjpk
837c478bd9Sstevel@tonic-gate #define DELTA 5 /* array size delta when full */
8445916cd2Sjpk #define SECLIB "/etc/security/lib"
857c478bd9Sstevel@tonic-gate
867c478bd9Sstevel@tonic-gate /* "/dev/rst...", "/dev/nrst...", "/dev/rmt/..." */
877c478bd9Sstevel@tonic-gate struct tape {
887c478bd9Sstevel@tonic-gate char *name;
897c478bd9Sstevel@tonic-gate char *device;
907c478bd9Sstevel@tonic-gate int number;
917c478bd9Sstevel@tonic-gate } *tape;
927c478bd9Sstevel@tonic-gate #define DFLT_NTAPE 10 /* size of initial array */
937c478bd9Sstevel@tonic-gate #define SIZE_OF_RST 3 /* |rmt| */
947c478bd9Sstevel@tonic-gate #define SIZE_OF_NRST 4 /* |nrmt| */
957e3e5701SJan Parcel #define SIZE_OF_TMP 4 /* |/tmp| */
967c478bd9Sstevel@tonic-gate #define SIZE_OF_RMT 8 /* |/dev/rmt| */
9745916cd2Sjpk #define TAPE_CLEAN SECLIB"/st_clean"
987c478bd9Sstevel@tonic-gate
997c478bd9Sstevel@tonic-gate /* "/dev/audio", "/dev/audioctl", "/dev/sound/..." */
1007c478bd9Sstevel@tonic-gate struct audio {
1017c478bd9Sstevel@tonic-gate char *name;
1027c478bd9Sstevel@tonic-gate char *device;
1037c478bd9Sstevel@tonic-gate int number;
1047c478bd9Sstevel@tonic-gate } *audio;
1057c478bd9Sstevel@tonic-gate #define DFLT_NAUDIO 10 /* size of initial array */
1067c478bd9Sstevel@tonic-gate #define SIZE_OF_SOUND 10 /* |/dev/sound| */
10745916cd2Sjpk #define AUDIO_CLEAN SECLIB"/audio_clean"
1087c478bd9Sstevel@tonic-gate
1097c478bd9Sstevel@tonic-gate /* "/dev/sr", "/dev/nsr", "/dev/dsk/c?t?d0s?", "/dev/rdsk/c?t?d0s?" */
1107c478bd9Sstevel@tonic-gate struct cd {
1117c478bd9Sstevel@tonic-gate char *name;
1127c478bd9Sstevel@tonic-gate char *device;
1137c478bd9Sstevel@tonic-gate int id;
1147c478bd9Sstevel@tonic-gate int controller;
1157c478bd9Sstevel@tonic-gate int number;
1167c478bd9Sstevel@tonic-gate } *cd;
1177c478bd9Sstevel@tonic-gate #define DFLT_NCD 10 /* size of initial array */
1187c478bd9Sstevel@tonic-gate #define SIZE_OF_SR 2 /* |sr| */
1197c478bd9Sstevel@tonic-gate #define SIZE_OF_RSR 3 /* |rsr| */
1207c478bd9Sstevel@tonic-gate #define SIZE_OF_DSK 8 /* |/dev/dsk| */
1217c478bd9Sstevel@tonic-gate #define SIZE_OF_RDSK 9 /* |/dev/rdsk| */
12245916cd2Sjpk #define CD_CLEAN SECLIB"/sr_clean"
1237c478bd9Sstevel@tonic-gate
12445916cd2Sjpk /* "/dev/sr", "/dev/nsr", "/dev/dsk/c?t?d0s?", "/dev/rdsk/c?t?d0s?" */
12545916cd2Sjpk struct rmdisk {
12645916cd2Sjpk char *name;
12745916cd2Sjpk char *device;
12845916cd2Sjpk int id;
12945916cd2Sjpk int controller;
13045916cd2Sjpk int number;
13145916cd2Sjpk } *rmdisk, *rmdisk_r;
13245916cd2Sjpk #define DFLT_RMDISK 10 /* size of initial array */
1337c478bd9Sstevel@tonic-gate
1347c478bd9Sstevel@tonic-gate /* "/dev/fd0*", "/dev/rfd0*", "/dev/fd1*", "/dev/rfd1*" */
1357c478bd9Sstevel@tonic-gate struct fp {
1367c478bd9Sstevel@tonic-gate char *name;
1377c478bd9Sstevel@tonic-gate char *device;
1387c478bd9Sstevel@tonic-gate int number;
1397c478bd9Sstevel@tonic-gate } *fp;
1407c478bd9Sstevel@tonic-gate #define DFLT_NFP 10 /* size of initial array */
1417c478bd9Sstevel@tonic-gate #define SIZE_OF_FD0 3 /* |fd0| */
1427c478bd9Sstevel@tonic-gate #define SIZE_OF_RFD0 4 /* |rfd0| */
14345916cd2Sjpk #define FLOPPY_CLEAN SECLIB"/fd_clean"
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate static void dotape();
1467c478bd9Sstevel@tonic-gate static void doaudio();
1477c478bd9Sstevel@tonic-gate static void dofloppy();
14845916cd2Sjpk static int docd();
14945916cd2Sjpk static void dormdisk(int);
1507c478bd9Sstevel@tonic-gate static void initmem();
1517c478bd9Sstevel@tonic-gate static int expandmem(int, void **, int);
1527c478bd9Sstevel@tonic-gate static void no_memory(void);
1537c478bd9Sstevel@tonic-gate
15445916cd2Sjpk int system_labeled = 0;
15545916cd2Sjpk int do_devalloc = 0;
15645916cd2Sjpk int do_devmaps = 0;
15745916cd2Sjpk int do_files = 0;
15845916cd2Sjpk devlist_t devlist;
15945916cd2Sjpk
1607883e825Spaulson int
main(int argc,char ** argv)16145916cd2Sjpk main(int argc, char **argv)
1627c478bd9Sstevel@tonic-gate {
16345916cd2Sjpk int cd_count = 0;
16445916cd2Sjpk char *progname;
16545916cd2Sjpk
1667c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, "");
1677c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN);
1687c478bd9Sstevel@tonic-gate
16945916cd2Sjpk if ((progname = strrchr(argv[0], '/')) == NULL)
17045916cd2Sjpk progname = argv[0];
17145916cd2Sjpk else
17245916cd2Sjpk progname++;
17345916cd2Sjpk if (strcmp(progname, MKDEVALLOC) == 0)
17445916cd2Sjpk do_devalloc = 1;
17545916cd2Sjpk else if (strcmp(progname, MKDEVMAPS) == 0)
17645916cd2Sjpk do_devmaps = 1;
17745916cd2Sjpk else
17845916cd2Sjpk exit(1);
1797c478bd9Sstevel@tonic-gate
18045916cd2Sjpk system_labeled = is_system_labeled();
181facf4a8dSllai
182f875b4ebSrica if (!system_labeled) {
183f875b4ebSrica /*
184f875b4ebSrica * is_system_labeled() will return false in case we are
185f875b4ebSrica * starting before the first reboot after Trusted Extensions
186f875b4ebSrica * is enabled. Check the setting in /etc/system to see if
187f875b4ebSrica * TX is enabled (even if not yet booted).
188f875b4ebSrica */
189f875b4ebSrica if (defopen("/etc/system") == 0) {
190f875b4ebSrica if (defread("set sys_labeling=1") != NULL)
191f875b4ebSrica system_labeled = 1;
192f875b4ebSrica
193f875b4ebSrica /* close defaults file */
194f875b4ebSrica (void) defopen(NULL);
195f875b4ebSrica }
196f875b4ebSrica }
197f875b4ebSrica
198f875b4ebSrica #ifdef DEBUG
199facf4a8dSllai /* test hook: see also devfsadm.c and allocate.c */
200facf4a8dSllai if (!system_labeled) {
201f875b4ebSrica struct stat tx_stat;
202f875b4ebSrica
203facf4a8dSllai system_labeled = is_system_labeled_debug(&tx_stat);
204facf4a8dSllai if (system_labeled) {
205facf4a8dSllai fprintf(stderr, "/ALLOCATE_FORCE_LABEL is set,\n"
206facf4a8dSllai "forcing system label on for testing...\n");
207facf4a8dSllai }
208facf4a8dSllai }
209f875b4ebSrica #endif
2107c478bd9Sstevel@tonic-gate
21145916cd2Sjpk if (system_labeled && do_devalloc && (argc == 2) &&
21245916cd2Sjpk (strcmp(argv[1], DA_IS_LABELED) == 0)) {
21345916cd2Sjpk /*
21445916cd2Sjpk * write device entries to device_allocate and device_maps.
21545916cd2Sjpk * default is to print them on stdout.
21645916cd2Sjpk */
21745916cd2Sjpk do_files = 1;
21845916cd2Sjpk }
2197c478bd9Sstevel@tonic-gate
22045916cd2Sjpk initmem(); /* initialize memory */
22145916cd2Sjpk dotape();
22245916cd2Sjpk doaudio();
22345916cd2Sjpk dofloppy();
22445916cd2Sjpk cd_count = docd();
22545916cd2Sjpk if (system_labeled)
22645916cd2Sjpk dormdisk(cd_count);
2277883e825Spaulson
2287883e825Spaulson return (0);
2297c478bd9Sstevel@tonic-gate }
2307c478bd9Sstevel@tonic-gate
2317c478bd9Sstevel@tonic-gate static void
dotape()2327c478bd9Sstevel@tonic-gate dotape()
2337c478bd9Sstevel@tonic-gate {
2347c478bd9Sstevel@tonic-gate DIR *dirp;
2357c478bd9Sstevel@tonic-gate struct dirent *dep; /* directory entry pointer */
23645916cd2Sjpk int i, j;
2377c478bd9Sstevel@tonic-gate char *nm; /* name/device of special device */
2387c478bd9Sstevel@tonic-gate char linkvalue[2048]; /* symlink value */
2397c478bd9Sstevel@tonic-gate struct stat stat; /* determine if it's a symlink */
2407c478bd9Sstevel@tonic-gate int sz; /* size of symlink value */
2417c478bd9Sstevel@tonic-gate char *cp; /* pointer into string */
2427c478bd9Sstevel@tonic-gate int ntape; /* max array size */
24345916cd2Sjpk int tape_count;
24445916cd2Sjpk int first = 0;
24545916cd2Sjpk char *dname, *dtype, *dclean;
24645916cd2Sjpk da_args dargs;
24745916cd2Sjpk deventry_t *entry;
2487c478bd9Sstevel@tonic-gate
2497c478bd9Sstevel@tonic-gate ntape = DFLT_NTAPE;
2507c478bd9Sstevel@tonic-gate
2517c478bd9Sstevel@tonic-gate /*
2527c478bd9Sstevel@tonic-gate * look for rst* and nrst*
2537c478bd9Sstevel@tonic-gate */
2547c478bd9Sstevel@tonic-gate
2557c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev")) == NULL) {
2567c478bd9Sstevel@tonic-gate perror(gettext("open /dev failure"));
2577c478bd9Sstevel@tonic-gate exit(1);
2587c478bd9Sstevel@tonic-gate }
2597c478bd9Sstevel@tonic-gate
2607c478bd9Sstevel@tonic-gate i = 0;
2617c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
2627c478bd9Sstevel@tonic-gate /* ignore if neither rst* nor nrst* */
2637c478bd9Sstevel@tonic-gate if (strncmp(dep->d_name, "rst", SIZE_OF_RST) &&
2647c478bd9Sstevel@tonic-gate strncmp(dep->d_name, "nrst", SIZE_OF_NRST))
2657c478bd9Sstevel@tonic-gate continue;
2667c478bd9Sstevel@tonic-gate
2677c478bd9Sstevel@tonic-gate /* if array full, then expand it */
2687c478bd9Sstevel@tonic-gate if (i == ntape) {
2697c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
2707c478bd9Sstevel@tonic-gate ntape = expandmem(i, (void **)&tape,
271f875b4ebSrica sizeof (struct tape));
2727c478bd9Sstevel@tonic-gate }
2737c478bd9Sstevel@tonic-gate
2747c478bd9Sstevel@tonic-gate /* save name (/dev + / + d_name + \0) */
2757c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_TMP + 1 + strlen(dep->d_name) + 1);
2767c478bd9Sstevel@tonic-gate if (nm == NULL)
2777c478bd9Sstevel@tonic-gate no_memory();
2787c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/");
2797c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
2807c478bd9Sstevel@tonic-gate tape[i].name = nm;
2817c478bd9Sstevel@tonic-gate
2827c478bd9Sstevel@tonic-gate /* ignore if not symbolic link (note i not incremented) */
2837c478bd9Sstevel@tonic-gate if (lstat(tape[i].name, &stat) < 0) {
2847c478bd9Sstevel@tonic-gate perror("stat(2) failed ");
2857c478bd9Sstevel@tonic-gate exit(1);
2867c478bd9Sstevel@tonic-gate }
2877c478bd9Sstevel@tonic-gate if ((stat.st_mode & S_IFMT) != S_IFLNK)
2887c478bd9Sstevel@tonic-gate continue;
2897c478bd9Sstevel@tonic-gate
2907c478bd9Sstevel@tonic-gate /* get name from symbolic link */
2917c478bd9Sstevel@tonic-gate if ((sz = readlink(tape[i].name, linkvalue,
292f875b4ebSrica sizeof (linkvalue))) < 0)
2937c478bd9Sstevel@tonic-gate continue;
2947c478bd9Sstevel@tonic-gate nm = (char *)malloc(sz + 1);
2957c478bd9Sstevel@tonic-gate if (nm == NULL)
2967c478bd9Sstevel@tonic-gate no_memory();
2977c478bd9Sstevel@tonic-gate (void) strncpy(nm, linkvalue, sz);
2987c478bd9Sstevel@tonic-gate nm[sz] = '\0';
2997c478bd9Sstevel@tonic-gate tape[i].device = nm;
3007c478bd9Sstevel@tonic-gate
3017c478bd9Sstevel@tonic-gate /* get device number */
3027c478bd9Sstevel@tonic-gate cp = strrchr(tape[i].device, '/');
3037c478bd9Sstevel@tonic-gate cp++; /* advance to device # */
3047c478bd9Sstevel@tonic-gate (void) sscanf(cp, "%d", &tape[i].number);
3057c478bd9Sstevel@tonic-gate
3067c478bd9Sstevel@tonic-gate i++;
3077c478bd9Sstevel@tonic-gate }
3087c478bd9Sstevel@tonic-gate
3097c478bd9Sstevel@tonic-gate (void) closedir(dirp);
3107c478bd9Sstevel@tonic-gate
3117c478bd9Sstevel@tonic-gate /*
3127c478bd9Sstevel@tonic-gate * scan /dev/rmt and add entry to table
3137c478bd9Sstevel@tonic-gate */
3147c478bd9Sstevel@tonic-gate
3157c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev/rmt")) == NULL) {
3167c478bd9Sstevel@tonic-gate perror(gettext("open /dev failure"));
3177c478bd9Sstevel@tonic-gate exit(1);
3187c478bd9Sstevel@tonic-gate }
3197c478bd9Sstevel@tonic-gate
3207c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
3217c478bd9Sstevel@tonic-gate /* skip . .. etc... */
322*98e97357SToomas Soome if (strncmp(dep->d_name, ".", 1) == 0)
3237c478bd9Sstevel@tonic-gate continue;
3247c478bd9Sstevel@tonic-gate
3257c478bd9Sstevel@tonic-gate /* if array full, then expand it */
3267c478bd9Sstevel@tonic-gate if (i == ntape) {
3277c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
3287c478bd9Sstevel@tonic-gate ntape = expandmem(i, (void **)&tape,
329f875b4ebSrica sizeof (struct tape));
3307c478bd9Sstevel@tonic-gate }
3317c478bd9Sstevel@tonic-gate
3327c478bd9Sstevel@tonic-gate /* save name (/dev/rmt + / + d_name + \0) */
3337c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_RMT + 1 + strlen(dep->d_name) + 1);
3347c478bd9Sstevel@tonic-gate if (nm == NULL)
3357c478bd9Sstevel@tonic-gate no_memory();
3367c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/rmt/");
3377c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
3387c478bd9Sstevel@tonic-gate tape[i].name = nm;
3397c478bd9Sstevel@tonic-gate
3407c478bd9Sstevel@tonic-gate /* save device name (rmt/ + d_name + \0) */
3417c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_TMP + strlen(dep->d_name) + 1);
3427c478bd9Sstevel@tonic-gate if (nm == NULL)
3437c478bd9Sstevel@tonic-gate no_memory();
3447c478bd9Sstevel@tonic-gate (void) strcpy(nm, "rmt/");
3457c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
3467c478bd9Sstevel@tonic-gate tape[i].device = nm;
3477c478bd9Sstevel@tonic-gate
3487c478bd9Sstevel@tonic-gate (void) sscanf(dep->d_name, "%d", &tape[i].number);
3497c478bd9Sstevel@tonic-gate
3507c478bd9Sstevel@tonic-gate i++;
3517c478bd9Sstevel@tonic-gate }
35245916cd2Sjpk tape_count = i;
3537c478bd9Sstevel@tonic-gate
3547c478bd9Sstevel@tonic-gate (void) closedir(dirp);
3557c478bd9Sstevel@tonic-gate
3567c478bd9Sstevel@tonic-gate /* remove duplicate entries */
35745916cd2Sjpk for (i = 0; i < tape_count - 1; i++) {
35845916cd2Sjpk for (j = i + 1; j < tape_count; j++) {
3597c478bd9Sstevel@tonic-gate if (strcmp(tape[i].device, tape[j].device))
3607c478bd9Sstevel@tonic-gate continue;
3617c478bd9Sstevel@tonic-gate tape[j].number = -1;
3627c478bd9Sstevel@tonic-gate }
3637c478bd9Sstevel@tonic-gate }
3647c478bd9Sstevel@tonic-gate
36545916cd2Sjpk if (system_labeled) {
36645916cd2Sjpk dname = DA_TAPE_NAME;
36745916cd2Sjpk dtype = DA_TAPE_TYPE;
36845916cd2Sjpk dclean = DA_DEFAULT_TAPE_CLEAN;
36945916cd2Sjpk } else {
37045916cd2Sjpk dname = "st";
37145916cd2Sjpk dtype = "st";
37245916cd2Sjpk dclean = TAPE_CLEAN;
37345916cd2Sjpk }
3747c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) {
37545916cd2Sjpk for (j = 0; j < tape_count; j++) {
37645916cd2Sjpk if (tape[j].number != i)
37745916cd2Sjpk continue;
37845916cd2Sjpk if (do_files) {
37945916cd2Sjpk (void) da_add_list(&devlist, tape[j].name, i,
38045916cd2Sjpk DA_TAPE);
38145916cd2Sjpk } else if (do_devalloc) {
38245916cd2Sjpk /* print device_allocate for tape devices */
38345916cd2Sjpk if (system_labeled) {
38445916cd2Sjpk (void) printf("%s%d%s\\\n",
38545916cd2Sjpk dname, i, KV_DELIMITER);
38645916cd2Sjpk (void) printf("\t%s%s\\\n",
38745916cd2Sjpk DA_TAPE_TYPE, KV_DELIMITER);
38845916cd2Sjpk (void) printf("\t%s%s\\\n",
38945916cd2Sjpk DA_RESERVED, KV_DELIMITER);
39045916cd2Sjpk (void) printf("\t%s%s\\\n",
39145916cd2Sjpk DA_RESERVED, KV_DELIMITER);
39245916cd2Sjpk (void) printf("\t%s%s\\\n",
39345916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH,
39445916cd2Sjpk KV_DELIMITER);
39545916cd2Sjpk (void) printf("\t%s\n\n", dclean);
39645916cd2Sjpk } else {
39745916cd2Sjpk (void) printf(
39845916cd2Sjpk "st%d;st;reserved;reserved;%s;",
39945916cd2Sjpk i, DEFAULT_DEV_ALLOC_AUTH);
40045916cd2Sjpk (void) printf("%s%s\n", SECLIB,
40145916cd2Sjpk "/st_clean");
40245916cd2Sjpk }
4037c478bd9Sstevel@tonic-gate break;
40445916cd2Sjpk } else if (do_devmaps) {
40545916cd2Sjpk /* print device_maps for tape devices */
40645916cd2Sjpk if (first) {
40745916cd2Sjpk (void) printf(" ");
40845916cd2Sjpk } else {
40945916cd2Sjpk if (system_labeled) {
41045916cd2Sjpk (void) printf("%s%d%s\\\n",
41145916cd2Sjpk dname, i, KV_TOKEN_DELIMIT);
41245916cd2Sjpk (void) printf("\t%s%s\\\n",
41345916cd2Sjpk dtype, KV_TOKEN_DELIMIT);
41445916cd2Sjpk (void) printf("\t");
41545916cd2Sjpk } else {
41645916cd2Sjpk (void) printf("st%d:\\\n", i);
41745916cd2Sjpk (void) printf("\trmt:\\\n");
41845916cd2Sjpk (void) printf("\t");
41945916cd2Sjpk }
42045916cd2Sjpk first++;
42145916cd2Sjpk }
42245916cd2Sjpk (void) printf("%s", tape[j].name);
4237c478bd9Sstevel@tonic-gate }
4247c478bd9Sstevel@tonic-gate }
42545916cd2Sjpk if (do_devmaps && first) {
42645916cd2Sjpk (void) printf("\n\n");
42745916cd2Sjpk first = 0;
42845916cd2Sjpk }
42945916cd2Sjpk }
43045916cd2Sjpk if (do_files && tape_count) {
43145916cd2Sjpk dargs.rootdir = NULL;
43245916cd2Sjpk dargs.devnames = NULL;
43345916cd2Sjpk dargs.optflag = DA_ADD;
43445916cd2Sjpk for (entry = devlist.tape; entry != NULL; entry = entry->next) {
43545916cd2Sjpk dargs.devinfo = &(entry->devinfo);
43645916cd2Sjpk (void) da_update_device(&dargs);
43745916cd2Sjpk }
4387c478bd9Sstevel@tonic-gate }
4397c478bd9Sstevel@tonic-gate }
4407c478bd9Sstevel@tonic-gate
4417c478bd9Sstevel@tonic-gate static void
doaudio()4427c478bd9Sstevel@tonic-gate doaudio()
4437c478bd9Sstevel@tonic-gate {
4447c478bd9Sstevel@tonic-gate DIR *dirp;
4457c478bd9Sstevel@tonic-gate struct dirent *dep; /* directory entry pointer */
44645916cd2Sjpk int i, j;
4477c478bd9Sstevel@tonic-gate char *nm; /* name/device of special device */
4487c478bd9Sstevel@tonic-gate char linkvalue[2048]; /* symlink value */
4497c478bd9Sstevel@tonic-gate struct stat stat; /* determine if it's a symlink */
4507c478bd9Sstevel@tonic-gate int sz; /* size of symlink value */
4517c478bd9Sstevel@tonic-gate char *cp; /* pointer into string */
4527c478bd9Sstevel@tonic-gate int naudio; /* max array size */
45345916cd2Sjpk int audio_count = 0;
45445916cd2Sjpk int len, slen;
45545916cd2Sjpk int first = 0;
45645916cd2Sjpk char dname[128];
45745916cd2Sjpk char *dclean;
45845916cd2Sjpk da_args dargs;
45945916cd2Sjpk deventry_t *entry;
4607c478bd9Sstevel@tonic-gate
4617c478bd9Sstevel@tonic-gate naudio = DFLT_NAUDIO;
4627c478bd9Sstevel@tonic-gate
4637c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev")) == NULL) {
4647c478bd9Sstevel@tonic-gate perror(gettext("open /dev failure"));
4657c478bd9Sstevel@tonic-gate exit(1);
4667c478bd9Sstevel@tonic-gate }
4677c478bd9Sstevel@tonic-gate
4687c478bd9Sstevel@tonic-gate i = 0;
4697c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
4707c478bd9Sstevel@tonic-gate if (strcmp(dep->d_name, "audio") &&
4717c478bd9Sstevel@tonic-gate strcmp(dep->d_name, "audioctl"))
4727c478bd9Sstevel@tonic-gate continue;
4737c478bd9Sstevel@tonic-gate
4747c478bd9Sstevel@tonic-gate /* if array full, then expand it */
4757c478bd9Sstevel@tonic-gate if (i == naudio) {
4767c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
4777c478bd9Sstevel@tonic-gate naudio = expandmem(i, (void **)&audio,
478f875b4ebSrica sizeof (struct audio));
4797c478bd9Sstevel@tonic-gate }
4807c478bd9Sstevel@tonic-gate
4817c478bd9Sstevel@tonic-gate /* save name (/dev + 1 + d_name + \0) */
4827c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_TMP + 1 + strlen(dep->d_name) + 1);
4837c478bd9Sstevel@tonic-gate if (nm == NULL)
4847c478bd9Sstevel@tonic-gate no_memory();
4857c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/");
4867c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
4877c478bd9Sstevel@tonic-gate audio[i].name = nm;
4887c478bd9Sstevel@tonic-gate
4897c478bd9Sstevel@tonic-gate /* ignore if not symbolic link (note i not incremented) */
4907c478bd9Sstevel@tonic-gate if (lstat(audio[i].name, &stat) < 0) {
4917c478bd9Sstevel@tonic-gate perror(gettext("stat(2) failed "));
4927c478bd9Sstevel@tonic-gate exit(1);
4937c478bd9Sstevel@tonic-gate }
4947c478bd9Sstevel@tonic-gate if ((stat.st_mode & S_IFMT) != S_IFLNK)
4957c478bd9Sstevel@tonic-gate continue;
4967c478bd9Sstevel@tonic-gate
4977c478bd9Sstevel@tonic-gate /* get name from symbolic link */
4987c478bd9Sstevel@tonic-gate if ((sz = readlink(audio[i].name, linkvalue,
499f875b4ebSrica sizeof (linkvalue))) < 0)
5007c478bd9Sstevel@tonic-gate continue;
5017c478bd9Sstevel@tonic-gate nm = (char *)malloc(sz + 1);
5027c478bd9Sstevel@tonic-gate if (nm == NULL)
5037c478bd9Sstevel@tonic-gate no_memory();
5047c478bd9Sstevel@tonic-gate (void) strncpy(nm, linkvalue, sz);
5057c478bd9Sstevel@tonic-gate nm[sz] = '\0';
5067c478bd9Sstevel@tonic-gate audio[i].device = nm;
5077c478bd9Sstevel@tonic-gate
5087c478bd9Sstevel@tonic-gate cp = strrchr(audio[i].device, '/');
5097c478bd9Sstevel@tonic-gate cp++; /* advance to device # */
5107c478bd9Sstevel@tonic-gate (void) sscanf(cp, "%d", &audio[i].number);
5117c478bd9Sstevel@tonic-gate
5127c478bd9Sstevel@tonic-gate i++;
5137c478bd9Sstevel@tonic-gate }
5147c478bd9Sstevel@tonic-gate
5157c478bd9Sstevel@tonic-gate (void) closedir(dirp);
5167c478bd9Sstevel@tonic-gate
5177c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev/sound")) == NULL) {
5187c478bd9Sstevel@tonic-gate goto skip;
5197c478bd9Sstevel@tonic-gate }
5207c478bd9Sstevel@tonic-gate
5217c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
5227c478bd9Sstevel@tonic-gate /* skip . .. etc... */
523*98e97357SToomas Soome if (strncmp(dep->d_name, ".", 1) == 0)
5247c478bd9Sstevel@tonic-gate continue;
5257c478bd9Sstevel@tonic-gate
5267c478bd9Sstevel@tonic-gate /* if array full, then expand it */
5277c478bd9Sstevel@tonic-gate if (i == naudio) {
5287c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
5297c478bd9Sstevel@tonic-gate naudio = expandmem(i, (void **)&audio,
530f875b4ebSrica sizeof (struct audio));
5317c478bd9Sstevel@tonic-gate }
5327c478bd9Sstevel@tonic-gate
5337c478bd9Sstevel@tonic-gate /* save name (/dev/sound + / + d_name + \0) */
5347c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_SOUND + 1 +
5357c478bd9Sstevel@tonic-gate strlen(dep->d_name) + 1);
5367c478bd9Sstevel@tonic-gate if (nm == NULL)
5377c478bd9Sstevel@tonic-gate no_memory();
5387c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/sound/");
5397c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
5407c478bd9Sstevel@tonic-gate audio[i].name = nm;
5417c478bd9Sstevel@tonic-gate
5427c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_SOUND + 1 +
5437c478bd9Sstevel@tonic-gate strlen(dep->d_name) + 1);
5447c478bd9Sstevel@tonic-gate if (nm == NULL)
5457c478bd9Sstevel@tonic-gate no_memory();
5467c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/sound/");
5477c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
5487c478bd9Sstevel@tonic-gate audio[i].device = nm;
5497c478bd9Sstevel@tonic-gate
5507c478bd9Sstevel@tonic-gate (void) sscanf(dep->d_name, "%d", &audio[i].number);
5517c478bd9Sstevel@tonic-gate
5527c478bd9Sstevel@tonic-gate i++;
5537c478bd9Sstevel@tonic-gate }
5547c478bd9Sstevel@tonic-gate
5557c478bd9Sstevel@tonic-gate (void) closedir(dirp);
5567c478bd9Sstevel@tonic-gate
5577c478bd9Sstevel@tonic-gate skip:
55845916cd2Sjpk audio_count = i;
5597c478bd9Sstevel@tonic-gate
5607c478bd9Sstevel@tonic-gate /* remove duplicate entries */
56145916cd2Sjpk for (i = 0; i < audio_count - 1; i++) {
56245916cd2Sjpk for (j = i + 1; j < audio_count; j++) {
5637c478bd9Sstevel@tonic-gate if (strcmp(audio[i].device, audio[j].device))
5647c478bd9Sstevel@tonic-gate continue;
5657c478bd9Sstevel@tonic-gate audio[j].number = -1;
5667c478bd9Sstevel@tonic-gate }
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate
56945916cd2Sjpk /* print out device_allocate entries for audio devices */
57045916cd2Sjpk (void) strcpy(dname, DA_AUDIO_NAME);
57145916cd2Sjpk slen = strlen(DA_AUDIO_NAME);
57245916cd2Sjpk len = sizeof (dname) - slen;
57345916cd2Sjpk dclean = system_labeled ? DA_DEFAULT_AUDIO_CLEAN : AUDIO_CLEAN;
5747c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) {
57545916cd2Sjpk for (j = 0; j < audio_count; j++) {
57645916cd2Sjpk if (audio[j].number != i)
57745916cd2Sjpk continue;
57845916cd2Sjpk if (system_labeled)
57945916cd2Sjpk (void) snprintf(dname+slen, len, "%d", i);
58045916cd2Sjpk if (do_files) {
58145916cd2Sjpk (void) da_add_list(&devlist, audio[j].name,
58245916cd2Sjpk i, DA_AUDIO);
58345916cd2Sjpk } else if (do_devalloc) {
58445916cd2Sjpk /* print device_allocate for audio devices */
58545916cd2Sjpk if (system_labeled) {
58645916cd2Sjpk (void) printf("%s%s\\\n",
58745916cd2Sjpk dname, KV_DELIMITER);
58845916cd2Sjpk (void) printf("\t%s%s\\\n",
58945916cd2Sjpk DA_AUDIO_TYPE, KV_DELIMITER);
59045916cd2Sjpk (void) printf("\t%s%s\\\n",
59145916cd2Sjpk DA_RESERVED, KV_DELIMITER);
59245916cd2Sjpk (void) printf("\t%s%s\\\n",
59345916cd2Sjpk DA_RESERVED, KV_DELIMITER);
59445916cd2Sjpk (void) printf("\t%s%s\\\n",
59545916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH,
59645916cd2Sjpk KV_DELIMITER);
59745916cd2Sjpk (void) printf("\t%s\n\n", dclean);
59845916cd2Sjpk } else {
59945916cd2Sjpk (void) printf("audio;audio;");
60045916cd2Sjpk (void) printf("reserved;reserved;%s;",
60145916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH);
60245916cd2Sjpk (void) printf("%s%s\n", SECLIB,
60345916cd2Sjpk "/audio_clean");
60445916cd2Sjpk }
6057c478bd9Sstevel@tonic-gate break;
60645916cd2Sjpk } else if (do_devmaps) {
60745916cd2Sjpk /* print device_maps for audio devices */
60845916cd2Sjpk if (first) {
60945916cd2Sjpk (void) printf(" ");
61045916cd2Sjpk } else {
61145916cd2Sjpk if (system_labeled) {
61245916cd2Sjpk (void) printf("%s%s\\\n",
61345916cd2Sjpk dname, KV_TOKEN_DELIMIT);
61445916cd2Sjpk (void) printf("\t%s%s\\\n",
61545916cd2Sjpk DA_AUDIO_TYPE,
61645916cd2Sjpk KV_TOKEN_DELIMIT);
61745916cd2Sjpk (void) printf("\t");
61845916cd2Sjpk } else {
61945916cd2Sjpk (void) printf("audio:\\\n");
62045916cd2Sjpk (void) printf("\taudio:\\\n");
62145916cd2Sjpk (void) printf("\t");
62245916cd2Sjpk }
62345916cd2Sjpk first++;
62445916cd2Sjpk }
62545916cd2Sjpk (void) printf("%s", audio[j].name);
6267c478bd9Sstevel@tonic-gate }
6277c478bd9Sstevel@tonic-gate }
62845916cd2Sjpk if (do_devmaps && first) {
62945916cd2Sjpk (void) printf("\n\n");
63045916cd2Sjpk first = 0;
63145916cd2Sjpk }
63245916cd2Sjpk }
63345916cd2Sjpk if (do_files && audio_count) {
63445916cd2Sjpk dargs.rootdir = NULL;
63545916cd2Sjpk dargs.devnames = NULL;
63645916cd2Sjpk dargs.optflag = DA_ADD;
63745916cd2Sjpk for (entry = devlist.audio; entry != NULL;
63845916cd2Sjpk entry = entry->next) {
63945916cd2Sjpk dargs.devinfo = &(entry->devinfo);
64045916cd2Sjpk (void) da_update_device(&dargs);
64145916cd2Sjpk }
6427c478bd9Sstevel@tonic-gate }
6437c478bd9Sstevel@tonic-gate }
6447c478bd9Sstevel@tonic-gate
6457c478bd9Sstevel@tonic-gate static void
dofloppy()6467c478bd9Sstevel@tonic-gate dofloppy()
6477c478bd9Sstevel@tonic-gate {
6487c478bd9Sstevel@tonic-gate DIR *dirp;
6497c478bd9Sstevel@tonic-gate struct dirent *dep; /* directory entry pointer */
65045916cd2Sjpk int i, j;
6517c478bd9Sstevel@tonic-gate char *nm; /* name/device of special device */
6527c478bd9Sstevel@tonic-gate char linkvalue[2048]; /* symlink value */
6537c478bd9Sstevel@tonic-gate struct stat stat; /* determine if it's a symlink */
6547c478bd9Sstevel@tonic-gate int sz; /* size of symlink value */
6557c478bd9Sstevel@tonic-gate char *cp; /* pointer into string */
6567c478bd9Sstevel@tonic-gate int nfp; /* max array size */
65745916cd2Sjpk int floppy_count = 0;
65845916cd2Sjpk int first = 0;
65945916cd2Sjpk char *dname, *dclean;
66045916cd2Sjpk da_args dargs;
66145916cd2Sjpk deventry_t *entry;
6627c478bd9Sstevel@tonic-gate
6637c478bd9Sstevel@tonic-gate nfp = DFLT_NFP;
6647c478bd9Sstevel@tonic-gate
6657c478bd9Sstevel@tonic-gate /*
6667c478bd9Sstevel@tonic-gate * look for fd* and rfd*
6677c478bd9Sstevel@tonic-gate */
6687c478bd9Sstevel@tonic-gate
6697c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev")) == NULL) {
6707c478bd9Sstevel@tonic-gate perror(gettext("open /dev failure"));
6717c478bd9Sstevel@tonic-gate exit(1);
6727c478bd9Sstevel@tonic-gate }
6737c478bd9Sstevel@tonic-gate
6747c478bd9Sstevel@tonic-gate i = 0;
6757c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
6767c478bd9Sstevel@tonic-gate /* ignore if neither rst* nor nrst* */
6777c478bd9Sstevel@tonic-gate if (strncmp(dep->d_name, "fd0", SIZE_OF_FD0) &&
6787c478bd9Sstevel@tonic-gate strncmp(dep->d_name, "rfd0", SIZE_OF_RFD0) &&
6797c478bd9Sstevel@tonic-gate strncmp(dep->d_name, "fd1", SIZE_OF_FD0) &&
6807c478bd9Sstevel@tonic-gate strncmp(dep->d_name, "rfd0", SIZE_OF_RFD0))
6817c478bd9Sstevel@tonic-gate continue;
6827c478bd9Sstevel@tonic-gate
6837c478bd9Sstevel@tonic-gate /* if array full, then expand it */
6847c478bd9Sstevel@tonic-gate if (i == nfp) {
6857c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
6867c478bd9Sstevel@tonic-gate nfp = expandmem(i, (void **)&fp, sizeof (struct fp));
6877c478bd9Sstevel@tonic-gate }
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate /* save name (/dev + 1 + d_name + \0) */
6907c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_TMP + 1 + strlen(dep->d_name) + 1);
6917c478bd9Sstevel@tonic-gate if (nm == NULL)
6927c478bd9Sstevel@tonic-gate no_memory();
6937c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/");
6947c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
6957c478bd9Sstevel@tonic-gate fp[i].name = nm;
6967c478bd9Sstevel@tonic-gate
6977c478bd9Sstevel@tonic-gate /* ignore if not symbolic link (note i not incremented) */
6987c478bd9Sstevel@tonic-gate if (lstat(fp[i].name, &stat) < 0) {
6997c478bd9Sstevel@tonic-gate perror(gettext("stat(2) failed "));
7007c478bd9Sstevel@tonic-gate exit(1);
7017c478bd9Sstevel@tonic-gate }
7027c478bd9Sstevel@tonic-gate if ((stat.st_mode&S_IFMT) != S_IFLNK)
7037c478bd9Sstevel@tonic-gate continue;
7047c478bd9Sstevel@tonic-gate
7057c478bd9Sstevel@tonic-gate /* get name from symbolic link */
7067c478bd9Sstevel@tonic-gate if ((sz = readlink(fp[i].name, linkvalue,
7077c478bd9Sstevel@tonic-gate sizeof (linkvalue))) < 0)
7087c478bd9Sstevel@tonic-gate continue;
7097c478bd9Sstevel@tonic-gate nm = (char *)malloc(sz+1);
7107c478bd9Sstevel@tonic-gate if (nm == NULL)
7117c478bd9Sstevel@tonic-gate no_memory();
7127c478bd9Sstevel@tonic-gate (void) strncpy(nm, linkvalue, sz);
7137c478bd9Sstevel@tonic-gate nm[sz] = '\0';
7147c478bd9Sstevel@tonic-gate fp[i].device = nm;
7157c478bd9Sstevel@tonic-gate
7167c478bd9Sstevel@tonic-gate /* get device number */
7177c478bd9Sstevel@tonic-gate cp = strchr(fp[i].name, 'd');
7187c478bd9Sstevel@tonic-gate cp++; /* advance to device # */
7197c478bd9Sstevel@tonic-gate cp = strchr(cp, 'd');
7207c478bd9Sstevel@tonic-gate cp++; /* advance to device # */
7217c478bd9Sstevel@tonic-gate (void) sscanf(cp, "%d", &fp[i].number);
7227c478bd9Sstevel@tonic-gate
7237c478bd9Sstevel@tonic-gate i++;
7247c478bd9Sstevel@tonic-gate }
7257c478bd9Sstevel@tonic-gate
7267c478bd9Sstevel@tonic-gate (void) closedir(dirp);
7277c478bd9Sstevel@tonic-gate
72845916cd2Sjpk floppy_count = i;
7297c478bd9Sstevel@tonic-gate
73045916cd2Sjpk /* print out device_allocate entries for floppy devices */
73145916cd2Sjpk if (system_labeled) {
73245916cd2Sjpk dname = DA_FLOPPY_NAME;
73345916cd2Sjpk dclean = DA_DEFAULT_DISK_CLEAN;
73445916cd2Sjpk } else {
73545916cd2Sjpk dname = "fd";
73645916cd2Sjpk dclean = FLOPPY_CLEAN;
73745916cd2Sjpk }
7387c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) {
73945916cd2Sjpk for (j = 0; j < floppy_count; j++) {
74045916cd2Sjpk if (fp[j].number != i)
74145916cd2Sjpk continue;
74245916cd2Sjpk if (do_files) {
74345916cd2Sjpk (void) da_add_list(&devlist, fp[j].name, i,
74445916cd2Sjpk DA_FLOPPY);
74545916cd2Sjpk } else if (do_devalloc) {
74645916cd2Sjpk /* print device_allocate for floppy devices */
74745916cd2Sjpk if (system_labeled) {
74845916cd2Sjpk (void) printf("%s%d%s\\\n",
74945916cd2Sjpk dname, i, KV_DELIMITER);
75045916cd2Sjpk (void) printf("\t%s%s\\\n",
75145916cd2Sjpk DA_FLOPPY_TYPE, KV_DELIMITER);
75245916cd2Sjpk (void) printf("\t%s%s\\\n",
75345916cd2Sjpk DA_RESERVED, KV_DELIMITER);
75445916cd2Sjpk (void) printf("\t%s%s\\\n",
75545916cd2Sjpk DA_RESERVED, KV_DELIMITER);
75645916cd2Sjpk (void) printf("\t%s%s\\\n",
75745916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH,
75845916cd2Sjpk KV_DELIMITER);
75945916cd2Sjpk (void) printf("\t%s\n\n", dclean);
76045916cd2Sjpk } else {
76145916cd2Sjpk (void) printf(
76245916cd2Sjpk "fd%d;fd;reserved;reserved;%s;",
76345916cd2Sjpk i, DEFAULT_DEV_ALLOC_AUTH);
76445916cd2Sjpk (void) printf("%s%s\n", SECLIB,
76545916cd2Sjpk "/fd_clean");
76645916cd2Sjpk }
76745916cd2Sjpk break;
76845916cd2Sjpk } else if (do_devmaps) {
76945916cd2Sjpk /* print device_maps for floppy devices */
77045916cd2Sjpk if (first) {
77145916cd2Sjpk (void) printf(" ");
77245916cd2Sjpk } else {
77345916cd2Sjpk if (system_labeled) {
77445916cd2Sjpk (void) printf("%s%d%s\\\n",
77545916cd2Sjpk dname, i, KV_TOKEN_DELIMIT);
77645916cd2Sjpk (void) printf("\t%s%s\\\n",
77745916cd2Sjpk DA_FLOPPY_TYPE,
77845916cd2Sjpk KV_TOKEN_DELIMIT);
77945916cd2Sjpk (void) printf("\t");
78045916cd2Sjpk } else {
78145916cd2Sjpk (void) printf("fd%d:\\\n", i);
78245916cd2Sjpk (void) printf("\tfd:\\\n");
78345916cd2Sjpk (void) printf("\t");
78445916cd2Sjpk }
78545916cd2Sjpk if (i == 0) {
78645916cd2Sjpk (void) printf("/dev/diskette ");
78745916cd2Sjpk (void) printf(
78845916cd2Sjpk "/dev/rdiskette ");
78945916cd2Sjpk }
79045916cd2Sjpk first++;
79145916cd2Sjpk }
79245916cd2Sjpk (void) printf("%s", fp[j].name);
79345916cd2Sjpk }
79445916cd2Sjpk }
79545916cd2Sjpk if (do_devmaps && first) {
79645916cd2Sjpk (void) printf("\n\n");
79745916cd2Sjpk first = 0;
79845916cd2Sjpk }
79945916cd2Sjpk }
80045916cd2Sjpk if (do_files && floppy_count) {
80145916cd2Sjpk dargs.rootdir = NULL;
80245916cd2Sjpk dargs.devnames = NULL;
80345916cd2Sjpk dargs.optflag = DA_ADD;
80445916cd2Sjpk for (entry = devlist.floppy; entry != NULL;
80545916cd2Sjpk entry = entry->next) {
80645916cd2Sjpk dargs.devinfo = &(entry->devinfo);
80745916cd2Sjpk (void) da_update_device(&dargs);
8087c478bd9Sstevel@tonic-gate }
8097c478bd9Sstevel@tonic-gate }
8107c478bd9Sstevel@tonic-gate }
8117c478bd9Sstevel@tonic-gate
81245916cd2Sjpk static int
docd()8137c478bd9Sstevel@tonic-gate docd()
8147c478bd9Sstevel@tonic-gate {
8157c478bd9Sstevel@tonic-gate DIR *dirp;
8167c478bd9Sstevel@tonic-gate struct dirent *dep; /* directory entry pointer */
81745916cd2Sjpk int i, j;
8187c478bd9Sstevel@tonic-gate char *nm; /* name/device of special device */
8197c478bd9Sstevel@tonic-gate char linkvalue[2048]; /* symlink value */
8207c478bd9Sstevel@tonic-gate struct stat stat; /* determine if it's a symlink */
8217c478bd9Sstevel@tonic-gate int sz; /* size of symlink value */
8227c478bd9Sstevel@tonic-gate char *cp; /* pointer into string */
8237c478bd9Sstevel@tonic-gate int id; /* disk id */
8247c478bd9Sstevel@tonic-gate int ctrl; /* disk controller */
8257c478bd9Sstevel@tonic-gate int ncd; /* max array size */
82645916cd2Sjpk int cd_count = 0;
82745916cd2Sjpk int first = 0;
82845916cd2Sjpk char *dname, *dclean;
82945916cd2Sjpk da_args dargs;
83045916cd2Sjpk deventry_t *entry;
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate ncd = DFLT_NCD;
8337c478bd9Sstevel@tonic-gate
8347c478bd9Sstevel@tonic-gate /*
8357c478bd9Sstevel@tonic-gate * look for sr* and rsr*
8367c478bd9Sstevel@tonic-gate */
8377c478bd9Sstevel@tonic-gate
8387c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev")) == NULL) {
8397c478bd9Sstevel@tonic-gate perror(gettext("open /dev failure"));
8407c478bd9Sstevel@tonic-gate exit(1);
8417c478bd9Sstevel@tonic-gate }
8427c478bd9Sstevel@tonic-gate
8437c478bd9Sstevel@tonic-gate i = 0;
8447c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
8457c478bd9Sstevel@tonic-gate /* ignore if neither sr* nor rsr* */
8467c478bd9Sstevel@tonic-gate if (strncmp(dep->d_name, "sr", SIZE_OF_SR) &&
8477c478bd9Sstevel@tonic-gate strncmp(dep->d_name, "rsr", SIZE_OF_RSR))
8487c478bd9Sstevel@tonic-gate continue;
8497c478bd9Sstevel@tonic-gate
8507c478bd9Sstevel@tonic-gate /* if array full, then expand it */
8517c478bd9Sstevel@tonic-gate if (i == ncd) {
8527c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
8537c478bd9Sstevel@tonic-gate ncd = expandmem(i, (void **)&cd, sizeof (struct cd));
8547c478bd9Sstevel@tonic-gate }
8557c478bd9Sstevel@tonic-gate
8567c478bd9Sstevel@tonic-gate /* save name (/dev + / + d_name + \0) */
8577c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_TMP + 1 + strlen(dep->d_name) + 1);
8587c478bd9Sstevel@tonic-gate if (nm == NULL)
8597c478bd9Sstevel@tonic-gate no_memory();
8607c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/");
8617c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
8627c478bd9Sstevel@tonic-gate cd[i].name = nm;
8637c478bd9Sstevel@tonic-gate
8647c478bd9Sstevel@tonic-gate /* ignore if not symbolic link (note i not incremented) */
8657c478bd9Sstevel@tonic-gate if (lstat(cd[i].name, &stat) < 0) {
8667c478bd9Sstevel@tonic-gate perror(gettext("stat(2) failed "));
8677c478bd9Sstevel@tonic-gate exit(1);
8687c478bd9Sstevel@tonic-gate }
8697c478bd9Sstevel@tonic-gate if ((stat.st_mode & S_IFMT) != S_IFLNK)
8707c478bd9Sstevel@tonic-gate continue;
8717c478bd9Sstevel@tonic-gate
8727c478bd9Sstevel@tonic-gate /* get name from symbolic link */
8737c478bd9Sstevel@tonic-gate if ((sz = readlink(cd[i].name, linkvalue, sizeof (linkvalue))) <
8747c478bd9Sstevel@tonic-gate 0)
8757c478bd9Sstevel@tonic-gate continue;
87645916cd2Sjpk
8777c478bd9Sstevel@tonic-gate nm = (char *)malloc(sz + 1);
8787c478bd9Sstevel@tonic-gate if (nm == NULL)
8797c478bd9Sstevel@tonic-gate no_memory();
8807c478bd9Sstevel@tonic-gate (void) strncpy(nm, linkvalue, sz);
8817c478bd9Sstevel@tonic-gate nm[sz] = '\0';
8827c478bd9Sstevel@tonic-gate cd[i].device = nm;
8837c478bd9Sstevel@tonic-gate
8847c478bd9Sstevel@tonic-gate cp = strrchr(cd[i].device, '/');
8857c478bd9Sstevel@tonic-gate cp++; /* advance to device # */
8867c478bd9Sstevel@tonic-gate (void) sscanf(cp, "c%dt%d", &cd[i].controller, &cd[i].number);
8871bf2a5e5Saj cd[i].id = cd[i].number;
8887c478bd9Sstevel@tonic-gate
8897c478bd9Sstevel@tonic-gate i++;
8907c478bd9Sstevel@tonic-gate }
89145916cd2Sjpk cd_count = i;
8927c478bd9Sstevel@tonic-gate
8937c478bd9Sstevel@tonic-gate (void) closedir(dirp);
8947c478bd9Sstevel@tonic-gate
8957c478bd9Sstevel@tonic-gate /*
8967c478bd9Sstevel@tonic-gate * scan /dev/dsk for cd devices
8977c478bd9Sstevel@tonic-gate */
8987c478bd9Sstevel@tonic-gate
8997c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev/dsk")) == NULL) {
9007c478bd9Sstevel@tonic-gate perror("gettext(open /dev/dsk failure)");
9017c478bd9Sstevel@tonic-gate exit(1);
9027c478bd9Sstevel@tonic-gate }
9037c478bd9Sstevel@tonic-gate
9047c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
9057c478bd9Sstevel@tonic-gate /* skip . .. etc... */
906*98e97357SToomas Soome if (strncmp(dep->d_name, ".", 1) == 0)
9077c478bd9Sstevel@tonic-gate continue;
9087c478bd9Sstevel@tonic-gate
9097c478bd9Sstevel@tonic-gate /* get device # (disk #) */
9107e3e5701SJan Parcel if (sscanf(dep->d_name, "c%dt%d", &ctrl, &id) != 2)
9117c478bd9Sstevel@tonic-gate continue;
9127c478bd9Sstevel@tonic-gate
9137c478bd9Sstevel@tonic-gate /* see if this is one of the cd special devices */
91445916cd2Sjpk for (j = 0; j < cd_count; j++) {
9157c478bd9Sstevel@tonic-gate if (cd[j].number == id && cd[j].controller == ctrl)
9167c478bd9Sstevel@tonic-gate goto found;
9177c478bd9Sstevel@tonic-gate }
9187c478bd9Sstevel@tonic-gate continue;
9197c478bd9Sstevel@tonic-gate
9207c478bd9Sstevel@tonic-gate /* add new entry to table (/dev/dsk + / + d_name + \0) */
9217c478bd9Sstevel@tonic-gate found:
9227c478bd9Sstevel@tonic-gate /* if array full, then expand it */
9237c478bd9Sstevel@tonic-gate if (i == ncd) {
9247c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
9257c478bd9Sstevel@tonic-gate ncd = expandmem(i, (void **)&cd, sizeof (struct cd));
9267c478bd9Sstevel@tonic-gate }
9277c478bd9Sstevel@tonic-gate
9287c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_DSK + 1 + strlen(dep->d_name) + 1);
9297c478bd9Sstevel@tonic-gate if (nm == NULL)
9307c478bd9Sstevel@tonic-gate no_memory();
9317c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/dsk/");
9327c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
9337c478bd9Sstevel@tonic-gate cd[i].name = nm;
9347c478bd9Sstevel@tonic-gate
9357c478bd9Sstevel@tonic-gate cd[i].id = cd[j].id;
9367c478bd9Sstevel@tonic-gate
9377c478bd9Sstevel@tonic-gate cd[i].device = "";
9387c478bd9Sstevel@tonic-gate
9397c478bd9Sstevel@tonic-gate cd[i].number = id;
9407c478bd9Sstevel@tonic-gate
9417c478bd9Sstevel@tonic-gate i++;
9427c478bd9Sstevel@tonic-gate }
9437c478bd9Sstevel@tonic-gate
9447c478bd9Sstevel@tonic-gate (void) closedir(dirp);
9457c478bd9Sstevel@tonic-gate
9467c478bd9Sstevel@tonic-gate /*
9477c478bd9Sstevel@tonic-gate * scan /dev/rdsk for cd devices
9487c478bd9Sstevel@tonic-gate */
9497c478bd9Sstevel@tonic-gate
9507c478bd9Sstevel@tonic-gate if ((dirp = opendir("/dev/rdsk")) == NULL) {
9517c478bd9Sstevel@tonic-gate perror(gettext("open /dev/dsk failure"));
9527c478bd9Sstevel@tonic-gate exit(1);
9537c478bd9Sstevel@tonic-gate }
9547c478bd9Sstevel@tonic-gate
9557c478bd9Sstevel@tonic-gate while (dep = readdir(dirp)) {
9567c478bd9Sstevel@tonic-gate /* skip . .. etc... */
957*98e97357SToomas Soome if (strncmp(dep->d_name, ".", 1) == 0)
9587c478bd9Sstevel@tonic-gate continue;
9597c478bd9Sstevel@tonic-gate
9607c478bd9Sstevel@tonic-gate /* get device # (disk #) */
9617c478bd9Sstevel@tonic-gate if (sscanf(dep->d_name, "c%dt%d", &ctrl, &id) != 2)
9627c478bd9Sstevel@tonic-gate continue;
9637c478bd9Sstevel@tonic-gate
9647c478bd9Sstevel@tonic-gate /* see if this is one of the cd special devices */
96545916cd2Sjpk for (j = 0; j < cd_count; j++) {
9667c478bd9Sstevel@tonic-gate if (cd[j].number == id && cd[j].controller == ctrl)
9677c478bd9Sstevel@tonic-gate goto found1;
9687c478bd9Sstevel@tonic-gate }
9697c478bd9Sstevel@tonic-gate continue;
9707c478bd9Sstevel@tonic-gate
9717c478bd9Sstevel@tonic-gate /* add new entry to table (/dev/rdsk + / + d_name + \0) */
9727c478bd9Sstevel@tonic-gate found1:
9737c478bd9Sstevel@tonic-gate /* if array full, then expand it */
9747c478bd9Sstevel@tonic-gate if (i == ncd) {
9757c478bd9Sstevel@tonic-gate /* will exit(1) if insufficient memory */
9767c478bd9Sstevel@tonic-gate ncd = expandmem(i, (void **)&cd, sizeof (struct cd));
9777c478bd9Sstevel@tonic-gate }
9787c478bd9Sstevel@tonic-gate
9797c478bd9Sstevel@tonic-gate nm = (char *)malloc(SIZE_OF_RDSK + 1 + strlen(dep->d_name) + 1);
9807c478bd9Sstevel@tonic-gate if (nm == NULL)
9817c478bd9Sstevel@tonic-gate no_memory();
9827c478bd9Sstevel@tonic-gate (void) strcpy(nm, "/dev/rdsk/");
9837c478bd9Sstevel@tonic-gate (void) strcat(nm, dep->d_name);
9847c478bd9Sstevel@tonic-gate cd[i].name = nm;
9857c478bd9Sstevel@tonic-gate
9867c478bd9Sstevel@tonic-gate cd[i].id = cd[j].id;
9877c478bd9Sstevel@tonic-gate
9887c478bd9Sstevel@tonic-gate cd[i].device = "";
9897c478bd9Sstevel@tonic-gate
9907c478bd9Sstevel@tonic-gate cd[i].number = id;
9917c478bd9Sstevel@tonic-gate
9927c478bd9Sstevel@tonic-gate cd[i].controller = ctrl;
9937c478bd9Sstevel@tonic-gate
9947c478bd9Sstevel@tonic-gate i++;
9957c478bd9Sstevel@tonic-gate }
9967c478bd9Sstevel@tonic-gate
9977c478bd9Sstevel@tonic-gate (void) closedir(dirp);
9987c478bd9Sstevel@tonic-gate
99945916cd2Sjpk cd_count = i;
100045916cd2Sjpk
100145916cd2Sjpk if (system_labeled) {
100245916cd2Sjpk dname = DA_CD_NAME;
100345916cd2Sjpk dclean = DA_DEFAULT_DISK_CLEAN;
100445916cd2Sjpk } else {
100545916cd2Sjpk dname = "sr";
100645916cd2Sjpk dclean = CD_CLEAN;
100745916cd2Sjpk }
100845916cd2Sjpk for (i = 0; i < 8; i++) {
100945916cd2Sjpk for (j = 0; j < cd_count; j++) {
101045916cd2Sjpk if (cd[j].id != i)
101145916cd2Sjpk continue;
101245916cd2Sjpk if (do_files) {
101345916cd2Sjpk (void) da_add_list(&devlist, cd[j].name, i,
101445916cd2Sjpk DA_CD);
101545916cd2Sjpk } else if (do_devalloc) {
101645916cd2Sjpk /* print device_allocate for cd devices */
101745916cd2Sjpk if (system_labeled) {
101845916cd2Sjpk (void) printf("%s%d%s\\\n",
101945916cd2Sjpk dname, i, KV_DELIMITER);
102045916cd2Sjpk (void) printf("\t%s%s\\\n",
102145916cd2Sjpk DA_CD_TYPE, KV_DELIMITER);
102245916cd2Sjpk (void) printf("\t%s%s\\\n",
102345916cd2Sjpk DA_RESERVED, KV_DELIMITER);
102445916cd2Sjpk (void) printf("\t%s%s\\\n",
102545916cd2Sjpk DA_RESERVED, KV_DELIMITER);
102645916cd2Sjpk (void) printf("\t%s%s\\\n",
102745916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH,
102845916cd2Sjpk KV_DELIMITER);
102945916cd2Sjpk (void) printf("\t%s\n\n", dclean);
103045916cd2Sjpk } else {
103145916cd2Sjpk (void) printf(
103245916cd2Sjpk "sr%d;sr;reserved;reserved;%s;",
103345916cd2Sjpk i, DEFAULT_DEV_ALLOC_AUTH);
103445916cd2Sjpk (void) printf("%s%s\n", SECLIB,
103545916cd2Sjpk "/sr_clean");
103645916cd2Sjpk }
103745916cd2Sjpk break;
103845916cd2Sjpk } else if (do_devmaps) {
103945916cd2Sjpk /* print device_maps for cd devices */
104045916cd2Sjpk if (first) {
104145916cd2Sjpk (void) printf(" ");
104245916cd2Sjpk } else {
104345916cd2Sjpk if (system_labeled) {
104445916cd2Sjpk (void) printf("%s%d%s\\\n",
104545916cd2Sjpk dname, i, KV_TOKEN_DELIMIT);
104645916cd2Sjpk (void) printf("\t%s%s\\\n",
104745916cd2Sjpk DA_CD_TYPE,
104845916cd2Sjpk KV_TOKEN_DELIMIT);
104945916cd2Sjpk (void) printf("\t");
105045916cd2Sjpk } else {
105145916cd2Sjpk (void) printf("sr%d:\\\n", i);
105245916cd2Sjpk (void) printf("\tsr:\\\n");
105345916cd2Sjpk (void) printf("\t");
105445916cd2Sjpk }
105545916cd2Sjpk first++;
105645916cd2Sjpk }
105745916cd2Sjpk (void) printf("%s", cd[j].name);
105845916cd2Sjpk }
105945916cd2Sjpk }
106045916cd2Sjpk if (do_devmaps && first) {
106145916cd2Sjpk (void) printf("\n\n");
106245916cd2Sjpk first = 0;
106345916cd2Sjpk }
106445916cd2Sjpk }
106545916cd2Sjpk if (do_files && cd_count) {
106645916cd2Sjpk dargs.rootdir = NULL;
106745916cd2Sjpk dargs.devnames = NULL;
106845916cd2Sjpk dargs.optflag = DA_ADD;
106945916cd2Sjpk for (entry = devlist.cd; entry != NULL; entry = entry->next) {
107045916cd2Sjpk dargs.devinfo = &(entry->devinfo);
107145916cd2Sjpk (void) da_update_device(&dargs);
107245916cd2Sjpk }
107345916cd2Sjpk }
107445916cd2Sjpk
107545916cd2Sjpk return (cd_count);
107645916cd2Sjpk }
107745916cd2Sjpk
107845916cd2Sjpk static void
dormdisk(int cd_count)107945916cd2Sjpk dormdisk(int cd_count)
108045916cd2Sjpk {
108145916cd2Sjpk DIR *dirp;
108245916cd2Sjpk struct dirent *dep; /* directory entry pointer */
108345916cd2Sjpk int i, j;
108445916cd2Sjpk char *nm; /* name/device of special device */
108545916cd2Sjpk int id; /* disk id */
108645916cd2Sjpk int ctrl; /* disk controller */
108745916cd2Sjpk int nrmdisk; /* max array size */
108845916cd2Sjpk int fd = -1;
108945916cd2Sjpk int rmdisk_count;
109045916cd2Sjpk int first = 0;
109145916cd2Sjpk int is_cd;
109245916cd2Sjpk int checked;
109345916cd2Sjpk int removable;
109445916cd2Sjpk char path[MAXPATHLEN];
109545916cd2Sjpk da_args dargs;
109645916cd2Sjpk deventry_t *entry;
109745916cd2Sjpk
109845916cd2Sjpk nrmdisk = DFLT_RMDISK;
109945916cd2Sjpk i = rmdisk_count = 0;
110045916cd2Sjpk
110145916cd2Sjpk /*
110245916cd2Sjpk * scan /dev/dsk for rmdisk devices
110345916cd2Sjpk */
110445916cd2Sjpk if ((dirp = opendir("/dev/dsk")) == NULL) {
110545916cd2Sjpk perror("gettext(open /dev/dsk failure)");
110645916cd2Sjpk exit(1);
110745916cd2Sjpk }
110845916cd2Sjpk
110945916cd2Sjpk while (dep = readdir(dirp)) {
111045916cd2Sjpk is_cd = 0;
111145916cd2Sjpk checked = 0;
111245916cd2Sjpk removable = 0;
111345916cd2Sjpk /* skip . .. etc... */
1114*98e97357SToomas Soome if (strncmp(dep->d_name, ".", 1) == 0)
111545916cd2Sjpk continue;
111645916cd2Sjpk
111745916cd2Sjpk /* get device # (disk #) */
11187e3e5701SJan Parcel if (sscanf(dep->d_name, "c%dt%d", &ctrl, &id) != 2)
111945916cd2Sjpk continue;
112045916cd2Sjpk
112145916cd2Sjpk /* see if we've already examined this device */
112245916cd2Sjpk for (j = 0; j < i; j++) {
112345916cd2Sjpk if (id == rmdisk[j].id &&
112445916cd2Sjpk ctrl == rmdisk[j].controller &&
112545916cd2Sjpk (strcmp(dep->d_name, rmdisk[j].name) == 0)) {
112645916cd2Sjpk checked = 1;
112745916cd2Sjpk break;
112845916cd2Sjpk }
112945916cd2Sjpk if (id == rmdisk[j].id && ctrl != rmdisk[j].controller)
113045916cd2Sjpk /*
113145916cd2Sjpk * c2t0d0s0 is a different rmdisk than c3t0d0s0.
113245916cd2Sjpk */
113345916cd2Sjpk id = rmdisk[j].id + 1;
113445916cd2Sjpk }
113545916cd2Sjpk if (checked)
113645916cd2Sjpk continue;
113745916cd2Sjpk
113845916cd2Sjpk /* ignore if this is a cd */
113945916cd2Sjpk for (j = 0; j < cd_count; j++) {
11401bf2a5e5Saj if (id == cd[j].id && ctrl == cd[j].controller) {
114145916cd2Sjpk is_cd = 1;
114245916cd2Sjpk break;
114345916cd2Sjpk }
114445916cd2Sjpk }
114545916cd2Sjpk if (is_cd)
114645916cd2Sjpk continue;
114745916cd2Sjpk
114845916cd2Sjpk /* see if device is removable */
114945916cd2Sjpk (void) snprintf(path, sizeof (path), "%s%s", "/dev/rdsk/",
115045916cd2Sjpk dep->d_name);
115145916cd2Sjpk if ((fd = open(path, O_RDONLY | O_NONBLOCK)) < 0)
115245916cd2Sjpk continue;
115345916cd2Sjpk (void) ioctl(fd, DKIOCREMOVABLE, &removable);
115445916cd2Sjpk (void) close(fd);
115545916cd2Sjpk if (removable == 0)
115645916cd2Sjpk continue;
115745916cd2Sjpk
115845916cd2Sjpk /*
115945916cd2Sjpk * add new entry to table (/dev/dsk + / + d_name + \0)
116045916cd2Sjpk * if array full, then expand it
116145916cd2Sjpk */
116245916cd2Sjpk if (i == nrmdisk) {
116345916cd2Sjpk /* will exit(1) if insufficient memory */
116445916cd2Sjpk nrmdisk = expandmem(i, (void **)&rmdisk,
116545916cd2Sjpk sizeof (struct rmdisk));
11667e3e5701SJan Parcel /* When we expand rmdisk, need to expand rmdisk_r */
11677e3e5701SJan Parcel (void) expandmem(i, (void **)&rmdisk_r,
11687e3e5701SJan Parcel sizeof (struct rmdisk));
116945916cd2Sjpk }
117045916cd2Sjpk nm = (char *)malloc(SIZE_OF_DSK + 1 + strlen(dep->d_name) + 1);
117145916cd2Sjpk if (nm == NULL)
117245916cd2Sjpk no_memory();
117345916cd2Sjpk (void) strcpy(nm, "/dev/dsk/");
117445916cd2Sjpk (void) strcat(nm, dep->d_name);
117545916cd2Sjpk rmdisk[i].name = nm;
117645916cd2Sjpk rmdisk[i].id = id;
117745916cd2Sjpk rmdisk[i].controller = ctrl;
117845916cd2Sjpk rmdisk[i].device = "";
117945916cd2Sjpk rmdisk[i].number = id;
118045916cd2Sjpk rmdisk_r[i].name = strdup(path);
118145916cd2Sjpk i++;
118245916cd2Sjpk }
118345916cd2Sjpk
118445916cd2Sjpk rmdisk_count = i;
118545916cd2Sjpk (void) closedir(dirp);
118645916cd2Sjpk
118745916cd2Sjpk for (i = 0, j = rmdisk_count; i < rmdisk_count; i++, j++) {
118845916cd2Sjpk if (j == nrmdisk) {
118945916cd2Sjpk /* will exit(1) if insufficient memory */
119045916cd2Sjpk nrmdisk = expandmem(j, (void **)&rmdisk,
119145916cd2Sjpk sizeof (struct rmdisk));
119245916cd2Sjpk }
119345916cd2Sjpk rmdisk[j].name = rmdisk_r[i].name;
119445916cd2Sjpk rmdisk[j].id = rmdisk[i].id;
119545916cd2Sjpk rmdisk[j].controller = rmdisk[i].controller;
119645916cd2Sjpk rmdisk[j].device = rmdisk[i].device;
119745916cd2Sjpk rmdisk[j].number = rmdisk[i].number;
119845916cd2Sjpk }
119945916cd2Sjpk rmdisk_count = j;
12007c478bd9Sstevel@tonic-gate
12017c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) {
120245916cd2Sjpk for (j = 0; j < rmdisk_count; j++) {
120345916cd2Sjpk if (rmdisk[j].id != i)
120445916cd2Sjpk continue;
120545916cd2Sjpk if (do_files) {
120645916cd2Sjpk (void) da_add_list(&devlist, rmdisk[j].name, i,
120745916cd2Sjpk DA_RMDISK);
120845916cd2Sjpk } else if (do_devalloc) {
120945916cd2Sjpk /* print device_allocate for rmdisk devices */
121045916cd2Sjpk (void) printf("%s%d%s\\\n",
121145916cd2Sjpk DA_RMDISK_NAME, i, KV_DELIMITER);
121245916cd2Sjpk (void) printf("\t%s%s\\\n",
121345916cd2Sjpk DA_RMDISK_TYPE, KV_DELIMITER);
121445916cd2Sjpk (void) printf("\t%s%s\\\n",
121545916cd2Sjpk DA_RESERVED, KV_DELIMITER);
121645916cd2Sjpk (void) printf("\t%s%s\\\n",
121745916cd2Sjpk DA_RESERVED, KV_DELIMITER);
121845916cd2Sjpk (void) printf("\t%s%s\\\n",
121945916cd2Sjpk DEFAULT_DEV_ALLOC_AUTH, KV_DELIMITER);
122045916cd2Sjpk (void) printf("\t%s\n", DA_DEFAULT_DISK_CLEAN);
12217c478bd9Sstevel@tonic-gate break;
122245916cd2Sjpk } else if (do_devmaps) {
122345916cd2Sjpk /* print device_maps for rmdisk devices */
122445916cd2Sjpk if (first) {
122545916cd2Sjpk (void) printf(" ");
122645916cd2Sjpk } else {
122745916cd2Sjpk (void) printf("%s%d%s\\\n",
122845916cd2Sjpk DA_RMDISK_NAME, i,
122945916cd2Sjpk KV_TOKEN_DELIMIT);
123045916cd2Sjpk (void) printf("\t%s%s\\\n",
123145916cd2Sjpk DA_RMDISK_TYPE, KV_TOKEN_DELIMIT);
123245916cd2Sjpk (void) printf("\t");
123345916cd2Sjpk first++;
123445916cd2Sjpk }
123545916cd2Sjpk (void) printf("%s", rmdisk[j].name);
12367c478bd9Sstevel@tonic-gate }
12377c478bd9Sstevel@tonic-gate }
123845916cd2Sjpk if (do_devmaps && first) {
123945916cd2Sjpk (void) printf("\n\n");
124045916cd2Sjpk first = 0;
124145916cd2Sjpk }
124245916cd2Sjpk }
124345916cd2Sjpk if (do_files && rmdisk_count) {
124445916cd2Sjpk dargs.rootdir = NULL;
124545916cd2Sjpk dargs.devnames = NULL;
124645916cd2Sjpk dargs.optflag = DA_ADD;
124745916cd2Sjpk for (entry = devlist.rmdisk; entry != NULL;
124845916cd2Sjpk entry = entry->next) {
124945916cd2Sjpk dargs.devinfo = &(entry->devinfo);
125045916cd2Sjpk (void) da_update_device(&dargs);
125145916cd2Sjpk }
12527c478bd9Sstevel@tonic-gate }
12537c478bd9Sstevel@tonic-gate }
12547c478bd9Sstevel@tonic-gate
12557c478bd9Sstevel@tonic-gate /* set default array sizes */
12567c478bd9Sstevel@tonic-gate static void
initmem()12577c478bd9Sstevel@tonic-gate initmem()
12587c478bd9Sstevel@tonic-gate {
12597c478bd9Sstevel@tonic-gate tape = (struct tape *)calloc(DFLT_NTAPE, sizeof (struct tape));
12607c478bd9Sstevel@tonic-gate audio = (struct audio *)calloc(DFLT_NAUDIO, sizeof (struct audio));
12617c478bd9Sstevel@tonic-gate cd = (struct cd *)calloc(DFLT_NCD, sizeof (struct cd));
12627c478bd9Sstevel@tonic-gate fp = (struct fp *)calloc(DFLT_NFP, sizeof (struct fp));
126345916cd2Sjpk if (system_labeled) {
126445916cd2Sjpk rmdisk = (struct rmdisk *)calloc(DFLT_RMDISK,
126545916cd2Sjpk sizeof (struct rmdisk));
126645916cd2Sjpk if (rmdisk == NULL)
126745916cd2Sjpk no_memory();
126845916cd2Sjpk rmdisk_r = (struct rmdisk *)calloc(DFLT_RMDISK,
126945916cd2Sjpk sizeof (struct rmdisk));
127045916cd2Sjpk if (rmdisk_r == NULL)
127145916cd2Sjpk no_memory();
127245916cd2Sjpk }
12737c478bd9Sstevel@tonic-gate
12747c478bd9Sstevel@tonic-gate if (tape == NULL || audio == NULL || cd == NULL || fp == NULL)
12757c478bd9Sstevel@tonic-gate no_memory();
127645916cd2Sjpk
127745916cd2Sjpk devlist.audio = devlist.cd = devlist.floppy = devlist.rmdisk =
127845916cd2Sjpk devlist.tape = NULL;
12797c478bd9Sstevel@tonic-gate }
12807c478bd9Sstevel@tonic-gate
12817c478bd9Sstevel@tonic-gate /* note n will be # elments in array (and could be 0) */
12827c478bd9Sstevel@tonic-gate static int
expandmem(int n,void ** array,int size)12837c478bd9Sstevel@tonic-gate expandmem(int n, void **array, int size)
12847c478bd9Sstevel@tonic-gate {
12857c478bd9Sstevel@tonic-gate void *old = *array;
12867c478bd9Sstevel@tonic-gate void *new;
12877c478bd9Sstevel@tonic-gate
12887c478bd9Sstevel@tonic-gate /* get new array space (n + DELTA) */
12897c478bd9Sstevel@tonic-gate new = (void *)calloc(n + DELTA, size);
12907c478bd9Sstevel@tonic-gate
12917c478bd9Sstevel@tonic-gate if (new == NULL) {
12927c478bd9Sstevel@tonic-gate perror("memory allocation failed");
12937c478bd9Sstevel@tonic-gate exit(1);
12947c478bd9Sstevel@tonic-gate }
12957c478bd9Sstevel@tonic-gate
12967c478bd9Sstevel@tonic-gate /* copy old array into new space */
12977c478bd9Sstevel@tonic-gate bcopy(old, new, n * size);
12987c478bd9Sstevel@tonic-gate
12997c478bd9Sstevel@tonic-gate /* now release old arrary */
13007c478bd9Sstevel@tonic-gate free(old);
13017c478bd9Sstevel@tonic-gate
13027c478bd9Sstevel@tonic-gate *array = new;
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate return (n + DELTA);
13057c478bd9Sstevel@tonic-gate }
13067c478bd9Sstevel@tonic-gate
13077c478bd9Sstevel@tonic-gate static void
no_memory(void)13087c478bd9Sstevel@tonic-gate no_memory(void)
13097c478bd9Sstevel@tonic-gate {
13107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s\n", "mkdevalloc",
13117c478bd9Sstevel@tonic-gate gettext("out of memory"));
13127c478bd9Sstevel@tonic-gate exit(1);
13137c478bd9Sstevel@tonic-gate /* NOT REACHED */
13147c478bd9Sstevel@tonic-gate }
1315