camcontrol(8): Fix building with -fno-common.
[dragonfly.git] / sbin / camcontrol / modeedit.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 2000 Kelly Yancey <kbyanc@posi.net>
3 * Derived from work done by Julian Elischer <julian@tfs.com,
4 * julian@dialix.oz.au>, 1993, and Peter Dufault <dufault@hda.com>, 1994.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1de703da
MD
27 *
28 * $FreeBSD: src/sbin/camcontrol/modeedit.c,v 1.5.2.2 2003/01/08 17:55:02 njl Exp $
984263bc
MD
29 */
30
984263bc
MD
31#include <sys/queue.h>
32#include <sys/types.h>
33
34#include <assert.h>
35#include <ctype.h>
36#include <err.h>
37#include <errno.h>
38#include <stdlib.h>
39#include <string.h>
40#include <stdio.h>
41#include <sysexits.h>
42#include <unistd.h>
43
4842621b 44#include <bus/cam/scsi/scsi_all.h>
45#include <bus/cam/cam.h>
46#include <bus/cam/cam_ccb.h>
984263bc
MD
47#include <camlib.h>
48#include "camcontrol.h"
49
984263bc
MD
50#define DEFAULT_SCSI_MODE_DB "/usr/share/misc/scsi_modes"
51#define DEFAULT_EDITOR "vi"
52#define MAX_FORMAT_SPEC 4096 /* Max CDB format specifier. */
53#define MAX_PAGENUM_LEN 10 /* Max characters in page num. */
54#define MAX_PAGENAME_LEN 64 /* Max characters in page name. */
55#define PAGEDEF_START '{' /* Page definition delimiter. */
56#define PAGEDEF_END '}' /* Page definition delimiter. */
57#define PAGENAME_START '"' /* Page name delimiter. */
58#define PAGENAME_END '"' /* Page name delimiter. */
59#define PAGEENTRY_END ';' /* Page entry terminator (optional). */
60#define MAX_COMMAND_SIZE 255 /* Mode/Log sense data buffer size. */
61#define PAGE_CTRL_SHIFT 6 /* Bit offset to page control field. */
62
63
64/* Macros for working with mode pages. */
65#define MODE_PAGE_HEADER(mh) \
66 (struct scsi_mode_page_header *)find_mode_page_6(mh)
67
68#define MODE_PAGE_DATA(mph) \
69 (u_int8_t *)(mph) + sizeof(struct scsi_mode_page_header)
70
71
72struct editentry {
73 STAILQ_ENTRY(editentry) link;
74 char *name;
75 char type;
76 int editable;
77 int size;
78 union {
79 int ivalue;
80 char *svalue;
81 } value;
82};
83STAILQ_HEAD(, editentry) editlist; /* List of page entries. */
84int editlist_changed = 0; /* Whether any entries were changed. */
85
86struct pagename {
87 SLIST_ENTRY(pagename) link;
88 int pagenum;
89 char *name;
90};
91SLIST_HEAD(, pagename) namelist; /* Page number to name mappings. */
92
93static char format[MAX_FORMAT_SPEC]; /* Buffer for scsi cdb format def. */
94
95static FILE *edit_file = NULL; /* File handle for edit file. */
96static char edit_path[] = "/tmp/camXXXXXX";
97
98
99/* Function prototypes. */
2e9424f2
CP
100static void editentry_create(void *, int, void *, int, char *);
101static void editentry_update(void *, int, void *, int, char *);
102static int editentry_save(void *, char *);
103static struct editentry *editentry_lookup(char *);
104static int editentry_set(char *, char *, int);
105static void editlist_populate(struct cam_device *, int, int, int,
106 int, int);
107static void editlist_save(struct cam_device *, int, int, int, int,
108 int);
109static void nameentry_create(int, char *);
110static struct pagename *nameentry_lookup(int);
111static int load_format(const char *, int);
112static int modepage_write(FILE *, int);
113static int modepage_read(FILE *);
984263bc 114static void modepage_edit(void);
2e9424f2
CP
115static void modepage_dump(struct cam_device *, int, int, int, int,
116 int);
984263bc 117static void cleanup_editfile(void);
984263bc
MD
118
119
120#define returnerr(code) do { \
121 errno = code; \
122 return (-1); \
123} while (0)
124
125
126#define RTRIM(string) do { \
127 int _length; \
128 while (isspace(string[_length = strlen(string) - 1])) \
129 string[_length] = '\0'; \
130} while (0)
131
132
133static void
2e9424f2
CP
134editentry_create(void *hook __unused, int letter, void *arg, int count,
135 char *name)
984263bc
MD
136{
137 struct editentry *newentry; /* Buffer to hold new entry. */
138
139 /* Allocate memory for the new entry and a copy of the entry name. */
140 if ((newentry = malloc(sizeof(struct editentry))) == NULL ||
141 (newentry->name = strdup(name)) == NULL)
142 err(EX_OSERR, NULL);
143
144 /* Trim any trailing whitespace for the entry name. */
145 RTRIM(newentry->name);
146
147 newentry->editable = (arg != NULL);
148 newentry->type = letter;
149 newentry->size = count; /* Placeholder; not accurate. */
150 newentry->value.svalue = NULL;
151
152 STAILQ_INSERT_TAIL(&editlist, newentry, link);
153}
154
155static void
2e9424f2
CP
156editentry_update(void *hook __unused, int letter, void *arg, int count,
157 char *name)
984263bc
MD
158{
159 struct editentry *dest; /* Buffer to hold entry to update. */
160
161 dest = editentry_lookup(name);
162 assert(dest != NULL);
163
164 dest->type = letter;
165 dest->size = count; /* We get the real size now. */
166
167 switch (dest->type) {
168 case 'i': /* Byte-sized integral type. */
169 case 'b': /* Bit-sized integral types. */
170 case 't':
171 dest->value.ivalue = (intptr_t)arg;
172 break;
173
174 case 'c': /* Character array. */
175 case 'z': /* Null-padded string. */
176 editentry_set(name, (char *)arg, 0);
177 break;
178 default:
179 ; /* NOTREACHED */
180 }
181}
182
183static int
2e9424f2 184editentry_save(void *hook __unused, char *name)
984263bc
MD
185{
186 struct editentry *src; /* Entry value to save. */
187
188 src = editentry_lookup(name);
189 assert(src != NULL);
190
191 switch (src->type) {
192 case 'i': /* Byte-sized integral type. */
193 case 'b': /* Bit-sized integral types. */
194 case 't':
195 return (src->value.ivalue);
196 /* NOTREACHED */
197
198 case 'c': /* Character array. */
199 case 'z': /* Null-padded string. */
200 return ((intptr_t)src->value.svalue);
201 /* NOTREACHED */
202
203 default:
204 ; /* NOTREACHED */
205 }
206
207 return (0); /* This should never happen. */
208}
209
210static struct editentry *
211editentry_lookup(char *name)
212{
213 struct editentry *scan;
214
215 assert(name != NULL);
216
217 STAILQ_FOREACH(scan, &editlist, link) {
218 if (strcasecmp(scan->name, name) == 0)
219 return (scan);
220 }
221
222 /* Not found during list traversal. */
223 return (NULL);
224}
225
226static int
227editentry_set(char *name, char *newvalue, int editonly)
228{
229 struct editentry *dest; /* Modepage entry to update. */
230 char *cval; /* Pointer to new string value. */
231 char *convertend; /* End-of-conversion pointer. */
232 int ival; /* New integral value. */
233 int resolution; /* Resolution in bits for integer conversion. */
2e9424f2 234 int resolution_max; /* Maximum resolution for modepage's size. */
984263bc
MD
235
236 assert(newvalue != NULL);
237 if (*newvalue == '\0')
238 return (0); /* Nothing to do. */
239
240 if ((dest = editentry_lookup(name)) == NULL)
241 returnerr(ENOENT);
242 if (!dest->editable && editonly)
243 returnerr(EPERM);
244
245 switch (dest->type) {
246 case 'i': /* Byte-sized integral type. */
247 case 'b': /* Bit-sized integral types. */
248 case 't':
249 /* Convert the value string to an integer. */
250 resolution = (dest->type == 'i')? 8: 1;
251 ival = (int)strtol(newvalue, &convertend, 0);
252 if (*convertend != '\0')
253 returnerr(EINVAL);
2e9424f2
CP
254
255 /*
256 * Determine the maximum value of the given size for the
257 * current resolution.
258 * XXX Lovely x86's optimize out the case of shifting by 32,
259 * and gcc doesn't currently workaround it (even for int64's),
260 * so we have to kludge it.
261 */
262 if (resolution * dest->size == 32)
263 resolution_max = 0xffffffff;
264 else
265 resolution_max = (1 << (resolution * dest->size)) - 1;
266
267 if (ival > resolution_max || ival < 0) {
268 int newival = (ival < 0) ? 0 : resolution_max;
984263bc
MD
269 warnx("value %d is out of range for entry %s; clipping "
270 "to %d", ival, name, newival);
271 ival = newival;
272 }
273 if (dest->value.ivalue != ival)
274 editlist_changed = 1;
275 dest->value.ivalue = ival;
276 break;
277
278 case 'c': /* Character array. */
279 case 'z': /* Null-padded string. */
280 if ((cval = malloc(dest->size + 1)) == NULL)
281 err(EX_OSERR, NULL);
282 bzero(cval, dest->size + 1);
283 strncpy(cval, newvalue, dest->size);
284 if (dest->type == 'z') {
285 /* Convert trailing spaces to nulls. */
2e9424f2 286 char *conv_end;
984263bc 287
2e9424f2
CP
288 for (conv_end = cval + dest->size;
289 conv_end >= cval; conv_end--) {
290 if (*conv_end == ' ')
291 *conv_end = '\0';
292 else if (*conv_end != '\0')
984263bc
MD
293 break;
294 }
295 }
296 if (strncmp(dest->value.svalue, cval, dest->size) == 0) {
297 /* Nothing changed, free the newly allocated string. */
298 free(cval);
299 break;
300 }
301 if (dest->value.svalue != NULL) {
302 /* Free the current string buffer. */
303 free(dest->value.svalue);
304 dest->value.svalue = NULL;
305 }
306 dest->value.svalue = cval;
307 editlist_changed = 1;
308 break;
309
310 default:
311 ; /* NOTREACHED */
312 }
313
314 return (0);
984263bc
MD
315}
316
317static void
318nameentry_create(int pagenum, char *name) {
319 struct pagename *newentry;
320
321 if (pagenum < 0 || name == NULL || name[0] == '\0')
322 return;
323
324 /* Allocate memory for the new entry and a copy of the entry name. */
325 if ((newentry = malloc(sizeof(struct pagename))) == NULL ||
326 (newentry->name = strdup(name)) == NULL)
327 err(EX_OSERR, NULL);
328
329 /* Trim any trailing whitespace for the page name. */
330 RTRIM(newentry->name);
331
332 newentry->pagenum = pagenum;
333 SLIST_INSERT_HEAD(&namelist, newentry, link);
334}
335
336static struct pagename *
337nameentry_lookup(int pagenum) {
338 struct pagename *scan;
339
340 SLIST_FOREACH(scan, &namelist, link) {
341 if (pagenum == scan->pagenum)
342 return (scan);
343 }
344
345 /* Not found during list traversal. */
346 return (NULL);
347}
348
349static int
2e9424f2 350load_format(const char *pagedb_path, int page)
984263bc
MD
351{
352 FILE *pagedb;
353 char str_pagenum[MAX_PAGENUM_LEN];
354 char str_pagename[MAX_PAGENAME_LEN];
355 int pagenum;
356 int depth; /* Quoting depth. */
357 int found;
358 int lineno;
359 enum { LOCATE, PAGENAME, PAGEDEF } state;
b0713724 360 int cc;
984263bc
MD
361 char c;
362
363#define SETSTATE_LOCATE do { \
364 str_pagenum[0] = '\0'; \
365 str_pagename[0] = '\0'; \
366 pagenum = -1; \
367 state = LOCATE; \
368} while (0)
369
370#define SETSTATE_PAGENAME do { \
371 str_pagename[0] = '\0'; \
372 state = PAGENAME; \
373} while (0)
374
375#define SETSTATE_PAGEDEF do { \
376 format[0] = '\0'; \
377 state = PAGEDEF; \
378} while (0)
379
380#define UPDATE_LINENO do { \
381 if (c == '\n') \
382 lineno++; \
383} while (0)
384
385#define BUFFERFULL(buffer) (strlen(buffer) + 1 >= sizeof(buffer))
386
387 if ((pagedb = fopen(pagedb_path, "r")) == NULL)
388 returnerr(ENOENT);
389
390 SLIST_INIT(&namelist);
391
392 depth = 0;
393 lineno = 0;
394 found = 0;
395 SETSTATE_LOCATE;
b0713724
MD
396 while ((cc = fgetc(pagedb)) != EOF) {
397 c = (char)cc;
984263bc
MD
398
399 /* Keep a line count to make error messages more useful. */
400 UPDATE_LINENO;
401
402 /* Skip over comments anywhere in the mode database. */
403 if (c == '#') {
404 do {
b0713724
MD
405 cc = fgetc(pagedb);
406 } while (cc != '\n' && cc != EOF);
407 c = (char)cc;
984263bc
MD
408 UPDATE_LINENO;
409 continue;
410 }
411
412 /* Strip out newline characters. */
413 if (c == '\n')
414 continue;
415
416 /* Keep track of the nesting depth for braces. */
417 if (c == PAGEDEF_START)
418 depth++;
419 else if (c == PAGEDEF_END) {
420 depth--;
421 if (depth < 0) {
422 errx(EX_OSFILE, "%s:%d: %s", pagedb_path,
423 lineno, "mismatched bracket");
424 }
425 }
426
427 switch (state) {
428 case LOCATE:
429 /*
430 * Locate the page the user is interested in, skipping
431 * all others.
432 */
433 if (isspace(c)) {
434 /* Ignore all whitespace between pages. */
435 break;
436 } else if (depth == 0 && c == PAGEENTRY_END) {
437 /*
438 * A page entry terminator will reset page
439 * scanning (useful for assigning names to
440 * modes without providing a mode definition).
441 */
442 /* Record the name of this page. */
443 pagenum = strtol(str_pagenum, NULL, 0);
444 nameentry_create(pagenum, str_pagename);
445 SETSTATE_LOCATE;
446 } else if (depth == 0 && c == PAGENAME_START) {
447 SETSTATE_PAGENAME;
448 } else if (c == PAGEDEF_START) {
449 pagenum = strtol(str_pagenum, NULL, 0);
450 if (depth == 1) {
451 /* Record the name of this page. */
452 nameentry_create(pagenum, str_pagename);
453 /*
454 * Only record the format if this is
455 * the page we are interested in.
456 */
457 if (page == pagenum && !found)
458 SETSTATE_PAGEDEF;
459 }
460 } else if (c == PAGEDEF_END) {
461 /* Reset the processor state. */
462 SETSTATE_LOCATE;
463 } else if (depth == 0 && ! BUFFERFULL(str_pagenum)) {
464 strncat(str_pagenum, &c, 1);
465 } else if (depth == 0) {
e11cf02d 466 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path,
984263bc
MD
467 lineno, "page identifier exceeds",
468 sizeof(str_pagenum) - 1, "characters");
469 }
470 break;
471
472 case PAGENAME:
473 if (c == PAGENAME_END) {
474 /*
475 * Return to LOCATE state without resetting the
476 * page number buffer.
477 */
478 state = LOCATE;
479 } else if (! BUFFERFULL(str_pagename)) {
480 strncat(str_pagename, &c, 1);
481 } else {
e11cf02d 482 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path,
984263bc
MD
483 lineno, "page name exceeds",
484 sizeof(str_pagenum) - 1, "characters");
485 }
486 break;
487
488 case PAGEDEF:
489 /*
490 * Transfer the page definition into a format buffer
491 * suitable for use with CDB encoding/decoding routines.
492 */
493 if (depth == 0) {
494 found = 1;
495 SETSTATE_LOCATE;
496 } else if (! BUFFERFULL(format)) {
497 strncat(format, &c, 1);
498 } else {
e11cf02d 499 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path,
984263bc
MD
500 lineno, "page definition exceeds",
501 sizeof(format) - 1, "characters");
502 }
503 break;
504
505 default:
506 ; /* NOTREACHED */
507 }
508
509 /* Repeat processing loop with next character. */
510 }
511
512 if (ferror(pagedb))
513 err(EX_OSFILE, "%s", pagedb_path);
514
515 /* Close the SCSI page database. */
516 fclose(pagedb);
517
518 if (!found) /* Never found a matching page. */
519 returnerr(ESRCH);
520
521 return (0);
522}
523
524static void
525editlist_populate(struct cam_device *device, int modepage, int page_control,
526 int dbd, int retries, int timeout)
527{
528 u_int8_t data[MAX_COMMAND_SIZE];/* Buffer to hold sense data. */
529 u_int8_t *mode_pars; /* Pointer to modepage params. */
530 struct scsi_mode_header_6 *mh; /* Location of mode header. */
531 struct scsi_mode_page_header *mph;
532
533 STAILQ_INIT(&editlist);
534
535 /* Fetch changeable values; use to build initial editlist. */
536 mode_sense(device, modepage, 1, dbd, retries, timeout, data,
537 sizeof(data));
538
539 mh = (struct scsi_mode_header_6 *)data;
540 mph = MODE_PAGE_HEADER(mh);
541 mode_pars = MODE_PAGE_DATA(mph);
542
543 /* Decode the value data, creating edit_entries for each value. */
544 buff_decode_visit(mode_pars, mh->data_length, format,
545 editentry_create, 0);
546
547 /* Fetch the current/saved values; use to set editentry values. */
548 mode_sense(device, modepage, page_control, dbd, retries, timeout, data,
549 sizeof(data));
550 buff_decode_visit(mode_pars, mh->data_length, format,
551 editentry_update, 0);
552}
553
554static void
555editlist_save(struct cam_device *device, int modepage, int page_control,
556 int dbd, int retries, int timeout)
557{
558 u_int8_t data[MAX_COMMAND_SIZE];/* Buffer to hold sense data. */
559 u_int8_t *mode_pars; /* Pointer to modepage params. */
560 struct scsi_mode_header_6 *mh; /* Location of mode header. */
561 struct scsi_mode_page_header *mph;
562
563 /* Make sure that something changed before continuing. */
564 if (! editlist_changed)
565 return;
566
567 /*
568 * Preload the CDB buffer with the current mode page data.
569 * XXX If buff_encode_visit would return the number of bytes encoded
570 * we *should* use that to build a header from scratch. As it is
571 * now, we need mode_sense to find out the page length.
572 */
573 mode_sense(device, modepage, page_control, dbd, retries, timeout, data,
574 sizeof(data));
575
576 /* Initial headers & offsets. */
577 mh = (struct scsi_mode_header_6 *)data;
578 mph = MODE_PAGE_HEADER(mh);
579 mode_pars = MODE_PAGE_DATA(mph);
580
581 /* Encode the value data to be passed back to the device. */
582 buff_encode_visit(mode_pars, mh->data_length, format,
583 editentry_save, 0);
584
585 /* Eliminate block descriptors. */
586 bcopy(mph, ((u_int8_t *)mh) + sizeof(*mh),
587 sizeof(*mph) + mph->page_length);
588
589 /* Recalculate headers & offsets. */
590 mh->blk_desc_len = 0; /* No block descriptors. */
591 mh->dev_spec = 0; /* Clear device-specific parameters. */
592 mph = MODE_PAGE_HEADER(mh);
593 mode_pars = MODE_PAGE_DATA(mph);
594
595 mph->page_code &= SMS_PAGE_CODE;/* Isolate just the page code. */
596 mh->data_length = 0; /* Reserved for MODE SELECT command. */
597
598 /*
599 * Write the changes back to the device. If the user editted control
600 * page 3 (saved values) then request the changes be permanently
601 * recorded.
602 */
603 mode_select(device,
604 (page_control << PAGE_CTRL_SHIFT == SMS_PAGE_CTRL_SAVED),
605 retries, timeout, (u_int8_t *)mh,
606 sizeof(*mh) + mh->blk_desc_len + sizeof(*mph) + mph->page_length);
607}
608
609static int
610modepage_write(FILE *file, int editonly)
611{
612 struct editentry *scan;
613 int written = 0;
614
615 STAILQ_FOREACH(scan, &editlist, link) {
616 if (scan->editable || !editonly) {
617 written++;
618 if (scan->type == 'c' || scan->type == 'z') {
619 fprintf(file, "%s: %s\n", scan->name,
620 scan->value.svalue);
621 } else {
622 fprintf(file, "%s: %d\n", scan->name,
623 scan->value.ivalue);
624 }
625 }
626 }
627 return (written);
628}
629
630static int
631modepage_read(FILE *file)
632{
633 char *buffer; /* Pointer to dynamic line buffer. */
634 char *line; /* Pointer to static fgetln buffer. */
635 char *name; /* Name portion of the line buffer. */
636 char *value; /* Value portion of line buffer. */
e43bcaac 637 size_t length; /* Length of static fgetln buffer. */
984263bc
MD
638
639#define ABORT_READ(message, param) do { \
640 warnx(message, param); \
641 free(buffer); \
642 returnerr(EAGAIN); \
643} while (0)
644
645 while ((line = fgetln(file, &length)) != NULL) {
646 /* Trim trailing whitespace (including optional newline). */
647 while (length > 0 && isspace(line[length - 1]))
648 length--;
649
650 /* Allocate a buffer to hold the line + terminating null. */
651 if ((buffer = malloc(length + 1)) == NULL)
652 err(EX_OSERR, NULL);
653 memcpy(buffer, line, length);
654 buffer[length] = '\0';
655
656 /* Strip out comments. */
657 if ((value = strchr(buffer, '#')) != NULL)
658 *value = '\0';
659
660 /* The name is first in the buffer. Trim whitespace.*/
661 name = buffer;
662 RTRIM(name);
663 while (isspace(*name))
664 name++;
665
666 /* Skip empty lines. */
667 if (strlen(name) == 0)
668 continue;
669
670 /* The name ends at the colon; the value starts there. */
671 if ((value = strrchr(buffer, ':')) == NULL)
672 ABORT_READ("no value associated with %s", name);
673 *value = '\0'; /* Null-terminate name. */
674 value++; /* Value starts afterwards. */
675
676 /* Trim leading and trailing whitespace. */
677 RTRIM(value);
678 while (isspace(*value))
679 value++;
680
681 /* Make sure there is a value left. */
682 if (strlen(value) == 0)
683 ABORT_READ("no value associated with %s", name);
684
685 /* Update our in-memory copy of the modepage entry value. */
686 if (editentry_set(name, value, 1) != 0) {
687 if (errno == ENOENT) {
688 /* No entry by the name. */
689 ABORT_READ("no such modepage entry \"%s\"",
690 name);
691 } else if (errno == EINVAL) {
692 /* Invalid value. */
693 ABORT_READ("Invalid value for entry \"%s\"",
694 name);
695 } else if (errno == ERANGE) {
696 /* Value out of range for entry type. */
697 ABORT_READ("value out of range for %s", name);
698 } else if (errno == EPERM) {
699 /* Entry is not editable; not fatal. */
700 warnx("modepage entry \"%s\" is read-only; "
701 "skipping.", name);
702 }
703 }
704
705 free(buffer);
706 }
707 return (ferror(file)? -1: 0);
708
709#undef ABORT_READ
710}
711
712static void
713modepage_edit(void)
714{
2e9424f2 715 const char *editor;
984263bc
MD
716 char *commandline;
717 int fd;
718 int written;
719
720 if (!isatty(fileno(stdin))) {
721 /* Not a tty, read changes from stdin. */
722 modepage_read(stdin);
723 return;
724 }
725
726 /* Lookup editor to invoke. */
727 if ((editor = getenv("EDITOR")) == NULL)
728 editor = DEFAULT_EDITOR;
729
730 /* Create temp file for editor to modify. */
731 if ((fd = mkstemp(edit_path)) == -1)
732 errx(EX_CANTCREAT, "mkstemp failed");
733
734 atexit(cleanup_editfile);
735
736 if ((edit_file = fdopen(fd, "w")) == NULL)
737 err(EX_NOINPUT, "%s", edit_path);
738
739 written = modepage_write(edit_file, 1);
740
741 fclose(edit_file);
742 edit_file = NULL;
743
744 if (written == 0) {
745 warnx("no editable entries");
746 cleanup_editfile();
747 return;
748 }
749
750 /*
751 * Allocate memory to hold the command line (the 2 extra characters
752 * are to hold the argument separator (a space), and the terminating
753 * null character.
754 */
755 commandline = malloc(strlen(editor) + strlen(edit_path) + 2);
756 if (commandline == NULL)
757 err(EX_OSERR, NULL);
758 sprintf(commandline, "%s %s", editor, edit_path);
759
760 /* Invoke the editor on the temp file. */
761 if (system(commandline) == -1)
762 err(EX_UNAVAILABLE, "could not invoke %s", editor);
763 free(commandline);
764
765 if ((edit_file = fopen(edit_path, "r")) == NULL)
766 err(EX_NOINPUT, "%s", edit_path);
767
768 /* Read any changes made to the temp file. */
769 modepage_read(edit_file);
770
771 cleanup_editfile();
772}
773
774static void
775modepage_dump(struct cam_device *device, int page, int page_control, int dbd,
776 int retries, int timeout)
777{
778 u_int8_t data[MAX_COMMAND_SIZE];/* Buffer to hold sense data. */
779 u_int8_t *mode_pars; /* Pointer to modepage params. */
780 struct scsi_mode_header_6 *mh; /* Location of mode header. */
781 struct scsi_mode_page_header *mph;
2e9424f2 782 int mode_idx; /* Index for scanning mode params. */
984263bc
MD
783
784 mode_sense(device, page, page_control, dbd, retries, timeout, data,
785 sizeof(data));
786
787 mh = (struct scsi_mode_header_6 *)data;
788 mph = MODE_PAGE_HEADER(mh);
789 mode_pars = MODE_PAGE_DATA(mph);
790
791 /* Print the raw mode page data with newlines each 8 bytes. */
2e9424f2
CP
792 for (mode_idx = 0; mode_idx < mph->page_length; mode_idx++) {
793 printf("%02x%c", mode_pars[mode_idx],
794 (((mode_idx + 1) % 8) == 0) ? '\n' : ' ');
984263bc
MD
795 }
796 putchar('\n');
797}
798
799static void
800cleanup_editfile(void)
801{
802 if (edit_file == NULL)
803 return;
804 if (fclose(edit_file) != 0 || unlink(edit_path) != 0)
805 warn("%s", edit_path);
806 edit_file = NULL;
807}
808
809void
810mode_edit(struct cam_device *device, int page, int page_control, int dbd,
811 int edit, int binary, int retry_count, int timeout)
812{
2e9424f2 813 const char *pagedb_path; /* Path to modepage database. */
984263bc
MD
814
815 if (edit && binary)
816 errx(EX_USAGE, "cannot edit in binary mode.");
817
818 if (! binary) {
819 if ((pagedb_path = getenv("SCSI_MODES")) == NULL)
820 pagedb_path = DEFAULT_SCSI_MODE_DB;
821
822 if (load_format(pagedb_path, page) != 0 && (edit || verbose)) {
823 if (errno == ENOENT) {
824 /* Modepage database file not found. */
825 warn("cannot open modepage database \"%s\"",
826 pagedb_path);
827 } else if (errno == ESRCH) {
828 /* Modepage entry not found in database. */
829 warnx("modepage %d not found in database"
830 "\"%s\"", page, pagedb_path);
831 }
832 /* We can recover in display mode, otherwise we exit. */
833 if (!edit) {
834 warnx("reverting to binary display only");
835 binary = 1;
836 } else
837 exit(EX_OSFILE);
838 }
839
840 editlist_populate(device, page, page_control, dbd, retry_count,
841 timeout);
842 }
843
844 if (edit) {
845 if (page_control << PAGE_CTRL_SHIFT != SMS_PAGE_CTRL_CURRENT &&
846 page_control << PAGE_CTRL_SHIFT != SMS_PAGE_CTRL_SAVED)
847 errx(EX_USAGE, "it only makes sense to edit page 0 "
848 "(current) or page 3 (saved values)");
849 modepage_edit();
850 editlist_save(device, page, page_control, dbd, retry_count,
851 timeout);
852 } else if (binary || STAILQ_EMPTY(&editlist)) {
853 /* Display without formatting information. */
854 modepage_dump(device, page, page_control, dbd, retry_count,
855 timeout);
856 } else {
857 /* Display with format. */
858 modepage_write(stdout, 0);
859 }
860}
861
862void
863mode_list(struct cam_device *device, int page_control, int dbd,
864 int retry_count, int timeout)
865{
866 u_int8_t data[MAX_COMMAND_SIZE];/* Buffer to hold sense data. */
984263bc
MD
867 struct scsi_mode_header_6 *mh; /* Location of mode header. */
868 struct scsi_mode_page_header *mph;
869 struct pagename *nameentry;
2e9424f2 870 const char *pagedb_path;
984263bc
MD
871 int len;
872
873 if ((pagedb_path = getenv("SCSI_MODES")) == NULL)
874 pagedb_path = DEFAULT_SCSI_MODE_DB;
875
876 if (load_format(pagedb_path, 0) != 0 && verbose && errno == ENOENT) {
877 /* Modepage database file not found. */
878 warn("cannot open modepage database \"%s\"", pagedb_path);
879 }
880
881 /* Build the list of all mode pages by querying the "all pages" page. */
882 mode_sense(device, SMS_ALL_PAGES_PAGE, page_control, dbd, retry_count,
883 timeout, data, sizeof(data));
884
885 mh = (struct scsi_mode_header_6 *)data;
886 len = mh->blk_desc_len; /* Skip block descriptors. */
887 /* Iterate through the pages in the reply. */
888 while (len < mh->data_length) {
889 /* Locate the next mode page header. */
890 mph = (struct scsi_mode_page_header *)
891 ((intptr_t)mh + sizeof(*mh) + len);
984263bc
MD
892
893 mph->page_code &= SMS_PAGE_CODE;
894 nameentry = nameentry_lookup(mph->page_code);
895
896 if (nameentry == NULL || nameentry->name == NULL)
897 printf("0x%02x\n", mph->page_code);
898 else
899 printf("0x%02x\t%s\n", mph->page_code,
900 nameentry->name);
901 len += mph->page_length + sizeof(*mph);
902 }
903}