1 /* $NetBSD: eject.c,v 1.22 2008/07/21 14:19:22 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Chris Jones. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1999\ 35 The NetBSD Foundation, Inc. All rights reserved."); 36 #endif /* not lint */ 37 38 #ifndef lint 39 __RCSID("$NetBSD: eject.c,v 1.22 2008/07/21 14:19:22 lukem Exp $"); 40 #endif /* not lint */ 41 42 #include <sys/types.h> 43 #include <sys/cdio.h> 44 #include <sys/disklabel.h> 45 #include <sys/ioctl.h> 46 #include <sys/param.h> 47 #include <sys/ucred.h> 48 #include <sys/mount.h> 49 #include <sys/mtio.h> 50 51 #include <ctype.h> 52 #include <err.h> 53 #include <fcntl.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <unistd.h> 58 #include <util.h> 59 60 struct nicknames_s { 61 char *name; /* The name given on the command line. */ 62 char *devname; /* The base name of the device */ 63 int type; /* The type of device, for determining what 64 * ioctl to use. */ 65 #define TAPE 0x10 66 #define DISK 0x20 67 /* OR one of the above with one of the below: */ 68 #define NOTLOADABLE 0x00 69 #define LOADABLE 0x01 70 #define FLOPPY 0x2 71 #define TYPEMASK ((int)~0x01) 72 } nicknames[] = { 73 { "diskette", "fd", DISK | FLOPPY | NOTLOADABLE }, 74 { "floppy", "fd", DISK | FLOPPY | NOTLOADABLE }, 75 { "fd", "fd", DISK | FLOPPY | NOTLOADABLE }, 76 { "sd", "sd", DISK | NOTLOADABLE }, 77 { "cdrom", "cd", DISK | LOADABLE }, 78 { "cd", "cd", DISK | LOADABLE }, 79 { "cdr", "cd", DISK | LOADABLE }, 80 { "cdrw", "cd", DISK | LOADABLE }, 81 { "dvdrom", "cd", DISK | LOADABLE }, 82 { "dvd", "cd", DISK | LOADABLE }, 83 { "dvdr", "cd", DISK | LOADABLE }, 84 { "dvdrw", "cd", DISK | LOADABLE }, 85 { "mcd", "mcd", DISK | LOADABLE }, /* XXX Is this true? */ 86 { "tape", "st", TAPE | NOTLOADABLE }, 87 { "st", "st", TAPE | NOTLOADABLE }, 88 { "dat", "st", TAPE | NOTLOADABLE }, 89 { "exabyte", "st", TAPE | NOTLOADABLE }, 90 }; 91 #define MAXNICKLEN 12 /* at least enough room for the longest 92 * nickname */ 93 #define MAXDEVLEN (MAXNICKLEN + 7) /* "/dev/r" ... "a" */ 94 95 struct devtypes_s { 96 char *name; 97 int type; 98 } devtypes[] = { 99 { "diskette", DISK | NOTLOADABLE }, 100 { "floppy", DISK | NOTLOADABLE }, 101 { "cdrom", DISK | LOADABLE }, 102 { "disk", DISK | NOTLOADABLE }, 103 { "tape", TAPE | NOTLOADABLE }, 104 }; 105 106 enum eject_op { 107 OP_EJECT, OP_LOAD, OP_LOCK, OP_UNLOCK 108 }; 109 110 int verbose_f = 0; 111 int umount_f = 1; 112 113 int main(int, char *[]); 114 void usage(void); 115 char *nick2dev(char *); 116 char *nick2rdev(char *); 117 int guess_devtype(char *); 118 char *guess_nickname(char *); 119 void eject_tape(char *, enum eject_op); 120 void eject_disk(char *, enum eject_op); 121 void unmount_dev(char *); 122 123 int 124 main(int argc, char *argv[]) 125 { 126 int ch; 127 int devtype = -1; 128 int n, i; 129 char *devname = NULL; 130 enum eject_op op = OP_EJECT; 131 132 while ((ch = getopt(argc, argv, "d:flLnt:Uv")) != -1) { 133 switch (ch) { 134 case 'd': 135 devname = optarg; 136 break; 137 case 'f': 138 umount_f = 0; 139 break; 140 case 'l': 141 if (op != OP_EJECT) 142 usage(); 143 op = OP_LOAD; 144 break; 145 case 'L': 146 if (op != OP_EJECT) 147 usage(); 148 op = OP_LOCK; 149 break; 150 case 'n': 151 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); 152 n++) { 153 struct nicknames_s *np = &nicknames[n]; 154 155 printf("%s -> %s\n", np->name, nick2dev(np->name)); 156 } 157 return (0); 158 case 't': 159 for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); 160 i++) { 161 if (strcasecmp(devtypes[i].name, optarg) == 0) { 162 devtype = devtypes[i].type; 163 break; 164 } 165 } 166 if (devtype == -1) 167 errx(1, "%s: unknown device type", optarg); 168 break; 169 case 'U': 170 if (op != OP_EJECT) 171 usage(); 172 op = OP_UNLOCK; 173 break; 174 case 'v': 175 verbose_f = 1; 176 break; 177 default: 178 usage(); 179 /* NOTREACHED */ 180 } 181 } 182 argc -= optind; 183 argv += optind; 184 185 if (devname == NULL) { 186 if (argc == 0) { 187 usage(); 188 /* NOTREACHED */ 189 } else 190 devname = argv[0]; 191 } 192 if (devtype == -1) 193 devtype = guess_devtype(devname); 194 if (devtype == -1) 195 errx(1, "%s: unable to determine type of device", 196 devname); 197 if (verbose_f) { 198 printf("device type == "); 199 if ((devtype & TYPEMASK) == TAPE) 200 printf("tape\n"); 201 else 202 printf("disk, floppy, or cdrom\n"); 203 } 204 if (umount_f) 205 unmount_dev(devname); 206 207 /* XXX Tapes and disks have different ioctl's: */ 208 if ((devtype & TYPEMASK) == TAPE) 209 eject_tape(devname, op); 210 else 211 eject_disk(devname, op); 212 213 if (verbose_f) 214 printf("done.\n"); 215 216 return (0); 217 } 218 219 void 220 usage(void) 221 { 222 223 fprintf(stderr, "usage: eject [-fv] [-l | -L | -U] " 224 "[-t device-type] [-d] device\n"); 225 fprintf(stderr, " eject -n\n"); 226 exit(1); 227 } 228 229 int 230 guess_devtype(char *devname) 231 { 232 int n; 233 234 /* Nickname match: */ 235 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); 236 n++) { 237 if (strncasecmp(nicknames[n].name, devname, 238 strlen(nicknames[n].name)) == 0) 239 return (nicknames[n].type); 240 } 241 242 /* 243 * If we still don't know it, then try to compare vs. dev 244 * and rdev names that we know. 245 */ 246 /* dev first: */ 247 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); n++) { 248 char *name; 249 name = nick2dev(nicknames[n].name); 250 /* 251 * Assume that the part of the name that distinguishes the 252 * instance of this device begins with a 0. 253 */ 254 *(strchr(name, '0')) = '\0'; 255 if (strncmp(name, devname, strlen(name)) == 0) 256 return (nicknames[n].type); 257 } 258 259 /* Now rdev: */ 260 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); n++) { 261 char *name = nick2rdev(nicknames[n].name); 262 *(strchr(name, '0')) = '\0'; 263 if (strncmp(name, devname, strlen(name)) == 0) 264 return (nicknames[n].type); 265 } 266 267 /* Not found. */ 268 return (-1); 269 } 270 /* "floppy5" -> "/dev/fd5a". Yep, this uses a static buffer. */ 271 char * 272 nick2dev(char *nn) 273 { 274 int n; 275 static char devname[MAXDEVLEN]; 276 int devnum = 0; 277 278 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); n++) { 279 if (strncasecmp(nicknames[n].name, nn, 280 strlen(nicknames[n].name)) == 0) { 281 sscanf(nn, "%*[^0-9]%d", &devnum); 282 sprintf(devname, "/dev/%s%d", nicknames[n].devname, 283 devnum); 284 if ((nicknames[n].type & TYPEMASK) != TAPE) 285 strcat(devname, "a"); 286 return (devname); 287 } 288 } 289 290 return (NULL); 291 } 292 /* "floppy5" -> "/dev/rfd5c". Static buffer. */ 293 char * 294 nick2rdev(char *nn) 295 { 296 int n; 297 static char devname[MAXDEVLEN]; 298 int devnum = 0; 299 300 for (n = 0; n < sizeof(nicknames) / sizeof(nicknames[0]); n++) { 301 if (strncasecmp(nicknames[n].name, nn, 302 strlen(nicknames[n].name)) == 0) { 303 sscanf(nn, "%*[^0-9]%d", &devnum); 304 sprintf(devname, "/dev/r%s%d", nicknames[n].devname, 305 devnum); 306 if ((nicknames[n].type & TYPEMASK) != TAPE) { 307 strcat(devname, "a"); 308 if ((nicknames[n].type & FLOPPY) != FLOPPY) 309 devname[strlen(devname) - 1] += getrawpartition(); 310 } 311 return (devname); 312 } 313 } 314 315 return (NULL); 316 } 317 /* Unmount all filesystems attached to dev. */ 318 void 319 unmount_dev(char *name) 320 { 321 struct statvfs *mounts; 322 int i, nmnts, len; 323 char *dn; 324 325 nmnts = getmntinfo(&mounts, MNT_NOWAIT); 326 if (nmnts == 0) { 327 err(1, "getmntinfo"); 328 } 329 /* Make sure we have a device name: */ 330 dn = nick2dev(name); 331 if (dn == NULL) 332 dn = name; 333 334 /* Set len to strip off the partition name: */ 335 len = strlen(dn); 336 if (!isdigit((unsigned char)dn[len - 1])) 337 len--; 338 if (!isdigit((unsigned char)dn[len - 1])) { 339 errx(1, "Can't figure out base name for dev name %s", dn); 340 } 341 for (i = 0; i < nmnts; i++) { 342 if (strncmp(mounts[i].f_mntfromname, dn, len) == 0) { 343 if (verbose_f) 344 printf("Unmounting %s from %s...\n", 345 mounts[i].f_mntfromname, 346 mounts[i].f_mntonname); 347 348 if (unmount(mounts[i].f_mntonname, 0) == -1) { 349 err(1, "unmount: %s", mounts[i].f_mntonname); 350 } 351 } 352 } 353 354 return; 355 } 356 357 void 358 eject_tape(char *name, enum eject_op op) 359 { 360 struct mtop m; 361 int fd; 362 char *dn; 363 364 dn = nick2rdev(name); 365 if (dn == NULL) 366 dn = name; /* Hope for the best. */ 367 fd = open(dn, O_RDONLY); 368 if (fd == -1) 369 err(1, "open: %s", dn); 370 switch (op) { 371 case OP_EJECT: 372 if (verbose_f) 373 printf("Ejecting %s...\n", dn); 374 375 m.mt_op = MTOFFL; 376 m.mt_count = 0; 377 if (ioctl(fd, MTIOCTOP, &m) == -1) 378 err(1, "ioctl: MTIOCTOP: %s", dn); 379 break; 380 case OP_LOAD: 381 errx(1, "cannot load tapes"); 382 /* NOTREACHED */ 383 case OP_LOCK: 384 errx(1, "cannot lock tapes"); 385 /* NOTREACHED */ 386 case OP_UNLOCK: 387 errx(1, "cannot unlock tapes"); 388 /* NOTREACHED */ 389 } 390 close(fd); 391 return; 392 } 393 394 void 395 eject_disk(char *name, enum eject_op op) 396 { 397 int fd; 398 char *dn; 399 int arg; 400 401 dn = nick2rdev(name); 402 if (dn == NULL) 403 dn = name; /* Hope for the best. */ 404 fd = open(dn, O_RDONLY); 405 if (fd == -1) 406 err(1, "open: %s", dn); 407 switch (op) { 408 case OP_LOAD: 409 if (verbose_f) 410 printf("Closing %s...\n", dn); 411 412 if (ioctl(fd, CDIOCCLOSE, NULL) == -1) 413 err(1, "ioctl: CDIOCCLOSE: %s", dn); 414 break; 415 case OP_EJECT: 416 if (verbose_f) 417 printf("Ejecting %s...\n", dn); 418 419 arg = 0; 420 if (umount_f == 0) { 421 /* force eject, unlock the device first */ 422 if (ioctl(fd, DIOCLOCK, &arg) == -1) 423 err(1, "ioctl: DIOCLOCK: %s", dn); 424 arg = 1; 425 } 426 if (ioctl(fd, DIOCEJECT, &arg) == -1) 427 err(1, "ioctl: DIOCEJECT: %s", dn); 428 break; 429 case OP_LOCK: 430 if (verbose_f) 431 printf("Locking %s...\n", dn); 432 433 arg = 1; 434 if (ioctl(fd, DIOCLOCK, &arg) == -1) 435 err(1, "ioctl: DIOCLOCK: %s", dn); 436 break; 437 case OP_UNLOCK: 438 if (verbose_f) 439 printf("Unlocking %s...\n", dn); 440 441 arg = 0; 442 if (ioctl(fd, DIOCLOCK, &arg) == -1) 443 err(1, "ioctl: DIOCLOCK: %s", dn); 444 break; 445 } 446 447 close(fd); 448 return; 449 } 450