sys/security/audit/bsm_token.c

   1 /*-
   2  * Copyright (c) 2004-2009 Apple Inc.
   3  * Copyright (c) 2005 SPARTA, Inc.
   4  * All rights reserved.
   5  *
   6  * This code was developed in part by Robert N. M. Watson, Senior Principal
   7  * Scientist, SPARTA, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1.  Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  * 2.  Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions and the following disclaimer in the
  16  *     documentation and/or other materials provided with the distribution.
  17  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  18  *     its contributors may be used to endorse or promote products derived
  19  *     from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
  25  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * P4: //depot/projects/trustedbsd/openbsm/libbsm/bsm_token.c#99
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/param.h>
  40 #include <sys/types.h>
  41 #include <sys/endian.h>
  42 #include <sys/queue.h>
  43 #include <sys/socket.h>
  44 #include <sys/time.h>
  45
  46 #include <sys/ipc.h>
  47 #include <sys/libkern.h>
  48 #include <sys/malloc.h>
  49 #include <sys/un.h>
  50
  51 #include <netinet/in.h>
  52 #include <netinet/in_systm.h>
  53 #include <netinet/ip.h>
  54
  55
  56 #include <bsm/audit.h>
  57 #include <bsm/audit_internal.h>
  58 #include <bsm/audit_record.h>
  59 #include <security/audit/audit.h>
  60 #include <security/audit/audit_private.h>
  61
  62 #define GET_TOKEN_AREA(t, dptr, length) do {                            \
  63         t = malloc(sizeof(token_t), M_AUDITBSM, M_WAITOK);              \
  64         t->t_data = malloc(length, M_AUDITBSM, M_WAITOK | M_ZERO);      \
  65         t->len = length;                                                \
  66         dptr = t->t_data;                                               \
  67 } while (0)
  68
  69 /*
  70  * token ID                1 byte
  71  * success/failure         1 byte
  72  * privstrlen              2 bytes
  73  * privstr                 N bytes + 1 (\0 byte)
  74  */
  75 token_t *
  76 au_to_upriv(char sorf, char *priv)
  77 {
  78         u_int16_t textlen;
  79         u_char *dptr;
  80         token_t *t;
  81
  82         textlen = strlen(priv) + 1;
  83         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_char) +
  84             sizeof(u_int16_t) + textlen);
  85
  86         ADD_U_CHAR(dptr, AUT_UPRIV);
  87         ADD_U_CHAR(dptr, sorf);
  88         ADD_U_INT16(dptr, textlen);
  89         ADD_STRING(dptr, priv, textlen);
  90         return (t);
  91 }
  92
  93 /*
  94  * token ID             1 byte
  95  * privtstrlen          2 bytes
  96  * privtstr             N bytes + 1
  97  * privstrlen           2 bytes
  98  * privstr              N bytes + 1
  99  */
 100 token_t *
 101 au_to_privset(char *privtypestr, char *privstr)
 102 {
 103         u_int16_t        type_len, priv_len;
 104         u_char          *dptr;
 105         token_t         *t;
 106
 107         type_len = strlen(privtypestr) + 1;
 108         priv_len = strlen(privstr) + 1;
 109         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) +
 110             sizeof(u_int16_t) + type_len + priv_len);
 111
 112         ADD_U_CHAR(dptr, AUT_PRIV);
 113         ADD_U_INT16(dptr, type_len);
 114         ADD_STRING(dptr, privtypestr, type_len);
 115         ADD_U_INT16(dptr, priv_len);
 116         ADD_STRING(dptr, privstr, priv_len);
 117         return (t);
 118 }
 119
 120 /*
 121  * token ID                1 byte
 122  * argument #              1 byte
 123  * argument value          4 bytes/8 bytes (32-bit/64-bit value)
 124  * text length             2 bytes
 125  * text                    N bytes + 1 terminating NULL byte
 126  */
 127 token_t *
 128 au_to_arg32(char n, const char *text, u_int32_t v)
 129 {
 130         token_t *t;
 131         u_char *dptr = NULL;
 132         u_int16_t textlen;
 133
 134         textlen = strlen(text);
 135         textlen += 1;
 136
 137         GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t) +
 138             sizeof(u_int16_t) + textlen);
 139
 140         ADD_U_CHAR(dptr, AUT_ARG32);
 141         ADD_U_CHAR(dptr, n);
 142         ADD_U_INT32(dptr, v);
 143         ADD_U_INT16(dptr, textlen);
 144         ADD_STRING(dptr, text, textlen);
 145
 146         return (t);
 147 }
 148
 149 token_t *
 150 au_to_arg64(char n, const char *text, u_int64_t v)
 151 {
 152         token_t *t;
 153         u_char *dptr = NULL;
 154         u_int16_t textlen;
 155
 156         textlen = strlen(text);
 157         textlen += 1;
 158
 159         GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int64_t) +
 160             sizeof(u_int16_t) + textlen);
 161
 162         ADD_U_CHAR(dptr, AUT_ARG64);
 163         ADD_U_CHAR(dptr, n);
 164         ADD_U_INT64(dptr, v);
 165         ADD_U_INT16(dptr, textlen);
 166         ADD_STRING(dptr, text, textlen);
 167
 168         return (t);
 169 }
 170
 171 token_t *
 172 au_to_arg(char n, const char *text, u_int32_t v)
 173 {
 174
 175         return (au_to_arg32(n, text, v));
 176 }
 177
 178 #if defined(_KERNEL) || defined(KERNEL)
 179 /*
 180  * token ID                1 byte
 181  * file access mode        4 bytes
 182  * owner user ID           4 bytes
 183  * owner group ID          4 bytes
 184  * file system ID          4 bytes
 185  * node ID                 8 bytes
 186  * device                  4 bytes/8 bytes (32-bit/64-bit)
 187  */
 188 token_t *
 189 au_to_attr32(struct vnode_au_info *vni)
 190 {
 191         token_t *t;
 192         u_char *dptr = NULL;
 193         u_int16_t pad0_16 = 0;
 194         u_int32_t pad0_32 = 0;
 195
 196         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) +
 197             3 * sizeof(u_int32_t) + sizeof(u_int64_t) + sizeof(u_int32_t));
 198
 199         ADD_U_CHAR(dptr, AUT_ATTR32);
 200
 201         /*
 202          * BSD defines the size for the file mode as 2 bytes; BSM defines 4
 203          * so pad with 0.
 204          *
 205          * XXXRW: Possibly should be conditionally compiled.
 206          *
 207          * XXXRW: Should any conversions take place on the mode?
 208          */
 209         ADD_U_INT16(dptr, pad0_16);
 210         ADD_U_INT16(dptr, vni->vn_mode);
 211
 212         ADD_U_INT32(dptr, vni->vn_uid);
 213         ADD_U_INT32(dptr, vni->vn_gid);
 214         ADD_U_INT32(dptr, vni->vn_fsid);
 215
 216         /*
 217          * Some systems use 32-bit file ID's, others use 64-bit file IDs.
 218          * Attempt to handle both, and let the compiler sort it out.  If we
 219          * could pick this out at compile-time, it would be better, so as to
 220          * avoid the else case below.
 221          */
 222         if (sizeof(vni->vn_fileid) == sizeof(uint32_t)) {
 223                 ADD_U_INT32(dptr, pad0_32);
 224                 ADD_U_INT32(dptr, vni->vn_fileid);
 225         } else if (sizeof(vni->vn_fileid) == sizeof(uint64_t))
 226                 ADD_U_INT64(dptr, vni->vn_fileid);
 227         else
 228                 ADD_U_INT64(dptr, 0LL);
 229
 230         ADD_U_INT32(dptr, vni->vn_dev);
 231
 232         return (t);
 233 }
 234
 235 token_t *
 236 au_to_attr64(struct vnode_au_info *vni)
 237 {
 238         token_t *t;
 239         u_char *dptr = NULL;
 240         u_int16_t pad0_16 = 0;
 241         u_int32_t pad0_32 = 0;
 242
 243         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) +
 244             3 * sizeof(u_int32_t) + sizeof(u_int64_t) * 2);
 245
 246         ADD_U_CHAR(dptr, AUT_ATTR64);
 247
 248         /*
 249          * BSD defines the size for the file mode as 2 bytes; BSM defines 4
 250          * so pad with 0.
 251          *
 252          * XXXRW: Possibly should be conditionally compiled.
 253          *
 254          * XXXRW: Should any conversions take place on the mode?
 255          */
 256         ADD_U_INT16(dptr, pad0_16);
 257         ADD_U_INT16(dptr, vni->vn_mode);
 258
 259         ADD_U_INT32(dptr, vni->vn_uid);
 260         ADD_U_INT32(dptr, vni->vn_gid);
 261         ADD_U_INT32(dptr, vni->vn_fsid);
 262
 263         /*
 264          * Some systems use 32-bit file ID's, other's use 64-bit file IDs.
 265          * Attempt to handle both, and let the compiler sort it out.  If we
 266          * could pick this out at compile-time, it would be better, so as to
 267          * avoid the else case below.
 268          */
 269         if (sizeof(vni->vn_fileid) == sizeof(uint32_t)) {
 270                 ADD_U_INT32(dptr, pad0_32);
 271                 ADD_U_INT32(dptr, vni->vn_fileid);
 272         } else if (sizeof(vni->vn_fileid) == sizeof(uint64_t))
 273                 ADD_U_INT64(dptr, vni->vn_fileid);
 274         else
 275                 ADD_U_INT64(dptr, 0LL);
 276
 277         ADD_U_INT64(dptr, vni->vn_dev);
 278
 279         return (t);
 280 }
 281
 282 token_t *
 283 au_to_attr(struct vnode_au_info *vni)
 284 {
 285
 286         return (au_to_attr32(vni));
 287 }
 288 #endif /* !(defined(_KERNEL) || defined(KERNEL) */
 289
 290 /*
 291  * token ID                1 byte
 292  * how to print            1 byte
 293  * basic unit              1 byte
 294  * unit count              1 byte
 295  * data items              (depends on basic unit)
 296  */
 297 token_t *
 298 au_to_data(char unit_print, char unit_type, char unit_count, const char *p)
 299 {
 300         token_t *t;
 301         u_char *dptr = NULL;
 302         size_t datasize, totdata;
 303
 304         /* Determine the size of the basic unit. */
 305         switch (unit_type) {
 306         case AUR_BYTE:
 307         /* case AUR_CHAR: */
 308                 datasize = AUR_BYTE_SIZE;
 309                 break;
 310
 311         case AUR_SHORT:
 312                 datasize = AUR_SHORT_SIZE;
 313                 break;
 314
 315         case AUR_INT32:
 316         /* case AUR_INT: */
 317                 datasize = AUR_INT32_SIZE;
 318                 break;
 319
 320         case AUR_INT64:
 321                 datasize = AUR_INT64_SIZE;
 322                 break;
 323
 324         default:
 325                 return (NULL);
 326         }
 327
 328         totdata = datasize * unit_count;
 329
 330         GET_TOKEN_AREA(t, dptr, 4 * sizeof(u_char) + totdata);
 331
 332         /*
 333          * XXXRW: We should be byte-swapping each data item for multi-byte
 334          * types.
 335          */
 336         ADD_U_CHAR(dptr, AUT_DATA);
 337         ADD_U_CHAR(dptr, unit_print);
 338         ADD_U_CHAR(dptr, unit_type);
 339         ADD_U_CHAR(dptr, unit_count);
 340         ADD_MEM(dptr, p, totdata);
 341
 342         return (t);
 343 }
 344
 345
 346 /*
 347  * token ID                1 byte
 348  * status                  4 bytes
 349  * return value            4 bytes
 350  */
 351 token_t *
 352 au_to_exit(int retval, int err)
 353 {
 354         token_t *t;
 355         u_char *dptr = NULL;
 356
 357         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int32_t));
 358
 359         ADD_U_CHAR(dptr, AUT_EXIT);
 360         ADD_U_INT32(dptr, err);
 361         ADD_U_INT32(dptr, retval);
 362
 363         return (t);
 364 }
 365
 366 /*
 367  */
 368 token_t *
 369 au_to_groups(int *groups)
 370 {
 371
 372         return (au_to_newgroups(AUDIT_MAX_GROUPS, (gid_t *)groups));
 373 }
 374
 375 /*
 376  * token ID                1 byte
 377  * number groups           2 bytes
 378  * group list              count * 4 bytes
 379  */
 380 token_t *
 381 au_to_newgroups(u_int16_t n, gid_t *groups)
 382 {
 383         token_t *t;
 384         u_char *dptr = NULL;
 385         int i;
 386
 387         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) +
 388             n * sizeof(u_int32_t));
 389
 390         ADD_U_CHAR(dptr, AUT_NEWGROUPS);
 391         ADD_U_INT16(dptr, n);
 392         for (i = 0; i < n; i++)
 393                 ADD_U_INT32(dptr, groups[i]);
 394
 395         return (t);
 396 }
 397
 398 /*
 399  * token ID                1 byte
 400  * internet address        4 bytes
 401  */
 402 token_t *
 403 au_to_in_addr(struct in_addr *internet_addr)
 404 {
 405         token_t *t;
 406         u_char *dptr = NULL;
 407
 408         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(uint32_t));
 409
 410         ADD_U_CHAR(dptr, AUT_IN_ADDR);
 411         ADD_MEM(dptr, &internet_addr->s_addr, sizeof(uint32_t));
 412
 413         return (t);
 414 }
 415
 416 /*
 417  * token ID                1 byte
 418  * address type/length     4 bytes
 419  * address                16 bytes
 420  */
 421 token_t *
 422 au_to_in_addr_ex(struct in6_addr *internet_addr)
 423 {
 424         token_t *t;
 425         u_char *dptr = NULL;
 426         u_int32_t type = AU_IPv6;
 427
 428         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 5 * sizeof(uint32_t));
 429
 430         ADD_U_CHAR(dptr, AUT_IN_ADDR_EX);
 431         ADD_U_INT32(dptr, type);
 432         ADD_MEM(dptr, internet_addr, 4 * sizeof(uint32_t));
 433
 434         return (t);
 435 }
 436
 437 /*
 438  * token ID                1 byte
 439  * ip header               20 bytes
 440  *
 441  * The IP header should be submitted in network byte order.
 442  */
 443 token_t *
 444 au_to_ip(struct ip *ip)
 445 {
 446         token_t *t;
 447         u_char *dptr = NULL;
 448
 449         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(struct ip));
 450
 451         ADD_U_CHAR(dptr, AUT_IP);
 452         ADD_MEM(dptr, ip, sizeof(struct ip));
 453
 454         return (t);
 455 }
 456
 457 /*
 458  * token ID                1 byte
 459  * object ID type          1 byte
 460  * object ID               4 bytes
 461  */
 462 token_t *
 463 au_to_ipc(char type, int id)
 464 {
 465         token_t *t;
 466         u_char *dptr = NULL;
 467
 468         GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t));
 469
 470         ADD_U_CHAR(dptr, AUT_IPC);
 471         ADD_U_CHAR(dptr, type);
 472         ADD_U_INT32(dptr, id);
 473
 474         return (t);
 475 }
 476
 477 /*
 478  * token ID                1 byte
 479  * owner user ID           4 bytes
 480  * owner group ID          4 bytes
 481  * creator user ID         4 bytes
 482  * creator group ID        4 bytes
 483  * access mode             4 bytes
 484  * slot sequence #         4 bytes
 485  * key                     4 bytes
 486  */
 487 token_t *
 488 au_to_ipc_perm(struct ipc_perm *perm)
 489 {
 490         token_t *t;
 491         u_char *dptr = NULL;
 492         u_int16_t pad0 = 0;
 493
 494         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 12 * sizeof(u_int16_t) +
 495             sizeof(u_int32_t));
 496
 497         ADD_U_CHAR(dptr, AUT_IPC_PERM);
 498
 499         /*
 500          * Systems vary significantly in what types they use in struct
 501          * ipc_perm; at least a few still use 16-bit uid's and gid's, so
 502          * allow for that, as BSM define 32-bit values here.
 503          * Some systems define the sizes for ipc_perm members as 2 bytes;
 504          * BSM defines 4 so pad with 0.
 505          *
 506          * XXXRW: Possibly shoulid be conditionally compiled, and more cases
 507          * need to be handled.
 508          */
 509         if (sizeof(perm->uid) != sizeof(u_int32_t)) {
 510                 ADD_U_INT16(dptr, pad0);
 511                 ADD_U_INT16(dptr, perm->uid);
 512                 ADD_U_INT16(dptr, pad0);
 513                 ADD_U_INT16(dptr, perm->gid);
 514                 ADD_U_INT16(dptr, pad0);
 515                 ADD_U_INT16(dptr, perm->cuid);
 516                 ADD_U_INT16(dptr, pad0);
 517                 ADD_U_INT16(dptr, perm->cgid);
 518         } else {
 519                 ADD_U_INT32(dptr, perm->uid);
 520                 ADD_U_INT32(dptr, perm->gid);
 521                 ADD_U_INT32(dptr, perm->cuid);
 522                 ADD_U_INT32(dptr, perm->cgid);
 523         }
 524
 525         ADD_U_INT16(dptr, pad0);
 526         ADD_U_INT16(dptr, perm->mode);
 527
 528         ADD_U_INT16(dptr, pad0);
 529
 530         ADD_U_INT16(dptr, perm->seq);
 531
 532         ADD_U_INT32(dptr, perm->key);
 533
 534         return (t);
 535 }
 536
 537 /*
 538  * token ID                1 byte
 539  * port IP address         2 bytes
 540  */
 541 token_t *
 542 au_to_iport(u_int16_t iport)
 543 {
 544         token_t *t;
 545         u_char *dptr = NULL;
 546
 547         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t));
 548
 549         ADD_U_CHAR(dptr, AUT_IPORT);
 550         ADD_U_INT16(dptr, iport);
 551
 552         return (t);
 553 }
 554
 555 /*
 556  * token ID                1 byte
 557  * size                    2 bytes
 558  * data                    size bytes
 559  */
 560 token_t *
 561 au_to_opaque(const char *data, u_int16_t bytes)
 562 {
 563         token_t *t;
 564         u_char *dptr = NULL;
 565
 566         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + bytes);
 567
 568         ADD_U_CHAR(dptr, AUT_OPAQUE);
 569         ADD_U_INT16(dptr, bytes);
 570         ADD_MEM(dptr, data, bytes);
 571
 572         return (t);
 573 }
 574
 575 /*
 576  * token ID                1 byte
 577  * seconds of time         4 bytes
 578  * milliseconds of time    4 bytes
 579  * file name len           2 bytes
 580  * file pathname           N bytes + 1 terminating NULL byte
 581  */
 582 token_t *
 583 au_to_file(const char *file, struct timeval tm)
 584 {
 585         token_t *t;
 586         u_char *dptr = NULL;
 587         u_int16_t filelen;
 588         u_int32_t timems;
 589
 590         filelen = strlen(file);
 591         filelen += 1;
 592
 593         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int32_t) +
 594             sizeof(u_int16_t) + filelen);
 595
 596         timems = tm.tv_usec/1000;
 597
 598         ADD_U_CHAR(dptr, AUT_OTHER_FILE32);
 599         ADD_U_INT32(dptr, tm.tv_sec);
 600         ADD_U_INT32(dptr, timems);      /* We need time in ms. */
 601         ADD_U_INT16(dptr, filelen);
 602         ADD_STRING(dptr, file, filelen);
 603
 604         return (t);
 605 }
 606
 607 /*
 608  * token ID                1 byte
 609  * text length             2 bytes
 610  * text                    N bytes + 1 terminating NULL byte
 611  */
 612 token_t *
 613 au_to_text(const char *text)
 614 {
 615         token_t *t;
 616         u_char *dptr = NULL;
 617         u_int16_t textlen;
 618
 619         textlen = strlen(text);
 620         textlen += 1;
 621
 622         /* XXXRW: Should validate length against token size limit. */
 623
 624         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen);
 625
 626         ADD_U_CHAR(dptr, AUT_TEXT);
 627         ADD_U_INT16(dptr, textlen);
 628         ADD_STRING(dptr, text, textlen);
 629
 630         return (t);
 631 }
 632
 633 /*
 634  * token ID                1 byte
 635  * path length             2 bytes
 636  * path                    N bytes + 1 terminating NULL byte
 637  */
 638 token_t *
 639 au_to_path(const char *text)
 640 {
 641         token_t *t;
 642         u_char *dptr = NULL;
 643         u_int16_t textlen;
 644
 645         textlen = strlen(text);
 646         textlen += 1;
 647
 648         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen);
 649
 650         ADD_U_CHAR(dptr, AUT_PATH);
 651         ADD_U_INT16(dptr, textlen);
 652         ADD_STRING(dptr, text, textlen);
 653
 654         return (t);
 655 }
 656
 657 /*
 658  * token ID                1 byte
 659  * audit ID                4 bytes
 660  * effective user ID       4 bytes
 661  * effective group ID      4 bytes
 662  * real user ID            4 bytes
 663  * real group ID           4 bytes
 664  * process ID              4 bytes
 665  * session ID              4 bytes
 666  * terminal ID
 667  *   port ID               4 bytes/8 bytes (32-bit/64-bit value)
 668  *   machine address       4 bytes
 669  */
 670 token_t *
 671 au_to_process32(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
 672     pid_t pid, au_asid_t sid, au_tid_t *tid)
 673 {
 674         token_t *t;
 675         u_char *dptr = NULL;
 676
 677         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 9 * sizeof(u_int32_t));
 678
 679         ADD_U_CHAR(dptr, AUT_PROCESS32);
 680         ADD_U_INT32(dptr, auid);
 681         ADD_U_INT32(dptr, euid);
 682         ADD_U_INT32(dptr, egid);
 683         ADD_U_INT32(dptr, ruid);
 684         ADD_U_INT32(dptr, rgid);
 685         ADD_U_INT32(dptr, pid);
 686         ADD_U_INT32(dptr, sid);
 687         ADD_U_INT32(dptr, tid->port);
 688
 689         /*
 690          * Note: Solaris will write out IPv6 addresses here as a 32-bit
 691          * address type and 16 bytes of address, but for IPv4 addresses it
 692          * simply writes the 4-byte address directly.  We support only IPv4
 693          * addresses for process32 tokens.
 694          */
 695         ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));
 696
 697         return (t);
 698 }
 699
 700 token_t *
 701 au_to_process64(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
 702     pid_t pid, au_asid_t sid, au_tid_t *tid)
 703 {
 704         token_t *t;
 705         u_char *dptr = NULL;
 706
 707         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 8 * sizeof(u_int32_t) +
 708             sizeof(u_int64_t));
 709
 710         ADD_U_CHAR(dptr, AUT_PROCESS64);
 711         ADD_U_INT32(dptr, auid);
 712         ADD_U_INT32(dptr, euid);
 713         ADD_U_INT32(dptr, egid);
 714         ADD_U_INT32(dptr, ruid);
 715         ADD_U_INT32(dptr, rgid);
 716         ADD_U_INT32(dptr, pid);
 717         ADD_U_INT32(dptr, sid);
 718         ADD_U_INT64(dptr, tid->port);
 719
 720         /*
 721          * Note: Solaris will write out IPv6 addresses here as a 32-bit
 722          * address type and 16 bytes of address, but for IPv4 addresses it
 723          * simply writes the 4-byte address directly.  We support only IPv4
 724          * addresses for process64 tokens.
 725          */
 726         ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));
 727
 728         return (t);
 729 }
 730
 731 token_t *
 732 au_to_process(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
 733     pid_t pid, au_asid_t sid, au_tid_t *tid)
 734 {
 735
 736         return (au_to_process32(auid, euid, egid, ruid, rgid, pid, sid,
 737             tid));
 738 }
 739
 740 /*
 741  * token ID                1 byte
 742  * audit ID                4 bytes
 743  * effective user ID       4 bytes
 744  * effective group ID      4 bytes
 745  * real user ID            4 bytes
 746  * real group ID           4 bytes
 747  * process ID              4 bytes
 748  * session ID              4 bytes
 749  * terminal ID
 750  *   port ID               4 bytes/8 bytes (32-bit/64-bit value)
 751  *   address type-len      4 bytes
 752  *   machine address      16 bytes
 753  */
 754 token_t *
 755 au_to_process32_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
 756     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
 757 {
 758         token_t *t;
 759         u_char *dptr = NULL;
 760
 761         KASSERT((tid->at_type == AU_IPv4) || (tid->at_type == AU_IPv6),
 762             ("au_to_process32_ex: type %u", (unsigned int)tid->at_type));
 763         if (tid->at_type == AU_IPv4)
 764                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 765                     10 * sizeof(u_int32_t));
 766         else
 767                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 768                     13 * sizeof(u_int32_t));
 769
 770         ADD_U_CHAR(dptr, AUT_PROCESS32_EX);
 771         ADD_U_INT32(dptr, auid);
 772         ADD_U_INT32(dptr, euid);
 773         ADD_U_INT32(dptr, egid);
 774         ADD_U_INT32(dptr, ruid);
 775         ADD_U_INT32(dptr, rgid);
 776         ADD_U_INT32(dptr, pid);
 777         ADD_U_INT32(dptr, sid);
 778         ADD_U_INT32(dptr, tid->at_port);
 779         ADD_U_INT32(dptr, tid->at_type);
 780         ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));
 781         if (tid->at_type == AU_IPv6) {
 782                 ADD_MEM(dptr, &tid->at_addr[1], sizeof(u_int32_t));
 783                 ADD_MEM(dptr, &tid->at_addr[2], sizeof(u_int32_t));
 784                 ADD_MEM(dptr, &tid->at_addr[3], sizeof(u_int32_t));
 785         }
 786
 787         return (t);
 788 }
 789
 790 token_t *
 791 au_to_process64_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
 792     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
 793 {
 794         token_t *t;
 795         u_char *dptr = NULL;
 796
 797         if (tid->at_type == AU_IPv4)
 798                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 799                     7 * sizeof(u_int32_t) + sizeof(u_int64_t) +
 800                     2 * sizeof(u_int32_t));
 801         else if (tid->at_type == AU_IPv6)
 802                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 803                     7 * sizeof(u_int32_t) + sizeof(u_int64_t) +
 804                     5 * sizeof(u_int32_t));
 805         else
 806                 panic("au_to_process64_ex: invalidate at_type (%d)",
 807                     tid->at_type);
 808
 809         ADD_U_CHAR(dptr, AUT_PROCESS64_EX);
 810         ADD_U_INT32(dptr, auid);
 811         ADD_U_INT32(dptr, euid);
 812         ADD_U_INT32(dptr, egid);
 813         ADD_U_INT32(dptr, ruid);
 814         ADD_U_INT32(dptr, rgid);
 815         ADD_U_INT32(dptr, pid);
 816         ADD_U_INT32(dptr, sid);
 817         ADD_U_INT64(dptr, tid->at_port);
 818         ADD_U_INT32(dptr, tid->at_type);
 819         ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));
 820         if (tid->at_type == AU_IPv6) {
 821                 ADD_MEM(dptr, &tid->at_addr[1], sizeof(u_int32_t));
 822                 ADD_MEM(dptr, &tid->at_addr[2], sizeof(u_int32_t));
 823                 ADD_MEM(dptr, &tid->at_addr[3], sizeof(u_int32_t));
 824         }
 825
 826         return (t);
 827 }
 828
 829 token_t *
 830 au_to_process_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
 831     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
 832 {
 833
 834         return (au_to_process32_ex(auid, euid, egid, ruid, rgid, pid, sid,
 835             tid));
 836 }
 837
 838 token_t *
 839 au_to_rights(cap_rights_t *rightsp)
 840 {
 841         token_t *t;
 842         u_char *dptr;
 843         int i;
 844
 845         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(*rightsp));
 846
 847         ADD_U_CHAR(dptr, AUT_RIGHTS);
 848         for (i = 0; i < nitems(rightsp->cr_rights); i++)
 849                 ADD_U_INT64(dptr, rightsp->cr_rights[i]);
 850
 851         return (t);
 852 }
 853
 854 /*
 855  * token ID                1 byte
 856  * error status            1 byte
 857  * return value            4 bytes/8 bytes (32-bit/64-bit value)
 858  */
 859 token_t *
 860 au_to_return32(char status, u_int32_t ret)
 861 {
 862         token_t *t;
 863         u_char *dptr = NULL;
 864
 865         GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int32_t));
 866
 867         ADD_U_CHAR(dptr, AUT_RETURN32);
 868         ADD_U_CHAR(dptr, status);
 869         ADD_U_INT32(dptr, ret);
 870
 871         return (t);
 872 }
 873
 874 token_t *
 875 au_to_return64(char status, u_int64_t ret)
 876 {
 877         token_t *t;
 878         u_char *dptr = NULL;
 879
 880         GET_TOKEN_AREA(t, dptr, 2 * sizeof(u_char) + sizeof(u_int64_t));
 881
 882         ADD_U_CHAR(dptr, AUT_RETURN64);
 883         ADD_U_CHAR(dptr, status);
 884         ADD_U_INT64(dptr, ret);
 885
 886         return (t);
 887 }
 888
 889 token_t *
 890 au_to_return(char status, u_int32_t ret)
 891 {
 892
 893         return (au_to_return32(status, ret));
 894 }
 895
 896 /*
 897  * token ID                1 byte
 898  * sequence number         4 bytes
 899  */
 900 token_t *
 901 au_to_seq(long audit_count)
 902 {
 903         token_t *t;
 904         u_char *dptr = NULL;
 905
 906         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t));
 907
 908         ADD_U_CHAR(dptr, AUT_SEQ);
 909         ADD_U_INT32(dptr, audit_count);
 910
 911         return (t);
 912 }
 913
 914 /*
 915  * token ID                1 byte
 916  * socket domain           2 bytes
 917  * socket type             2 bytes
 918  * address type            2 byte
 919  * local port              2 bytes
 920  * local address           4 bytes/16 bytes (IPv4/IPv6 address)
 921  * remote port             2 bytes
 922  * remote address          4 bytes/16 bytes (IPv4/IPv6 address)
 923  *
 924  * Domain and type arguments to this routine are assumed to already have been
 925  * converted to the BSM constant space, so we don't do that here.
 926  */
 927 token_t *
 928 au_to_socket_ex(u_short so_domain, u_short so_type,
 929     struct sockaddr *sa_local, struct sockaddr *sa_remote)
 930 {
 931         token_t *t;
 932         u_char *dptr = NULL;
 933         struct sockaddr_in *sin;
 934         struct sockaddr_in6 *sin6;
 935
 936         if (so_domain == AF_INET)
 937                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 938                     5 * sizeof(u_int16_t) + 2 * sizeof(u_int32_t));
 939         else if (so_domain == AF_INET6)
 940                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
 941                     5 * sizeof(u_int16_t) + 8 * sizeof(u_int32_t));
 942         else
 943                 return (NULL);
 944
 945         ADD_U_CHAR(dptr, AUT_SOCKET_EX);
 946         ADD_U_INT16(dptr, au_domain_to_bsm(so_domain));
 947         ADD_U_INT16(dptr, au_socket_type_to_bsm(so_type));
 948         if (so_domain == AF_INET) {
 949                 ADD_U_INT16(dptr, AU_IPv4);
 950                 sin = (struct sockaddr_in *)sa_local;
 951                 ADD_MEM(dptr, &sin->sin_port, sizeof(uint16_t));
 952                 ADD_MEM(dptr, &sin->sin_addr.s_addr, sizeof(uint32_t));
 953                 sin = (struct sockaddr_in *)sa_remote;
 954                 ADD_MEM(dptr, &sin->sin_port, sizeof(uint16_t));
 955                 ADD_MEM(dptr, &sin->sin_addr.s_addr, sizeof(uint32_t));
 956         } else {
 957                 ADD_U_INT16(dptr, AU_IPv6);
 958                 sin6 = (struct sockaddr_in6 *)sa_local;
 959                 ADD_MEM(dptr, &sin6->sin6_port, sizeof(uint16_t));
 960                 ADD_MEM(dptr, &sin6->sin6_addr, 4 * sizeof(uint32_t));
 961                 sin6 = (struct sockaddr_in6 *)sa_remote;
 962                 ADD_MEM(dptr, &sin6->sin6_port, sizeof(uint16_t));
 963                 ADD_MEM(dptr, &sin6->sin6_addr, 4 * sizeof(uint32_t));
 964         }
 965
 966         return (t);
 967 }
 968
 969 /*
 970  * Kernel-specific version of the above function.
 971  *
 972  * XXXRW: Should now use au_to_socket_ex() here.
 973  */
 974 #ifdef _KERNEL
 975 token_t *
 976 kau_to_socket(struct socket_au_info *soi)
 977 {
 978         token_t *t;
 979         u_char *dptr;
 980         u_int16_t so_type;
 981
 982         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(u_int16_t) +
 983             sizeof(u_int32_t) + sizeof(u_int16_t) + sizeof(u_int32_t));
 984
 985         ADD_U_CHAR(dptr, AUT_SOCKET);
 986         /* Coerce the socket type into a short value */
 987         so_type = soi->so_type;
 988         ADD_U_INT16(dptr, so_type);
 989         ADD_U_INT16(dptr, soi->so_lport);
 990         ADD_U_INT32(dptr, soi->so_laddr);
 991         ADD_U_INT16(dptr, soi->so_rport);
 992         ADD_U_INT32(dptr, soi->so_raddr);
 993
 994         return (t);
 995 }
 996 #endif
 997
 998 /*
 999  * token ID                1 byte
1000  * socket family           2 bytes
1001  * path                    (up to) 104 bytes + NULL  (NULL terminated string)
1002  */
1003 token_t *
1004 au_to_sock_unix(struct sockaddr_un *so)
1005 {
1006         token_t *t;
1007         u_char *dptr;
1008
1009         GET_TOKEN_AREA(t, dptr, 3 * sizeof(u_char) + strlen(so->sun_path) + 1);
1010
1011         ADD_U_CHAR(dptr, AUT_SOCKUNIX);
1012         /* BSM token has two bytes for family */
1013         ADD_U_CHAR(dptr, 0);
1014         ADD_U_CHAR(dptr, so->sun_family);
1015         ADD_STRING(dptr, so->sun_path, strlen(so->sun_path) + 1);
1016
1017         return (t);
1018 }
1019
1020 /*
1021  * token ID                1 byte
1022  * socket family           2 bytes
1023  * local port              2 bytes
1024  * socket address          4 bytes
1025  */
1026 token_t *
1027 au_to_sock_inet32(struct sockaddr_in *so)
1028 {
1029         token_t *t;
1030         u_char *dptr = NULL;
1031         uint16_t family;
1032
1033         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 2 * sizeof(uint16_t) +
1034             sizeof(uint32_t));
1035
1036         ADD_U_CHAR(dptr, AUT_SOCKINET32);
1037         /*
1038          * BSM defines the family field as 16 bits, but many operating
1039          * systems have an 8-bit sin_family field.  Extend to 16 bits before
1040          * writing into the token.  Assume that both the port and the address
1041          * in the sockaddr_in are already in network byte order, but family
1042          * is in local byte order.
1043          *
1044          * XXXRW: Should a name space conversion be taking place on the value
1045          * of sin_family?
1046          */
1047         family = so->sin_family;
1048         ADD_U_INT16(dptr, family);
1049         ADD_MEM(dptr, &so->sin_port, sizeof(uint16_t));
1050         ADD_MEM(dptr, &so->sin_addr.s_addr, sizeof(uint32_t));
1051
1052         return (t);
1053 }
1054
1055 token_t *
1056 au_to_sock_inet128(struct sockaddr_in6 *so)
1057 {
1058         token_t *t;
1059         u_char *dptr = NULL;
1060
1061         GET_TOKEN_AREA(t, dptr, 3 * sizeof(u_char) + sizeof(u_int16_t) +
1062             4 * sizeof(u_int32_t));
1063
1064         ADD_U_CHAR(dptr, AUT_SOCKINET128);
1065         /*
1066          * In BSD, sin6_family is one octet, but BSM defines the token to
1067          * store two. So we copy in a 0 first.  XXXRW: Possibly should be
1068          * conditionally compiled.
1069          */
1070         ADD_U_CHAR(dptr, 0);
1071         ADD_U_CHAR(dptr, so->sin6_family);
1072
1073         ADD_U_INT16(dptr, so->sin6_port);
1074         ADD_MEM(dptr, &so->sin6_addr, 4 * sizeof(uint32_t));
1075
1076         return (t);
1077 }
1078
1079 token_t *
1080 au_to_sock_inet(struct sockaddr_in *so)
1081 {
1082
1083         return (au_to_sock_inet32(so));
1084 }
1085
1086 /*
1087  * token ID                1 byte
1088  * audit ID                4 bytes
1089  * effective user ID       4 bytes
1090  * effective group ID      4 bytes
1091  * real user ID            4 bytes
1092  * real group ID           4 bytes
1093  * process ID              4 bytes
1094  * session ID              4 bytes
1095  * terminal ID
1096  *   port ID               4 bytes/8 bytes (32-bit/64-bit value)
1097  *   machine address       4 bytes
1098  */
1099 token_t *
1100 au_to_subject32(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
1101     pid_t pid, au_asid_t sid, au_tid_t *tid)
1102 {
1103         token_t *t;
1104         u_char *dptr = NULL;
1105
1106         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 9 * sizeof(u_int32_t));
1107
1108         ADD_U_CHAR(dptr, AUT_SUBJECT32);
1109         ADD_U_INT32(dptr, auid);
1110         ADD_U_INT32(dptr, euid);
1111         ADD_U_INT32(dptr, egid);
1112         ADD_U_INT32(dptr, ruid);
1113         ADD_U_INT32(dptr, rgid);
1114         ADD_U_INT32(dptr, pid);
1115         ADD_U_INT32(dptr, sid);
1116         ADD_U_INT32(dptr, tid->port);
1117         ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));
1118
1119         return (t);
1120 }
1121
1122 token_t *
1123 au_to_subject64(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
1124     pid_t pid, au_asid_t sid, au_tid_t *tid)
1125 {
1126         token_t *t;
1127         u_char *dptr = NULL;
1128
1129         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 7 * sizeof(u_int32_t) +
1130             sizeof(u_int64_t) + sizeof(u_int32_t));
1131
1132         ADD_U_CHAR(dptr, AUT_SUBJECT64);
1133         ADD_U_INT32(dptr, auid);
1134         ADD_U_INT32(dptr, euid);
1135         ADD_U_INT32(dptr, egid);
1136         ADD_U_INT32(dptr, ruid);
1137         ADD_U_INT32(dptr, rgid);
1138         ADD_U_INT32(dptr, pid);
1139         ADD_U_INT32(dptr, sid);
1140         ADD_U_INT64(dptr, tid->port);
1141         ADD_MEM(dptr, &tid->machine, sizeof(u_int32_t));
1142
1143         return (t);
1144 }
1145
1146 token_t *
1147 au_to_subject(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid, gid_t rgid,
1148     pid_t pid, au_asid_t sid, au_tid_t *tid)
1149 {
1150
1151         return (au_to_subject32(auid, euid, egid, ruid, rgid, pid, sid,
1152             tid));
1153 }
1154
1155 /*
1156  * token ID                1 byte
1157  * audit ID                4 bytes
1158  * effective user ID       4 bytes
1159  * effective group ID      4 bytes
1160  * real user ID            4 bytes
1161  * real group ID           4 bytes
1162  * process ID              4 bytes
1163  * session ID              4 bytes
1164  * terminal ID
1165  *   port ID               4 bytes/8 bytes (32-bit/64-bit value)
1166  *   address type/length   4 bytes
1167  *   machine address      16 bytes
1168  */
1169 token_t *
1170 au_to_subject32_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
1171     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
1172 {
1173         token_t *t;
1174         u_char *dptr = NULL;
1175
1176         KASSERT((tid->at_type == AU_IPv4) || (tid->at_type == AU_IPv6),
1177             ("au_to_subject32_ex: type %u", (unsigned int)tid->at_type));
1178
1179         if (tid->at_type == AU_IPv4)
1180                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 10 *
1181                     sizeof(u_int32_t));
1182         else
1183                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) + 13 *
1184                     sizeof(u_int32_t));
1185
1186         ADD_U_CHAR(dptr, AUT_SUBJECT32_EX);
1187         ADD_U_INT32(dptr, auid);
1188         ADD_U_INT32(dptr, euid);
1189         ADD_U_INT32(dptr, egid);
1190         ADD_U_INT32(dptr, ruid);
1191         ADD_U_INT32(dptr, rgid);
1192         ADD_U_INT32(dptr, pid);
1193         ADD_U_INT32(dptr, sid);
1194         ADD_U_INT32(dptr, tid->at_port);
1195         ADD_U_INT32(dptr, tid->at_type);
1196         if (tid->at_type == AU_IPv6)
1197                 ADD_MEM(dptr, &tid->at_addr[0], 4 * sizeof(u_int32_t));
1198         else
1199                 ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));
1200
1201         return (t);
1202 }
1203
1204 token_t *
1205 au_to_subject64_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
1206     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
1207 {
1208         token_t *t;
1209         u_char *dptr = NULL;
1210
1211         KASSERT((tid->at_type == AU_IPv4) || (tid->at_type == AU_IPv6),
1212             ("au_to_subject64_ex: type %u", (unsigned int)tid->at_type));
1213
1214         if (tid->at_type == AU_IPv4)
1215                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
1216                     7 * sizeof(u_int32_t) + sizeof(u_int64_t) +
1217                     2 * sizeof(u_int32_t));
1218         else
1219                 GET_TOKEN_AREA(t, dptr, sizeof(u_char) +
1220                     7 * sizeof(u_int32_t) + sizeof(u_int64_t) +
1221                     5 * sizeof(u_int32_t));
1222
1223         ADD_U_CHAR(dptr, AUT_SUBJECT64_EX);
1224         ADD_U_INT32(dptr, auid);
1225         ADD_U_INT32(dptr, euid);
1226         ADD_U_INT32(dptr, egid);
1227         ADD_U_INT32(dptr, ruid);
1228         ADD_U_INT32(dptr, rgid);
1229         ADD_U_INT32(dptr, pid);
1230         ADD_U_INT32(dptr, sid);
1231         ADD_U_INT64(dptr, tid->at_port);
1232         ADD_U_INT32(dptr, tid->at_type);
1233         if (tid->at_type == AU_IPv6)
1234                 ADD_MEM(dptr, &tid->at_addr[0], 4 * sizeof(u_int32_t));
1235         else
1236                 ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));
1237
1238         return (t);
1239 }
1240
1241 token_t *
1242 au_to_subject_ex(au_id_t auid, uid_t euid, gid_t egid, uid_t ruid,
1243     gid_t rgid, pid_t pid, au_asid_t sid, au_tid_addr_t *tid)
1244 {
1245
1246         return (au_to_subject32_ex(auid, euid, egid, ruid, rgid, pid, sid,
1247             tid));
1248 }
1249
1250 #if !defined(_KERNEL) && !defined(KERNEL) && defined(HAVE_AUDIT_SYSCALLS)
1251 /*
1252  * Collects audit information for the current process and creates a subject
1253  * token from it.
1254  */
1255 token_t *
1256 au_to_me(void)
1257 {
1258         auditinfo_t auinfo;
1259         auditinfo_addr_t aia;
1260
1261         /*
1262          * Try to use getaudit_addr(2) first.  If this kernel does not support
1263          * it, then fall back on to getaudit(2).
1264          */
1265         if (getaudit_addr(&aia, sizeof(aia)) != 0) {
1266                 if (errno == ENOSYS) {
1267                         if (getaudit(&auinfo) != 0)
1268                                 return (NULL);
1269                         return (au_to_subject32(auinfo.ai_auid, geteuid(),
1270                                 getegid(), getuid(), getgid(), getpid(),
1271                                 auinfo.ai_asid, &auinfo.ai_termid));
1272                 } else {
1273                         /* getaudit_addr(2) failed for some other reason. */
1274                         return (NULL);
1275                 }
1276         }
1277
1278         return (au_to_subject32_ex(aia.ai_auid, geteuid(), getegid(), getuid(),
1279                 getgid(), getpid(), aia.ai_asid, &aia.ai_termid));
1280 }
1281 #endif
1282
1283 #if defined(_KERNEL) || defined(KERNEL)
1284 static token_t *
1285 au_to_exec_strings(char *strs, int count, u_char type)
1286 {
1287         token_t *t;
1288         u_char *dptr = NULL;
1289         u_int32_t totlen;
1290         int ctr;
1291         char *p;
1292
1293         totlen = 0;
1294         ctr = count;
1295         p = strs;
1296         while (ctr-- > 0) {
1297                 totlen += strlen(p) + 1;
1298                 p = strs + totlen;
1299         }
1300         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);
1301         ADD_U_CHAR(dptr, type);
1302         ADD_U_INT32(dptr, count);
1303         ADD_STRING(dptr, strs, totlen);
1304
1305         return (t);
1306 }
1307
1308 /*
1309  * token ID                             1 byte
1310  * count                                4 bytes
1311  * text                                 count null-terminated strings
1312  */
1313 token_t *
1314 au_to_exec_args(char *args, int argc)
1315 {
1316
1317         return (au_to_exec_strings(args, argc, AUT_EXEC_ARGS));
1318 }
1319
1320 /*
1321  * token ID                             1 byte
1322  * count                                4 bytes
1323  * text                                 count null-terminated strings
1324  */
1325 token_t *
1326 au_to_exec_env(char *envs, int envc)
1327 {
1328
1329         return (au_to_exec_strings(envs, envc, AUT_EXEC_ENV));
1330 }
1331 #else
1332 /*
1333  * token ID                             1 byte
1334  * count                                4 bytes
1335  * text                                 count null-terminated strings
1336  */
1337 token_t *
1338 au_to_exec_args(char **argv)
1339 {
1340         token_t *t;
1341         u_char *dptr = NULL;
1342         const char *nextarg;
1343         int i, count = 0;
1344         size_t totlen = 0;
1345
1346         nextarg = *argv;
1347
1348         while (nextarg != NULL) {
1349                 int nextlen;
1350
1351                 nextlen = strlen(nextarg);
1352                 totlen += nextlen + 1;
1353                 count++;
1354                 nextarg = *(argv + count);
1355         }
1356
1357         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);
1358
1359         ADD_U_CHAR(dptr, AUT_EXEC_ARGS);
1360         ADD_U_INT32(dptr, count);
1361
1362         for (i = 0; i < count; i++) {
1363                 nextarg = *(argv + i);
1364                 ADD_MEM(dptr, nextarg, strlen(nextarg) + 1);
1365         }
1366
1367         return (t);
1368 }
1369
1370 /*
1371  * token ID                             1 byte
1372  * count                                4 bytes
1373  * text                                 count null-terminated strings
1374  */
1375 token_t *
1376 au_to_exec_env(char **envp)
1377 {
1378         token_t *t;
1379         u_char *dptr = NULL;
1380         int i, count = 0;
1381         size_t totlen = 0;
1382         const char *nextenv;
1383
1384         nextenv = *envp;
1385
1386         while (nextenv != NULL) {
1387                 int nextlen;
1388
1389                 nextlen = strlen(nextenv);
1390                 totlen += nextlen + 1;
1391                 count++;
1392                 nextenv = *(envp + count);
1393         }
1394
1395         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) + totlen);
1396
1397         ADD_U_CHAR(dptr, AUT_EXEC_ENV);
1398         ADD_U_INT32(dptr, count);
1399
1400         for (i = 0; i < count; i++) {
1401                 nextenv = *(envp + i);
1402                 ADD_MEM(dptr, nextenv, strlen(nextenv) + 1);
1403         }
1404
1405         return (t);
1406 }
1407 #endif
1408
1409 /*
1410  * token ID                1 byte
1411  * zonename length         2 bytes
1412  * zonename                N bytes + 1 terminating NULL byte
1413  */
1414 token_t *
1415 au_to_zonename(const char *zonename)
1416 {
1417         u_char *dptr = NULL;
1418         u_int16_t textlen;
1419         token_t *t;
1420
1421         textlen = strlen(zonename) + 1;
1422         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) + textlen);
1423
1424         ADD_U_CHAR(dptr, AUT_ZONENAME);
1425         ADD_U_INT16(dptr, textlen);
1426         ADD_STRING(dptr, zonename, textlen);
1427         return (t);
1428 }
1429
1430 /*
1431  * token ID                1 byte
1432  * record byte count       4 bytes
1433  * version #               1 byte    [2]
1434  * event type              2 bytes
1435  * event modifier          2 bytes
1436  * seconds of time         4 bytes/8 bytes (32-bit/64-bit value)
1437  * milliseconds of time    4 bytes/8 bytes (32-bit/64-bit value)
1438  */
1439 token_t *
1440 au_to_header32_tm(int rec_size, au_event_t e_type, au_emod_t e_mod,
1441     struct timeval tm)
1442 {
1443         token_t *t;
1444         u_char *dptr = NULL;
1445         u_int32_t timems;
1446
1447         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) +
1448             sizeof(u_char) + 2 * sizeof(u_int16_t) + 2 * sizeof(u_int32_t));
1449
1450         ADD_U_CHAR(dptr, AUT_HEADER32);
1451         ADD_U_INT32(dptr, rec_size);
1452         ADD_U_CHAR(dptr, AUDIT_HEADER_VERSION_OPENBSM);
1453         ADD_U_INT16(dptr, e_type);
1454         ADD_U_INT16(dptr, e_mod);
1455
1456         timems = tm.tv_usec/1000;
1457         /* Add the timestamp */
1458         ADD_U_INT32(dptr, tm.tv_sec);
1459         ADD_U_INT32(dptr, timems);      /* We need time in ms. */
1460
1461         return (t);
1462 }
1463
1464 /*
1465  * token ID                1 byte
1466  * record byte count       4 bytes
1467  * version #               1 byte    [2]
1468  * event type              2 bytes
1469  * event modifier          2 bytes
1470  * address type/length     4 bytes
1471  * machine address         4 bytes/16 bytes (IPv4/IPv6 address)
1472  * seconds of time         4 bytes/8 bytes (32-bit/64-bit value)
1473  * milliseconds of time    4 bytes/8 bytes (32-bit/64-bit value)
1474  */
1475 token_t *
1476 au_to_header32_ex_tm(int rec_size, au_event_t e_type, au_emod_t e_mod,
1477     struct timeval tm, struct auditinfo_addr *aia)
1478 {
1479         token_t *t;
1480         u_char *dptr = NULL;
1481         u_int32_t timems;
1482         au_tid_addr_t *tid;
1483
1484         tid = &aia->ai_termid;
1485         KASSERT(tid->at_type == AU_IPv4 || tid->at_type == AU_IPv6,
1486             ("au_to_header32_ex_tm: invalid address family"));
1487
1488         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) +
1489             sizeof(u_char) + 2 * sizeof(u_int16_t) + 3 *
1490             sizeof(u_int32_t) + tid->at_type);
1491
1492         ADD_U_CHAR(dptr, AUT_HEADER32_EX);
1493         ADD_U_INT32(dptr, rec_size);
1494         ADD_U_CHAR(dptr, AUDIT_HEADER_VERSION_OPENBSM);
1495         ADD_U_INT16(dptr, e_type);
1496         ADD_U_INT16(dptr, e_mod);
1497
1498         ADD_U_INT32(dptr, tid->at_type);
1499         if (tid->at_type == AU_IPv6)
1500                 ADD_MEM(dptr, &tid->at_addr[0], 4 * sizeof(u_int32_t));
1501         else
1502                 ADD_MEM(dptr, &tid->at_addr[0], sizeof(u_int32_t));
1503         timems = tm.tv_usec/1000;
1504         /* Add the timestamp */
1505         ADD_U_INT32(dptr, tm.tv_sec);
1506         ADD_U_INT32(dptr, timems);      /* We need time in ms. */
1507
1508         return (t);
1509 }
1510
1511 token_t *
1512 au_to_header64_tm(int rec_size, au_event_t e_type, au_emod_t e_mod,
1513     struct timeval tm)
1514 {
1515         token_t *t;
1516         u_char *dptr = NULL;
1517         u_int32_t timems;
1518
1519         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int32_t) +
1520             sizeof(u_char) + 2 * sizeof(u_int16_t) + 2 * sizeof(u_int64_t));
1521
1522         ADD_U_CHAR(dptr, AUT_HEADER64);
1523         ADD_U_INT32(dptr, rec_size);
1524         ADD_U_CHAR(dptr, AUDIT_HEADER_VERSION_OPENBSM);
1525         ADD_U_INT16(dptr, e_type);
1526         ADD_U_INT16(dptr, e_mod);
1527
1528         timems = tm.tv_usec/1000;
1529         /* Add the timestamp */
1530         ADD_U_INT64(dptr, tm.tv_sec);
1531         ADD_U_INT64(dptr, timems);      /* We need time in ms. */
1532
1533         return (t);
1534 }
1535
1536 #if !defined(KERNEL) && !defined(_KERNEL)
1537 #ifdef HAVE_AUDIT_SYSCALLS
1538 token_t *
1539 au_to_header32_ex(int rec_size, au_event_t e_type, au_emod_t e_mod)
1540 {
1541         struct timeval tm;
1542         struct auditinfo_addr aia;
1543
1544         if (gettimeofday(&tm, NULL) == -1)
1545                 return (NULL);
1546         if (audit_get_kaudit(&aia, sizeof(aia)) != 0) {
1547                 if (errno != ENOSYS)
1548                         return (NULL);
1549                 return (au_to_header32_tm(rec_size, e_type, e_mod, tm));
1550         }
1551         return (au_to_header32_ex_tm(rec_size, e_type, e_mod, tm, &aia));
1552 }
1553 #endif /* HAVE_AUDIT_SYSCALLS */
1554
1555 token_t *
1556 au_to_header32(int rec_size, au_event_t e_type, au_emod_t e_mod)
1557 {
1558         struct timeval tm;
1559
1560         if (gettimeofday(&tm, NULL) == -1)
1561                 return (NULL);
1562         return (au_to_header32_tm(rec_size, e_type, e_mod, tm));
1563 }
1564
1565 token_t *
1566 au_to_header64(__unused int rec_size, __unused au_event_t e_type,
1567     __unused au_emod_t e_mod)
1568 {
1569         struct timeval tm;
1570
1571         if (gettimeofday(&tm, NULL) == -1)
1572                 return (NULL);
1573         return (au_to_header64_tm(rec_size, e_type, e_mod, tm));
1574 }
1575
1576 token_t *
1577 au_to_header(int rec_size, au_event_t e_type, au_emod_t e_mod)
1578 {
1579
1580         return (au_to_header32(rec_size, e_type, e_mod));
1581 }
1582
1583 #ifdef HAVE_AUDIT_SYSCALLS
1584 token_t *
1585 au_to_header_ex(int rec_size, au_event_t e_type, au_emod_t e_mod)
1586 {
1587
1588         return (au_to_header32_ex(rec_size, e_type, e_mod));
1589 }
1590 #endif /* HAVE_AUDIT_SYSCALLS */
1591 #endif /* !defined(KERNEL) && !defined(_KERNEL) */
1592
1593 /*
1594  * token ID                1 byte
1595  * trailer magic number    2 bytes
1596  * record byte count       4 bytes
1597  */
1598 token_t *
1599 au_to_trailer(int rec_size)
1600 {
1601         token_t *t;
1602         u_char *dptr = NULL;
1603         u_int16_t magic = AUT_TRAILER_MAGIC;
1604
1605         GET_TOKEN_AREA(t, dptr, sizeof(u_char) + sizeof(u_int16_t) +
1606             sizeof(u_int32_t));
1607
1608         ADD_U_CHAR(dptr, AUT_TRAILER);
1609         ADD_U_INT16(dptr, magic);
1610         ADD_U_INT32(dptr, rec_size);
1611
1612         return (t);
1613 }