1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 #include <errno.h> 27 #include <sys/types.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <strings.h> 31 #include <stdio.h> 32 #include <ofmt.h> 33 #include <sys/termios.h> 34 #include <unistd.h> 35 #include <sys/sysmacros.h> 36 #include <libintl.h> 37 38 /* 39 * functions and structures to internally process a comma-separated string 40 * of fields selected for output. 41 */ 42 typedef struct { 43 char *s_buf; 44 const char **s_fields; /* array of pointers to the fields in s_buf */ 45 uint_t s_nfields; /* the number of fields in s_buf */ 46 uint_t s_currfield; /* the current field being processed */ 47 } split_t; 48 static void splitfree(split_t *); 49 static split_t *split_str(const char *, uint_t); 50 static split_t *split_fields(const ofmt_field_t *, uint_t, uint_t); 51 52 /* 53 * The state of the output is tracked in a ofmt_state_t structure. 54 * Each os_fields[i] entry points at an ofmt_field_t array for 55 * the sub-command whose contents are provided by the caller, with 56 * os_nfields set to the number of requested fields. 57 */ 58 typedef struct ofmt_state_s { 59 ofmt_field_t *os_fields; 60 uint_t os_nfields; 61 boolean_t os_lastfield; 62 uint_t os_overflow; 63 struct winsize os_winsize; 64 int os_nrow; 65 uint_t os_flags; 66 int os_nbad; 67 char **os_badfields; 68 int os_maxnamelen; /* longest name (f. multiline) */ 69 } ofmt_state_t; 70 /* 71 * A B_TRUE return value from the callback function will print out the contents 72 * of the output buffer, except when the buffer is returned with the empty 73 * string "", in which case the OFMT_VAL_UNDEF will be printed. 74 * 75 * If the callback function returns B_FALSE, the "?" string will be emitted. 76 */ 77 #define OFMT_VAL_UNDEF "--" 78 #define OFMT_VAL_UNKNOWN "?" 79 80 /* 81 * The maximum number of rows supported by the OFMT_WRAP option. 82 */ 83 #define OFMT_MAX_ROWS 128 84 85 static void ofmt_print_header(ofmt_state_t *); 86 static void ofmt_print_field(ofmt_state_t *, ofmt_field_t *, const char *, 87 boolean_t); 88 89 /* 90 * Split `str' into at most `maxfields' fields, Return a pointer to a 91 * split_t containing the split fields, or NULL on failure. 92 */ 93 static split_t * 94 split_str(const char *str, uint_t maxfields) 95 { 96 char *field, *token, *lasts = NULL; 97 split_t *sp; 98 99 if (*str == '\0' || maxfields == 0) 100 return (NULL); 101 102 sp = calloc(sizeof (split_t), 1); 103 if (sp == NULL) 104 return (NULL); 105 106 sp->s_buf = strdup(str); 107 sp->s_fields = malloc(sizeof (char *) * maxfields); 108 if (sp->s_buf == NULL || sp->s_fields == NULL) 109 goto fail; 110 111 token = sp->s_buf; 112 while ((field = strtok_r(token, ",", &lasts)) != NULL) { 113 if (sp->s_nfields == maxfields) 114 goto fail; 115 token = NULL; 116 sp->s_fields[sp->s_nfields++] = field; 117 } 118 return (sp); 119 fail: 120 splitfree(sp); 121 return (NULL); 122 } 123 124 /* 125 * Split `fields' into at most `maxfields' fields. Return a pointer to 126 * a split_t containing the split fields, or NULL on failure. Invoked 127 * when all fields are implicitly selected at handle creation by 128 * passing in a NULL fields_str 129 */ 130 static split_t * 131 split_fields(const ofmt_field_t *template, uint_t maxfields, uint_t maxcols) 132 { 133 split_t *sp; 134 int i, cols; 135 136 sp = calloc(sizeof (split_t), 1); 137 if (sp == NULL) 138 return (NULL); 139 140 sp->s_fields = malloc(sizeof (char *) * maxfields); 141 if (sp->s_fields == NULL) 142 goto fail; 143 cols = 0; 144 for (i = 0; i < maxfields; i++) { 145 cols += template[i].of_width; 146 /* 147 * If all fields are implied without explicitly passing 148 * in a fields_str, build a list of field names, stopping 149 * when we run out of columns. 150 */ 151 if (maxcols > 0 && cols > maxcols) 152 break; 153 sp->s_fields[sp->s_nfields++] = template[i].of_name; 154 } 155 return (sp); 156 fail: 157 splitfree(sp); 158 return (NULL); 159 } 160 161 /* 162 * Free the split_t structure pointed to by `sp'. 163 */ 164 static void 165 splitfree(split_t *sp) 166 { 167 if (sp == NULL) 168 return; 169 free(sp->s_buf); 170 free(sp->s_fields); 171 free(sp); 172 } 173 174 /* 175 * Open a handle to be used for printing formatted output. 176 */ 177 ofmt_status_t 178 ofmt_open(const char *str, const ofmt_field_t *template, uint_t flags, 179 uint_t maxcols, ofmt_handle_t *ofmt) 180 { 181 split_t *sp; 182 uint_t i, j, of_index; 183 const ofmt_field_t *ofp; 184 ofmt_field_t *of; 185 ofmt_state_t *os = NULL; 186 int nfields = 0; 187 ofmt_status_t error = OFMT_SUCCESS; 188 boolean_t parsable = (flags & OFMT_PARSABLE); 189 boolean_t wrap = (flags & OFMT_WRAP); 190 boolean_t multiline = (flags & OFMT_MULTILINE); 191 192 *ofmt = NULL; 193 if (parsable) { 194 if (multiline) 195 return (OFMT_EPARSEMULTI); 196 /* 197 * For parsable output mode, the caller always needs 198 * to specify precisely which fields are to be selected, 199 * since the set of fields may change over time. 200 */ 201 if (str == NULL || str[0] == '\0') 202 return (OFMT_EPARSENONE); 203 if (strcasecmp(str, "all") == 0) 204 return (OFMT_EPARSEALL); 205 if (wrap) 206 return (OFMT_EPARSEWRAP); 207 } 208 if (template == NULL) 209 return (OFMT_ENOTEMPLATE); 210 for (ofp = template; ofp->of_name != NULL; ofp++) 211 nfields++; 212 /* 213 * split str into the columns selected, or construct the 214 * full set of columns (equivalent to -o all). 215 */ 216 if (str != NULL && strcasecmp(str, "all") != 0) { 217 sp = split_str(str, nfields); 218 } else { 219 if (parsable || (str != NULL && strcasecmp(str, "all") == 0)) 220 maxcols = 0; 221 sp = split_fields(template, nfields, maxcols); 222 } 223 if (sp == NULL) 224 goto nomem; 225 226 os = calloc(sizeof (ofmt_state_t) + 227 sp->s_nfields * sizeof (ofmt_field_t), 1); 228 if (os == NULL) 229 goto nomem; 230 *ofmt = os; 231 os->os_fields = (ofmt_field_t *)&os[1]; 232 os->os_flags = flags; 233 234 of = os->os_fields; 235 of_index = 0; 236 /* 237 * sp->s_nfields is the number of fields requested in fields_str. 238 * nfields is the number of fields in template. 239 */ 240 for (i = 0; i < sp->s_nfields; i++) { 241 for (j = 0; j < nfields; j++) { 242 if (strcasecmp(sp->s_fields[i], 243 template[j].of_name) == 0) { 244 break; 245 } 246 } 247 if (j == nfields) { 248 int nbad = os->os_nbad++; 249 250 error = OFMT_EBADFIELDS; 251 if (os->os_badfields == NULL) { 252 os->os_badfields = malloc(sp->s_nfields * 253 sizeof (char *)); 254 if (os->os_badfields == NULL) 255 goto nomem; 256 } 257 os->os_badfields[nbad] = strdup(sp->s_fields[i]); 258 if (os->os_badfields[nbad] == NULL) 259 goto nomem; 260 continue; 261 } 262 of[of_index].of_name = strdup(template[j].of_name); 263 if (of[of_index].of_name == NULL) 264 goto nomem; 265 if (multiline) { 266 int n = strlen(of[of_index].of_name); 267 268 os->os_maxnamelen = MAX(n, os->os_maxnamelen); 269 } 270 of[of_index].of_width = template[j].of_width; 271 of[of_index].of_id = template[j].of_id; 272 of[of_index].of_cb = template[j].of_cb; 273 of_index++; 274 } 275 splitfree(sp); 276 if (of_index == 0) /* all values in str are bogus */ 277 return (OFMT_ENOFIELDS); 278 os->os_nfields = of_index; /* actual number of fields printed */ 279 ofmt_update_winsize(*ofmt); 280 return (error); 281 nomem: 282 error = OFMT_ENOMEM; 283 if (os != NULL) 284 ofmt_close(os); 285 *ofmt = NULL; 286 splitfree(sp); 287 return (error); 288 } 289 290 /* 291 * free resources associated with the ofmt_handle_t 292 */ 293 void 294 ofmt_close(ofmt_handle_t ofmt) 295 { 296 ofmt_state_t *os = ofmt; 297 int i; 298 299 if (os == NULL) 300 return; 301 for (i = 0; i < os->os_nfields; i++) 302 free(os->os_fields[i].of_name); 303 for (i = 0; i < os->os_nbad; i++) 304 free(os->os_badfields[i]); 305 free(os->os_badfields); 306 free(os); 307 } 308 309 /* 310 * Print the value for the selected field by calling the callback-function 311 * registered for the field. 312 */ 313 static void 314 ofmt_print_field(ofmt_state_t *os, ofmt_field_t *ofp, const char *value, 315 boolean_t escsep) 316 { 317 uint_t width = ofp->of_width; 318 uint_t valwidth; 319 uint_t compress; 320 boolean_t parsable = (os->os_flags & OFMT_PARSABLE); 321 boolean_t multiline = (os->os_flags & OFMT_MULTILINE); 322 boolean_t rightjust = (os->os_flags & OFMT_RIGHTJUST); 323 char c; 324 325 /* 326 * Parsable fields are separated by ':'. If such a field contains 327 * a ':' or '\', this character is prefixed by a '\'. 328 */ 329 if (parsable) { 330 if (os->os_nfields == 1) { 331 (void) printf("%s", value); 332 return; 333 } 334 while ((c = *value++) != '\0') { 335 if (escsep && ((c == ':' || c == '\\'))) 336 (void) putchar('\\'); 337 (void) putchar(c); 338 } 339 if (!os->os_lastfield) 340 (void) putchar(':'); 341 } else if (multiline) { 342 if (value[0] == '\0') 343 value = OFMT_VAL_UNDEF; 344 (void) printf("%*.*s: %s", os->os_maxnamelen, 345 os->os_maxnamelen, ofp->of_name, value); 346 if (!os->os_lastfield) 347 (void) putchar('\n'); 348 } else { 349 if (os->os_lastfield) { 350 if (rightjust) 351 (void) printf("%*s", width, value); 352 else 353 (void) printf("%s", value); 354 os->os_overflow = 0; 355 return; 356 } 357 358 valwidth = strlen(value); 359 if (valwidth + os->os_overflow >= width) { 360 os->os_overflow += valwidth - width + 1; 361 if (rightjust) 362 (void) printf("%*s ", width, value); 363 else 364 (void) printf("%s ", value); 365 return; 366 } 367 368 if (os->os_overflow > 0) { 369 compress = MIN(os->os_overflow, width - valwidth); 370 os->os_overflow -= compress; 371 width -= compress; 372 } 373 if (rightjust) 374 (void) printf("%*s ", width, value); 375 else 376 (void) printf("%-*s", width, value); 377 } 378 } 379 380 /* 381 * Print enough to fit the field width. 382 */ 383 static void 384 ofmt_fit_width(split_t **spp, uint_t width, char *value, uint_t bufsize) 385 { 386 split_t *sp = *spp; 387 char *ptr = value, *lim = ptr + bufsize; 388 int i, nextlen; 389 390 if (sp == NULL) { 391 sp = split_str(value, OFMT_MAX_ROWS); 392 if (sp == NULL) 393 return; 394 395 *spp = sp; 396 } 397 for (i = sp->s_currfield; i < sp->s_nfields; i++) { 398 ptr += snprintf(ptr, lim - ptr, "%s,", sp->s_fields[i]); 399 if (i + 1 == sp->s_nfields) { 400 nextlen = 0; 401 if (ptr > value) 402 ptr[-1] = '\0'; 403 } else { 404 nextlen = strlen(sp->s_fields[i + 1]); 405 } 406 407 if (strlen(value) + nextlen > width || ptr >= lim) { 408 i++; 409 break; 410 } 411 } 412 sp->s_currfield = i; 413 } 414 415 /* 416 * Print one or more rows of output values for the selected columns. 417 */ 418 void 419 ofmt_print(ofmt_handle_t ofmt, void *arg) 420 { 421 ofmt_state_t *os = ofmt; 422 int i; 423 char value[1024]; 424 ofmt_field_t *of; 425 boolean_t escsep, more_rows; 426 ofmt_arg_t ofarg; 427 split_t **sp = NULL; 428 boolean_t parsable = (os->os_flags & OFMT_PARSABLE); 429 boolean_t multiline = (os->os_flags & OFMT_MULTILINE); 430 boolean_t wrap = (os->os_flags & OFMT_WRAP); 431 432 if (wrap) { 433 sp = calloc(sizeof (split_t *), os->os_nfields); 434 if (sp == NULL) 435 return; 436 } 437 438 if ((os->os_nrow++ % os->os_winsize.ws_row) == 0 && 439 !parsable && !multiline) { 440 ofmt_print_header(os); 441 os->os_nrow++; 442 } 443 444 if (multiline && os->os_nrow > 1) 445 (void) putchar('\n'); 446 447 of = os->os_fields; 448 escsep = (os->os_nfields > 1); 449 more_rows = B_FALSE; 450 for (i = 0; i < os->os_nfields; i++) { 451 os->os_lastfield = (i + 1 == os->os_nfields); 452 value[0] = '\0'; 453 ofarg.ofmt_id = of[i].of_id; 454 ofarg.ofmt_cbarg = arg; 455 456 if ((*of[i].of_cb)(&ofarg, value, sizeof (value))) { 457 if (wrap) { 458 /* 459 * 'value' will be split at comma boundaries 460 * and stored into sp[i]. 461 */ 462 ofmt_fit_width(&sp[i], of[i].of_width, value, 463 sizeof (value)); 464 if (sp[i] != NULL && 465 sp[i]->s_currfield < sp[i]->s_nfields) 466 more_rows = B_TRUE; 467 } 468 469 ofmt_print_field(os, &of[i], 470 (*value == '\0' && !parsable) ? 471 OFMT_VAL_UNDEF : value, escsep); 472 } else { 473 ofmt_print_field(os, &of[i], OFMT_VAL_UNKNOWN, escsep); 474 } 475 } 476 (void) putchar('\n'); 477 478 while (more_rows) { 479 more_rows = B_FALSE; 480 for (i = 0; i < os->os_nfields; i++) { 481 os->os_lastfield = (i + 1 == os->os_nfields); 482 value[0] = '\0'; 483 484 ofmt_fit_width(&sp[i], of[i].of_width, 485 value, sizeof (value)); 486 if (sp[i] != NULL && 487 sp[i]->s_currfield < sp[i]->s_nfields) 488 more_rows = B_TRUE; 489 490 ofmt_print_field(os, &of[i], value, escsep); 491 } 492 (void) putchar('\n'); 493 } 494 (void) fflush(stdout); 495 496 if (sp != NULL) { 497 for (i = 0; i < os->os_nfields; i++) 498 splitfree(sp[i]); 499 free(sp); 500 } 501 } 502 503 /* 504 * Print the field headers 505 */ 506 static void 507 ofmt_print_header(ofmt_state_t *os) 508 { 509 int i; 510 ofmt_field_t *of = os->os_fields; 511 boolean_t escsep = (os->os_nfields > 1); 512 513 for (i = 0; i < os->os_nfields; i++) { 514 os->os_lastfield = (i + 1 == os->os_nfields); 515 ofmt_print_field(os, &of[i], of[i].of_name, escsep); 516 } 517 (void) putchar('\n'); 518 } 519 520 /* 521 * Update the current window size. 522 */ 523 void 524 ofmt_update_winsize(ofmt_handle_t ofmt) 525 { 526 ofmt_state_t *os = ofmt; 527 struct winsize *winsize = &os->os_winsize; 528 529 if (ioctl(1, TIOCGWINSZ, winsize) == -1 || 530 winsize->ws_col == 0 || winsize->ws_row == 0) { 531 winsize->ws_col = 80; 532 winsize->ws_row = 24; 533 } 534 } 535 536 /* 537 * Return error diagnostics using the information in the ofmt_handle_t 538 */ 539 char * 540 ofmt_strerror(ofmt_handle_t ofmt, ofmt_status_t error, char *buf, 541 uint_t bufsize) 542 { 543 ofmt_state_t *os = ofmt; 544 int i; 545 const char *s; 546 char ebuf[OFMT_BUFSIZE]; 547 boolean_t parsable; 548 549 /* 550 * ebuf is intended for optional error-specific data to be appended 551 * after the internationalized error string for an error code. 552 */ 553 ebuf[0] = '\0'; 554 555 switch (error) { 556 case OFMT_SUCCESS: 557 s = "success"; 558 break; 559 case OFMT_EBADFIELDS: 560 /* 561 * Enumerate the singular/plural version of the warning 562 * and error to simplify and improve localization. 563 */ 564 parsable = (os->os_flags & OFMT_PARSABLE); 565 if (!parsable) { 566 if (os->os_nbad > 1) 567 s = "ignoring unknown output fields:"; 568 else 569 s = "ignoring unknown output field:"; 570 } else { 571 if (os->os_nbad > 1) 572 s = "unknown output fields:"; 573 else 574 s = "unknown output field:"; 575 } 576 /* set up the bad fields in ebuf */ 577 for (i = 0; i < os->os_nbad; i++) { 578 (void) strlcat(ebuf, " `", sizeof (ebuf)); 579 (void) strlcat(ebuf, os->os_badfields[i], 580 sizeof (ebuf)); 581 (void) strlcat(ebuf, "'", sizeof (ebuf)); 582 } 583 break; 584 case OFMT_ENOFIELDS: 585 s = "no valid output fields"; 586 break; 587 case OFMT_EPARSEMULTI: 588 s = "multiline mode incompatible with parsable mode"; 589 break; 590 case OFMT_EPARSEALL: 591 s = "output field `all' invalid in parsable mode"; 592 break; 593 case OFMT_EPARSENONE: 594 s = "output fields must be specified in parsable mode"; 595 break; 596 case OFMT_EPARSEWRAP: 597 s = "parsable mode is incompatible with wrap mode"; 598 break; 599 case OFMT_ENOTEMPLATE: 600 s = "no template provided for fields"; 601 break; 602 case OFMT_ENOMEM: 603 s = strerror(ENOMEM); 604 break; 605 default: 606 (void) snprintf(buf, bufsize, 607 dgettext(TEXT_DOMAIN, "unknown ofmt error (%d)"), 608 error); 609 return (buf); 610 } 611 (void) snprintf(buf, bufsize, dgettext(TEXT_DOMAIN, s)); 612 (void) strlcat(buf, ebuf, bufsize); 613 return (buf); 614 } 615