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