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 <sys/types.h> 28 #include <unistd.h> 29 #include <bsm/audit.h> 30 #include <bsm/audit_record.h> 31 #include <bsm/libbsm.h> 32 #include <priv.h> 33 #include <sys/ipc.h> 34 #include <sys/param.h> 35 #include <sys/socket.h> 36 #include <sys/time.h> 37 #include <sys/vnode.h> 38 #include <malloc.h> 39 #include <net/route.h> 40 #include <netinet/in.h> 41 #include <netinet/in_pcb.h> 42 #include <string.h> 43 #include <ucred.h> 44 #include <zone.h> 45 #include <sys/tsol/label.h> 46 47 #define NGROUPS 16 /* XXX - temporary */ 48 49 token_t *au_to_arg(char n, char *text, uint32_t v); 50 #pragma weak au_to_arg = au_to_arg32 51 token_t *au_to_return(char number, uint32_t value); 52 #pragma weak au_to_return = au_to_return32 53 54 static token_t *au_to_exec(char **, char); 55 56 static token_t * 57 get_token(int s) 58 { 59 token_t *token; /* Resultant token */ 60 61 if ((token = (token_t *)malloc(sizeof (token_t))) == NULL) 62 return (NULL); 63 if ((token->tt_data = malloc(s)) == NULL) { 64 free(token); 65 return (NULL); 66 } 67 token->tt_size = s; 68 token->tt_next = NULL; 69 return (token); 70 } 71 72 /* 73 * au_to_header 74 * return s: 75 * pointer to header token. 76 */ 77 token_t * 78 au_to_header(au_event_t e_type, au_emod_t e_mod) 79 { 80 adr_t adr; /* adr memory stream header */ 81 token_t *token; /* token pointer */ 82 char version = TOKEN_VERSION; /* version of token family */ 83 int32_t byte_count; 84 struct timeval tv; 85 #ifdef _LP64 86 char data_header = AUT_HEADER64; /* header for this token */ 87 88 token = get_token(2 * sizeof (char) + sizeof (int32_t) + 89 2 * sizeof (int64_t) + 2 * sizeof (short)); 90 #else 91 char data_header = AUT_HEADER32; 92 93 token = get_token(2 * sizeof (char) + 3 * sizeof (int32_t) + 94 2 * sizeof (short)); 95 #endif 96 97 if (token == NULL) 98 return (NULL); 99 adr_start(&adr, token->tt_data); 100 adr_char(&adr, &data_header, 1); /* token ID */ 101 adr_int32(&adr, &byte_count, 1); /* length of audit record */ 102 adr_char(&adr, &version, 1); /* version of audit tokens */ 103 adr_ushort(&adr, &e_type, 1); /* event ID */ 104 adr_ushort(&adr, &e_mod, 1); /* event ID modifier */ 105 #ifdef _LP64 106 adr_int64(&adr, (int64_t *)&tv, 2); /* time & date */ 107 #else 108 adr_int32(&adr, (int32_t *)&tv, 2); /* time & date */ 109 #endif 110 return (token); 111 } 112 113 /* 114 * au_to_header_ex 115 * return s: 116 * pointer to header token. 117 */ 118 token_t * 119 au_to_header_ex(au_event_t e_type, au_emod_t e_mod) 120 { 121 adr_t adr; /* adr memory stream header */ 122 token_t *token; /* token pointer */ 123 char version = TOKEN_VERSION; /* version of token family */ 124 int32_t byte_count; 125 struct timeval tv; 126 auditinfo_addr_t audit_info; 127 au_tid_addr_t *host_info = &audit_info.ai_termid; 128 #ifdef _LP64 129 char data_header = AUT_HEADER64_EX; /* header for this token */ 130 #else 131 char data_header = AUT_HEADER32_EX; 132 #endif 133 134 /* If our host address can't be determined, revert to un-extended hdr */ 135 136 if (auditon(A_GETKAUDIT, (caddr_t)&audit_info, 137 sizeof (audit_info)) < 0) 138 return (au_to_header(e_type, e_mod)); 139 140 if (host_info->at_type == AU_IPv6) 141 if (IN6_IS_ADDR_UNSPECIFIED((in6_addr_t *)host_info->at_addr)) 142 return (au_to_header(e_type, e_mod)); 143 else 144 if (host_info->at_addr[0] == htonl(INADDR_ANY)) 145 return (au_to_header(e_type, e_mod)); 146 147 #ifdef _LP64 148 token = get_token(2 * sizeof (char) + sizeof (int32_t) + 149 2 * sizeof (int64_t) + 2 * sizeof (short) + 150 sizeof (int32_t) + host_info->at_type); 151 #else 152 token = get_token(2 * sizeof (char) + 3 * sizeof (int32_t) + 153 2 * sizeof (short) + sizeof (int32_t) + host_info->at_type); 154 #endif 155 156 if (token == NULL) 157 return (NULL); 158 adr_start(&adr, token->tt_data); 159 adr_char(&adr, &data_header, 1); /* token ID */ 160 adr_int32(&adr, &byte_count, 1); /* length of audit record */ 161 adr_char(&adr, &version, 1); /* version of audit tokens */ 162 adr_ushort(&adr, &e_type, 1); /* event ID */ 163 adr_ushort(&adr, &e_mod, 1); /* event ID modifier */ 164 adr_int32(&adr, (int32_t *)&host_info->at_type, 1); 165 adr_char(&adr, (char *)host_info->at_addr, 166 (int)host_info->at_type); 167 #ifdef _LP64 168 adr_int64(&adr, (int64_t *)&tv, 2); /* time & date */ 169 #else 170 adr_int32(&adr, (int32_t *)&tv, 2); /* time & date */ 171 #endif 172 return (token); 173 } 174 175 /* 176 * au_to_trailer 177 * return s: 178 * pointer to a trailer token. 179 */ 180 token_t * 181 au_to_trailer(void) 182 { 183 adr_t adr; /* adr memory stream header */ 184 token_t *token; /* token pointer */ 185 char data_header = AUT_TRAILER; /* header for this token */ 186 short magic = (short)AUT_TRAILER_MAGIC; /* trailer magic number */ 187 int32_t byte_count; 188 189 token = get_token(sizeof (char) + sizeof (int32_t) + sizeof (short)); 190 if (token == NULL) 191 return (NULL); 192 adr_start(&adr, token->tt_data); 193 adr_char(&adr, &data_header, 1); /* token ID */ 194 adr_short(&adr, &magic, 1); /* magic number */ 195 adr_int32(&adr, &byte_count, 1); /* length of audit record */ 196 197 return (token); 198 } 199 200 /* 201 * au_to_arg32 202 * return s: 203 * pointer to an argument token. 204 */ 205 token_t * 206 au_to_arg32(char n, char *text, uint32_t v) 207 { 208 token_t *token; /* local token */ 209 adr_t adr; /* adr memory stream header */ 210 char data_header = AUT_ARG32; /* header for this token */ 211 short bytes; /* length of string */ 212 213 bytes = strlen(text) + 1; 214 215 token = get_token((int)(2 * sizeof (char) + sizeof (int32_t) + 216 sizeof (short) + bytes)); 217 if (token == NULL) 218 return (NULL); 219 adr_start(&adr, token->tt_data); 220 adr_char(&adr, &data_header, 1); /* token type */ 221 adr_char(&adr, &n, 1); /* argument id */ 222 adr_int32(&adr, (int32_t *)&v, 1); /* argument value */ 223 adr_short(&adr, &bytes, 1); 224 adr_char(&adr, text, bytes); 225 226 return (token); 227 } 228 229 /* 230 * au_to_arg64 231 * return s: 232 * pointer to an argument token. 233 */ 234 token_t * 235 au_to_arg64(char n, char *text, uint64_t v) 236 { 237 token_t *token; /* local token */ 238 adr_t adr; /* adr memory stream header */ 239 char data_header = AUT_ARG64; /* header for this token */ 240 short bytes; /* length of string */ 241 242 bytes = strlen(text) + 1; 243 244 token = get_token((int)(2 * sizeof (char) + sizeof (int64_t) + 245 sizeof (short) + bytes)); 246 if (token == NULL) 247 return (NULL); 248 adr_start(&adr, token->tt_data); 249 adr_char(&adr, &data_header, 1); /* token type */ 250 adr_char(&adr, &n, 1); /* argument id */ 251 adr_int64(&adr, (int64_t *)&v, 1); /* argument value */ 252 adr_short(&adr, &bytes, 1); 253 adr_char(&adr, text, bytes); 254 255 return (token); 256 } 257 258 259 /* 260 * au_to_attr 261 * return s: 262 * pointer to an attribute token. 263 */ 264 token_t * 265 au_to_attr(struct vattr *attr) 266 { 267 token_t *token; /* local token */ 268 adr_t adr; /* adr memory stream header */ 269 int32_t value; 270 #ifdef _LP64 271 char data_header = AUT_ATTR64; /* header for this token */ 272 273 token = get_token(sizeof (char) + 274 sizeof (int32_t) * 4 + 275 sizeof (int64_t) * 2); 276 #else 277 char data_header = AUT_ATTR32; 278 279 token = get_token(sizeof (char) + sizeof (int32_t) * 5 + 280 sizeof (int64_t)); 281 #endif 282 283 if (token == NULL) 284 return (NULL); 285 adr_start(&adr, token->tt_data); 286 adr_char(&adr, &data_header, 1); 287 value = (int32_t)attr->va_mode; 288 adr_int32(&adr, &value, 1); 289 value = (int32_t)attr->va_uid; 290 adr_int32(&adr, &value, 1); 291 value = (int32_t)attr->va_gid; 292 adr_int32(&adr, &value, 1); 293 adr_int32(&adr, (int32_t *)&(attr->va_fsid), 1); 294 adr_int64(&adr, (int64_t *)&(attr->va_nodeid), 1); 295 #ifdef _LP64 296 adr_int64(&adr, (int64_t *)&(attr->va_rdev), 1); 297 #else 298 adr_int32(&adr, (int32_t *)&(attr->va_rdev), 1); 299 #endif 300 301 return (token); 302 } 303 304 /* 305 * au_to_data 306 * return s: 307 * pointer to a data token. 308 */ 309 token_t * 310 au_to_data(char unit_print, char unit_type, char unit_count, char *p) 311 { 312 adr_t adr; /* adr memory stream header */ 313 token_t *token; /* token pointer */ 314 char data_header = AUT_DATA; /* header for this token */ 315 int byte_count; /* number of bytes */ 316 317 if (p == NULL || unit_count < 1) 318 return (NULL); 319 320 /* 321 * Check validity of print type 322 */ 323 if (unit_print < AUP_BINARY || unit_print > AUP_STRING) 324 return (NULL); 325 326 switch (unit_type) { 327 case AUR_SHORT: 328 byte_count = unit_count * sizeof (short); 329 break; 330 case AUR_INT32: 331 byte_count = unit_count * sizeof (int32_t); 332 break; 333 case AUR_INT64: 334 byte_count = unit_count * sizeof (int64_t); 335 break; 336 /* case AUR_CHAR: */ 337 case AUR_BYTE: 338 byte_count = unit_count * sizeof (char); 339 break; 340 default: 341 return (NULL); 342 } 343 344 token = get_token((int)(4 * sizeof (char) + byte_count)); 345 if (token == NULL) 346 return (NULL); 347 adr_start(&adr, token->tt_data); 348 adr_char(&adr, &data_header, 1); 349 adr_char(&adr, &unit_print, 1); 350 adr_char(&adr, &unit_type, 1); 351 adr_char(&adr, &unit_count, 1); 352 353 switch (unit_type) { 354 case AUR_SHORT: 355 /* LINTED */ 356 adr_short(&adr, (short *)p, unit_count); 357 break; 358 case AUR_INT32: 359 /* LINTED */ 360 adr_int32(&adr, (int32_t *)p, unit_count); 361 break; 362 case AUR_INT64: 363 /* LINTED */ 364 adr_int64(&adr, (int64_t *)p, unit_count); 365 break; 366 /* case AUR_CHAR: */ 367 case AUR_BYTE: 368 adr_char(&adr, p, unit_count); 369 break; 370 } 371 372 return (token); 373 } 374 375 /* 376 * au_to_privset 377 * 378 * priv_type (LIMIT, INHERIT...) is the first string and privilege 379 * in translated into the second string. The format is as follows: 380 * 381 * token id adr_char 382 * priv type adr_string (short, string) 383 * priv set adr_string (short, string) 384 * 385 * return s: 386 * pointer to a AUT_PRIV token. 387 */ 388 token_t * 389 au_to_privset(const char *priv_type, const priv_set_t *privilege) 390 { 391 token_t *token; /* local token */ 392 adr_t adr; /* adr memory stream header */ 393 char data_header = AUT_PRIV; /* header for this token */ 394 short t_bytes; /* length of type string */ 395 short p_bytes; /* length of privilege string */ 396 char *priv_string; /* privilege string */ 397 398 t_bytes = strlen(priv_type) + 1; 399 400 if ((privilege == NULL) || (priv_string = 401 priv_set_to_str(privilege, ',', 402 PRIV_STR_LIT)) == NULL) 403 return (NULL); 404 405 p_bytes = strlen(priv_string) + 1; 406 407 token = get_token((int)(sizeof (char) + (2 * sizeof (short)) + t_bytes 408 + p_bytes)); 409 if (token == NULL) 410 return (NULL); 411 412 adr_start(&adr, token->tt_data); 413 adr_char(&adr, &data_header, 1); 414 adr_short(&adr, &t_bytes, 1); 415 adr_char(&adr, (char *)priv_type, t_bytes); 416 adr_short(&adr, &p_bytes, 1); 417 adr_char(&adr, priv_string, p_bytes); 418 419 free(priv_string); 420 421 return (token); 422 } 423 424 /* 425 * au_to_process 426 * return s: 427 * pointer to a process token. 428 */ 429 430 token_t * 431 au_to_process(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, 432 pid_t pid, au_asid_t sid, au_tid_t *tid) 433 { 434 token_t *token; /* local token */ 435 adr_t adr; /* adr memory stream header */ 436 #ifdef _LP64 437 char data_header = AUT_PROCESS64; /* header for this token */ 438 439 token = get_token(sizeof (char) + 8 * sizeof (int32_t) + 440 sizeof (int64_t)); 441 #else 442 char data_header = AUT_PROCESS32; 443 444 token = get_token(sizeof (char) + 9 * sizeof (int32_t)); 445 #endif 446 447 if (token == NULL) 448 return (NULL); 449 adr_start(&adr, token->tt_data); 450 adr_char(&adr, &data_header, 1); 451 adr_int32(&adr, (int32_t *)&auid, 1); 452 adr_int32(&adr, (int32_t *)&euid, 1); 453 adr_int32(&adr, (int32_t *)&egid, 1); 454 adr_int32(&adr, (int32_t *)&ruid, 1); 455 adr_int32(&adr, (int32_t *)&rgid, 1); 456 adr_int32(&adr, (int32_t *)&pid, 1); 457 adr_int32(&adr, (int32_t *)&sid, 1); 458 #ifdef _LP64 459 adr_int64(&adr, (int64_t *)&tid->port, 1); 460 #else 461 adr_int32(&adr, (int32_t *)&tid->port, 1); 462 #endif 463 adr_int32(&adr, (int32_t *)&tid->machine, 1); 464 465 return (token); 466 } 467 468 /* 469 * au_to_process_ex 470 * return s: 471 * pointer to a process_ex token. 472 */ 473 token_t * 474 au_to_process_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, 475 pid_t pid, au_asid_t sid, au_tid_addr_t *tid) 476 { 477 token_t *token; /* local token */ 478 adr_t adr; /* adr memory stream header */ 479 char data_header; /* header for this token */ 480 481 #ifdef _LP64 482 if (tid->at_type == AU_IPv6) { 483 data_header = AUT_PROCESS64_EX; 484 token = get_token(sizeof (char) + sizeof (int64_t) + 485 12 * sizeof (int32_t)); 486 } else { 487 data_header = AUT_PROCESS64; 488 token = get_token(sizeof (char) + sizeof (int64_t) + 489 8 * sizeof (int32_t)); 490 } 491 #else 492 if (tid->at_type == AU_IPv6) { 493 data_header = AUT_PROCESS32_EX; 494 token = get_token(sizeof (char) + 13 * sizeof (int32_t)); 495 } else { 496 data_header = AUT_PROCESS32; 497 token = get_token(sizeof (char) + 9 * sizeof (int32_t)); 498 } 499 #endif 500 if (token == NULL) 501 return (NULL); 502 adr_start(&adr, token->tt_data); 503 adr_char(&adr, &data_header, 1); 504 adr_int32(&adr, (int32_t *)&auid, 1); 505 adr_int32(&adr, (int32_t *)&euid, 1); 506 adr_int32(&adr, (int32_t *)&egid, 1); 507 adr_int32(&adr, (int32_t *)&ruid, 1); 508 adr_int32(&adr, (int32_t *)&rgid, 1); 509 adr_int32(&adr, (int32_t *)&pid, 1); 510 adr_int32(&adr, (int32_t *)&sid, 1); 511 #ifdef _LP64 512 adr_int64(&adr, (int64_t *)&tid->at_port, 1); 513 #else 514 adr_int32(&adr, (int32_t *)&tid->at_port, 1); 515 #endif 516 if (tid->at_type == AU_IPv6) { 517 adr_int32(&adr, (int32_t *)&tid->at_type, 1); 518 adr_char(&adr, (char *)tid->at_addr, 16); 519 } else { 520 adr_char(&adr, (char *)tid->at_addr, 4); 521 } 522 523 return (token); 524 } 525 526 /* 527 * au_to_seq 528 * return s: 529 * pointer to token chain containing a sequence token 530 */ 531 token_t * 532 au_to_seq(int audit_count) 533 { 534 token_t *token; /* local token */ 535 adr_t adr; /* adr memory stream header */ 536 char data_header = AUT_SEQ; /* header for this token */ 537 538 token = get_token(sizeof (char) + sizeof (int32_t)); 539 if (token == NULL) 540 return (NULL); 541 adr_start(&adr, token->tt_data); 542 adr_char(&adr, &data_header, 1); 543 adr_int32(&adr, (int32_t *)&audit_count, 1); 544 545 return (token); 546 } 547 548 /* 549 * au_to_socket 550 * return s: 551 * pointer to mbuf chain containing a socket token. 552 */ 553 token_t * 554 au_to_socket(struct oldsocket *so) 555 { 556 adr_t adr; 557 token_t *token; 558 char data_header = AUT_SOCKET; 559 struct inpcb *inp = so->so_pcb; 560 561 token = get_token(sizeof (char) + sizeof (short) * 3 + 562 sizeof (int32_t) * 2); 563 if (token == NULL) 564 return (NULL); 565 adr_start(&adr, token->tt_data); 566 adr_char(&adr, &data_header, 1); 567 adr_short(&adr, (short *)&so->so_type, 1); 568 adr_short(&adr, (short *)&inp->inp_lport, 1); 569 adr_int32(&adr, (int32_t *)&inp->inp_laddr, 1); 570 adr_short(&adr, (short *)&inp->inp_fport, 1); 571 adr_int32(&adr, (int32_t *)&inp->inp_faddr, 1); 572 573 return (token); 574 } 575 576 /* 577 * au_to_subject 578 * return s: 579 * pointer to a process token. 580 */ 581 582 token_t * 583 au_to_subject(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, 584 pid_t pid, au_asid_t sid, au_tid_t *tid) 585 { 586 token_t *token; /* local token */ 587 adr_t adr; /* adr memory stream header */ 588 #ifdef _LP64 589 char data_header = AUT_SUBJECT64; /* header for this token */ 590 591 token = get_token(sizeof (char) + sizeof (int64_t) + 592 8 * sizeof (int32_t)); 593 #else 594 char data_header = AUT_SUBJECT32; 595 596 token = get_token(sizeof (char) + 9 * sizeof (int32_t)); 597 #endif 598 599 if (token == NULL) 600 return (NULL); 601 adr_start(&adr, token->tt_data); 602 adr_char(&adr, &data_header, 1); 603 adr_int32(&adr, (int32_t *)&auid, 1); 604 adr_int32(&adr, (int32_t *)&euid, 1); 605 adr_int32(&adr, (int32_t *)&egid, 1); 606 adr_int32(&adr, (int32_t *)&ruid, 1); 607 adr_int32(&adr, (int32_t *)&rgid, 1); 608 adr_int32(&adr, (int32_t *)&pid, 1); 609 adr_int32(&adr, (int32_t *)&sid, 1); 610 #ifdef _LP64 611 adr_int64(&adr, (int64_t *)&tid->port, 1); 612 #else 613 adr_int32(&adr, (int32_t *)&tid->port, 1); 614 #endif 615 adr_int32(&adr, (int32_t *)&tid->machine, 1); 616 617 return (token); 618 } 619 620 /* 621 * au_to_subject_ex 622 * return s: 623 * pointer to a process token. 624 */ 625 626 token_t * 627 au_to_subject_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid, 628 pid_t pid, au_asid_t sid, au_tid_addr_t *tid) 629 { 630 token_t *token; /* local token */ 631 adr_t adr; /* adr memory stream header */ 632 #ifdef _LP64 633 char data_header; /* header for this token */ 634 635 if (tid->at_type == AU_IPv6) { 636 data_header = AUT_SUBJECT64_EX; 637 token = get_token(sizeof (char) + sizeof (int64_t) + 638 12 * sizeof (int32_t)); 639 } else { 640 data_header = AUT_SUBJECT64; 641 token = get_token(sizeof (char) + sizeof (int64_t) + 642 8 * sizeof (int32_t)); 643 } 644 #else 645 char data_header; /* header for this token */ 646 647 if (tid->at_type == AU_IPv6) { 648 data_header = AUT_SUBJECT32_EX; 649 token = get_token(sizeof (char) + 13 * sizeof (int32_t)); 650 } else { 651 data_header = AUT_SUBJECT32; 652 token = get_token(sizeof (char) + 9 * sizeof (int32_t)); 653 } 654 #endif 655 656 if (token == NULL) 657 return (NULL); 658 adr_start(&adr, token->tt_data); 659 adr_char(&adr, &data_header, 1); 660 adr_int32(&adr, (int32_t *)&auid, 1); 661 adr_int32(&adr, (int32_t *)&euid, 1); 662 adr_int32(&adr, (int32_t *)&egid, 1); 663 adr_int32(&adr, (int32_t *)&ruid, 1); 664 adr_int32(&adr, (int32_t *)&rgid, 1); 665 adr_int32(&adr, (int32_t *)&pid, 1); 666 adr_int32(&adr, (int32_t *)&sid, 1); 667 #ifdef _LP64 668 adr_int64(&adr, (int64_t *)&tid->at_port, 1); 669 #else 670 adr_int32(&adr, (int32_t *)&tid->at_port, 1); 671 #endif 672 if (tid->at_type == AU_IPv6) { 673 adr_int32(&adr, (int32_t *)&tid->at_type, 1); 674 adr_char(&adr, (char *)tid->at_addr, 16); 675 } else { 676 adr_char(&adr, (char *)tid->at_addr, 4); 677 } 678 679 return (token); 680 } 681 682 /* 683 * au_to_me 684 * return s: 685 * pointer to a process token. 686 */ 687 688 token_t * 689 au_to_me(void) 690 { 691 auditinfo_addr_t info; 692 693 if (getaudit_addr(&info, sizeof (info))) 694 return (NULL); 695 return (au_to_subject_ex(info.ai_auid, geteuid(), getegid(), getuid(), 696 getgid(), getpid(), info.ai_asid, &info.ai_termid)); 697 } 698 /* 699 * au_to_text 700 * return s: 701 * pointer to a text token. 702 */ 703 token_t * 704 au_to_text(char *text) 705 { 706 token_t *token; /* local token */ 707 adr_t adr; /* adr memory stream header */ 708 char data_header = AUT_TEXT; /* header for this token */ 709 short bytes; /* length of string */ 710 711 bytes = strlen(text) + 1; 712 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 713 if (token == NULL) 714 return (NULL); 715 adr_start(&adr, token->tt_data); 716 adr_char(&adr, &data_header, 1); 717 adr_short(&adr, &bytes, 1); 718 adr_char(&adr, text, bytes); 719 720 return (token); 721 } 722 723 /* 724 * au_to_path 725 * return s: 726 * pointer to a path token. 727 */ 728 token_t * 729 au_to_path(char *path) 730 { 731 token_t *token; /* local token */ 732 adr_t adr; /* adr memory stream header */ 733 char data_header = AUT_PATH; /* header for this token */ 734 short bytes; /* length of string */ 735 736 bytes = (short)strlen(path) + 1; 737 738 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 739 if (token == NULL) 740 return (NULL); 741 adr_start(&adr, token->tt_data); 742 adr_char(&adr, &data_header, 1); 743 adr_short(&adr, &bytes, 1); 744 adr_char(&adr, path, bytes); 745 746 return (token); 747 } 748 749 /* 750 * au_to_cmd 751 * return s: 752 * pointer to an command line argument token 753 */ 754 token_t * 755 au_to_cmd(uint_t argc, char **argv, char **envp) 756 { 757 token_t *token; /* local token */ 758 adr_t adr; /* adr memory stream header */ 759 char data_header = AUT_CMD; /* header for this token */ 760 short len = 0; 761 short cnt = 0; 762 short envc = 0; 763 short largc = (short)argc; 764 765 /* 766 * one char for the header, one short for argc, 767 * one short for # envp strings. 768 */ 769 len = sizeof (char) + sizeof (short) + sizeof (short); 770 771 /* get sizes of strings */ 772 773 for (cnt = 0; cnt < argc; cnt++) { 774 len += (short)sizeof (short) + (short)(strlen(argv[cnt]) + 1); 775 } 776 777 if (envp != NULL) { 778 for (envc = 0; envp[envc] != NULL; envc++) { 779 len += (short)sizeof (short) + 780 (short)(strlen(envp[envc]) + 1); 781 } 782 } 783 784 token = get_token(len); 785 if (token == NULL) 786 return (NULL); 787 788 adr_start(&adr, token->tt_data); 789 adr_char(&adr, &data_header, 1); 790 791 adr_short(&adr, &largc, 1); 792 793 for (cnt = 0; cnt < argc; cnt++) { 794 len = (short)(strlen(argv[cnt]) + 1); 795 adr_short(&adr, &len, 1); 796 adr_char(&adr, argv[cnt], len); 797 } 798 799 adr_short(&adr, &envc, 1); 800 801 for (cnt = 0; cnt < envc; cnt++) { 802 len = (short)(strlen(envp[cnt]) + 1); 803 adr_short(&adr, &len, 1); 804 adr_char(&adr, envp[cnt], len); 805 } 806 807 return (token); 808 } 809 810 /* 811 * au_to_exit 812 * return s: 813 * pointer to a exit value token. 814 */ 815 token_t * 816 au_to_exit(int retval, int err) 817 { 818 token_t *token; /* local token */ 819 adr_t adr; /* adr memory stream header */ 820 char data_header = AUT_EXIT; /* header for this token */ 821 822 token = get_token(sizeof (char) + (2 * sizeof (int32_t))); 823 if (token == NULL) 824 return (NULL); 825 adr_start(&adr, token->tt_data); 826 adr_char(&adr, &data_header, 1); 827 adr_int32(&adr, (int32_t *)&retval, 1); 828 adr_int32(&adr, (int32_t *)&err, 1); 829 830 return (token); 831 } 832 833 /* 834 * au_to_return 835 * return s: 836 * pointer to a return value token. 837 */ 838 token_t * 839 au_to_return32(char number, uint32_t value) 840 { 841 token_t *token; /* local token */ 842 adr_t adr; /* adr memory stream header */ 843 char data_header = AUT_RETURN32; /* header for this token */ 844 845 token = get_token(2 * sizeof (char) + sizeof (int32_t)); 846 if (token == NULL) 847 return (NULL); 848 adr_start(&adr, token->tt_data); 849 adr_char(&adr, &data_header, 1); 850 adr_char(&adr, &number, 1); 851 adr_int32(&adr, (int32_t *)&value, 1); 852 853 return (token); 854 } 855 856 /* 857 * au_to_return 858 * return s: 859 * pointer to a return value token. 860 */ 861 token_t * 862 au_to_return64(char number, uint64_t value) 863 { 864 token_t *token; /* local token */ 865 adr_t adr; /* adr memory stream header */ 866 char data_header = AUT_RETURN64; /* header for this token */ 867 868 token = get_token(2 * sizeof (char) + sizeof (int64_t)); 869 if (token == NULL) 870 return (NULL); 871 adr_start(&adr, token->tt_data); 872 adr_char(&adr, &data_header, 1); 873 adr_char(&adr, &number, 1); 874 adr_int64(&adr, (int64_t *)&value, 1); 875 876 return (token); 877 } 878 879 880 /* 881 * au_to_opaque 882 * return s: 883 * pointer to a opaque token. 884 */ 885 token_t * 886 au_to_opaque(char *opaque, short bytes) 887 { 888 token_t *token; /* local token */ 889 adr_t adr; /* adr memory stream header */ 890 char data_header = AUT_OPAQUE; /* header for this token */ 891 892 if (bytes < 1) 893 return (NULL); 894 895 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 896 if (token == NULL) 897 return (NULL); 898 adr_start(&adr, token->tt_data); 899 adr_char(&adr, &data_header, 1); 900 adr_short(&adr, &bytes, 1); 901 adr_char(&adr, opaque, bytes); 902 903 return (token); 904 } 905 906 /* 907 * au_to_in_addr 908 * return s: 909 * pointer to an internet address token 910 */ 911 token_t * 912 au_to_in_addr(struct in_addr *internet_addr) 913 { 914 token_t *token; /* local token */ 915 adr_t adr; /* adr memory stream header */ 916 char data_header = AUT_IN_ADDR; /* header for this token */ 917 918 token = get_token(sizeof (char) + sizeof (struct in_addr)); 919 if (token == NULL) 920 return (NULL); 921 adr_start(&adr, token->tt_data); 922 adr_char(&adr, &data_header, 1); 923 adr_char(&adr, (char *)internet_addr, sizeof (struct in_addr)); 924 925 return (token); 926 } 927 928 /* 929 * au_to_in_addr_ex 930 * return s: 931 * pointer to an internet extended token 932 */ 933 token_t * 934 au_to_in_addr_ex(struct in6_addr *addr) 935 { 936 token_t *token; 937 adr_t adr; 938 939 if (IN6_IS_ADDR_V4MAPPED(addr)) { 940 ipaddr_t in4; 941 942 /* 943 * An IPv4-mapped IPv6 address is really an IPv4 address 944 * in IPv6 format. 945 */ 946 947 IN6_V4MAPPED_TO_IPADDR(addr, in4); 948 return (au_to_in_addr((struct in_addr *)&in4)); 949 950 } else { 951 char data_header = AUT_IN_ADDR_EX; 952 int32_t type = AU_IPv6; 953 954 if ((token = get_token(sizeof (char) + sizeof (int32_t) + 955 sizeof (struct in6_addr))) == NULL) { 956 return (NULL); 957 } 958 959 adr_start(&adr, token->tt_data); 960 adr_char(&adr, &data_header, 1); 961 adr_int32(&adr, &type, 1); 962 adr_char(&adr, (char *)addr, sizeof (struct in6_addr)); 963 } 964 965 return (token); 966 } 967 968 /* 969 * au_to_iport 970 * return s: 971 * pointer to token chain containing a ip port address token 972 */ 973 token_t * 974 au_to_iport(ushort_t iport) 975 { 976 token_t *token; /* local token */ 977 adr_t adr; /* adr memory stream header */ 978 char data_header = AUT_IPORT; /* header for this token */ 979 980 token = get_token(sizeof (char) + sizeof (short)); 981 if (token == NULL) 982 return (NULL); 983 adr_start(&adr, token->tt_data); 984 adr_char(&adr, &data_header, 1); 985 adr_short(&adr, (short *)&iport, 1); 986 987 return (token); 988 } 989 990 token_t * 991 au_to_ipc(char type, int id) 992 { 993 token_t *token; /* local token */ 994 adr_t adr; /* adr memory stream header */ 995 char data_header = AUT_IPC; /* header for this token */ 996 997 token = get_token((2 * sizeof (char)) + sizeof (int32_t)); 998 if (token == NULL) 999 return (NULL); 1000 adr_start(&adr, token->tt_data); 1001 adr_char(&adr, &data_header, 1); 1002 adr_char(&adr, &type, 1); 1003 adr_int32(&adr, (int32_t *)&id, 1); 1004 1005 return (token); 1006 } 1007 1008 /* 1009 * au_to_tid 1010 * 1011 * output format depends on type; at present only IP v4 and v6 addresses 1012 * are defined. 1013 * 1014 * IPv4 -- tid type, 16 bit remote port, 16 bit local port, ip type, 1015 * 32 bit IP address. 1016 * IPv6 -- tid type, 16 bit remote port, 16 bit local port, ip type, 1017 * 4 x 32 bit IP address. 1018 * 1019 */ 1020 token_t * 1021 au_to_tid(au_generic_tid_t *tid) 1022 { 1023 char data_header = AUT_TID; /* header for this token */ 1024 adr_t adr; /* adr memory stream header */ 1025 token_t *token; /* local token */ 1026 au_ip_t *ip; 1027 1028 switch (tid->gt_type) { 1029 case AU_IPADR: 1030 ip = &(tid->gt_adr.at_ip); 1031 token = get_token((int)(2 * sizeof (char) + 2 * sizeof (short) + 1032 sizeof (uint32_t) + ip->at_type)); 1033 if (token == NULL) 1034 return (NULL); 1035 1036 adr_start(&adr, token->tt_data); 1037 adr_char(&adr, &data_header, 1); 1038 adr_char(&adr, (char *)&(tid->gt_type), 1); 1039 adr_short(&adr, (short *)&(ip->at_r_port), 1); 1040 adr_short(&adr, (short *)&(ip->at_l_port), 1); 1041 adr_int32(&adr, (int32_t *)&(ip->at_type), 1); 1042 1043 adr_char(&adr, (char *)ip->at_addr, ip->at_type); 1044 1045 break; 1046 default: 1047 return (NULL); 1048 } 1049 return (token); 1050 } 1051 1052 /* 1053 * The Modifier tokens 1054 */ 1055 1056 /* 1057 * au_to_groups 1058 * return s: 1059 * pointer to a group list token. 1060 * 1061 * This function is obsolete. Please use au_to_newgroups. 1062 */ 1063 token_t * 1064 au_to_groups(int *groups) 1065 { 1066 token_t *token; /* local token */ 1067 adr_t adr; /* adr memory stream header */ 1068 char data_header = AUT_GROUPS; /* header for this token */ 1069 1070 token = get_token(sizeof (char) + NGROUPS * sizeof (int32_t)); 1071 if (token == NULL) 1072 return (NULL); 1073 adr_start(&adr, token->tt_data); 1074 adr_char(&adr, &data_header, 1); 1075 adr_int32(&adr, (int32_t *)groups, NGROUPS); 1076 1077 return (token); 1078 } 1079 1080 /* 1081 * au_to_newgroups 1082 * return s: 1083 * pointer to a group list token. 1084 */ 1085 token_t * 1086 au_to_newgroups(int n, gid_t *groups) 1087 { 1088 token_t *token; /* local token */ 1089 adr_t adr; /* adr memory stream header */ 1090 char data_header = AUT_NEWGROUPS; /* header for this token */ 1091 short n_groups; 1092 1093 if (n < 0 || n > SHRT_MAX || groups == NULL) 1094 return (NULL); 1095 token = get_token(sizeof (char) + sizeof (short) + n * sizeof (gid_t)); 1096 if (token == NULL) 1097 return (NULL); 1098 n_groups = (short)n; 1099 adr_start(&adr, token->tt_data); 1100 adr_char(&adr, &data_header, 1); 1101 adr_short(&adr, &n_groups, 1); 1102 adr_int32(&adr, (int32_t *)groups, n_groups); 1103 1104 return (token); 1105 } 1106 1107 /* 1108 * au_to_exec_args 1109 * returns: 1110 * pointer to an exec args token. 1111 */ 1112 token_t * 1113 au_to_exec_args(char **argv) 1114 { 1115 return (au_to_exec(argv, AUT_EXEC_ARGS)); 1116 } 1117 1118 /* 1119 * au_to_exec_env 1120 * returns: 1121 * pointer to an exec args token. 1122 */ 1123 token_t * 1124 au_to_exec_env(char **envp) 1125 { 1126 return (au_to_exec(envp, AUT_EXEC_ENV)); 1127 } 1128 1129 /* 1130 * au_to_exec 1131 * returns: 1132 * pointer to an exec args token. 1133 */ 1134 static token_t * 1135 au_to_exec(char **v, char data_header) 1136 { 1137 token_t *token; 1138 adr_t adr; 1139 char **p; 1140 int32_t n = 0; 1141 int len = 0; 1142 1143 for (p = v; *p != NULL; p++) { 1144 len += strlen(*p) + 1; 1145 n++; 1146 } 1147 token = get_token(sizeof (char) + sizeof (int32_t) + len); 1148 if (token == (token_t *)NULL) 1149 return ((token_t *)NULL); 1150 adr_start(&adr, token->tt_data); 1151 adr_char(&adr, &data_header, 1); 1152 adr_int32(&adr, &n, 1); 1153 for (p = v; *p != NULL; p++) { 1154 adr_char(&adr, *p, strlen(*p) + 1); 1155 } 1156 return (token); 1157 } 1158 1159 /* 1160 * au_to_uauth 1161 * return s: 1162 * pointer to a uauth token. 1163 */ 1164 token_t * 1165 au_to_uauth(char *text) 1166 { 1167 token_t *token; /* local token */ 1168 adr_t adr; /* adr memory stream header */ 1169 char data_header = AUT_UAUTH; /* header for this token */ 1170 short bytes; /* length of string */ 1171 1172 bytes = strlen(text) + 1; 1173 1174 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 1175 if (token == NULL) 1176 return (NULL); 1177 adr_start(&adr, token->tt_data); 1178 adr_char(&adr, &data_header, 1); 1179 adr_short(&adr, &bytes, 1); 1180 adr_char(&adr, text, bytes); 1181 1182 return (token); 1183 } 1184 1185 /* 1186 * au_to_upriv 1187 * return s: 1188 * pointer to a use of privilege token. 1189 */ 1190 token_t * 1191 au_to_upriv(char sorf, char *priv) 1192 { 1193 token_t *token; /* local token */ 1194 adr_t adr; /* adr memory stream header */ 1195 char data_header = AUT_UAUTH; /* header for this token */ 1196 short bytes; /* length of string */ 1197 1198 bytes = strlen(priv) + 1; 1199 1200 token = get_token(sizeof (char) + sizeof (char) + sizeof (short) + 1201 bytes); 1202 if (token == NULL) 1203 return (NULL); 1204 adr_start(&adr, token->tt_data); 1205 adr_char(&adr, &data_header, 1); 1206 adr_char(&adr, &sorf, 1); /* success/failure */ 1207 adr_short(&adr, &bytes, 1); 1208 adr_char(&adr, priv, bytes); 1209 1210 return (token); 1211 } 1212 1213 /* 1214 * au_to_user 1215 * return s: 1216 * pointer to a user token. 1217 */ 1218 token_t * 1219 au_to_user(uid_t uid, char *username) 1220 { 1221 token_t *token; /* local token */ 1222 adr_t adr; /* adr memory stream header */ 1223 char data_header = AUT_USER; /* header for this token */ 1224 short bytes; /* length of string */ 1225 1226 bytes = (short)strlen(username) + 1; 1227 1228 token = get_token(sizeof (char) + sizeof (uid_t) + sizeof (short) + 1229 bytes); 1230 if (token == NULL) 1231 return (NULL); 1232 adr_start(&adr, token->tt_data); 1233 adr_char(&adr, &data_header, 1); 1234 adr_uid(&adr, &uid, 1); 1235 adr_short(&adr, &bytes, 1); 1236 adr_char(&adr, username, bytes); 1237 1238 return (token); 1239 } 1240 1241 /* 1242 * au_to_xatom 1243 * return s: 1244 * pointer to a xatom token. 1245 */ 1246 token_t * 1247 au_to_xatom(char *atom) 1248 { 1249 token_t *token; /* local token */ 1250 adr_t adr; /* adr memory stream header */ 1251 char data_header = AUT_XATOM; /* header for this token */ 1252 short len; 1253 1254 len = strlen(atom) + 1; 1255 1256 token = get_token(sizeof (char) + sizeof (short) + len); 1257 if (token == NULL) 1258 return (NULL); 1259 adr_start(&adr, token->tt_data); 1260 adr_char(&adr, &data_header, 1); 1261 adr_short(&adr, (short *)&len, 1); 1262 adr_char(&adr, atom, len); 1263 1264 return (token); 1265 } 1266 1267 /* 1268 * au_to_xselect 1269 * return s: 1270 * pointer to a X select token. 1271 */ 1272 token_t * 1273 au_to_xselect(char *propname, char *proptype, char *windata) 1274 { 1275 token_t *token; /* local token */ 1276 adr_t adr; /* adr memory stream header */ 1277 char data_header = AUT_XSELECT; /* header for this token */ 1278 short proplen; 1279 short typelen; 1280 short datalen; 1281 1282 proplen = strlen(propname) + 1; 1283 typelen = strlen(proptype) + 1; 1284 datalen = strlen(windata) + 1; 1285 1286 token = get_token(sizeof (char) + (sizeof (short) * 3) + 1287 proplen + typelen + datalen); 1288 if (token == NULL) 1289 return (NULL); 1290 adr_start(&adr, token->tt_data); 1291 adr_char(&adr, &data_header, 1); 1292 adr_short(&adr, &proplen, 1); 1293 adr_char(&adr, propname, proplen); 1294 adr_short(&adr, &typelen, 1); 1295 adr_char(&adr, proptype, typelen); 1296 adr_short(&adr, &datalen, 1); 1297 adr_char(&adr, windata, datalen); 1298 1299 return (token); 1300 } 1301 1302 /* 1303 * x_common 1304 * return s: 1305 * pointer to a common X token. 1306 */ 1307 1308 static token_t * 1309 x_common(char data_header, int32_t xid, uid_t cuid) 1310 { 1311 token_t *token; /* local token */ 1312 adr_t adr; /* adr memory stream header */ 1313 1314 token = get_token(sizeof (char) + sizeof (int32_t) + sizeof (uid_t)); 1315 if (token == NULL) 1316 return (NULL); 1317 adr_start(&adr, token->tt_data); 1318 adr_char(&adr, &data_header, 1); 1319 adr_int32(&adr, &xid, 1); 1320 adr_uid(&adr, &cuid, 1); 1321 1322 return (token); 1323 } 1324 1325 /* 1326 * au_to_xcolormap 1327 * return s: 1328 * pointer to a X Colormap token. 1329 */ 1330 1331 token_t * 1332 au_to_xcolormap(int32_t xid, uid_t cuid) 1333 { 1334 return (x_common(AUT_XCOLORMAP, xid, cuid)); 1335 } 1336 1337 /* 1338 * au_to_xcursor 1339 * return s: 1340 * pointer to a X Cursor token. 1341 */ 1342 1343 token_t * 1344 au_to_xcursor(int32_t xid, uid_t cuid) 1345 { 1346 return (x_common(AUT_XCURSOR, xid, cuid)); 1347 } 1348 1349 /* 1350 * au_to_xfont 1351 * return s: 1352 * pointer to a X Font token. 1353 */ 1354 1355 token_t * 1356 au_to_xfont(int32_t xid, uid_t cuid) 1357 { 1358 return (x_common(AUT_XFONT, xid, cuid)); 1359 } 1360 1361 /* 1362 * au_to_xgc 1363 * return s: 1364 * pointer to a X Graphic Context token. 1365 */ 1366 1367 token_t * 1368 au_to_xgc(int32_t xid, uid_t cuid) 1369 { 1370 return (x_common(AUT_XGC, xid, cuid)); 1371 } 1372 1373 /* 1374 * au_to_xpixmap 1375 * return s: 1376 * pointer to a X Pixal Map token. 1377 */ 1378 1379 token_t * 1380 au_to_xpixmap(int32_t xid, uid_t cuid) 1381 { 1382 return (x_common(AUT_XPIXMAP, xid, cuid)); 1383 } 1384 1385 /* 1386 * au_to_xwindow 1387 * return s: 1388 * pointer to a X Window token. 1389 */ 1390 1391 token_t * 1392 au_to_xwindow(int32_t xid, uid_t cuid) 1393 { 1394 return (x_common(AUT_XWINDOW, xid, cuid)); 1395 } 1396 1397 /* 1398 * au_to_xproperty 1399 * return s: 1400 * pointer to a X Property token. 1401 */ 1402 1403 token_t * 1404 au_to_xproperty(int32_t xid, uid_t cuid, char *propname) 1405 { 1406 token_t *token; /* local token */ 1407 adr_t adr; /* adr memory stream header */ 1408 char data_header = AUT_XPROPERTY; /* header for this token */ 1409 short proplen; 1410 1411 proplen = strlen(propname) + 1; 1412 1413 token = get_token(sizeof (char) + sizeof (int32_t) + sizeof (uid_t) + 1414 sizeof (short) + proplen); 1415 if (token == NULL) 1416 return (NULL); 1417 adr_start(&adr, token->tt_data); 1418 adr_char(&adr, &data_header, 1); 1419 adr_int32(&adr, &xid, 1); 1420 adr_uid(&adr, &cuid, 1); 1421 adr_short(&adr, &proplen, 1); 1422 adr_char(&adr, propname, proplen); 1423 1424 return (token); 1425 } 1426 1427 /* 1428 * au_to_xclient 1429 * return s: 1430 * pointer to a X Client token 1431 */ 1432 1433 token_t * 1434 au_to_xclient(uint32_t client) 1435 { 1436 token_t *token; /* local token */ 1437 adr_t adr; /* adr memory stream header */ 1438 char data_header = AUT_XCLIENT; /* header for this token */ 1439 1440 token = get_token(sizeof (char) + sizeof (uint32_t)); 1441 if (token == NULL) 1442 return (NULL); 1443 adr_start(&adr, token->tt_data); 1444 adr_char(&adr, &data_header, 1); 1445 adr_int32(&adr, (int32_t *)&client, 1); 1446 1447 return (token); 1448 } 1449 1450 /* 1451 * au_to_label 1452 * return s: 1453 * pointer to a label token. 1454 */ 1455 token_t * 1456 au_to_label(m_label_t *label) 1457 { 1458 token_t *token; /* local token */ 1459 adr_t adr; /* adr memory stream header */ 1460 char data_header = AUT_LABEL; /* header for this token */ 1461 size32_t llen = blabel_size(); 1462 1463 token = get_token(sizeof (char) + llen); 1464 if (token == NULL) { 1465 return (NULL); 1466 } else if (label == NULL) { 1467 free(token); 1468 return (NULL); 1469 } 1470 adr_start(&adr, token->tt_data); 1471 adr_char(&adr, &data_header, 1); 1472 adr_char(&adr, (char *)label, llen); 1473 1474 return (token); 1475 } 1476 1477 /* 1478 * au_to_mylabel 1479 * return s: 1480 * pointer to a label token. 1481 */ 1482 token_t * 1483 au_to_mylabel(void) 1484 { 1485 ucred_t *uc; 1486 token_t *token; 1487 1488 if ((uc = ucred_get(P_MYID)) == NULL) { 1489 return (NULL); 1490 } 1491 1492 token = au_to_label(ucred_getlabel(uc)); 1493 ucred_free(uc); 1494 return (token); 1495 } 1496 1497 /* 1498 * au_to_zonename 1499 * return s: 1500 * pointer to a zonename token. 1501 */ 1502 token_t * 1503 au_to_zonename(char *name) 1504 { 1505 token_t *token; /* local token */ 1506 adr_t adr; /* adr memory stream header */ 1507 char data_header = AUT_ZONENAME; /* header for this token */ 1508 short bytes; /* length of string */ 1509 1510 if (name == NULL) 1511 return (NULL); 1512 1513 bytes = strlen(name) + 1; 1514 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 1515 if (token == NULL) 1516 return (NULL); 1517 adr_start(&adr, token->tt_data); 1518 adr_char(&adr, &data_header, 1); 1519 adr_short(&adr, &bytes, 1); 1520 adr_char(&adr, name, bytes); 1521 1522 return (token); 1523 } 1524 1525 /* 1526 * au_to_fmri 1527 * return s: 1528 * pointer to a fmri token. 1529 */ 1530 token_t * 1531 au_to_fmri(char *fmri) 1532 { 1533 token_t *token; /* local token */ 1534 adr_t adr; /* adr memory stream header */ 1535 char data_header = AUT_FMRI; /* header for this token */ 1536 short bytes; /* length of string */ 1537 1538 if (fmri == NULL) 1539 return (NULL); 1540 1541 bytes = strlen(fmri) + 1; 1542 token = get_token((int)(sizeof (char) + sizeof (short) + bytes)); 1543 if (token == NULL) 1544 return (NULL); 1545 adr_start(&adr, token->tt_data); 1546 adr_char(&adr, &data_header, 1); 1547 adr_short(&adr, &bytes, 1); 1548 adr_char(&adr, fmri, bytes); 1549 1550 return (token); 1551 } 1552