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 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 #include <ctype.h> 28 #include <dirent.h> 29 #include <grp.h> 30 #include <libintl.h> 31 #include <limits.h> 32 #include <locale.h> 33 #include <pwd.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <sys/types.h> 38 #include <sys/inttypes.h> 39 #include <sys/file.h> 40 #include <sys/param.h> 41 #include <sys/uio.h> 42 #include <sys/stat.h> 43 #include <sys/acl.h> 44 #include <sys/socket.h> 45 #include <sys/errno.h> 46 #include <sys/ipc.h> 47 #include <sys/sem.h> 48 #include <sys/systm.h> 49 #include <netinet/in.h> 50 #include <sys/tiuser.h> 51 #include <rpc/types.h> 52 #include <rpc/auth.h> 53 #include <rpc/auth_unix.h> 54 #include <rpc/svc.h> 55 #include <rpc/xdr.h> 56 #include <nfs/nfs.h> 57 #include <sys/fs/ufs_quota.h> 58 #include <sys/time.h> 59 #include <sys/mkdev.h> 60 #include <unistd.h> 61 62 #include <bsm/audit.h> 63 #include <bsm/audit_record.h> 64 #include <bsm/libbsm.h> 65 66 #include <tsol/label.h> 67 68 #include "praudit.h" 69 #include "toktable.h" 70 71 #include <netdb.h> 72 #include <arpa/inet.h> 73 74 static char *anchor_path(char *); 75 static char *collapse_path(char *); 76 77 78 /* 79 * ----------------------------------------------------------------------- 80 * is_file_token: 81 * Tests whether the specified token id represents a type 82 * of file token. 83 * return codes : 1 - tokenid is a file token type 84 * : 0 - otherwise 85 * ----------------------------------------------------------------------- 86 */ 87 int 88 is_file_token(int tokenid) 89 { 90 if ((tokenid == AUT_OTHER_FILE32) || (tokenid == AUT_OTHER_FILE64)) 91 return (1); 92 93 return (0); 94 } 95 96 /* 97 * ----------------------------------------------------------------------- 98 * is_header_token: 99 * Tests whether the specified token id represents a type 100 * of header token (signifying the start of a record). 101 * return codes : 1 - tokenid is a header type 102 * : 0 - otherwise 103 * ----------------------------------------------------------------------- 104 */ 105 int 106 is_header_token(int tokenid) 107 { 108 if ((tokenid == AUT_OHEADER) || (tokenid == AUT_HEADER32) || 109 (tokenid == AUT_HEADER32_EX) || (tokenid == AUT_HEADER64) || 110 (tokenid == AUT_HEADER64_EX)) 111 return (1); 112 113 return (0); 114 } 115 116 /* 117 * ----------------------------------------------------------------------- 118 * is_token: 119 * Tests whether the specified token id represents a true 120 * token, as opposed to a regular tag. 121 * return codes : 1 - tokenid is a true token 122 * : 0 - otherwise 123 * ----------------------------------------------------------------------- 124 */ 125 int 126 is_token(int tokenid) 127 { 128 if ((tokenid > 0) && (tokenid <= MAXTOKEN)) 129 return (1); 130 131 return (0); 132 } 133 134 135 /* 136 * ----------------------------------------------------------------------- 137 * exit_token() : Process information label token and display contents 138 * return codes : -1 - error 139 * : 0 - successful 140 * NOTE: At the time of call, the label token id has been retrieved 141 * 142 * Format of exit token: 143 * exit token id adr_char 144 * ----------------------------------------------------------------------- 145 */ 146 int 147 exit_token(pr_context_t *context) 148 { 149 int returnstat; 150 int retval; 151 uval_t uval; 152 153 if ((returnstat = open_tag(context, TAG_ERRVAL)) != 0) 154 return (returnstat); 155 156 if ((returnstat = pr_adr_int32(context, (int32_t *)&retval, 1)) == 0) { 157 if (!(context->format & PRF_RAWM)) { 158 char *emsg = strerror(retval); 159 160 if (emsg == NULL) 161 uval.string_val = gettext("Unknown errno"); 162 else 163 uval.string_val = gettext(emsg); 164 uval.uvaltype = PRA_STRING; 165 } else { 166 uval.uvaltype = PRA_INT32; 167 uval.int32_val = retval; 168 } 169 returnstat = pa_print(context, &uval, 0); 170 } 171 if (returnstat == 0) 172 returnstat = close_tag(context, TAG_ERRVAL); 173 174 return (process_tag(context, TAG_RETVAL, returnstat, 1)); 175 } 176 177 /* 178 * ------------------------------------------------------------------ 179 * file_token() : prints out seconds of time and other file name 180 * return codes : -1 - error 181 * : 0 - successful, valid file token fields 182 * At the time of entry, the file token ID has already been retrieved 183 * 184 * Format of file token: 185 * file token id adr_char 186 * seconds of time adr_u_int 187 * name of other file adr_string 188 * ------------------------------------------------------------------ 189 */ 190 int 191 file_token(pr_context_t *context) 192 { 193 int returnstat; 194 195 returnstat = pa_utime32(context, 0, 0); /* time from usecs */ 196 197 /* other file name */ 198 returnstat = pa_file_string(context, returnstat, 1); 199 200 return (returnstat); 201 } 202 203 int 204 file64_token(pr_context_t *context) 205 { 206 int returnstat; 207 208 returnstat = pa_utime64(context, 0, 0); /* time from usecs */ 209 210 /* other file name */ 211 returnstat = pa_file_string(context, returnstat, 1); 212 213 return (returnstat); 214 } 215 216 /* 217 * ----------------------------------------------------------------------- 218 * header_token() : Process record header token and display contents 219 * return codes : -1 - error 220 * : 0 - successful 221 * : 1 - warning, password entry not found 222 * 223 * NOTE: At the time of call, the header token id has been retrieved 224 * 225 * Format of header token: 226 * header token id adr_char 227 * record byte count adr_u_int 228 * event type adr_u_short (printed either ASCII or raw) 229 * event class adr_u_int (printed either ASCII or raw) 230 * event action adr_u_int 231 * if extended: extended host name (IPv4/IPv6) 232 * seconds of time adr_u_int (printed either ASCII or raw) 233 * nanoseconds of time adr_u_int 234 * ----------------------------------------------------------------------- 235 */ 236 int 237 header_token(pr_context_t *context) 238 { 239 int returnstat; 240 241 returnstat = pa_reclen(context, 0); /* record byte */ 242 /* version ID */ 243 returnstat = process_tag(context, TAG_TOKVERS, returnstat, 0); 244 /* event type */ 245 returnstat = process_tag(context, TAG_EVTYPE, returnstat, 0); 246 /* event modifier */ 247 returnstat = pa_event_modifier(context, returnstat, 0); 248 /* time from nsec */ 249 returnstat = pa_ntime32(context, returnstat, 1); 250 251 return (returnstat); 252 } 253 254 int 255 header64_token(pr_context_t *context) 256 { 257 int returnstat; 258 259 returnstat = pa_reclen(context, 0); /* record byte */ 260 /* version ID */ 261 returnstat = process_tag(context, TAG_TOKVERS, returnstat, 0); 262 /* event type */ 263 returnstat = process_tag(context, TAG_EVTYPE, returnstat, 0); 264 /* event modifier */ 265 returnstat = pa_event_modifier(context, returnstat, 0); 266 /* time from nsec */ 267 returnstat = pa_ntime64(context, returnstat, 1); 268 269 return (returnstat); 270 } 271 272 int 273 header32_ex_token(pr_context_t *context) 274 { 275 int returnstat; 276 277 returnstat = pa_reclen(context, 0); /* record byte */ 278 /* version ID */ 279 returnstat = process_tag(context, TAG_TOKVERS, returnstat, 0); 280 /* event type */ 281 returnstat = process_tag(context, TAG_EVTYPE, returnstat, 0); 282 /* event modifier */ 283 returnstat = pa_event_modifier(context, returnstat, 0); 284 /* machine name */ 285 returnstat = pa_hostname_ex(context, returnstat, 0); 286 /* time from nsec */ 287 returnstat = pa_ntime32(context, returnstat, 1); 288 289 return (returnstat); 290 } 291 292 int 293 header64_ex_token(pr_context_t *context) 294 { 295 int returnstat; 296 297 returnstat = pa_reclen(context, 0); /* record byte */ 298 /* version ID */ 299 returnstat = process_tag(context, TAG_TOKVERS, returnstat, 0); 300 /* event type */ 301 returnstat = process_tag(context, TAG_EVTYPE, returnstat, 0); 302 /* event modifier */ 303 returnstat = pa_event_modifier(context, returnstat, 0); 304 /* machine name */ 305 returnstat = pa_hostname_ex(context, returnstat, 0); 306 /* time from nsec */ 307 returnstat = pa_ntime64(context, returnstat, 1); 308 309 return (returnstat); 310 } 311 312 /* 313 * ----------------------------------------------------------------------- 314 * trailer_token() : Process record trailer token and display contents 315 * return codes : -1 - error 316 * : 0 - successful 317 * NOTE: At the time of call, the trailer token id has already been 318 * retrieved 319 * 320 * Format of trailer token: 321 * trailer token id adr_char 322 * record sequence no adr_u_short (should be AUT_TRAILER_MAGIC) 323 * record byte count adr_u_int 324 * ----------------------------------------------------------------------- 325 */ 326 int 327 trailer_token(pr_context_t *context) 328 { 329 short magic_number; 330 331 if (pr_adr_u_short(context, (ushort_t *)&magic_number, 1) < 0) { 332 (void) fprintf(stderr, gettext( 333 "praudit: Cannot retrieve trailer magic number\n")); 334 return (-1); 335 } else { 336 if (magic_number != AUT_TRAILER_MAGIC) { 337 (void) fprintf(stderr, gettext( 338 "praudit: Invalid trailer magic number\n")); 339 return (-1); 340 } else 341 /* Do not display trailer in XML mode */ 342 if (context->format & PRF_XMLM) { 343 uint32_t junk; 344 int retstat; 345 346 retstat = pr_adr_u_int32(context, &junk, 1); 347 return (retstat); 348 } else { 349 return (pa_adr_u_int32(context, 0, 1)); 350 } 351 } 352 } 353 354 /* 355 * ----------------------------------------------------------------------- 356 * arbitrary_data_token(): 357 * Process arbitrary data token and display contents 358 * return codes : -1 - error 359 * : 0 - successful 360 * NOTE: At the time of call, the arbitrary data token id has already 361 * been retrieved 362 * 363 * Format of arbitrary data token: 364 * arbitrary data token id adr char 365 * how to print adr_char 366 * From audit_record.h, this may be either: 367 * AUP_BINARY binary 368 * AUP_OCTAL octal 369 * AUP_DECIMAL decimal 370 * AUP_HEX hexadecimal 371 * basic unit adr_char 372 * From audit_record.h, this may be either: 373 * AUR_BYTE byte 374 * AUR_CHAR char 375 * AUR_SHORT short 376 * AUR_INT32 int32_t 377 * AUR_INT64 int64_t 378 * unit count adr_char, specifying number of units of 379 * data in the "data items" parameter below 380 * data items depends on basic unit 381 * 382 * ----------------------------------------------------------------------- 383 */ 384 int 385 arbitrary_data_token(pr_context_t *context) 386 { 387 int returnstat; 388 int i; 389 char c1; 390 short c2; 391 int32_t c3; 392 int64_t c4; 393 char how_to_print, basic_unit, unit_count, fwid; 394 char *p; 395 int index = 0; 396 char *pformat = "%*s"; 397 398 uval_t uval; 399 400 if ((returnstat = pr_adr_char(context, &how_to_print, 1)) != 0) 401 return (returnstat); 402 403 if ((returnstat = pr_adr_char(context, &basic_unit, 1)) != 0) 404 return (returnstat); 405 406 if ((returnstat = pr_adr_char(context, &unit_count, 1)) != 0) 407 return (returnstat); 408 409 if (!(context->format & PRF_RAWM)) { 410 uval.uvaltype = PRA_STRING; 411 uval.string_val = htp2string(how_to_print); 412 } else { 413 uval.uvaltype = PRA_INT32; 414 uval.int32_val = (int)how_to_print; 415 } 416 417 if ((returnstat = open_tag(context, TAG_ARBPRINT)) != 0) 418 return (returnstat); 419 if ((returnstat = pa_print(context, &uval, 0)) < 0) 420 return (returnstat); 421 if ((returnstat = close_tag(context, TAG_ARBPRINT)) != 0) 422 return (returnstat); 423 424 if (!(context->format & PRF_RAWM)) { 425 uval.uvaltype = PRA_STRING; 426 uval.string_val = bu2string(basic_unit); 427 } else { 428 uval.uvaltype = PRA_INT32; 429 uval.int32_val = (int32_t)basic_unit; 430 } 431 432 if ((returnstat = open_tag(context, TAG_ARBTYPE)) != 0) 433 return (returnstat); 434 if ((returnstat = pa_print(context, &uval, 0)) < 0) 435 return (returnstat); 436 if ((returnstat = close_tag(context, TAG_ARBTYPE)) != 0) 437 return (returnstat); 438 439 uval.uvaltype = PRA_INT32; 440 uval.int32_val = (int32_t)unit_count; 441 442 if ((returnstat = open_tag(context, TAG_ARBCOUNT)) != 0) 443 return (returnstat); 444 if ((returnstat = pa_print(context, &uval, 1)) < 0) 445 return (returnstat); 446 if ((returnstat = close_tag(context, TAG_ARBCOUNT)) != 0) 447 return (returnstat); 448 449 /* Done with attributes; force end of token open */ 450 if ((returnstat = finish_open_tag(context)) != 0) 451 return (returnstat); 452 453 /* get the field width in case we need to format output */ 454 fwid = findfieldwidth(basic_unit, how_to_print); 455 p = (char *)malloc(80); 456 457 /* now get the data items and print them */ 458 for (i = 0; (i < unit_count); i++) { 459 switch (basic_unit) { 460 /* case AUR_BYTE: */ 461 case AUR_CHAR: 462 if (pr_adr_char(context, &c1, 1) == 0) 463 (void) convert_char_to_string(how_to_print, 464 c1, p); 465 else { 466 free(p); 467 return (-1); 468 } 469 break; 470 case AUR_SHORT: 471 if (pr_adr_short(context, &c2, 1) == 0) 472 (void) convert_short_to_string(how_to_print, 473 c2, p); 474 else { 475 free(p); 476 return (-1); 477 } 478 break; 479 case AUR_INT32: 480 if (pr_adr_int32(context, &c3, 1) == 0) 481 (void) convert_int32_to_string(how_to_print, 482 c3, p); 483 else { 484 free(p); 485 return (-1); 486 } 487 break; 488 case AUR_INT64: 489 if (pr_adr_int64(context, &c4, 1) == 0) 490 (void) convert_int64_to_string(how_to_print, 491 c4, p); 492 else { 493 free(p); 494 return (-1); 495 } 496 break; 497 default: 498 free(p); 499 return (-1); 500 /*NOTREACHED*/ 501 } 502 503 /* 504 * At this point, we have successfully retrieved a data 505 * item and converted it into an ASCII string pointed to 506 * by p. If all output is to be printed on one line, 507 * simply separate the data items by a space (or by the 508 * delimiter if this is the last data item), otherwise, we 509 * need to format the output before display. 510 */ 511 if (context->format & PRF_ONELINE) { 512 returnstat = pr_printf(context, "%s", p); 513 if ((returnstat >= 0) && (i == (unit_count - 1))) 514 returnstat = pr_printf(context, "%s", 515 context->SEPARATOR); 516 else 517 returnstat = pr_putchar(context, ' '); 518 } else { /* format output */ 519 returnstat = pr_printf(context, pformat, fwid, p); 520 index += fwid; 521 if ((returnstat >= 0) && 522 (((index + fwid) > 75) || 523 (i == (unit_count - 1)))) { 524 returnstat = pr_putchar(context, '\n'); 525 index = 0; 526 } 527 } /* else if PRF_ONELINE */ 528 if (returnstat < 0) { 529 free(p); 530 return (returnstat); 531 } 532 } 533 free(p); 534 535 return (returnstat); 536 } 537 538 /* 539 * ----------------------------------------------------------------------- 540 * opaque_token() : Process opaque token and display contents 541 * return codes : -1 - error 542 * : 0 - successful 543 * NOTE: At the time of call, the opaque token id has already been 544 * retrieved 545 * 546 * Format of opaque token: 547 * opaque token id adr_char 548 * size adr_short 549 * data adr_char, size times 550 * ----------------------------------------------------------------------- 551 */ 552 int 553 opaque_token(pr_context_t *context) 554 { 555 int returnstat; 556 short size; 557 char *charp; 558 uval_t uval; 559 560 561 /* print the size of the token */ 562 if (pr_adr_short(context, &size, 1) == 0) { 563 uval.uvaltype = PRA_SHORT; 564 uval.short_val = size; 565 returnstat = pa_print(context, &uval, 0); 566 } else 567 returnstat = -1; 568 569 /* now print out the data field in hexadecimal */ 570 if (returnstat >= 0) { 571 /* try to allocate memory for the character string */ 572 if ((charp = (char *)malloc(size * sizeof (char))) == NULL) 573 returnstat = -1; 574 else { 575 if ((returnstat = pr_adr_char(context, charp, 576 size)) == 0) { 577 /* print out in hexadecimal format */ 578 uval.uvaltype = PRA_STRING; 579 uval.string_val = hexconvert(charp, size, size); 580 if (uval.string_val) { 581 returnstat = pa_print(context, 582 &uval, 1); 583 free(uval.string_val); 584 } 585 } 586 free(charp); 587 } 588 } 589 590 return (returnstat); 591 } 592 593 /* 594 * ----------------------------------------------------------------------- 595 * path_token() : Process path token and display contents 596 * return codes : -1 - error 597 * : 0 - successful 598 * NOTE: At the time of call, the path token id has been retrieved 599 * 600 * Format of path token: 601 * token id adr_char 602 * path adr_string 603 * ----------------------------------------------------------------------- 604 */ 605 int 606 path_token(pr_context_t *context) 607 { 608 char *path; /* path */ 609 char *apath; /* anchored path */ 610 char *cpath; /* collapsed path */ 611 short length; 612 int returnstat; 613 uval_t uval; 614 615 /* 616 * We need to know how much space to allocate for our string, so 617 * read the length first, then call pr_adr_char to read those bytes. 618 */ 619 if (pr_adr_short(context, &length, 1) == 0) { 620 if ((path = (char *)malloc(length + 1)) == NULL) { 621 returnstat = -1; 622 } else if (pr_adr_char(context, path, length) == 0) { 623 path[length] = '\0'; 624 uval.uvaltype = PRA_STRING; 625 if (*path != '/') { 626 apath = anchor_path(path); 627 free(path); 628 } else 629 apath = path; 630 cpath = collapse_path(apath); 631 uval.string_val = cpath; 632 returnstat = pa_print(context, &uval, 1); 633 free(cpath); 634 } else { 635 free(path); 636 returnstat = -1; 637 } 638 return (returnstat); 639 } else 640 return (-1); 641 } 642 643 /* 644 * anchor a path name with a slash 645 */ 646 char * 647 anchor_path(char *sp) 648 { 649 char *dp; /* destination path */ 650 char *tp; /* temporary path */ 651 size_t len; 652 653 len = strlen(sp) + 2; 654 if ((dp = tp = (char *)calloc(1, len)) == (char *)0) 655 return ((char *)0); 656 657 *dp++ = '/'; 658 659 (void) strlcpy(dp, sp, len); 660 661 return (tp); 662 } 663 664 /* 665 * copy path to collapsed path. 666 * collapsed path does not contain: 667 * successive slashes 668 * instances of dot-slash 669 * instances of dot-dot-slash 670 * passed path must be anchored with a '/' 671 */ 672 char * 673 collapse_path(char *s) 674 { 675 int id; /* index of where we are in destination string */ 676 int is; /* index of where we are in source string */ 677 int slashseen; /* have we seen a slash */ 678 int ls; /* length of source string */ 679 680 ls = strlen(s) + 1; 681 682 slashseen = 0; 683 for (is = 0, id = 0; is < ls; is++) { 684 /* thats all folks, we've reached the end of input */ 685 if (s[is] == '\0') { 686 if (id > 1 && s[id-1] == '/') { 687 --id; 688 } 689 s[id++] = '\0'; 690 break; 691 } 692 /* previous character was a / */ 693 if (slashseen) { 694 if (s[is] == '/') 695 continue; /* another slash, ignore it */ 696 } else if (s[is] == '/') { 697 /* we see a /, just copy it and try again */ 698 slashseen = 1; 699 s[id++] = '/'; 700 continue; 701 } 702 /* /./ seen */ 703 if (s[is] == '.' && s[is+1] == '/') { 704 is += 1; 705 continue; 706 } 707 /* XXX/. seen */ 708 if (s[is] == '.' && s[is+1] == '\0') { 709 if (id > 1) 710 id--; 711 continue; 712 } 713 /* XXX/.. seen */ 714 if (s[is] == '.' && s[is+1] == '.' && s[is+2] == '\0') { 715 is += 1; 716 if (id > 0) 717 id--; 718 while (id > 0 && s[--id] != '/') 719 continue; 720 id++; 721 continue; 722 } 723 /* XXX/../ seen */ 724 if (s[is] == '.' && s[is+1] == '.' && s[is+2] == '/') { 725 is += 2; 726 if (id > 0) 727 id--; 728 while (id > 0 && s[--id] != '/') 729 continue; 730 id++; 731 continue; 732 } 733 while (is < ls && (s[id++] = s[is++]) != '/') 734 continue; 735 is--; 736 } 737 return (s); 738 } 739 740 /* 741 * ----------------------------------------------------------------------- 742 * cmd_token() : Process cmd token and display contents 743 * return codes : -1 - error 744 * : 0 - successful 745 * NOTE: At the time of call, the cmd token id has been retrieved 746 * 747 * Format of command token: 748 * token id adr_char 749 * argc adr_short 750 * N*argv[i] adr_string (short, string) 751 * env cnt adr_short 752 * N*arge[i] adr_string (short, string) 753 * ----------------------------------------------------------------------- 754 */ 755 int 756 cmd_token(pr_context_t *context) 757 { 758 int returnstat; 759 short num; 760 761 returnstat = pr_adr_short(context, &num, 1); 762 if (returnstat < 0) 763 return (returnstat); 764 765 if (!(context->format & PRF_XMLM)) { 766 returnstat = pr_printf(context, "%s%s%d%s", 767 (context->format & PRF_ONELINE) ? "" : gettext("argcnt"), 768 (context->format & PRF_ONELINE) ? "" : context->SEPARATOR, 769 num, context->SEPARATOR); 770 if (returnstat < 0) 771 return (returnstat); 772 } 773 774 for (; num > 0; num--) { 775 if ((returnstat = process_tag(context, TAG_ARGV, 776 returnstat, 0)) < 0) 777 return (returnstat); 778 } 779 780 if ((returnstat = pr_adr_short(context, &num, 1)) < 0) 781 return (returnstat); 782 783 if (!(context->format & PRF_XMLM)) { 784 returnstat = pr_printf(context, "%s%s%d%s", 785 (context->format & PRF_ONELINE) ? "" : gettext("envcnt"), 786 (context->format & PRF_ONELINE) ? "" : context->SEPARATOR, 787 num, context->SEPARATOR); 788 if (returnstat < 0) 789 return (returnstat); 790 } 791 792 if ((num == 0) && !(context->format & PRF_XMLM)) { 793 returnstat = do_newline(context, 1); 794 if (returnstat < 0) 795 return (returnstat); 796 } 797 798 for (; num > 1; num--) { 799 if ((returnstat = process_tag(context, TAG_ARGE, 800 returnstat, 0)) < 0) 801 return (returnstat); 802 } 803 if (num) 804 returnstat = process_tag(context, TAG_ARGE, returnstat, 1); 805 806 return (returnstat); 807 808 } 809 810 /* 811 * ----------------------------------------------------------------------- 812 * argument32_token() : Process argument token and display contents 813 * return codes : -1 - error 814 * : 0 - successful 815 * NOTE: At the time of call, the arg token id has been retrieved 816 * 817 * Format of argument token: 818 * current directory token id adr_char 819 * argument number adr_char 820 * argument value adr_int32 821 * argument description adr_string 822 * ----------------------------------------------------------------------- 823 */ 824 int 825 argument32_token(pr_context_t *context) 826 { 827 int returnstat; 828 829 returnstat = process_tag(context, TAG_ARGNUM, 0, 0); 830 returnstat = process_tag(context, TAG_ARGVAL32, returnstat, 0); 831 returnstat = process_tag(context, TAG_ARGDESC, returnstat, 1); 832 833 return (returnstat); 834 835 } 836 837 /* 838 * ----------------------------------------------------------------------- 839 * argument64_token() : Process argument token and display contents 840 * return codes : -1 - error 841 * : 0 - successful 842 * NOTE: At the time of call, the arg token id has been retrieved 843 * 844 * Format of 64 bit argument token: 845 * current directory token id adr_char 846 * argument number adr_char 847 * argument value adr_int64 848 * argument description adr_string 849 * ----------------------------------------------------------------------- 850 */ 851 int 852 argument64_token(pr_context_t *context) 853 { 854 int returnstat; 855 856 returnstat = process_tag(context, TAG_ARGNUM, 0, 0); 857 returnstat = process_tag(context, TAG_ARGVAL64, returnstat, 0); 858 returnstat = process_tag(context, TAG_ARGDESC, returnstat, 1); 859 860 return (returnstat); 861 862 } 863 864 /* 865 * ----------------------------------------------------------------------- 866 * process_token() : Process process token and display contents 867 * return codes : -1 - error 868 * : 0 - successful 869 * NOTE: At the time of call, the process token id has been retrieved 870 * 871 * Format of process token: 872 * process token id adr_char 873 * auid adr_u_int32 874 * euid adr_u_int32 875 * egid adr_u_int32 876 * ruid adr_u_int32 877 * egid adr_u_int32 878 * pid adr_u_int32 879 * sid adr_u_int32 880 * tid adr_u_int32, adr_u_int32 881 * ----------------------------------------------------------------------- 882 */ 883 int 884 process32_token(pr_context_t *context) 885 { 886 int returnstat; 887 888 /* auid */ 889 returnstat = process_tag(context, TAG_AUID, 0, 0); 890 /* uid */ 891 returnstat = process_tag(context, TAG_UID, returnstat, 0); 892 /* gid */ 893 returnstat = process_tag(context, TAG_GID, returnstat, 0); 894 /* ruid */ 895 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 896 /* rgid */ 897 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 898 /* pid */ 899 returnstat = process_tag(context, TAG_PID, returnstat, 0); 900 /* sid */ 901 returnstat = process_tag(context, TAG_SID, returnstat, 0); 902 /* tid */ 903 returnstat = process_tag(context, TAG_TID32, returnstat, 1); 904 905 return (returnstat); 906 } 907 908 int 909 process64_token(pr_context_t *context) 910 { 911 int returnstat; 912 913 /* auid */ 914 returnstat = process_tag(context, TAG_AUID, 0, 0); 915 /* uid */ 916 returnstat = process_tag(context, TAG_UID, returnstat, 0); 917 /* gid */ 918 returnstat = process_tag(context, TAG_GID, returnstat, 0); 919 /* ruid */ 920 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 921 /* rgid */ 922 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 923 /* pid */ 924 returnstat = process_tag(context, TAG_PID, returnstat, 0); 925 /* sid */ 926 returnstat = process_tag(context, TAG_SID, returnstat, 0); 927 /* tid */ 928 returnstat = process_tag(context, TAG_TID64, returnstat, 1); 929 930 return (returnstat); 931 } 932 933 /* 934 * ----------------------------------------------------------------------- 935 * process_ex_token() : Process process token and display contents 936 * return codes : -1 - error 937 * : 0 - successful 938 * NOTE: At the time of call, the process token id has been retrieved 939 * 940 * Format of extended process token: 941 * process token id adr_char 942 * auid adr_u_int32 943 * euid adr_u_int32 944 * egid adr_u_int32 945 * ruid adr_u_int32 946 * egid adr_u_int32 947 * pid adr_u_int32 948 * sid adr_u_int32 949 * tid adr_u_int32, adr_u_int32, 4*adr_u_int32 950 * ----------------------------------------------------------------------- 951 */ 952 int 953 process32_ex_token(pr_context_t *context) 954 { 955 int returnstat; 956 957 /* auid */ 958 returnstat = process_tag(context, TAG_AUID, 0, 0); 959 /* uid */ 960 returnstat = process_tag(context, TAG_UID, returnstat, 0); 961 /* gid */ 962 returnstat = process_tag(context, TAG_GID, returnstat, 0); 963 /* ruid */ 964 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 965 /* rgid */ 966 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 967 /* pid */ 968 returnstat = process_tag(context, TAG_PID, returnstat, 0); 969 /* sid */ 970 returnstat = process_tag(context, TAG_SID, returnstat, 0); 971 /* tid */ 972 returnstat = process_tag(context, TAG_TID32_EX, returnstat, 1); 973 974 return (returnstat); 975 } 976 977 int 978 process64_ex_token(pr_context_t *context) 979 { 980 int returnstat; 981 982 /* auid */ 983 returnstat = process_tag(context, TAG_AUID, 0, 0); 984 /* uid */ 985 returnstat = process_tag(context, TAG_UID, returnstat, 0); 986 /* gid */ 987 returnstat = process_tag(context, TAG_GID, returnstat, 0); 988 /* ruid */ 989 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 990 /* rgid */ 991 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 992 /* pid */ 993 returnstat = process_tag(context, TAG_PID, returnstat, 0); 994 /* sid */ 995 returnstat = process_tag(context, TAG_SID, returnstat, 0); 996 /* tid */ 997 returnstat = process_tag(context, TAG_TID64_EX, returnstat, 1); 998 999 return (returnstat); 1000 } 1001 1002 /* 1003 * ----------------------------------------------------------------------- 1004 * return_value32_token(): Process return value and display contents 1005 * return codes : -1 - error 1006 * : 0 - successful 1007 * NOTE: At the time of call, the return value token id has been retrieved 1008 * 1009 * Format of return value token: 1010 * return value token id adr_char 1011 * error number adr_char 1012 * return value adr_int32 1013 * ----------------------------------------------------------------------- 1014 */ 1015 int 1016 return_value32_token(pr_context_t *context) 1017 { 1018 int returnstat; 1019 uchar_t number; 1020 int32_t value; 1021 char pb[512]; /* print buffer */ 1022 uval_t uval; 1023 bool_t used_ret_val = 0; 1024 1025 /* 1026 * Every audit record generated contains a return token. 1027 * 1028 * The return token is a special token. It indicates the success 1029 * or failure of the event that contains it. 1030 * The return32 token contains two pieces of data: 1031 * 1032 * char number; 1033 * int32_t return_value; 1034 * 1035 * For audit records generated by the kernel: 1036 * The kernel always puts a positive value in "number". 1037 * Upon success "number" is 0. 1038 * Upon failure "number" is a positive errno value that is less than 1039 * sys_nerr. 1040 * 1041 * For audit records generated at the user level: 1042 * Upon success "number" is 0. 1043 * Upon failure "number" is -1. 1044 * 1045 * For both kernel and user land the value of "return_value" is 1046 * arbitrary. For the kernel it contains the return value of 1047 * the system call. For user land it contains an arbitrary return 1048 * value if it is less than ADT_FAIL_VALUE; ADT_FAIL_VALUE 1049 * and above are messages defined in adt_event.h. ADT_FAIL_PAM and 1050 * above are messages from pam_strerror(). No interpretation is done 1051 * on "return_value" if it is outside the range of ADT_FAIL_VALUE_* or 1052 * ADT_FAIL_PAM values. 1053 */ 1054 if ((returnstat = open_tag(context, TAG_ERRVAL)) != 0) 1055 return (returnstat); 1056 1057 if ((returnstat = pr_adr_u_char(context, &number, 1)) == 0) { 1058 if (!(context->format & PRF_RAWM)) { 1059 used_ret_val = 1; 1060 pa_error(number, pb, sizeof (pb)); 1061 uval.uvaltype = PRA_STRING; 1062 uval.string_val = pb; 1063 if ((returnstat = pa_print(context, &uval, 0)) != 0) 1064 return (returnstat); 1065 if ((returnstat = close_tag(context, TAG_ERRVAL)) != 0) 1066 return (returnstat); 1067 if ((returnstat = open_tag(context, TAG_RETVAL)) != 0) 1068 return (returnstat); 1069 1070 if ((returnstat = pr_adr_int32( 1071 context, &value, 1)) != 0) 1072 return (returnstat); 1073 1074 pa_retval(number, value, pb, sizeof (pb)); 1075 } else { 1076 uval.uvaltype = PRA_INT32; 1077 if ((char)number == -1) 1078 uval.int32_val = -1; 1079 else 1080 uval.int32_val = number; 1081 } 1082 returnstat = pa_print(context, &uval, used_ret_val); 1083 } 1084 if (used_ret_val) { 1085 if (returnstat == 0) 1086 returnstat = close_tag(context, TAG_RETVAL); 1087 return (returnstat); 1088 } 1089 if (!returnstat) 1090 if (returnstat = close_tag(context, TAG_ERRVAL)) 1091 return (returnstat); 1092 1093 return (process_tag(context, TAG_RETVAL, returnstat, 1)); 1094 } 1095 1096 /* 1097 * ----------------------------------------------------------------------- 1098 * return_value64_token(): Process return value and display contents 1099 * return codes : -1 - error 1100 * : 0 - successful 1101 * NOTE: At the time of call, the return value token id has been retrieved 1102 * 1103 * Format of return value token: 1104 * return value token id adr_char 1105 * error number adr_char 1106 * return value adr_int64 1107 * 1108 * HOWEVER, the 64 bit return value is a concatenation of two 1109 * 32 bit return values; the first of which is the same as is 1110 * carried in the return32 token. The second 32 bits are ignored 1111 * here so that the displayed return token will have the same 1112 * number whether the application is 32 or 64 bits. 1113 * ----------------------------------------------------------------------- 1114 */ 1115 int 1116 return_value64_token(pr_context_t *context) 1117 { 1118 int returnstat; 1119 uchar_t number; 1120 rval_t rval; 1121 char pb[512]; /* print buffer */ 1122 uval_t uval; 1123 1124 /* 1125 * Every audit record generated contains a return token. 1126 * 1127 * The return token is a special token. It indicates the success 1128 * or failure of the event that contains it. 1129 * The return64 token contains two pieces of data: 1130 * 1131 * char number; 1132 * int64_t return_value; 1133 * 1134 * For audit records generated by the kernel: 1135 * The kernel always puts a positive value in "number". 1136 * Upon success "number" is 0. 1137 * Upon failure "number" is a positive errno value that is less than 1138 * sys_nerr. 1139 * 1140 * For audit records generated at the user level: 1141 * Upon success "number" is 0. 1142 * Upon failure "number" is -1. 1143 * 1144 * For both kernel and user land the value of "return_value" is 1145 * arbitrary. For the kernel it contains the return value of 1146 * the system call. For user land it contains an arbitrary return 1147 * value if it is less than ADT_FAIL_VALUE; ADT_FAIL_VALUE 1148 * and above are messages defined in adt_event.h. ADT_FAIL_PAM and 1149 * above are messages from pam_strerror(). No interpretation is done 1150 * on "return_value" if it is outside the range of ADT_FAIL_VALUE_* or 1151 * ADT_FAIL_PAM values. 1152 * 1153 * The 64 bit return value consists of two 32bit parts; for 1154 * system calls, the first part is the value returned by the 1155 * system call and the second part depends on the system call 1156 * implementation. In most cases, the second part is either 0 1157 * or garbage; because of that, it is omitted from the praudit 1158 * output. 1159 */ 1160 if ((returnstat = open_tag(context, TAG_ERRVAL)) != 0) 1161 return (returnstat); 1162 1163 if ((returnstat = pr_adr_u_char(context, &number, 1)) == 0) { 1164 if (!(context->format & PRF_RAWM)) { 1165 pa_error(number, pb, sizeof (pb)); 1166 uval.uvaltype = PRA_STRING; 1167 uval.string_val = pb; 1168 if ((returnstat = pa_print(context, &uval, 0)) != 0) 1169 return (returnstat); 1170 1171 if ((returnstat = close_tag(context, TAG_ERRVAL)) != 0) 1172 return (returnstat); 1173 if ((returnstat = open_tag(context, TAG_RETVAL)) != 0) 1174 return (returnstat); 1175 1176 if ((returnstat = pr_adr_int64(context, 1177 &rval.r_vals, 1)) != 0) 1178 return (returnstat); 1179 pa_retval(number, rval.r_val1, pb, sizeof (pb)); 1180 } else { 1181 uval.uvaltype = PRA_INT32; 1182 if ((char)number == -1) 1183 uval.int32_val = -1; 1184 else 1185 uval.int32_val = number; 1186 1187 if ((returnstat = pa_print(context, &uval, 0)) != 0) 1188 return (returnstat); 1189 1190 if ((returnstat = close_tag(context, TAG_ERRVAL)) != 0) 1191 return (returnstat); 1192 if ((returnstat = open_tag(context, TAG_RETVAL)) != 0) 1193 return (returnstat); 1194 1195 if ((returnstat = pr_adr_int64(context, 1196 &rval.r_vals, 1)) != 0) 1197 return (returnstat); 1198 uval.int32_val = rval.r_val1; 1199 } 1200 returnstat = pa_print(context, &uval, 1); 1201 } else { 1202 return (returnstat); 1203 } 1204 1205 if (returnstat == 0) 1206 returnstat = close_tag(context, TAG_RETVAL); 1207 1208 return (returnstat); 1209 } 1210 1211 /* 1212 * ----------------------------------------------------------------------- 1213 * subject32_token() : Process subject token and display contents 1214 * return codes : -1 - error 1215 * : 0 - successful 1216 * NOTE: At the time of call, the subject token id has been retrieved 1217 * 1218 * Format of subject token: 1219 * subject token id adr_char 1220 * auid adr_u_int32 1221 * euid adr_u_int32 1222 * egid adr_u_int32 1223 * ruid adr_u_int32 1224 * egid adr_u_int32 1225 * pid adr_u_int32 1226 * sid adr_u_int32 1227 * tid adr_u_int32, adr_u_int32 1228 * ----------------------------------------------------------------------- 1229 */ 1230 int 1231 subject32_token(pr_context_t *context) 1232 { 1233 int returnstat; 1234 1235 /* auid */ 1236 returnstat = process_tag(context, TAG_AUID, 0, 0); 1237 /* uid */ 1238 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1239 /* gid */ 1240 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1241 /* ruid */ 1242 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 1243 /* rgid */ 1244 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 1245 /* pid */ 1246 returnstat = process_tag(context, TAG_PID, returnstat, 0); 1247 /* sid */ 1248 returnstat = process_tag(context, TAG_SID, returnstat, 0); 1249 /* tid */ 1250 returnstat = process_tag(context, TAG_TID32, returnstat, 1); 1251 1252 return (returnstat); 1253 } 1254 1255 int 1256 subject64_token(pr_context_t *context) 1257 { 1258 int returnstat; 1259 1260 /* auid */ 1261 returnstat = process_tag(context, TAG_AUID, 0, 0); 1262 /* uid */ 1263 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1264 /* gid */ 1265 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1266 /* ruid */ 1267 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 1268 /* rgid */ 1269 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 1270 /* pid */ 1271 returnstat = process_tag(context, TAG_PID, returnstat, 0); 1272 /* sid */ 1273 returnstat = process_tag(context, TAG_SID, returnstat, 0); 1274 /* tid */ 1275 returnstat = process_tag(context, TAG_TID64, returnstat, 1); 1276 1277 return (returnstat); 1278 } 1279 1280 /* 1281 * ----------------------------------------------------------------------- 1282 * subject_ex_token(): Process subject token and display contents 1283 * return codes : -1 - error 1284 * : 0 - successful 1285 * NOTE: At the time of call, the subject token id has been retrieved 1286 * 1287 * Format of extended subject token: 1288 * subject token id adr_char 1289 * auid adr_u_int32 1290 * euid adr_u_int32 1291 * egid adr_u_int32 1292 * ruid adr_u_int32 1293 * egid adr_u_int32 1294 * pid adr_u_int32 1295 * sid adr_u_int32 1296 * tid adr_u_int32, adr_u_int32 1297 * ----------------------------------------------------------------------- 1298 */ 1299 int 1300 subject32_ex_token(pr_context_t *context) 1301 { 1302 int returnstat; 1303 1304 /* auid */ 1305 returnstat = process_tag(context, TAG_AUID, 0, 0); 1306 /* uid */ 1307 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1308 /* gid */ 1309 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1310 /* ruid */ 1311 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 1312 /* rgid */ 1313 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 1314 /* pid */ 1315 returnstat = process_tag(context, TAG_PID, returnstat, 0); 1316 /* sid */ 1317 returnstat = process_tag(context, TAG_SID, returnstat, 0); 1318 /* tid */ 1319 returnstat = process_tag(context, TAG_TID32_EX, returnstat, 1); 1320 1321 return (returnstat); 1322 } 1323 1324 int 1325 subject64_ex_token(pr_context_t *context) 1326 { 1327 int returnstat; 1328 1329 /* auid */ 1330 returnstat = process_tag(context, TAG_AUID, 0, 0); 1331 /* uid */ 1332 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1333 /* gid */ 1334 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1335 /* ruid */ 1336 returnstat = process_tag(context, TAG_RUID, returnstat, 0); 1337 /* rgid */ 1338 returnstat = process_tag(context, TAG_RGID, returnstat, 0); 1339 /* pid */ 1340 returnstat = process_tag(context, TAG_PID, returnstat, 0); 1341 /* sid */ 1342 returnstat = process_tag(context, TAG_SID, returnstat, 0); 1343 /* tid */ 1344 returnstat = process_tag(context, TAG_TID64_EX, returnstat, 1); 1345 1346 return (returnstat); 1347 } 1348 1349 /* 1350 * ----------------------------------------------------------------------- 1351 * s5_IPC_token() : Process System V IPC token and display contents 1352 * return codes : -1 - error 1353 * : 0 - successful 1354 * NOTE: At the time of call, the System V IPC id has been retrieved 1355 * 1356 * Format of System V IPC token: 1357 * System V IPC token id adr_char 1358 * object id adr_int32 1359 * ----------------------------------------------------------------------- 1360 */ 1361 int 1362 s5_IPC_token(pr_context_t *context) 1363 { 1364 int returnstat; 1365 uchar_t ipctype; 1366 uval_t uval; 1367 1368 /* 1369 * TRANSLATION_NOTE 1370 * These names refer to the type of System V IPC object: 1371 * message queue, semaphore, shared memory. 1372 */ 1373 1374 if (pr_adr_u_char(context, &ipctype, 1) == 0) { 1375 if ((returnstat = open_tag(context, TAG_IPCTYPE)) != 0) 1376 return (returnstat); 1377 1378 if (!(context->format & PRF_RAWM)) { 1379 /* print in ASCII form */ 1380 uval.uvaltype = PRA_STRING; 1381 switch (ipctype) { 1382 case AT_IPC_MSG: 1383 uval.string_val = gettext("msg"); 1384 break; 1385 case AT_IPC_SEM: 1386 uval.string_val = gettext("sem"); 1387 break; 1388 case AT_IPC_SHM: 1389 uval.string_val = gettext("shm"); 1390 break; 1391 } 1392 returnstat = pa_print(context, &uval, 0); 1393 } 1394 /* print in integer form */ 1395 if ((context->format & PRF_RAWM) || (returnstat == 1)) { 1396 uval.uvaltype = PRA_BYTE; 1397 uval.char_val = ipctype; 1398 returnstat = pa_print(context, &uval, 0); 1399 } 1400 if ((returnstat = close_tag(context, TAG_IPCTYPE)) != 0) 1401 return (returnstat); 1402 1403 /* next get and print ipc id */ 1404 return (process_tag(context, TAG_IPCID, returnstat, 1)); 1405 } else { 1406 /* cannot retrieve ipc type */ 1407 return (-1); 1408 } 1409 } 1410 1411 /* 1412 * ----------------------------------------------------------------------- 1413 * text_token() : Process text token and display contents 1414 * return codes : -1 - error 1415 * : 0 - successful 1416 * NOTE: At the time of call, the text token id has been retrieved 1417 * 1418 * Format of text token: 1419 * text token id adr_char 1420 * text adr_string 1421 * ----------------------------------------------------------------------- 1422 */ 1423 int 1424 text_token(pr_context_t *context) 1425 { 1426 return (pa_adr_string(context, 0, 1)); 1427 } 1428 1429 /* 1430 * ----------------------------------------------------------------------- 1431 * tid_token() : Process a generic terminal id token / AUT_TID 1432 * return codes : -1 - error 1433 * : 0 - successful 1434 * NOTE: At the time of call, the token id has been retrieved 1435 * 1436 * Format of tid token: 1437 * ip token id adr_char 1438 * terminal type adr_char 1439 * terminal type = AU_IPADR: 1440 * remote port: adr_short 1441 * local port: adr_short 1442 * IP type: adt_int32 -- AU_IPv4 or AU_IPv6 1443 * address: adr_int32 if IPv4, else 4 * adr_int32 1444 * ----------------------------------------------------------------------- 1445 */ 1446 int 1447 tid_token(pr_context_t *context) 1448 { 1449 int returnstat; 1450 uchar_t type; 1451 uval_t uval; 1452 1453 if ((returnstat = pr_adr_u_char(context, &type, 1)) != 0) 1454 return (returnstat); 1455 uval.uvaltype = PRA_STRING; 1456 if ((returnstat = open_tag(context, TAG_TID_TYPE)) != 0) 1457 return (returnstat); 1458 1459 switch (type) { 1460 default: 1461 return (-1); /* other than IP type is not implemented */ 1462 case AU_IPADR: 1463 uval.string_val = "ip"; 1464 returnstat = pa_print(context, &uval, 0); 1465 returnstat = close_tag(context, TAG_TID_TYPE); 1466 returnstat = open_tag(context, TAG_IP); 1467 returnstat = process_tag(context, TAG_IP_REMOTE, returnstat, 0); 1468 returnstat = process_tag(context, TAG_IP_LOCAL, returnstat, 0); 1469 returnstat = process_tag(context, TAG_IP_ADR, returnstat, 1); 1470 returnstat = close_tag(context, TAG_IP); 1471 break; 1472 } 1473 return (returnstat); 1474 } 1475 1476 /* 1477 * ----------------------------------------------------------------------- 1478 * ip_addr_token() : Process ip token and display contents 1479 * return codes : -1 - error 1480 * : 0 - successful 1481 * NOTE: At the time of call, the ip token id has been retrieved 1482 * 1483 * Format of ip address token: 1484 * ip token id adr_char 1485 * address adr_int32 (printed in hex) 1486 * ----------------------------------------------------------------------- 1487 */ 1488 1489 int 1490 ip_addr_token(pr_context_t *context) 1491 { 1492 return (pa_hostname(context, 0, 1)); 1493 } 1494 1495 int 1496 ip_addr_ex_token(pr_context_t *context) 1497 { 1498 int returnstat; 1499 uint32_t ip_addr[16]; 1500 uint32_t ip_type; 1501 struct in_addr ia; 1502 char *ipstring; 1503 char buf[256]; 1504 uval_t uval; 1505 1506 /* get address type */ 1507 if ((returnstat = pr_adr_u_int32(context, &ip_type, 1)) != 0) 1508 return (returnstat); 1509 1510 /* legal address types are either AU_IPv4 or AU_IPv6 only */ 1511 if ((ip_type != AU_IPv4) && (ip_type != AU_IPv6)) 1512 return (-1); 1513 1514 /* get address (4/16) */ 1515 if ((returnstat = pr_adr_char(context, (char *)ip_addr, ip_type)) != 0) 1516 return (returnstat); 1517 1518 uval.uvaltype = PRA_STRING; 1519 if (ip_type == AU_IPv4) { 1520 uval.string_val = buf; 1521 1522 if (!(context->format & PRF_RAWM)) { 1523 get_Hname(ip_addr[0], buf, sizeof (buf)); 1524 return (pa_print(context, &uval, 1)); 1525 } 1526 1527 ia.s_addr = ip_addr[0]; 1528 if ((ipstring = inet_ntoa(ia)) == NULL) 1529 return (-1); 1530 1531 (void) snprintf(buf, sizeof (buf), "%s", ipstring); 1532 1533 } else { 1534 uval.string_val = buf; 1535 1536 if (!(context->format & PRF_RAWM)) { 1537 get_Hname_ex(ip_addr, buf, sizeof (buf)); 1538 return (pa_print(context, &uval, 1)); 1539 } 1540 1541 (void) inet_ntop(AF_INET6, (void *) ip_addr, buf, 1542 sizeof (buf)); 1543 1544 } 1545 1546 return (pa_print(context, &uval, 1)); 1547 } 1548 1549 /* 1550 * ----------------------------------------------------------------------- 1551 * ip_token() : Process ip header token and display contents 1552 * return codes : -1 - error 1553 * : 0 - successful 1554 * NOTE: At the time of call, the ip token id has been retrieved 1555 * 1556 * Format of ip header token: 1557 * ip header token id adr_char 1558 * version adr_char (printed in hex) 1559 * type of service adr_char (printed in hex) 1560 * length adr_short 1561 * id adr_u_short 1562 * offset adr_u_short 1563 * ttl adr_char (printed in hex) 1564 * protocol adr_char (printed in hex) 1565 * checksum adr_u_short 1566 * source address adr_int32 (printed in hex) 1567 * destination address adr_int32 (printed in hex) 1568 * ----------------------------------------------------------------------- 1569 */ 1570 int 1571 ip_token(pr_context_t *context) 1572 { 1573 int returnstat; 1574 1575 returnstat = process_tag(context, TAG_IPVERS, 0, 0); 1576 returnstat = process_tag(context, TAG_IPSERV, returnstat, 0); 1577 returnstat = process_tag(context, TAG_IPLEN, returnstat, 0); 1578 returnstat = process_tag(context, TAG_IPID, returnstat, 0); 1579 returnstat = process_tag(context, TAG_IPOFFS, returnstat, 0); 1580 returnstat = process_tag(context, TAG_IPTTL, returnstat, 0); 1581 returnstat = process_tag(context, TAG_IPPROTO, returnstat, 0); 1582 returnstat = process_tag(context, TAG_IPCKSUM, returnstat, 0); 1583 returnstat = process_tag(context, TAG_IPSRC, returnstat, 0); 1584 returnstat = process_tag(context, TAG_IPDEST, returnstat, 1); 1585 1586 return (returnstat); 1587 } 1588 1589 /* 1590 * ----------------------------------------------------------------------- 1591 * iport_token() : Process ip port address token and display contents 1592 * return codes : -1 - error 1593 * : 0 - successful 1594 * NOTE: At time of call, the ip port address token id has been retrieved 1595 * 1596 * Format of ip port token: 1597 * ip port address token id adr_char 1598 * port address adr_short (in_port_t == uint16_t) 1599 * ----------------------------------------------------------------------- 1600 */ 1601 int 1602 iport_token(pr_context_t *context) 1603 { 1604 return (pa_adr_u_short(context, 0, 1)); 1605 } 1606 1607 /* 1608 * ----------------------------------------------------------------------- 1609 * socket_token() : Process socket token and display contents 1610 * return codes : -1 - error 1611 * : 0 - successful 1612 * NOTE: At time of call, the socket token id has been retrieved 1613 * 1614 * Format of socket token: 1615 * ip socket token id adr_char 1616 * socket type adr_short (in hex) 1617 * foreign port adr_short (in hex) 1618 * foreign internet address adr_hostname/adr_int32 (in ascii/hex) 1619 * ----------------------------------------------------------------------- 1620 * 1621 * Note: local port and local internet address have been removed for 5.x 1622 */ 1623 int 1624 socket_token(pr_context_t *context) 1625 { 1626 int returnstat; 1627 1628 returnstat = process_tag(context, TAG_SOCKTYPE, 0, 0); 1629 returnstat = process_tag(context, TAG_SOCKPORT, returnstat, 0); 1630 if (returnstat != 0) 1631 return (returnstat); 1632 1633 if ((returnstat = open_tag(context, TAG_SOCKADDR)) != 0) 1634 return (returnstat); 1635 1636 if ((returnstat = pa_hostname(context, returnstat, 1)) != 0) 1637 return (returnstat); 1638 1639 return (close_tag(context, TAG_SOCKADDR)); 1640 } 1641 1642 /* 1643 * ----------------------------------------------------------------------- 1644 * socket_ex_token() : Process socket token and display contents 1645 * return codes : -1 - error 1646 * : 0 - successful 1647 * NOTE: At time of call, the extended socket token id has been retrieved 1648 * 1649 * Format of extended socket token: 1650 * token id adr_char 1651 * socket domain adr_short (in hex) 1652 * socket type adr_short (in hex) 1653 * IP address type adr_short (in hex) [not displayed] 1654 * local port adr_short (in hex) 1655 * local internet address adr_hostname/adr_int32 (in ascii/hex) 1656 * foreign port adr_short (in hex) 1657 * foreign internet address adr_hostname/adr_int32 (in ascii/hex) 1658 * ----------------------------------------------------------------------- 1659 * 1660 * Note: local port and local internet address have been removed for 5.x 1661 */ 1662 int 1663 socket_ex_token(pr_context_t *context) 1664 { 1665 int returnstat; 1666 1667 returnstat = process_tag(context, TAG_SOCKEXDOM, 0, 0); 1668 returnstat = process_tag(context, TAG_SOCKEXTYPE, returnstat, 0); 1669 returnstat = pa_hostname_so(context, returnstat, 1); 1670 1671 return (returnstat); 1672 } 1673 1674 /* 1675 * ----------------------------------------------------------------------- 1676 * sequence_token() : Process sequence token and display contents 1677 * return codes : -1 - error 1678 * : 0 - successful 1679 * NOTE: At time of call, the socket token id has been retrieved 1680 * 1681 * Format of sequence token: 1682 * sequence token id adr_char 1683 * sequence number adr_u_int32 (in hex) 1684 * ----------------------------------------------------------------------- 1685 */ 1686 int 1687 sequence_token(pr_context_t *context) 1688 { 1689 return (process_tag(context, TAG_SEQNUM, 0, 1)); 1690 } 1691 1692 /* 1693 * ----------------------------------------------------------------------- 1694 * acl_token() : Process access control list term 1695 * return codes : -1 - error 1696 * : 0 - successful 1697 * 1698 * Format of acl token: 1699 * token id adr_char 1700 * term type adr_u_int32 1701 * term value adr_u_int32 (depends on type) 1702 * file mode adr_u_int (in octal) 1703 * ----------------------------------------------------------------------- 1704 */ 1705 int 1706 acl_token(pr_context_t *context) 1707 { 1708 int returnstat; 1709 1710 returnstat = pa_pw_uid_gr_gid(context, 0, 0); 1711 1712 return (process_tag(context, TAG_MODE, returnstat, 1)); 1713 } 1714 1715 /* 1716 * ----------------------------------------------------------------------- 1717 * ace_token() : Process ZFS/NFSv4 access control list term 1718 * return codes : -1 - error 1719 * : 0 - successful 1720 * 1721 * Format of ace token: 1722 * token id adr_char 1723 * term who adr_u_int32 (uid/gid) 1724 * term mask adr_u_int32 1725 * term flags adr_u_int16 1726 * term type adr_u_int16 1727 * ----------------------------------------------------------------------- 1728 */ 1729 int 1730 ace_token(pr_context_t *context) 1731 { 1732 return (pa_ace(context, 0, 1)); 1733 } 1734 1735 /* 1736 * ----------------------------------------------------------------------- 1737 * attribute_token() : Process attribute token and display contents 1738 * return codes : -1 - error 1739 * : 0 - successful 1740 * NOTE: At the time of call, the attribute token id has been retrieved 1741 * 1742 * Format of attribute token: 1743 * attribute token id adr_char 1744 * mode adr_u_int (printed in octal) 1745 * uid adr_u_int 1746 * gid adr_u_int 1747 * file system id adr_int 1748 * 1749 * node id adr_int (attribute_token 1750 * pre SunOS 5.7) 1751 * device adr_u_int 1752 * or 1753 * node id adr_int64 (attribute32_token) 1754 * device adr_u_int 1755 * or 1756 * node id adr_int64 (attribute64_token) 1757 * device adr_u_int64 1758 * ----------------------------------------------------------------------- 1759 */ 1760 int 1761 attribute_token(pr_context_t *context) 1762 { 1763 int returnstat; 1764 1765 returnstat = process_tag(context, TAG_MODE, 0, 0); 1766 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1767 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1768 returnstat = process_tag(context, TAG_FSID, returnstat, 0); 1769 returnstat = process_tag(context, TAG_NODEID32, returnstat, 0); 1770 returnstat = process_tag(context, TAG_DEVICE32, returnstat, 1); 1771 1772 return (returnstat); 1773 } 1774 1775 int 1776 attribute32_token(pr_context_t *context) 1777 { 1778 int returnstat; 1779 1780 returnstat = process_tag(context, TAG_MODE, 0, 0); 1781 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1782 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1783 returnstat = process_tag(context, TAG_FSID, returnstat, 0); 1784 returnstat = process_tag(context, TAG_NODEID64, returnstat, 0); 1785 returnstat = process_tag(context, TAG_DEVICE32, returnstat, 1); 1786 1787 return (returnstat); 1788 } 1789 1790 int 1791 attribute64_token(pr_context_t *context) 1792 { 1793 int returnstat; 1794 1795 returnstat = process_tag(context, TAG_MODE, 0, 0); 1796 returnstat = process_tag(context, TAG_UID, returnstat, 0); 1797 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1798 returnstat = process_tag(context, TAG_FSID, returnstat, 0); 1799 returnstat = process_tag(context, TAG_NODEID64, returnstat, 0); 1800 returnstat = process_tag(context, TAG_DEVICE64, returnstat, 1); 1801 1802 return (returnstat); 1803 } 1804 1805 /* 1806 * ----------------------------------------------------------------------- 1807 * group_token() : Process group token and display contents 1808 * return codes : -1 - error 1809 * : 0 - successful 1810 * NOTE: At the time of call, the group token id has been retrieved 1811 * NOTE: This token is obsolete; it supports exactly NGROUPS_MAX 1812 * groups. 1813 * 1814 * Format of group token: 1815 * group token id adr_char 1816 * group list adr_long, 16 times 1817 * ----------------------------------------------------------------------- 1818 */ 1819 int 1820 group_token(pr_context_t *context) 1821 { 1822 int returnstat = 0; 1823 int i; 1824 1825 for (i = 0; i < NGROUPS_MAX - 1; i++) { 1826 if ((returnstat = process_tag(context, TAG_GROUPID, 1827 returnstat, 0)) < 0) 1828 return (returnstat); 1829 } 1830 1831 return (process_tag(context, TAG_GROUPID, returnstat, 1)); 1832 } 1833 1834 /* 1835 * ----------------------------------------------------------------------- 1836 * newgroup_token() : Process group token and display contents 1837 * return codes : -1 - error 1838 * : 0 - successful 1839 * NOTE: At the time of call, the group token id has been retrieved 1840 * 1841 * Format of new group token: 1842 * group token id adr_char 1843 * group number adr_short 1844 * group list adr_int32, group number times 1845 * ----------------------------------------------------------------------- 1846 */ 1847 int 1848 newgroup_token(pr_context_t *context) 1849 { 1850 int returnstat; 1851 int i, num; 1852 short n_groups; 1853 1854 returnstat = pr_adr_short(context, &n_groups, 1); 1855 if (returnstat != 0) 1856 return (returnstat); 1857 1858 num = (int)n_groups; 1859 if (num == 0) { 1860 if (!(context->format & PRF_XMLM)) { 1861 returnstat = do_newline(context, 1); 1862 } 1863 return (returnstat); 1864 } 1865 for (i = 0; i < num - 1; i++) { 1866 if ((returnstat = process_tag(context, TAG_GROUPID, 1867 returnstat, 0)) < 0) 1868 return (returnstat); 1869 } 1870 1871 return (process_tag(context, TAG_GROUPID, returnstat, 1)); 1872 } 1873 1874 static int 1875 string_token_common(pr_context_t *context, int tag) 1876 { 1877 int returnstat; 1878 int num; 1879 1880 returnstat = pr_adr_int32(context, (int32_t *)&num, 1); 1881 if (returnstat != 0) 1882 return (returnstat); 1883 1884 if (!(context->format & PRF_XMLM)) { 1885 returnstat = pr_printf(context, "%d%s", num, 1886 context->SEPARATOR); 1887 if (returnstat != 0) 1888 return (returnstat); 1889 } 1890 1891 if (num == 0) 1892 return (do_newline(context, 1)); 1893 1894 for (; num > 1; num--) { 1895 if ((returnstat = (process_tag(context, tag, 1896 returnstat, 0))) < 0) 1897 return (returnstat); 1898 } 1899 1900 return (process_tag(context, tag, returnstat, 1)); 1901 } 1902 1903 int 1904 path_attr_token(pr_context_t *context) 1905 { 1906 return (string_token_common(context, TAG_XAT)); 1907 } 1908 1909 int 1910 exec_args_token(pr_context_t *context) 1911 { 1912 return (string_token_common(context, TAG_ARG)); 1913 } 1914 1915 int 1916 exec_env_token(pr_context_t *context) 1917 { 1918 return (string_token_common(context, TAG_ENV)); 1919 } 1920 1921 /* 1922 * ----------------------------------------------------------------------- 1923 * s5_IPC_perm_token() : Process System V IPC permission token and display 1924 * contents 1925 * return codes : -1 - error 1926 * : 0 - successful 1927 * NOTE: At the time of call, the System V IPC permission token id 1928 * has been retrieved 1929 * 1930 * Format of System V IPC permission token: 1931 * System V IPC permission token id adr_char 1932 * uid adr_u_int32 1933 * gid adr_u_int32 1934 * cuid adr_u_int32 1935 * cgid adr_u_int32 1936 * mode adr_u_int32 1937 * seq adr_u_int32 1938 * key adr_int32 1939 * ----------------------------------------------------------------------- 1940 */ 1941 int 1942 s5_IPC_perm_token(pr_context_t *context) 1943 { 1944 int returnstat; 1945 1946 returnstat = process_tag(context, TAG_UID, 0, 0); 1947 returnstat = process_tag(context, TAG_GID, returnstat, 0); 1948 returnstat = process_tag(context, TAG_CUID, returnstat, 0); 1949 returnstat = process_tag(context, TAG_CGID, returnstat, 0); 1950 returnstat = process_tag(context, TAG_MODE, returnstat, 0); 1951 returnstat = process_tag(context, TAG_SEQ, returnstat, 0); 1952 returnstat = process_tag(context, TAG_KEY, returnstat, 1); 1953 1954 return (returnstat); 1955 } 1956 1957 /* 1958 * ----------------------------------------------------------------------- 1959 * host_token() : Process host token and display contents 1960 * return codes : -1 - error 1961 * : 0 - successful 1962 * NOTE: At the time of call, the host token id has been retrieved 1963 * 1964 * Format of host token: 1965 * host token id adr_char 1966 * hostid adr_u_int32 1967 * ----------------------------------------------------------------------- 1968 */ 1969 int 1970 host_token(pr_context_t *context) 1971 { 1972 return (pa_hostname(context, 0, 1)); 1973 } 1974 1975 /* 1976 * ----------------------------------------------------------------------- 1977 * liaison_token() : Process liaison token and display contents 1978 * return codes : -1 - error 1979 * : 0 - successful 1980 * NOTE: At the time of call, the liaison token id has been retrieved 1981 * 1982 * Format of liaison token: 1983 * liaison token id adr_char 1984 * liaison adr_u_int32 1985 * ----------------------------------------------------------------------- 1986 */ 1987 int 1988 liaison_token(pr_context_t *context) 1989 { 1990 return (pa_liaison(context, 0, 1)); 1991 } 1992 1993 /* 1994 * ----------------------------------------------------------------------- 1995 * useofauth_token(): Process useofauth token and display contents 1996 * return codes : -1 - error 1997 * : 0 - successful 1998 * NOTE: At the time of call, the uauth token id has been retrieved 1999 * 2000 * Format of useofauth token: 2001 * uauth token id adr_char 2002 * uauth adr_string 2003 * ----------------------------------------------------------------------- 2004 */ 2005 int 2006 useofauth_token(pr_context_t *context) 2007 { 2008 return (pa_adr_string(context, 0, 1)); 2009 } 2010 2011 /* 2012 * ----------------------------------------------------------------------- 2013 * user_token(): Process user token and display contents 2014 * return codes : -1 - error 2015 * : 0 - successful 2016 * NOTE: At the time of call, the user token id has been retrieved 2017 * 2018 * Format of user token: 2019 * user token id adr_char 2020 * user id adr_uid 2021 * user name adr_string 2022 * ----------------------------------------------------------------------- 2023 */ 2024 int 2025 user_token(pr_context_t *context) 2026 { 2027 int returnstat; 2028 2029 returnstat = process_tag(context, TAG_UID, 0, 0); 2030 return (process_tag(context, TAG_USERNAME, returnstat, 1)); 2031 } 2032 2033 /* 2034 * ----------------------------------------------------------------------- 2035 * zonename_token(): Process zonename token and display contents 2036 * return codes : -1 - error 2037 * : 0 - successful 2038 * NOTE: At the time of call, the zonename token id has been retrieved 2039 * 2040 * Format of zonename token: 2041 * zonename token id adr_char 2042 * zone name adr_string 2043 * ----------------------------------------------------------------------- 2044 */ 2045 int 2046 zonename_token(pr_context_t *context) 2047 { 2048 return (process_tag(context, TAG_ZONENAME, 0, 1)); 2049 } 2050 2051 /* 2052 * ----------------------------------------------------------------------- 2053 * fmri_token(): Process fmri token and display contents 2054 * return codes : -1 - error 2055 * : 0 - successful 2056 * NOTE: At the time of call, the fmri token id has been retrieved 2057 * 2058 * Format of fmri token: 2059 * fmri token id adr_char 2060 * service instance name adr_string 2061 * ----------------------------------------------------------------------- 2062 */ 2063 int 2064 fmri_token(pr_context_t *context) 2065 { 2066 return (pa_adr_string(context, 0, 1)); 2067 } 2068 2069 /* 2070 * ----------------------------------------------------------------------- 2071 * xatom_token() : Process Xatom token and display contents in hex. 2072 * return codes : -1 - error 2073 * : 0 - successful 2074 * NOTE: At the time of call, the xatom token id has been retrieved 2075 * 2076 * Format of xatom token: 2077 * token id adr_char 2078 * length adr_short 2079 * atom adr_char length times 2080 * ----------------------------------------------------------------------- 2081 */ 2082 int 2083 xatom_token(pr_context_t *context) 2084 { 2085 return (pa_adr_string(context, 0, 1)); 2086 } 2087 2088 int 2089 xcolormap_token(pr_context_t *context) 2090 { 2091 return (pa_xgeneric(context)); 2092 } 2093 2094 int 2095 xcursor_token(pr_context_t *context) 2096 { 2097 return (pa_xgeneric(context)); 2098 } 2099 2100 int 2101 xfont_token(pr_context_t *context) 2102 { 2103 return (pa_xgeneric(context)); 2104 } 2105 2106 int 2107 xgc_token(pr_context_t *context) 2108 { 2109 return (pa_xgeneric(context)); 2110 } 2111 2112 int 2113 xpixmap_token(pr_context_t *context) 2114 { 2115 return (pa_xgeneric(context)); 2116 } 2117 2118 int 2119 xwindow_token(pr_context_t *context) 2120 { 2121 return (pa_xgeneric(context)); 2122 } 2123 2124 /* 2125 * ----------------------------------------------------------------------- 2126 * xproperty_token(): Process Xproperty token and display contents 2127 * 2128 * return codes : -1 - error 2129 * : 0 - successful 2130 * NOTE: At the time of call, the xproperty token id has been retrieved 2131 * 2132 * Format of xproperty token: 2133 * token id adr_char 2134 * XID adr_u_int32 2135 * creator UID adr_u_int32 2136 * text adr_text 2137 * ----------------------------------------------------------------------- 2138 */ 2139 int 2140 xproperty_token(pr_context_t *context) 2141 { 2142 int returnstat; 2143 2144 returnstat = process_tag(context, TAG_XID, 0, 0); 2145 returnstat = process_tag(context, TAG_XCUID, returnstat, 0); 2146 2147 /* Done with attributes; force end of token open */ 2148 if (returnstat == 0) 2149 returnstat = finish_open_tag(context); 2150 2151 returnstat = pa_adr_string(context, returnstat, 1); 2152 2153 return (returnstat); 2154 } 2155 2156 /* 2157 * ----------------------------------------------------------------------- 2158 * xselect_token(): Process Xselect token and display contents in hex 2159 * 2160 * return codes : -1 - error 2161 * : 0 - successful 2162 * NOTE: At the time of call, the xselect token id has been retrieved 2163 * 2164 * Format of xselect token 2165 * text token id adr_char 2166 * property text adr_string 2167 * property type adr_string 2168 * property data adr_string 2169 * ----------------------------------------------------------------------- 2170 */ 2171 int 2172 xselect_token(pr_context_t *context) 2173 { 2174 int returnstat; 2175 2176 returnstat = process_tag(context, TAG_XSELTEXT, 0, 0); 2177 returnstat = process_tag(context, TAG_XSELTYPE, returnstat, 0); 2178 returnstat = process_tag(context, TAG_XSELDATA, returnstat, 1); 2179 2180 return (returnstat); 2181 } 2182 2183 /* 2184 * ----------------------------------------------------------------------- 2185 * xclient_token(): Process Xclient token and display contents in hex. 2186 * 2187 * return codes : -1 - error 2188 * : 0 - successful 2189 * 2190 * Format of xclient token: 2191 * token id adr_char 2192 * client adr_int32 2193 * ----------------------------------------------------------------------- 2194 */ 2195 int 2196 xclient_token(pr_context_t *context) 2197 { 2198 return (pa_adr_int32(context, 0, 1)); 2199 } 2200 2201 /* 2202 * ----------------------------------------------------------------------- 2203 * label_token() : Process label token and display contents 2204 * return codes : -1 - error 2205 * : 0 - successful 2206 * NOTE: At the time of call, the label token id has been retrieved 2207 * 2208 * Format of label token: 2209 * label token id adr_char 2210 * label ID adr_char 2211 * label compartment length adr_char 2212 * label classification adr_short 2213 * label compartment words <compartment length> * 4 adr_char 2214 * ----------------------------------------------------------------------- 2215 */ 2216 /*ARGSUSED*/ 2217 int 2218 label_token(pr_context_t *context) 2219 { 2220 static m_label_t *label = NULL; 2221 static size32_t l_size; 2222 int len; 2223 int returnstat; 2224 uval_t uval; 2225 2226 if (label == NULL) { 2227 if ((label = m_label_alloc(MAC_LABEL)) == NULL) { 2228 return (-1); 2229 } 2230 l_size = blabel_size() - 4; 2231 } 2232 if ((returnstat = pr_adr_char(context, (char *)label, 4)) == 0) { 2233 len = (int)(((char *)label)[1] * 4); 2234 if ((len > l_size) || 2235 (pr_adr_char(context, &((char *)label)[4], len) != 0)) { 2236 return (-1); 2237 } 2238 uval.uvaltype = PRA_STRING; 2239 if (!(context->format & PRF_RAWM)) { 2240 /* print in ASCII form */ 2241 if (label_to_str(label, &uval.string_val, M_LABEL, 2242 DEF_NAMES) == 0) { 2243 returnstat = pa_print(context, &uval, 1); 2244 } else /* cannot convert to string */ 2245 returnstat = 1; 2246 } 2247 /* print in hexadecimal form */ 2248 if ((context->format & PRF_RAWM) || (returnstat == 1)) { 2249 uval.string_val = hexconvert((char *)label, len, len); 2250 if (uval.string_val) { 2251 returnstat = pa_print(context, &uval, 1); 2252 } 2253 } 2254 free(uval.string_val); 2255 } 2256 return (returnstat); 2257 } 2258 2259 /* 2260 * ----------------------------------------------------------------------- 2261 * useofpriv_token() : Process priv token and display contents 2262 * return codes : -1 - error 2263 * : 0 - successful 2264 * NOTE: At the time of call, the useofpriv token id has been retrieved 2265 * 2266 * Format of useofpriv token: 2267 * useofpriv token id adr_char 2268 * success/failure flag adr_char 2269 * priv adr_int32 (Trusted Solaris) 2270 * priv_set '\0' separated privileges. 2271 * ----------------------------------------------------------------------- 2272 */ 2273 /*ARGSUSED*/ 2274 int 2275 useofpriv_token(pr_context_t *context) 2276 { 2277 int returnstat; 2278 char sf; 2279 uval_t uval; 2280 2281 if ((returnstat = pr_adr_char(context, &sf, 1)) != 0) { 2282 return (returnstat); 2283 } 2284 if (!(context->format & PRF_RAWM)) { 2285 /* print in ASCII form */ 2286 2287 if ((returnstat = open_tag(context, TAG_RESULT)) != 0) 2288 return (returnstat); 2289 2290 uval.uvaltype = PRA_STRING; 2291 if (sf) { 2292 uval.string_val = gettext("successful use of priv"); 2293 returnstat = pa_print(context, &uval, 0); 2294 } else { 2295 uval.string_val = gettext("failed use of priv"); 2296 returnstat = pa_print(context, &uval, 0); 2297 } 2298 if (returnstat == 0) 2299 returnstat = close_tag(context, TAG_RESULT); 2300 2301 /* Done with attributes; force end of token open */ 2302 if (returnstat == 0) 2303 returnstat = finish_open_tag(context); 2304 } else { 2305 /* print in hexadecimal form */ 2306 if ((returnstat = open_tag(context, TAG_RESULT)) != 0) 2307 return (returnstat); 2308 uval.uvaltype = PRA_SHORT; 2309 uval.short_val = sf; 2310 returnstat = pa_print(context, &uval, 0); 2311 if (returnstat == 0) 2312 returnstat = close_tag(context, TAG_RESULT); 2313 2314 /* Done with attributes; force end of token open */ 2315 if (returnstat == 0) 2316 returnstat = finish_open_tag(context); 2317 } 2318 return (pa_adr_string(context, 0, 1)); 2319 } 2320 2321 /* 2322 * ----------------------------------------------------------------------- 2323 * privilege_token() : Process privilege token and display contents 2324 * return codes : -1 - error 2325 * : 0 - successful 2326 * NOTE: At the time of call, the privilege token id has been retrieved 2327 * 2328 * Format of privilege token: 2329 * privilege token id adr_char 2330 * privilege type adr_string 2331 * privilege adr_string 2332 * ----------------------------------------------------------------------- 2333 */ 2334 int 2335 privilege_token(pr_context_t *context) 2336 { 2337 int returnstat; 2338 2339 /* privilege type: */ 2340 returnstat = process_tag(context, TAG_SETTYPE, 0, 0); 2341 2342 /* Done with attributes; force end of token open */ 2343 if (returnstat == 0) 2344 returnstat = finish_open_tag(context); 2345 2346 /* privilege: */ 2347 return (pa_adr_string(context, returnstat, 1)); 2348 } 2349