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. 27 * 28 * $FreeBSD: src/sbin/camcontrol/modeedit.c,v 1.5.2.2 2003/01/08 17:55:02 njl Exp $ 29 * $DragonFly: src/sbin/camcontrol/modeedit.c,v 1.3 2005/01/11 23:58:55 cpressey Exp $ 30 */ 31 32 #include <sys/queue.h> 33 #include <sys/types.h> 34 35 #include <assert.h> 36 #include <ctype.h> 37 #include <err.h> 38 #include <errno.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <stdio.h> 42 #include <sysexits.h> 43 #include <unistd.h> 44 45 #include <cam/scsi/scsi_all.h> 46 #include <cam/cam.h> 47 #include <cam/cam_ccb.h> 48 #include <camlib.h> 49 #include "camcontrol.h" 50 51 int verbose = 0; 52 53 #define DEFAULT_SCSI_MODE_DB "/usr/share/misc/scsi_modes" 54 #define DEFAULT_EDITOR "vi" 55 #define MAX_FORMAT_SPEC 4096 /* Max CDB format specifier. */ 56 #define MAX_PAGENUM_LEN 10 /* Max characters in page num. */ 57 #define MAX_PAGENAME_LEN 64 /* Max characters in page name. */ 58 #define PAGEDEF_START '{' /* Page definition delimiter. */ 59 #define PAGEDEF_END '}' /* Page definition delimiter. */ 60 #define PAGENAME_START '"' /* Page name delimiter. */ 61 #define PAGENAME_END '"' /* Page name delimiter. */ 62 #define PAGEENTRY_END ';' /* Page entry terminator (optional). */ 63 #define MAX_COMMAND_SIZE 255 /* Mode/Log sense data buffer size. */ 64 #define PAGE_CTRL_SHIFT 6 /* Bit offset to page control field. */ 65 66 67 /* Macros for working with mode pages. */ 68 #define MODE_PAGE_HEADER(mh) \ 69 (struct scsi_mode_page_header *)find_mode_page_6(mh) 70 71 #define MODE_PAGE_DATA(mph) \ 72 (u_int8_t *)(mph) + sizeof(struct scsi_mode_page_header) 73 74 75 struct editentry { 76 STAILQ_ENTRY(editentry) link; 77 char *name; 78 char type; 79 int editable; 80 int size; 81 union { 82 int ivalue; 83 char *svalue; 84 } value; 85 }; 86 STAILQ_HEAD(, editentry) editlist; /* List of page entries. */ 87 int editlist_changed = 0; /* Whether any entries were changed. */ 88 89 struct pagename { 90 SLIST_ENTRY(pagename) link; 91 int pagenum; 92 char *name; 93 }; 94 SLIST_HEAD(, pagename) namelist; /* Page number to name mappings. */ 95 96 static char format[MAX_FORMAT_SPEC]; /* Buffer for scsi cdb format def. */ 97 98 static FILE *edit_file = NULL; /* File handle for edit file. */ 99 static char edit_path[] = "/tmp/camXXXXXX"; 100 101 102 /* Function prototypes. */ 103 static void editentry_create(void *, int, void *, int, char *); 104 static void editentry_update(void *, int, void *, int, char *); 105 static int editentry_save(void *, char *); 106 static struct editentry *editentry_lookup(char *); 107 static int editentry_set(char *, char *, int); 108 static void editlist_populate(struct cam_device *, int, int, int, 109 int, int); 110 static void editlist_save(struct cam_device *, int, int, int, int, 111 int); 112 static void nameentry_create(int, char *); 113 static struct pagename *nameentry_lookup(int); 114 static int load_format(const char *, int); 115 static int modepage_write(FILE *, int); 116 static int modepage_read(FILE *); 117 static void modepage_edit(void); 118 static void modepage_dump(struct cam_device *, int, int, int, int, 119 int); 120 static void cleanup_editfile(void); 121 122 123 #define returnerr(code) do { \ 124 errno = code; \ 125 return (-1); \ 126 } while (0) 127 128 129 #define RTRIM(string) do { \ 130 int _length; \ 131 while (isspace(string[_length = strlen(string) - 1])) \ 132 string[_length] = '\0'; \ 133 } while (0) 134 135 136 static void 137 editentry_create(void *hook __unused, int letter, void *arg, int count, 138 char *name) 139 { 140 struct editentry *newentry; /* Buffer to hold new entry. */ 141 142 /* Allocate memory for the new entry and a copy of the entry name. */ 143 if ((newentry = malloc(sizeof(struct editentry))) == NULL || 144 (newentry->name = strdup(name)) == NULL) 145 err(EX_OSERR, NULL); 146 147 /* Trim any trailing whitespace for the entry name. */ 148 RTRIM(newentry->name); 149 150 newentry->editable = (arg != NULL); 151 newentry->type = letter; 152 newentry->size = count; /* Placeholder; not accurate. */ 153 newentry->value.svalue = NULL; 154 155 STAILQ_INSERT_TAIL(&editlist, newentry, link); 156 } 157 158 static void 159 editentry_update(void *hook __unused, int letter, void *arg, int count, 160 char *name) 161 { 162 struct editentry *dest; /* Buffer to hold entry to update. */ 163 164 dest = editentry_lookup(name); 165 assert(dest != NULL); 166 167 dest->type = letter; 168 dest->size = count; /* We get the real size now. */ 169 170 switch (dest->type) { 171 case 'i': /* Byte-sized integral type. */ 172 case 'b': /* Bit-sized integral types. */ 173 case 't': 174 dest->value.ivalue = (intptr_t)arg; 175 break; 176 177 case 'c': /* Character array. */ 178 case 'z': /* Null-padded string. */ 179 editentry_set(name, (char *)arg, 0); 180 break; 181 default: 182 ; /* NOTREACHED */ 183 } 184 } 185 186 static int 187 editentry_save(void *hook __unused, char *name) 188 { 189 struct editentry *src; /* Entry value to save. */ 190 191 src = editentry_lookup(name); 192 assert(src != NULL); 193 194 switch (src->type) { 195 case 'i': /* Byte-sized integral type. */ 196 case 'b': /* Bit-sized integral types. */ 197 case 't': 198 return (src->value.ivalue); 199 /* NOTREACHED */ 200 201 case 'c': /* Character array. */ 202 case 'z': /* Null-padded string. */ 203 return ((intptr_t)src->value.svalue); 204 /* NOTREACHED */ 205 206 default: 207 ; /* NOTREACHED */ 208 } 209 210 return (0); /* This should never happen. */ 211 } 212 213 static struct editentry * 214 editentry_lookup(char *name) 215 { 216 struct editentry *scan; 217 218 assert(name != NULL); 219 220 STAILQ_FOREACH(scan, &editlist, link) { 221 if (strcasecmp(scan->name, name) == 0) 222 return (scan); 223 } 224 225 /* Not found during list traversal. */ 226 return (NULL); 227 } 228 229 static int 230 editentry_set(char *name, char *newvalue, int editonly) 231 { 232 struct editentry *dest; /* Modepage entry to update. */ 233 char *cval; /* Pointer to new string value. */ 234 char *convertend; /* End-of-conversion pointer. */ 235 int ival; /* New integral value. */ 236 int resolution; /* Resolution in bits for integer conversion. */ 237 int resolution_max; /* Maximum resolution for modepage's size. */ 238 239 assert(newvalue != NULL); 240 if (*newvalue == '\0') 241 return (0); /* Nothing to do. */ 242 243 if ((dest = editentry_lookup(name)) == NULL) 244 returnerr(ENOENT); 245 if (!dest->editable && editonly) 246 returnerr(EPERM); 247 248 switch (dest->type) { 249 case 'i': /* Byte-sized integral type. */ 250 case 'b': /* Bit-sized integral types. */ 251 case 't': 252 /* Convert the value string to an integer. */ 253 resolution = (dest->type == 'i')? 8: 1; 254 ival = (int)strtol(newvalue, &convertend, 0); 255 if (*convertend != '\0') 256 returnerr(EINVAL); 257 258 /* 259 * Determine the maximum value of the given size for the 260 * current resolution. 261 * XXX Lovely x86's optimize out the case of shifting by 32, 262 * and gcc doesn't currently workaround it (even for int64's), 263 * so we have to kludge it. 264 */ 265 if (resolution * dest->size == 32) 266 resolution_max = 0xffffffff; 267 else 268 resolution_max = (1 << (resolution * dest->size)) - 1; 269 270 if (ival > resolution_max || ival < 0) { 271 int newival = (ival < 0) ? 0 : resolution_max; 272 warnx("value %d is out of range for entry %s; clipping " 273 "to %d", ival, name, newival); 274 ival = newival; 275 } 276 if (dest->value.ivalue != ival) 277 editlist_changed = 1; 278 dest->value.ivalue = ival; 279 break; 280 281 case 'c': /* Character array. */ 282 case 'z': /* Null-padded string. */ 283 if ((cval = malloc(dest->size + 1)) == NULL) 284 err(EX_OSERR, NULL); 285 bzero(cval, dest->size + 1); 286 strncpy(cval, newvalue, dest->size); 287 if (dest->type == 'z') { 288 /* Convert trailing spaces to nulls. */ 289 char *conv_end; 290 291 for (conv_end = cval + dest->size; 292 conv_end >= cval; conv_end--) { 293 if (*conv_end == ' ') 294 *conv_end = '\0'; 295 else if (*conv_end != '\0') 296 break; 297 } 298 } 299 if (strncmp(dest->value.svalue, cval, dest->size) == 0) { 300 /* Nothing changed, free the newly allocated string. */ 301 free(cval); 302 break; 303 } 304 if (dest->value.svalue != NULL) { 305 /* Free the current string buffer. */ 306 free(dest->value.svalue); 307 dest->value.svalue = NULL; 308 } 309 dest->value.svalue = cval; 310 editlist_changed = 1; 311 break; 312 313 default: 314 ; /* NOTREACHED */ 315 } 316 317 return (0); 318 } 319 320 static void 321 nameentry_create(int pagenum, char *name) { 322 struct pagename *newentry; 323 324 if (pagenum < 0 || name == NULL || name[0] == '\0') 325 return; 326 327 /* Allocate memory for the new entry and a copy of the entry name. */ 328 if ((newentry = malloc(sizeof(struct pagename))) == NULL || 329 (newentry->name = strdup(name)) == NULL) 330 err(EX_OSERR, NULL); 331 332 /* Trim any trailing whitespace for the page name. */ 333 RTRIM(newentry->name); 334 335 newentry->pagenum = pagenum; 336 SLIST_INSERT_HEAD(&namelist, newentry, link); 337 } 338 339 static struct pagename * 340 nameentry_lookup(int pagenum) { 341 struct pagename *scan; 342 343 SLIST_FOREACH(scan, &namelist, link) { 344 if (pagenum == scan->pagenum) 345 return (scan); 346 } 347 348 /* Not found during list traversal. */ 349 return (NULL); 350 } 351 352 static int 353 load_format(const char *pagedb_path, int page) 354 { 355 FILE *pagedb; 356 char str_pagenum[MAX_PAGENUM_LEN]; 357 char str_pagename[MAX_PAGENAME_LEN]; 358 int pagenum; 359 int depth; /* Quoting depth. */ 360 int found; 361 int lineno; 362 enum { LOCATE, PAGENAME, PAGEDEF } state; 363 char c; 364 365 #define SETSTATE_LOCATE do { \ 366 str_pagenum[0] = '\0'; \ 367 str_pagename[0] = '\0'; \ 368 pagenum = -1; \ 369 state = LOCATE; \ 370 } while (0) 371 372 #define SETSTATE_PAGENAME do { \ 373 str_pagename[0] = '\0'; \ 374 state = PAGENAME; \ 375 } while (0) 376 377 #define SETSTATE_PAGEDEF do { \ 378 format[0] = '\0'; \ 379 state = PAGEDEF; \ 380 } while (0) 381 382 #define UPDATE_LINENO do { \ 383 if (c == '\n') \ 384 lineno++; \ 385 } while (0) 386 387 #define BUFFERFULL(buffer) (strlen(buffer) + 1 >= sizeof(buffer)) 388 389 if ((pagedb = fopen(pagedb_path, "r")) == NULL) 390 returnerr(ENOENT); 391 392 SLIST_INIT(&namelist); 393 394 depth = 0; 395 lineno = 0; 396 found = 0; 397 SETSTATE_LOCATE; 398 while ((c = fgetc(pagedb)) != EOF) { 399 400 /* Keep a line count to make error messages more useful. */ 401 UPDATE_LINENO; 402 403 /* Skip over comments anywhere in the mode database. */ 404 if (c == '#') { 405 do { 406 c = fgetc(pagedb); 407 } while (c != '\n' && c != EOF); 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) { 466 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path, 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 { 482 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path, 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 { 499 errx(EX_OSFILE, "%s:%d: %s %zd %s", pagedb_path, 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 524 static void 525 editlist_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 554 static void 555 editlist_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 609 static int 610 modepage_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 630 static int 631 modepage_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. */ 637 size_t length; /* Length of static fgetln buffer. */ 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 712 static void 713 modepage_edit(void) 714 { 715 const char *editor; 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 774 static void 775 modepage_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; 782 int mode_idx; /* Index for scanning mode params. */ 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. */ 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' : ' '); 795 } 796 putchar('\n'); 797 } 798 799 static void 800 cleanup_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 809 void 810 mode_edit(struct cam_device *device, int page, int page_control, int dbd, 811 int edit, int binary, int retry_count, int timeout) 812 { 813 const char *pagedb_path; /* Path to modepage database. */ 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 862 void 863 mode_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. */ 867 u_int8_t *mode_pars; /* Pointer to modepage params. */ 868 struct scsi_mode_header_6 *mh; /* Location of mode header. */ 869 struct scsi_mode_page_header *mph; 870 struct pagename *nameentry; 871 const char *pagedb_path; 872 int len; 873 874 if ((pagedb_path = getenv("SCSI_MODES")) == NULL) 875 pagedb_path = DEFAULT_SCSI_MODE_DB; 876 877 if (load_format(pagedb_path, 0) != 0 && verbose && errno == ENOENT) { 878 /* Modepage database file not found. */ 879 warn("cannot open modepage database \"%s\"", pagedb_path); 880 } 881 882 /* Build the list of all mode pages by querying the "all pages" page. */ 883 mode_sense(device, SMS_ALL_PAGES_PAGE, page_control, dbd, retry_count, 884 timeout, data, sizeof(data)); 885 886 mh = (struct scsi_mode_header_6 *)data; 887 len = mh->blk_desc_len; /* Skip block descriptors. */ 888 /* Iterate through the pages in the reply. */ 889 while (len < mh->data_length) { 890 /* Locate the next mode page header. */ 891 mph = (struct scsi_mode_page_header *) 892 ((intptr_t)mh + sizeof(*mh) + len); 893 mode_pars = MODE_PAGE_DATA(mph); 894 895 mph->page_code &= SMS_PAGE_CODE; 896 nameentry = nameentry_lookup(mph->page_code); 897 898 if (nameentry == NULL || nameentry->name == NULL) 899 printf("0x%02x\n", mph->page_code); 900 else 901 printf("0x%02x\t%s\n", mph->page_code, 902 nameentry->name); 903 len += mph->page_length + sizeof(*mph); 904 } 905 } 906