xref: /freebsd/bin/chio/chio.c (revision 8b6876e1)
1 /*	$NetBSD: chio.c,v 1.6 1998/01/04 23:53:58 thorpej Exp $ */
2 /*-
3  * Copyright (c) 1996 Jason R. Thorpe <thorpej@and.com>
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. All advertising materials mentioning features or use of this software
15  *    must display the following acknowledgements:
16  *	This product includes software developed by Jason R. Thorpe
17  *	for And Communications, http://www.and.com/
18  * 4. The name of the author may not be used to endorse or promote products
19  *    derived from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 /*
34  * Additional Copyright (c) 1997, by Matthew Jacob, for NASA/Ames Research Ctr.
35  * Additional Copyright (c) 2000, by C. Stephen Gunn, Waterspout Communications
36  */
37 
38 #include <sys/param.h>
39 #include <sys/chio.h>
40 #include <err.h>
41 #include <fcntl.h>
42 #include <stdio.h>
43 #include <stdint.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <langinfo.h>
48 #include <locale.h>
49 
50 #include "defs.h"
51 #include "pathnames.h"
52 
53 static	void usage(void) __dead2;
54 static	void cleanup(void);
55 static	u_int16_t parse_element_type(char *);
56 static	u_int16_t parse_element_unit(char *);
57 static	const char * element_type_name(int et);
58 static	int parse_special(char *);
59 static	int is_special(char *);
60 static	const char *bits_to_string(ces_status_flags, const char *);
61 
62 static	void find_element(char *, uint16_t *, uint16_t *);
63 static	struct changer_element_status *get_element_status
64 	   (unsigned int, unsigned int, int);
65 
66 static	int do_move(const char *, int, char **);
67 static	int do_exchange(const char *, int, char **);
68 static	int do_position(const char *, int, char **);
69 static	int do_params(const char *, int, char **);
70 static	int do_getpicker(const char *, int, char **);
71 static	int do_setpicker(const char *, int, char **);
72 static	int do_status(const char *, int, char **);
73 static	int do_ielem(const char *, int, char **);
74 static	int do_return(const char *, int, char **);
75 static	int do_voltag(const char *, int, char **);
76 static	void print_designator(const char *, u_int8_t, u_int8_t);
77 
78 #ifndef CHET_VT
79 #define	CHET_VT		10			/* Completely Arbitrary */
80 #endif
81 
82 /* Valid changer element types. */
83 static	const struct element_type elements[] = {
84 	{ "drive",		CHET_DT },
85 	{ "picker",		CHET_MT },
86 	{ "portal",		CHET_IE },
87 	{ "slot",		CHET_ST },
88 	{ "voltag",		CHET_VT },	/* Select tapes by barcode */
89 	{ NULL,			0 },
90 };
91 
92 /* Valid commands. */
93 static	const struct changer_command commands[] = {
94 	{ "exchange",		do_exchange },
95 	{ "getpicker",		do_getpicker },
96 	{ "ielem", 		do_ielem },
97 	{ "move",		do_move },
98 	{ "params",		do_params },
99 	{ "position",		do_position },
100 	{ "setpicker",		do_setpicker },
101 	{ "status",		do_status },
102 	{ "return",		do_return },
103 	{ "voltag",		do_voltag },
104 	{ NULL,			0 },
105 };
106 
107 /* Valid special words. */
108 static	const struct special_word specials[] = {
109 	{ "inv",		SW_INVERT },
110 	{ "inv1",		SW_INVERT1 },
111 	{ "inv2",		SW_INVERT2 },
112 	{ NULL,			0 },
113 };
114 
115 static	int changer_fd;
116 static	const char *changer_name;
117 
118 int
main(int argc,char ** argv)119 main(int argc, char **argv)
120 {
121 	int ch, i;
122 
123 	while ((ch = getopt(argc, argv, "f:")) != -1) {
124 		switch (ch) {
125 		case 'f':
126 			changer_name = optarg;
127 			break;
128 
129 		default:
130 			usage();
131 		}
132 	}
133 	argc -= optind;
134 	argv += optind;
135 
136 	if (argc == 0)
137 		usage();
138 
139 	/* Get the default changer if not already specified. */
140 	if (changer_name == NULL)
141 		if ((changer_name = getenv(CHANGER_ENV_VAR)) == NULL)
142 			changer_name = _PATH_CH;
143 
144 	/* Open the changer device. */
145 	if ((changer_fd = open(changer_name, O_RDWR, 0600)) == -1)
146 		err(1, "%s: open", changer_name);
147 
148 	/* Register cleanup function. */
149 	if (atexit(cleanup))
150 		err(1, "can't register cleanup function");
151 
152 	/* Find the specified command. */
153 	for (i = 0; commands[i].cc_name != NULL; ++i)
154 		if (strcmp(*argv, commands[i].cc_name) == 0)
155 			break;
156 	if (commands[i].cc_name == NULL) {
157 		/* look for abbreviation */
158 		for (i = 0; commands[i].cc_name != NULL; ++i)
159 			if (strncmp(*argv, commands[i].cc_name,
160 			    strlen(*argv)) == 0)
161 				break;
162 	}
163 
164 	if (commands[i].cc_name == NULL)
165 		errx(1, "unknown command: %s", *argv);
166 
167 	exit ((*commands[i].cc_handler)(commands[i].cc_name, argc, argv));
168 	/* NOTREACHED */
169 }
170 
171 static int
do_move(const char * cname,int argc,char ** argv)172 do_move(const char *cname, int argc, char **argv)
173 {
174 	struct changer_move cmd;
175 	int val;
176 
177 	/*
178 	 * On a move command, we expect the following:
179 	 *
180 	 * <from ET> <from EU> <to ET> <to EU> [inv]
181 	 *
182 	 * where ET == element type and EU == element unit.
183 	 */
184 
185 	++argv; --argc;
186 
187 	if (argc < 4) {
188 		warnx("%s: too few arguments", cname);
189 		goto usage;
190 	} else if (argc > 5) {
191 		warnx("%s: too many arguments", cname);
192 		goto usage;
193 	}
194 	(void) memset(&cmd, 0, sizeof(cmd));
195 
196 	/* <from ET>  */
197 	cmd.cm_fromtype = parse_element_type(*argv);
198 	++argv; --argc;
199 
200 	/* Check for voltag virtual type */
201 	if (CHET_VT == cmd.cm_fromtype) {
202 		find_element(*argv, &cmd.cm_fromtype, &cmd.cm_fromunit);
203 	} else {
204 		/* <from EU> */
205 		cmd.cm_fromunit = parse_element_unit(*argv);
206 	}
207 	++argv; --argc;
208 
209 	/* <to ET> */
210 	cmd.cm_totype = parse_element_type(*argv);
211 	++argv; --argc;
212 
213 	/* Check for voltag virtual type, and report error */
214 	if (CHET_VT == cmd.cm_totype)
215 		errx(1,"%s: voltag only makes sense as an element source",
216 		     cname);
217 
218 	/* <to EU> */
219 	cmd.cm_tounit = parse_element_unit(*argv);
220 	++argv; --argc;
221 
222 	/* Deal with optional command modifier. */
223 	if (argc) {
224 		val = parse_special(*argv);
225 		switch (val) {
226 		case SW_INVERT:
227 			cmd.cm_flags |= CM_INVERT;
228 			break;
229 
230 		default:
231 			errx(1, "%s: inappropriate modifier `%s'",
232 			    cname, *argv);
233 			/* NOTREACHED */
234 		}
235 	}
236 
237 	/* Send command to changer. */
238 	if (ioctl(changer_fd, CHIOMOVE, &cmd))
239 		err(1, "%s: CHIOMOVE", changer_name);
240 
241 	return (0);
242 
243  usage:
244 	(void) fprintf(stderr, "usage: %s %s "
245 	    "<from ET> <from EU> <to ET> <to EU> [inv]\n", getprogname(), cname);
246 	return (1);
247 }
248 
249 static int
do_exchange(const char * cname,int argc,char ** argv)250 do_exchange(const char *cname, int argc, char **argv)
251 {
252 	struct changer_exchange cmd;
253 	int val;
254 
255 	/*
256 	 * On an exchange command, we expect the following:
257 	 *
258   * <src ET> <src EU> <dst1 ET> <dst1 EU> [<dst2 ET> <dst2 EU>] [inv1] [inv2]
259 	 *
260 	 * where ET == element type and EU == element unit.
261 	 */
262 
263 	++argv; --argc;
264 
265 	if (argc < 4) {
266 		warnx("%s: too few arguments", cname);
267 		goto usage;
268 	} else if (argc > 8) {
269 		warnx("%s: too many arguments", cname);
270 		goto usage;
271 	}
272 	(void) memset(&cmd, 0, sizeof(cmd));
273 
274 	/* <src ET>  */
275 	cmd.ce_srctype = parse_element_type(*argv);
276 	++argv; --argc;
277 
278 	/* Check for voltag virtual type */
279 	if (CHET_VT == cmd.ce_srctype) {
280 		find_element(*argv, &cmd.ce_srctype, &cmd.ce_srcunit);
281 	} else {
282 		/* <from EU> */
283 		cmd.ce_srcunit = parse_element_unit(*argv);
284 	}
285 	++argv; --argc;
286 
287 	/* <dst1 ET> */
288 	cmd.ce_fdsttype = parse_element_type(*argv);
289 	++argv; --argc;
290 
291 	/* Check for voltag virtual type */
292 	if (CHET_VT == cmd.ce_fdsttype) {
293 		find_element(*argv, &cmd.ce_fdsttype, &cmd.ce_fdstunit);
294 	} else {
295 		/* <from EU> */
296 		cmd.ce_fdstunit = parse_element_unit(*argv);
297 	}
298 	++argv; --argc;
299 
300 	/*
301 	 * If the next token is a special word or there are no more
302 	 * arguments, then this is a case of simple exchange.
303 	 * dst2 == src.
304 	 */
305 	if ((argc == 0) || is_special(*argv)) {
306 		cmd.ce_sdsttype = cmd.ce_srctype;
307 		cmd.ce_sdstunit = cmd.ce_srcunit;
308 		goto do_special;
309 	}
310 
311 	/* <dst2 ET> */
312 	cmd.ce_sdsttype = parse_element_type(*argv);
313 	++argv; --argc;
314 
315 	if (CHET_VT == cmd.ce_sdsttype)
316 		errx(1,"%s %s: voltag only makes sense as an element source",
317 		     cname, *argv);
318 
319 	/* <dst2 EU> */
320 	cmd.ce_sdstunit = parse_element_unit(*argv);
321 	++argv; --argc;
322 
323  do_special:
324 	/* Deal with optional command modifiers. */
325 	while (argc) {
326 		val = parse_special(*argv);
327 		++argv; --argc;
328 		switch (val) {
329 		case SW_INVERT1:
330 			cmd.ce_flags |= CE_INVERT1;
331 			break;
332 
333 		case SW_INVERT2:
334 			cmd.ce_flags |= CE_INVERT2;
335 			break;
336 
337 		default:
338 			errx(1, "%s: inappropriate modifier `%s'",
339 			    cname, *argv);
340 			/* NOTREACHED */
341 		}
342 	}
343 
344 	/* Send command to changer. */
345 	if (ioctl(changer_fd, CHIOEXCHANGE, &cmd))
346 		err(1, "%s: CHIOEXCHANGE", changer_name);
347 
348 	return (0);
349 
350  usage:
351 	(void) fprintf(stderr,
352 	    "usage: %s %s <src ET> <src EU> <dst1 ET> <dst1 EU>\n"
353 	    "       [<dst2 ET> <dst2 EU>] [inv1] [inv2]\n",
354 	    getprogname(), cname);
355 	return (1);
356 }
357 
358 static int
do_position(const char * cname,int argc,char ** argv)359 do_position(const char *cname, int argc, char **argv)
360 {
361 	struct changer_position cmd;
362 	int val;
363 
364 	/*
365 	 * On a position command, we expect the following:
366 	 *
367 	 * <to ET> <to EU> [inv]
368 	 *
369 	 * where ET == element type and EU == element unit.
370 	 */
371 
372 	++argv; --argc;
373 
374 	if (argc < 2) {
375 		warnx("%s: too few arguments", cname);
376 		goto usage;
377 	} else if (argc > 3) {
378 		warnx("%s: too many arguments", cname);
379 		goto usage;
380 	}
381 	(void) memset(&cmd, 0, sizeof(cmd));
382 
383 	/* <to ET>  */
384 	cmd.cp_type = parse_element_type(*argv);
385 	++argv; --argc;
386 
387 	/* <to EU> */
388 	cmd.cp_unit = parse_element_unit(*argv);
389 	++argv; --argc;
390 
391 	/* Deal with optional command modifier. */
392 	if (argc) {
393 		val = parse_special(*argv);
394 		switch (val) {
395 		case SW_INVERT:
396 			cmd.cp_flags |= CP_INVERT;
397 			break;
398 
399 		default:
400 			errx(1, "%s: inappropriate modifier `%s'",
401 			    cname, *argv);
402 			/* NOTREACHED */
403 		}
404 	}
405 
406 	/* Send command to changer. */
407 	if (ioctl(changer_fd, CHIOPOSITION, &cmd))
408 		err(1, "%s: CHIOPOSITION", changer_name);
409 
410 	return (0);
411 
412  usage:
413 	(void) fprintf(stderr, "usage: %s %s <to ET> <to EU> [inv]\n",
414 	    getprogname(), cname);
415 	return (1);
416 }
417 
418 /* ARGSUSED */
419 static int
do_params(const char * cname,int argc,char ** argv __unused)420 do_params(const char *cname, int argc, char **argv __unused)
421 {
422 	struct changer_params data;
423 	int picker;
424 
425 	/* No arguments to this command. */
426 
427 	++argv; --argc;
428 
429 	if (argc) {
430 		warnx("%s: no arguments expected", cname);
431 		goto usage;
432 	}
433 
434 	/* Get params from changer and display them. */
435 	(void) memset(&data, 0, sizeof(data));
436 	if (ioctl(changer_fd, CHIOGPARAMS, &data))
437 		err(1, "%s: CHIOGPARAMS", changer_name);
438 
439 	(void) printf("%s: %d slot%s, %d drive%s, %d picker%s",
440 	    changer_name,
441 	    data.cp_nslots, (data.cp_nslots > 1) ? "s" : "",
442 	    data.cp_ndrives, (data.cp_ndrives > 1) ? "s" : "",
443 	    data.cp_npickers, (data.cp_npickers > 1) ? "s" : "");
444 	if (data.cp_nportals)
445 		(void) printf(", %d portal%s", data.cp_nportals,
446 		    (data.cp_nportals > 1) ? "s" : "");
447 
448 	/* Get current picker from changer and display it. */
449 	if (ioctl(changer_fd, CHIOGPICKER, &picker))
450 		err(1, "%s: CHIOGPICKER", changer_name);
451 
452 	(void) printf("\n%s: current picker: %d\n", changer_name, picker);
453 
454 	return (0);
455 
456  usage:
457 	(void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
458 	return (1);
459 }
460 
461 /* ARGSUSED */
462 static int
do_getpicker(const char * cname,int argc,char ** argv __unused)463 do_getpicker(const char *cname, int argc, char **argv __unused)
464 {
465 	int picker;
466 
467 	/* No arguments to this command. */
468 
469 	++argv; --argc;
470 
471 	if (argc) {
472 		warnx("%s: no arguments expected", cname);
473 		goto usage;
474 	}
475 
476 	/* Get current picker from changer and display it. */
477 	if (ioctl(changer_fd, CHIOGPICKER, &picker))
478 		err(1, "%s: CHIOGPICKER", changer_name);
479 
480 	(void) printf("%s: current picker: %d\n", changer_name, picker);
481 
482 	return (0);
483 
484  usage:
485 	(void) fprintf(stderr, "usage: %s %s\n", getprogname(), cname);
486 	return (1);
487 }
488 
489 static int
do_setpicker(const char * cname,int argc,char ** argv)490 do_setpicker(const char *cname, int argc, char **argv)
491 {
492 	int picker;
493 
494 	++argv; --argc;
495 
496 	if (argc < 1) {
497 		warnx("%s: too few arguments", cname);
498 		goto usage;
499 	} else if (argc > 1) {
500 		warnx("%s: too many arguments", cname);
501 		goto usage;
502 	}
503 
504 	picker = parse_element_unit(*argv);
505 
506 	/* Set the changer picker. */
507 	if (ioctl(changer_fd, CHIOSPICKER, &picker))
508 		err(1, "%s: CHIOSPICKER", changer_name);
509 
510 	return (0);
511 
512  usage:
513 	(void) fprintf(stderr, "usage: %s %s <picker>\n", getprogname(), cname);
514 	return (1);
515 }
516 
517 static int
do_status(const char * cname,int argc,char ** argv)518 do_status(const char *cname, int argc, char **argv)
519 {
520 	struct changer_params cp;
521 	struct changer_element_status_request cesr;
522 	int i;
523 	u_int16_t base, count, chet, schet, echet;
524 	const char *description;
525 	int pvoltag = 0;
526 	int avoltag = 0;
527 	int sense = 0;
528 	int scsi = 0;
529 	int source = 0;
530 	int intaddr = 0;
531 	int c;
532 
533 	count = 0;
534 	base = 0;
535 	description = NULL;
536 
537 	optind = optreset = 1;
538 	while ((c = getopt(argc, argv, "vVsSbaI")) != -1) {
539 		switch (c) {
540 		case 'v':
541 			pvoltag = 1;
542 			break;
543 		case 'V':
544 			avoltag = 1;
545 			break;
546 		case 's':
547 			sense = 1;
548 			break;
549 		case 'S':
550 			source = 1;
551 			break;
552 		case 'b':
553 			scsi = 1;
554 			break;
555 		case 'I':
556 			intaddr = 1;
557 			break;
558 		case 'a':
559 			pvoltag = avoltag = source = sense = scsi = intaddr = 1;
560 			break;
561 		default:
562 			warnx("%s: bad option", cname);
563 			goto usage;
564 		}
565 	}
566 
567 	argc -= optind;
568 	argv += optind;
569 
570 	/*
571 	 * On a status command, we expect the following:
572 	 *
573 	 * [<ET> [<start> [<end>] ] ]
574 	 *
575 	 * where ET == element type, start == first element to report,
576 	 * end == number of elements to report
577 	 *
578 	 * If we get no arguments, we get the status of all
579 	 * known element types.
580 	 */
581 	if (argc > 3) {
582 		warnx("%s: too many arguments", cname);
583 		goto usage;
584 	}
585 
586 	/*
587 	 * Get params from changer.  Specifically, we need the element
588 	 * counts.
589 	 */
590 	if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
591 		err(1, "%s: CHIOGPARAMS", changer_name);
592 
593 	if (argc > 0)
594 		schet = echet = parse_element_type(argv[0]);
595 	else {
596 		schet = CHET_MT;
597 		echet = CHET_DT;
598 	}
599 	if (argc > 1) {
600 		base = (u_int16_t)atol(argv[1]);
601 		count = 1;
602 	}
603 	if (argc > 2)
604 		count = (u_int16_t)atol(argv[2]) - base + 1;
605 
606 	for (chet = schet; chet <= echet; ++chet) {
607 		switch (chet) {
608 		case CHET_MT:
609 			if (count == 0)
610 				count = cp.cp_npickers;
611 			else if (count > cp.cp_npickers)
612 				errx(1, "not that many pickers in device");
613 			description = "picker";
614 			break;
615 
616 		case CHET_ST:
617 			if (count == 0)
618 				count = cp.cp_nslots;
619 			else if (count > cp.cp_nslots)
620 				errx(1, "not that many slots in device");
621 			description = "slot";
622 			break;
623 
624 		case CHET_IE:
625 			if (count == 0)
626 				count = cp.cp_nportals;
627 			else if (count > cp.cp_nportals)
628 				errx(1, "not that many portals in device");
629 			description = "portal";
630 			break;
631 
632 		case CHET_DT:
633 			if (count == 0)
634 				count = cp.cp_ndrives;
635 			else if (count > cp.cp_ndrives)
636 				errx(1, "not that many drives in device");
637 			description = "drive";
638 			break;
639 
640  		default:
641  			/* To appease gcc -Wuninitialized. */
642  			count = 0;
643  			description = NULL;
644 		}
645 
646 		if (count == 0) {
647 			if (argc == 0)
648 				continue;
649 			else {
650 				printf("%s: no %s elements\n",
651 				    changer_name, description);
652 				return (0);
653 			}
654 		}
655 
656 		bzero(&cesr, sizeof(cesr));
657 		cesr.cesr_element_type = chet;
658 		cesr.cesr_element_base = base;
659 		cesr.cesr_element_count = count;
660 		/* Allocate storage for the status structures. */
661 		cesr.cesr_element_status =
662 		  (struct changer_element_status *)
663 		  calloc((size_t)count, sizeof(struct changer_element_status));
664 
665 		if (!cesr.cesr_element_status)
666 			errx(1, "can't allocate status storage");
667 
668 		if (avoltag || pvoltag)
669 			cesr.cesr_flags |= CESR_VOLTAGS;
670 
671 		if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr)) {
672 			free(cesr.cesr_element_status);
673 			err(1, "%s: CHIOGSTATUS", changer_name);
674 		}
675 
676 		/* Dump the status for each reported element. */
677 		for (i = 0; i < count; ++i) {
678 			struct changer_element_status *ces =
679 			         &(cesr.cesr_element_status[i]);
680 			printf("%s %d: %s", description, ces->ces_addr,
681 			    bits_to_string(ces->ces_flags,
682 					   CESTATUS_BITS));
683 			if (sense)
684 				printf(" sense: <0x%02x/0x%02x>",
685 				       ces->ces_sensecode,
686 				       ces->ces_sensequal);
687 			if (pvoltag)
688 				printf(" voltag: <%s:%d>",
689 				       ces->ces_pvoltag.cv_volid,
690 				       ces->ces_pvoltag.cv_serial);
691 			if (avoltag)
692 				printf(" avoltag: <%s:%d>",
693 				       ces->ces_avoltag.cv_volid,
694 				       ces->ces_avoltag.cv_serial);
695 			if (source) {
696 				if (ces->ces_flags & CES_SOURCE_VALID)
697 					printf(" source: <%s %d>",
698 					       element_type_name(
699 						       ces->ces_source_type),
700 					       ces->ces_source_addr);
701 				else
702 					printf(" source: <>");
703 			}
704 			if (intaddr)
705 				printf(" intaddr: <%d>", ces->ces_int_addr);
706 			if (scsi) {
707 				printf(" scsi: <");
708 				if (ces->ces_flags & CES_SCSIID_VALID)
709 					printf("%d", ces->ces_scsi_id);
710 				else
711 					putchar('?');
712 				putchar(':');
713 				if (ces->ces_flags & CES_LUN_VALID)
714 					printf("%d", ces->ces_scsi_lun);
715 				else
716 					putchar('?');
717 				putchar('>');
718 			}
719 			if (ces->ces_designator_length > 0)
720 				print_designator(ces->ces_designator,
721 						 ces->ces_code_set,
722 						 ces->ces_designator_length);
723 			putchar('\n');
724 		}
725 
726 		free(cesr.cesr_element_status);
727 		count = 0;
728 	}
729 
730 	return (0);
731 
732  usage:
733 	(void) fprintf(stderr, "usage: %s %s [-vVsSbaA] [<element type> [<start-addr> [<end-addr>] ] ]\n",
734 		       getprogname(), cname);
735 	return (1);
736 }
737 
738 static int
do_ielem(const char * cname,int argc,char ** argv)739 do_ielem(const char *cname, int argc, char **argv)
740 {
741 	int timeout = 0;
742 
743 	if (argc == 2) {
744 		timeout = atol(argv[1]);
745 	} else if (argc > 1) {
746 		warnx("%s: too many arguments", cname);
747 		goto usage;
748 	}
749 
750 	if (ioctl(changer_fd, CHIOIELEM, &timeout))
751 		err(1, "%s: CHIOIELEM", changer_name);
752 
753 	return (0);
754 
755  usage:
756 	(void) fprintf(stderr, "usage: %s %s [<timeout>]\n",
757 		       getprogname(), cname);
758 	return (1);
759 }
760 
761 static int
do_voltag(const char * cname,int argc,char ** argv)762 do_voltag(const char *cname, int argc, char **argv)
763 {
764 	int force = 0;
765 	int clear = 0;
766 	int alternate = 0;
767 	int c;
768 	struct changer_set_voltag_request csvr;
769 
770 	bzero(&csvr, sizeof(csvr));
771 
772 	optind = optreset = 1;
773 	while ((c = getopt(argc, argv, "fca")) != -1) {
774 		switch (c) {
775 		case 'f':
776 			force = 1;
777 			break;
778 		case 'c':
779 			clear = 1;
780 			break;
781 		case 'a':
782 			alternate = 1;
783 			break;
784 		default:
785 			warnx("%s: bad option", cname);
786 			goto usage;
787 		}
788 	}
789 
790 	argc -= optind;
791 	argv += optind;
792 
793 	if (argc < 2) {
794 		warnx("%s: missing element specification", cname);
795 		goto usage;
796 	}
797 
798 	csvr.csvr_type = parse_element_type(argv[0]);
799 	csvr.csvr_addr = (u_int16_t)atol(argv[1]);
800 
801 	if (!clear) {
802 		if (argc < 3 || argc > 4) {
803 			warnx("%s: missing argument", cname);
804 			goto usage;
805 		}
806 
807 		if (force)
808 			csvr.csvr_flags = CSVR_MODE_REPLACE;
809 		else
810 			csvr.csvr_flags = CSVR_MODE_SET;
811 
812 		if (strlen(argv[2]) > sizeof(csvr.csvr_voltag.cv_volid)) {
813 			warnx("%s: volume label too long", cname);
814 			goto usage;
815 		}
816 
817 		strlcpy((char *)csvr.csvr_voltag.cv_volid, argv[2],
818 		       sizeof(csvr.csvr_voltag.cv_volid));
819 
820 		if (argc == 4) {
821 			csvr.csvr_voltag.cv_serial = (u_int16_t)atol(argv[3]);
822 		}
823 	} else {
824 		if (argc != 2) {
825 			warnx("%s: unexpected argument", cname);
826 			goto usage;
827 		}
828 		csvr.csvr_flags = CSVR_MODE_CLEAR;
829 	}
830 
831 	if (alternate) {
832 		csvr.csvr_flags |= CSVR_ALTERNATE;
833 	}
834 
835 	if (ioctl(changer_fd, CHIOSETVOLTAG, &csvr))
836 		err(1, "%s: CHIOSETVOLTAG", changer_name);
837 
838 	return 0;
839  usage:
840 	(void) fprintf(stderr,
841 		       "usage: %s %s [-fca] <element> [<voltag> [<vsn>] ]\n",
842 		       getprogname(), cname);
843 	return 1;
844 }
845 
846 static u_int16_t
parse_element_type(char * cp)847 parse_element_type(char *cp)
848 {
849 	int i;
850 
851 	for (i = 0; elements[i].et_name != NULL; ++i)
852 		if (strcmp(elements[i].et_name, cp) == 0)
853 			return ((u_int16_t)elements[i].et_type);
854 
855 	errx(1, "invalid element type `%s'", cp);
856 	/* NOTREACHED */
857 }
858 
859 static const char *
element_type_name(int et)860 element_type_name(int et)
861 {
862 	int i;
863 
864 	for (i = 0; elements[i].et_name != NULL; i++)
865 		if (elements[i].et_type == et)
866 			return elements[i].et_name;
867 
868 	return "unknown";
869 }
870 
871 static u_int16_t
parse_element_unit(char * cp)872 parse_element_unit(char *cp)
873 {
874 	int i;
875 	char *p;
876 
877 	i = (int)strtol(cp, &p, 10);
878 	if ((i < 0) || (*p != '\0'))
879 		errx(1, "invalid unit number `%s'", cp);
880 
881 	return ((u_int16_t)i);
882 }
883 
884 static int
parse_special(char * cp)885 parse_special(char *cp)
886 {
887 	int val;
888 
889 	val = is_special(cp);
890 	if (val)
891 		return (val);
892 
893 	errx(1, "invalid modifier `%s'", cp);
894 	/* NOTREACHED */
895 }
896 
897 static int
is_special(char * cp)898 is_special(char *cp)
899 {
900 	int i;
901 
902 	for (i = 0; specials[i].sw_name != NULL; ++i)
903 		if (strcmp(specials[i].sw_name, cp) == 0)
904 			return (specials[i].sw_value);
905 
906 	return (0);
907 }
908 
909 static const char *
bits_to_string(ces_status_flags v,const char * cp)910 bits_to_string(ces_status_flags v, const char *cp)
911 {
912 	const char *np;
913 	char f, sep, *bp;
914 	static char buf[128];
915 
916 	bp = buf;
917 	(void) memset(buf, 0, sizeof(buf));
918 
919 	for (sep = '<'; (f = *cp++) != 0; cp = np) {
920 		for (np = cp; *np >= ' ';)
921 			np++;
922 		if (((int)v & (1 << (f - 1))) == 0)
923 			continue;
924 		(void) snprintf(bp, sizeof(buf) - (size_t)(bp - &buf[0]),
925 			"%c%.*s", sep, (int)(long)(np - cp), cp);
926 		bp += strlen(bp);
927 		sep = ',';
928 	}
929 	if (sep != '<')
930 		*bp = '>';
931 
932 	return (buf);
933 }
934 /*
935  * do_return()
936  *
937  * Given an element reference, ask the changer/picker to move that
938  * element back to its source slot.
939  */
940 static int
do_return(const char * cname,int argc,char ** argv)941 do_return(const char *cname, int argc, char **argv)
942 {
943 	struct changer_element_status *ces;
944 	struct changer_move cmd;
945 	uint16_t	type, element;
946 
947 	++argv; --argc;
948 
949 	if (argc < 2) {
950 		warnx("%s: too few arguments", cname);
951 		goto usage;
952 	} else if (argc > 3) {
953 		warnx("%s: too many arguments", cname);
954 		goto usage;
955 	}
956 
957 	type = parse_element_type(*argv);
958 	++argv; --argc;
959 
960 	/* Handle voltag virtual Changer Element Type */
961 	if (CHET_VT == type) {
962 		find_element(*argv, &type, &element);
963 	} else {
964 		element = parse_element_unit(*argv);
965 	}
966 	++argv; --argc;
967 
968 	/* Get the status */
969 	ces = get_element_status((unsigned int)type, (unsigned int)element,
970 	    CHET_VT == type);
971 
972 	if (NULL == ces)
973 		errx(1, "%s: null element status pointer", cname);
974 
975 	if (!(ces->ces_flags & CES_SOURCE_VALID))
976 		errx(1, "%s: no source information", cname);
977 
978 	(void) memset(&cmd, 0, sizeof(cmd));
979 
980 	cmd.cm_fromtype = type;
981 	cmd.cm_fromunit = element;
982 	cmd.cm_totype = ces->ces_source_type;
983 	cmd.cm_tounit = ces->ces_source_addr;
984 
985 	if (ioctl(changer_fd, CHIOMOVE, &cmd) == -1)
986 		err(1, "%s: CHIOMOVE", changer_name);
987 	free(ces);
988 
989 	return(0);
990 
991 usage:
992 	(void) fprintf(stderr, "usage: %s %s "
993 	    "<from ET> <from EU>\n", getprogname(), cname);
994 	return(1);
995 }
996 
997 /*
998  * get_element_status()
999  *
1000  * return a *cesr for the specified changer element.  This
1001  * routing will malloc()/calloc() the memory.  The caller
1002  * should free() it when done.
1003  */
1004 static struct changer_element_status *
get_element_status(unsigned int type,unsigned int element,int use_voltags)1005 get_element_status(unsigned int type, unsigned int element, int use_voltags)
1006 {
1007 	struct changer_element_status_request cesr;
1008 	struct changer_element_status *ces;
1009 
1010 	ces = (struct changer_element_status *)
1011 	    calloc((size_t)1, sizeof(struct changer_element_status));
1012 
1013 	if (NULL == ces)
1014 		errx(1, "can't allocate status storage");
1015 
1016 	(void)memset(&cesr, 0, sizeof(cesr));
1017 
1018 	cesr.cesr_element_type = (uint16_t)type;
1019 	cesr.cesr_element_base = (uint16_t)element;
1020 	cesr.cesr_element_count = 1;		/* Only this one element */
1021 	if (use_voltags)
1022 		cesr.cesr_flags |= CESR_VOLTAGS; /* Grab voltags as well */
1023 	cesr.cesr_element_status = ces;
1024 
1025 	if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1026 		free(ces);
1027 		err(1, "%s: CHIOGSTATUS", changer_name);
1028 		/* NOTREACHED */
1029 	}
1030 
1031 	return ces;
1032 }
1033 
1034 
1035 /*
1036  * find_element()
1037  *
1038  * Given a <voltag> find the chager element and unit, or exit
1039  * with an error if it isn't found.  We grab the changer status
1040  * and iterate until we find a match, or crap out.
1041  */
1042 static void
find_element(char * voltag,uint16_t * et,uint16_t * eu)1043 find_element(char *voltag, uint16_t *et, uint16_t *eu)
1044 {
1045 	struct changer_params cp;
1046 	struct changer_element_status_request cesr;
1047 	struct changer_element_status *ch_ces, *ces;
1048 	int found = 0;
1049 	size_t elem, total_elem;
1050 
1051 	/*
1052 	 * Get the changer parameters, we're interested in the counts
1053 	 * for all types of elements to perform our search.
1054 	 */
1055 	if (ioctl(changer_fd, CHIOGPARAMS, (char *)&cp))
1056 		err(1, "%s: CHIOGPARAMS", changer_name);
1057 
1058 	/* Allocate some memory for the results */
1059 	total_elem = (cp.cp_nslots + cp.cp_ndrives
1060 	    + cp.cp_npickers + cp.cp_nportals);
1061 
1062 	ch_ces = (struct changer_element_status *)
1063 	    calloc(total_elem, sizeof(struct changer_element_status));
1064 
1065 	if (NULL == ch_ces)
1066 		errx(1, "can't allocate status storage");
1067 
1068 	ces = ch_ces;
1069 
1070 	/* Read in the changer slots */
1071 	if (cp.cp_nslots > 0) {
1072 		(void) memset(&cesr, 0, sizeof(cesr));
1073 		cesr.cesr_element_type = CHET_ST;
1074 		cesr.cesr_element_base = 0;
1075 		cesr.cesr_element_count = cp.cp_nslots;
1076 		cesr.cesr_flags |= CESR_VOLTAGS;
1077 		cesr.cesr_element_status = ces;
1078 
1079 		if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1080 			free(ch_ces);
1081 			err(1, "%s: CHIOGSTATUS", changer_name);
1082 		}
1083 		ces += cp.cp_nslots;
1084 	}
1085 
1086 	/* Read in the drive information */
1087 	if (cp.cp_ndrives > 0 ) {
1088 
1089 		(void) memset(&cesr, 0, sizeof(cesr));
1090 		cesr.cesr_element_type = CHET_DT;
1091 		cesr.cesr_element_base = 0;
1092 		cesr.cesr_element_count = cp.cp_ndrives;
1093 		cesr.cesr_flags |= CESR_VOLTAGS;
1094 		cesr.cesr_element_status = ces;
1095 
1096 		if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1097 			free(ch_ces);
1098 			err(1, "%s: CHIOGSTATUS", changer_name);
1099 		}
1100 		ces += cp.cp_ndrives;
1101 	}
1102 
1103 	/* Read in the portal information */
1104 	if (cp.cp_nportals > 0 ) {
1105 		(void) memset(&cesr, 0, sizeof(cesr));
1106 		cesr.cesr_element_type = CHET_IE;
1107 		cesr.cesr_element_base = 0;
1108 		cesr.cesr_element_count = cp.cp_nportals;
1109 		cesr.cesr_flags |= CESR_VOLTAGS;
1110 		cesr.cesr_element_status = ces;
1111 
1112 		if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1113 			free(ch_ces);
1114 			err(1, "%s: CHIOGSTATUS", changer_name);
1115 		}
1116 		ces += cp.cp_nportals;
1117 	}
1118 
1119 	/* Read in the picker information */
1120 	if (cp.cp_npickers > 0) {
1121 		(void) memset(&cesr, 0, sizeof(cesr));
1122 		cesr.cesr_element_type = CHET_MT;
1123 		cesr.cesr_element_base = 0;
1124 		cesr.cesr_element_count = cp.cp_npickers;
1125 		cesr.cesr_flags |= CESR_VOLTAGS;
1126 		cesr.cesr_element_status = ces;
1127 
1128 		if (ioctl(changer_fd, CHIOGSTATUS, (char *)&cesr) == -1) {
1129 			free(ch_ces);
1130 			err(1, "%s: CHIOGSTATUS", changer_name);
1131 		}
1132 	}
1133 
1134 	/*
1135 	 * Now search the list the specified <voltag>
1136 	 */
1137 	for (elem = 0; elem < total_elem; ++elem) {
1138 
1139 		ces = &ch_ces[elem];
1140 
1141 		/* Make sure we have a tape in this element */
1142 		if ((ces->ces_flags & (CES_STATUS_ACCESS|CES_STATUS_FULL))
1143 		    != (CES_STATUS_ACCESS|CES_STATUS_FULL))
1144 			continue;
1145 
1146 		/* Check to see if it is our target */
1147 		if (strcasecmp(voltag,
1148 		    (const char *)ces->ces_pvoltag.cv_volid) == 0) {
1149 			*et = ces->ces_type;
1150 			*eu = ces->ces_addr;
1151 			++found;
1152 			break;
1153 		}
1154 	}
1155 	if (!found) {
1156 		errx(1, "%s: unable to locate voltag: %s", changer_name,
1157 		     voltag);
1158 	}
1159 	free(ch_ces);
1160 	return;
1161 }
1162 
1163 static void
cleanup(void)1164 cleanup(void)
1165 {
1166 	/* Simple enough... */
1167 	(void)close(changer_fd);
1168 }
1169 
1170 static void
usage(void)1171 usage(void)
1172 {
1173 	(void)fprintf(stderr, "usage: %s [-f changer] command [-<flags>] "
1174 		"arg1 arg2 [arg3 [...]]\n", getprogname());
1175 	exit(1);
1176 }
1177 
1178 #define	UTF8CODESET	"UTF-8"
1179 
1180 static void
print_designator(const char * designator,u_int8_t code_set,u_int8_t designator_length)1181 print_designator(const char *designator, u_int8_t code_set,
1182     u_int8_t designator_length)
1183 {
1184 	printf(" serial number: <");
1185 	switch (code_set) {
1186 	case CES_CODE_SET_ASCII: {
1187 		/*
1188 		 * The driver insures that the string is always NUL terminated.
1189 		 */
1190 		printf("%s", designator);
1191 		break;
1192 	}
1193 	case CES_CODE_SET_UTF_8: {
1194 		char *cs_native;
1195 
1196 		setlocale(LC_ALL, "");
1197 		cs_native = nl_langinfo(CODESET);
1198 
1199 		/* See if we can natively print UTF-8 */
1200 		if (strcmp(cs_native, UTF8CODESET) == 0)
1201 			cs_native = NULL;
1202 
1203 		if (cs_native == NULL) {
1204 			/* We can natively print UTF-8, so use printf. */
1205 			printf("%s", designator);
1206 		} else {
1207 			int i;
1208 
1209 			/*
1210 			 * We can't natively print UTF-8.  We should
1211 			 * convert it to the terminal's codeset, but that
1212 			 * requires iconv(3) and FreeBSD doesn't have
1213 			 * iconv(3) in the base system yet.  So we use %XX
1214 			 * notation for non US-ASCII characters instead.
1215 			 */
1216 			for (i = 0; i < designator_length &&
1217 			    designator[i] != '\0'; i++) {
1218 				if ((unsigned char)designator[i] < 0x80)
1219 					printf("%c", designator[i]);
1220 				else
1221 					printf("%%%02x",
1222 					    (unsigned char)designator[i]);
1223 			}
1224 		}
1225 		break;
1226 	}
1227 	case CES_CODE_SET_BINARY: {
1228 		int i;
1229 
1230 		for (i = 0; i < designator_length; i++)
1231 			printf("%02X%s", designator[i],
1232 			    (i == designator_length - 1) ? "" : " ");
1233 		break;
1234 	}
1235 	default:
1236 		break;
1237 	}
1238 	printf(">");
1239 }
1240