usr/src/lib/libbsm/auditxml

   1 #!/usr/perl5/bin/perl -w
   2 #
   3 # CDDL HEADER START
   4 #
   5 # The contents of this file are subject to the terms of the
   6 # Common Development and Distribution License (the "License").
   7 # You may not use this file except in compliance with the License.
   8 #
   9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10 # or http://www.opensolaris.org/os/licensing.
  11 # See the License for the specific language governing permissions
  12 # and limitations under the License.
  13 #
  14 # When distributing Covered Code, include this CDDL HEADER in each
  15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16 # If applicable, add the following below this CDDL HEADER, with the
  17 # fields enclosed by brackets "[]" replaced with your own identifying
  18 # information: Portions Copyright [yyyy] [name of copyright owner]
  19 #
  20 # CDDL HEADER END
  21 #
  22 #
  23 # Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24 # Use is subject to license terms.
  25 #
  26
  27 # auditxml takes the audit record description (.xml file) and
  28 # generates the files needed for the C audit api.
  29
  30 my $prog = $0; $prog =~ s|.*/||g;
  31 my $usage = <<EOF;
  32
  33 Usage: $prog [options] <xml-input-file>
  34 Options:
  35         -d      Enable debug output
  36         -e pfx  Internal event prefix (default: AUE)
  37         -i pfx  Interface prefix (default: adt)
  38                 External event prefix is uppercase version of this string.
  39         -o dir  Output directory (default: current dir)
  40
  41 EOF
  42
  43 use auditxml;
  44 use Getopt::Std;
  45 use strict;
  46
  47 our $debug = 0; # normal use is to set via the file being parsed.
  48                # <debug set="on"/> or <debug set="off"/> or <debug/>
  49                # if the set attribute is omitted, debug state is toggled
  50                # Override with appDebug, but toggle won't do what you
  51                # want.
  52 my $appDebug = 0; # used after return from "new auditxml";
  53
  54 # Process command-line options
  55 our ($opt_d, $opt_e, $opt_i, $opt_o);
  56 $opt_e = "";
  57 $opt_i = "";
  58 $opt_o = "";
  59 if (!getopts('de:i:o:') || $#ARGV != 0) {
  60     die $usage;
  61 }
  62 my $outdir = $opt_o || ".";
  63 my $pfx_adt = lc($opt_i) || "adt";
  64 my $pfx_ADT = uc($pfx_adt);
  65 my $pfx_AUE = uc($opt_e) || "AUE";
  66
  67 $appDebug = $opt_d;
  68
  69 my $uniLabel = "adr";
  70 my $xlateUniLabelInc = 0;
  71
  72
  73 # where everything comes from and where it goes:
  74
  75 my $xlateFile = "$outdir/${pfx_adt}_xlate.c";
  76 my $headerFile = "$outdir/${pfx_adt}_event_N.h";
  77
  78 my $filename = $ARGV[0];  # input XML file
  79 my $doc = new auditxml ($filename);
  80 $filename =~ s|.*/||g;
  81
  82 $debug = $appDebug;
  83
  84 my $genNotice = "
  85 DO NOT EDIT. This file is auto generated by the Solaris Audit
  86 system from $filename.
  87
  88 See http://opensolaris.org/os/project/audit/
  89 ";
  90
  91 # trim leading/trailing newlines
  92 $genNotice =~ s/^\n//s;
  93 $genNotice =~ s/\n$//s;
  94
  95 my %xlateEventTable = ();
  96 my @xlateTypeList = ();
  97 my %xlateTypeList = ();
  98 my %eventAPI = ();
  99 my %eventExtra = ();
 100 my %headers = ();
 101 my %externalIdNo = ();
 102 my @outputState = ();
 103 my %nameTranslation = ();
 104 my @xlateDefaults = ();
 105 my %xlateDefault = ();
 106 my %msg_list = ();
 107
 108 my $event;
 109 while ($event = $doc->getNextEvent()) {
 110     my $eventId = $event->getId();
 111     my $eventHeader = $event->getHeader();
 112     my $idNo = $event->getIdNo();
 113     $externalIdNo{$eventId} = $idNo;
 114     addHeader($eventHeader) if defined ($eventHeader);
 115     my $super;
 116     my $omit = $event->getOmit();
 117     my $eventType = '';
 118     if ($super = $event->getSuperClass()) {
 119         $event = $super;
 120         $eventType = 'instance';
 121     } else {
 122         $eventType = $event->getType();
 123     }
 124
 125     # header file for API use
 126     generateAPIFile($event, $eventId, $eventType, $eventHeader, $idNo)
 127         unless $omit eq 'always';
 128
 129     # c file table for translation
 130     generateTableC($event, $eventId, $eventType, $eventHeader, $omit);
 131 }
 132
 133 my $textList;
 134 while ($textList = $doc->getNextMsgId()) {
 135     generateMsgLists($textList);  # enum -> text mappings
 136 }
 137
 138 printTableC($xlateFile);
 139 printAPIFile($headerFile, $doc);
 140
 141 exit 0;
 142
 143
 144 sub printTableC {
 145     my $file = shift;
 146
 147     unless (open(Cfile, ">$file")) {
 148         print STDERR "can't open output file ($file): $!\n";
 149         return;
 150     }
 151
 152     my $notice = $genNotice;
 153     $notice =~ s/\n/\n * /gs;
 154     $notice =~ s/\s+\n/\n/gs;
 155     print Cfile <<EOF;
 156 /*
 157  * $notice
 158  */
 159
 160 #include <bsm/libbsm.h>
 161 #include <adt_xlate.h>
 162 #include <libintl.h>
 163
 164 EOF
 165     print Cfile "#ifndef _PRAUDIT\n";
 166     print Cfile "/* Internal data type definitions */\n\n";
 167     my $extDef;
 168     foreach $extDef (@xlateTypeList) {
 169       print Cfile "static $extDef\n";
 170     }
 171     @xlateTypeList = ();
 172
 173     print Cfile "\n/* External event structure to internal event structure */\n\n";
 174
 175     my @pointers = ();
 176
 177     foreach my $eventId (sort keys %xlateEventTable) {
 178         if ($xlateEventTable{$eventId}) {
 179             my ($ref1, $eventType, $firstToken, $eventHeader) =
 180               @{$xlateEventTable{$eventId}};
 181             my @entries = @$ref1;
 182             my $entry;
 183             my $entries = $#entries;
 184             my $count = $entries + 1;
 185             my $externalName = $nameTranslation{$eventId};
 186             my $externalRoot = $externalName;
 187             $externalRoot =~ s/${pfx_AUE}_//;
 188             my $structName = "XX_$externalRoot";
 189             my $root = $eventId;
 190             $root =~ s/${pfx_AUE}_//;
 191             my $externalId = $eventId;
 192             $externalId =~ s/${pfx_AUE}_/${pfx_ADT}_/;
 193
 194             unless ($eventType eq 'generic') {
 195                 print Cfile "static struct entry $structName\[$count\] = {\n";
 196                 foreach $entry (@entries) {
 197                     if ($entries--) {
 198                         $entry =~ s/EOL/,/;
 199                     }
 200                     else {
 201                         $entry =~ s/EOL//;
 202                     }
 203                     $entry =~ s/selfReference/$structName/;
 204                     print Cfile "\t$entry\n";
 205                 }
 206                 print Cfile "};\n";
 207
 208                 print Cfile "static struct translation X_$externalRoot = {\n";
 209                 push (@pointers, "X_$externalRoot");
 210
 211                 print Cfile "\t0,\n";   # tx_offsetsCalculated = 0
 212                 print Cfile "\t$externalId,\n";
 213                 print Cfile "\t$externalName,\n";
 214
 215                 print Cfile "\t$count,\n";
 216                 print Cfile "\t&XX_$externalRoot\[$firstToken\],\n";
 217                 print Cfile "\t&XX_$externalRoot\[0\]\n};\n";
 218             }
 219         } else {
 220             print STDERR "expected entry for $eventId but none found\n";
 221         }
 222     }
 223
 224     my $count = $#pointers + 2;
 225     print Cfile "adt_translation_t *${pfx_adt}_xlate_table[$count] = {\n";
 226
 227     my $firstEvent = 1;
 228     foreach my $eventId (@pointers) {
 229         if ($firstEvent) {
 230             $firstEvent = 0;
 231         }
 232         else {
 233             print Cfile ",\n";
 234         }
 235         print Cfile "\t&$eventId";
 236     }
 237     print Cfile ",\n\tNULL\n};\n";
 238
 239     # generate the Event preload() function
 240
 241     print Cfile <<EOF;
 242
 243 void
 244 ${pfx_adt}_preload(au_event_t event_id, adt_event_data_t *event_data)
 245 {
 246         switch (event_id) {
 247 EOF
 248
 249         foreach my $id (@xlateDefaults) {
 250                 my $adtID = $id;
 251                 $adtID =~ s/${pfx_AUE}/${pfx_ADT}/;
 252
 253                 print Cfile <<EOF;
 254         case $adtID:
 255 EOF
 256                 my @preloads = @{$xlateDefault{$id}};
 257                 while (@preloads) {
 258                         my $fieldName = shift @preloads;
 259                         my $default = shift @preloads;
 260                         $id =~ s/${pfx_AUE}_/${pfx_adt}_/;
 261
 262                         print Cfile <<EOF;
 263                 event_data->$id.$fieldName = $default;
 264 EOF
 265                 }
 266
 267                 print Cfile <<EOF;
 268                 break;
 269 EOF
 270         }
 271
 272     print Cfile <<EOF;
 273         default:
 274                 break;
 275         }
 276 }
 277 #endif
 278
 279 EOF
 280
 281     print Cfile "/* message lists */\n\n";
 282     my $listName;
 283     my @listName;
 284     foreach $listName (sort keys %msg_list) {
 285         my ($listRef, $headref) = @{$msg_list{$listName}};
 286         my ($header, $start, $public, $deprecated) = @$headref;
 287
 288         my @listValue =  @$listRef;
 289         my $listValue;
 290         my $listLength = $#listValue + 1;
 291
 292         $listName = 'NULL' if ($#listValue < 0);
 293
 294         push (@listName, [$listName, $listLength - 1, $start, $public]);
 295
 296         next if ($#listValue < 0);
 297
 298         print Cfile "/* Deprecated message list */\n" if ($deprecated);
 299         print Cfile "static char *msg_$listName\[$listLength] = {\n";
 300
 301         my $ffirst = 1;
 302         foreach $listValue (@listValue) {
 303             print Cfile ",\n" unless $ffirst;
 304             $ffirst = 0;
 305             my ($id, $text) = split(/\s*::\s*/, $listValue);
 306             if ($text) {
 307                 print Cfile "\t\"$text\"";
 308             }
 309             else {
 310                 print Cfile "\tNULL";
 311             }
 312         }
 313         print Cfile "\n};\n";
 314     }
 315
 316     if ($#listName >= 0) {
 317         print Cfile "\nstruct msg_text ${pfx_adt}_msg_text[", $#listName + 1,
 318                         "] = {\n";
 319         my $ffirst = 1;
 320         foreach $listName (@listName) {
 321             my ($name, $max, $start) = @$listName;
 322             $start = -$start if $start;
 323             print Cfile ",\n" unless $ffirst;
 324             $ffirst = 0;
 325             $name = "msg_$name" if ($name ne 'NULL');
 326             print Cfile "\t{0, $max, $name, $start}";
 327         }
 328         print Cfile "\n};\n";
 329     }
 330
 331     close Cfile;
 332 }
 333
 334 sub printAPIFile {
 335     my $file = shift;
 336     my $xmlDoc = shift;
 337
 338     my @Hfile;
 339     @Hfile = openHeaderFiles($file);
 340
 341     my $notice = $genNotice;
 342     $notice =~ s/\n/\n * /gs;
 343     $notice =~ s/\s+\n/\n/gs;
 344
 345     foreach my $header (keys %headers) {
 346         next unless $Hfile[$header];
 347         *Hfile = $Hfile[$header];
 348         my $include = "adt.h";
 349         my $adt_event_n = "_${pfx_ADT}_EVENT_H";
 350         if ($header > 0) {
 351             $include = "${pfx_adt}_event.h";
 352             $adt_event_n = "_${pfx_ADT}_EVENT_".$header."_H";
 353         }
 354         print Hfile <<EOF;
 355 /*
 356  * $notice
 357  */
 358
 359 #ifndef $adt_event_n
 360 #define $adt_event_n
 361
 362 #include <bsm/$include>
 363
 364 #ifdef  __cplusplus
 365 extern "C" {
 366 #endif
 367
 368 /*
 369  * adt_put_event() status values.  Positive values are for kernel-generated
 370  * failure, -1 for user-space.  For ADT_SUCCESS, the adt_put_event() return_val
 371  * is not used; the convention is to set it to ADT_SUCCESS.
 372  */
 373 #define ADT_SUCCESS     0
 374 #define ADT_FAILURE     -1
 375
 376 EOF
 377     }
 378
 379     foreach my $listName (sort keys %msg_list) {
 380         my $shortName = uc $listName;
 381         $shortName =~ s/_TEXT//;
 382
 383         my ($listRef, $headref) = @{$msg_list{$listName}};
 384         my ($header, $start, $public, $deprecated) = @$headref;
 385         next unless $Hfile[$header];
 386         *Hfile = $Hfile[$header];
 387
 388         print Hfile "/* Deprecated message list */\n" if $deprecated;
 389         print Hfile "#define\t${pfx_ADT}_$shortName\t$start\n" if $start;
 390
 391         my @listValue =  @$listRef;
 392         next unless ($#listValue >= 0);
 393         print Hfile "enum\t${pfx_adt}_$listName", " {\n";
 394
 395         my $listValue;
 396         my $i = 0;
 397         my $j = $#listValue;
 398         my $comma = ',';
 399         foreach $listValue (@listValue) {
 400             my ($id, $text) = split(/\s*::\s*/, $listValue);
 401             $comma = '' if $i++ == $j;
 402             if ($start) {
 403                 $start = " = $start$comma";
 404             } else {
 405                 $start = "$comma\t";
 406             }
 407             $text = "(no token will be generated)" unless $text;
 408             my $line = "\t${pfx_ADT}_$shortName"."_$id$start\t/* ";
 409             # ensure whole line does not exceed 80 chars
 410             my $eline = $line.$text;
 411             #expand tabs
 412             1 while $eline =~ s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e;
 413             if ((length($eline) > 77) && ($line =~ /\t\t/)) {
 414                 # 77 = 80 - length(" */")
 415                 # strip off double tab so that comment can be longer
 416                 $line =~ s/\t\t/\t/;
 417                 # shorten eline; don't mind where the spaces are removed, it is
 418                 # only $eline length which matters
 419                 $eline =~ s/ {8}//;
 420             }
 421             if (length($eline) > 77) { # 80 - length(" */")
 422                 # here we use negative length in substr to leave off from the
 423                 # right side; 74 = 77 - length("...")
 424                 $line .= substr($text, 0, 74 - length($eline));
 425                 # strip off part of last word (already cut)
 426                 $line =~ s/\s(\S+)$/ /;
 427                 $line .= "...";
 428             } else {
 429                 $line .= $text;
 430             }
 431             print Hfile "$line */\n";
 432             $start = '';
 433         }
 434         print Hfile "};\n";
 435     }
 436
 437     # generate defines for external event names
 438
 439     foreach my $eventId (sort keys %eventAPI) {
 440         my ($header, $idNo) = @{$eventExtra{$eventId}};
 441         unless (defined ($header)) {
 442             print STDERR "missing header selection for $eventId\n";
 443             next;
 444         }
 445         *Hfile = $Hfile[$header];
 446         next unless $Hfile[$header];
 447
 448         my $l = length($eventId) + 8; # label plus preceding #define\t
 449         $l = 5 - int(($l + 8)/8);
 450         $l = 1 if $l < 1;
 451         my $tab = "\t" x $l;
 452
 453         print STDERR "missing id number for $eventId\n" unless $idNo;
 454
 455         $eventId =~ s/${pfx_AUE}_/${pfx_ADT}_/;
 456         print Hfile "#define\t$eventId$tab$idNo\n";
 457     }
 458
 459
 460     # generate per-event structures
 461
 462     foreach my $eventId (sort keys %eventAPI) {
 463         my ($header, $idNo) = @{$eventExtra{$eventId}};
 464         my $dataId = $eventId;
 465         $dataId =~ s/^${pfx_AUE}_/${pfx_adt}_/;
 466         unless(defined ($header)) {
 467             print STDERR "$eventId is missing the header assignment\n";
 468             next;
 469         }
 470         *Hfile = $Hfile[$header];
 471         next unless $Hfile[$header];
 472
 473         my $externalId = $eventId;
 474         $externalId =~ s/${pfx_AUE}_/${pfx_ADT}_/;
 475
 476         print Hfile "\nstruct $dataId {\t/* $externalId */\n";
 477
 478         my @entries = @{$eventAPI{$eventId}};
 479         my $entry;
 480         if ($#entries < 0) {
 481             print Hfile "\tint\tdummy;\t/* not used */\n";
 482         } else {
 483             foreach $entry (@entries) {
 484                 $entry =~ s/termid/adt_termid_t/;
 485                 print Hfile "\t$entry\n";
 486             }
 487         }
 488         print Hfile "};\n";
 489         $eventId =~ s/^${pfx_AUE}_/${pfx_adt}_/;
 490         print Hfile "typedef struct $dataId $eventId","_t;\n";
 491     }
 492
 493     foreach my $header (sort keys %headers) {
 494         $outputState[$header] = 0;
 495     }
 496
 497     foreach my $eventId (sort keys %eventAPI) {
 498         my ($header, $idNo) = @{$eventExtra{$eventId}};
 499         unless(defined ($header)) {
 500             # don't print duplicate error message
 501             next;
 502         }
 503         *Hfile = $Hfile[$header];
 504         next unless $Hfile[$header];
 505         if ($outputState[$header] == 0) {
 506             $outputState[$header] = 1;
 507             my $suffix = '';
 508             $suffix = "_$header" if $header;
 509             print Hfile "\nunion adt_event_data$suffix {\n";
 510         }
 511         my $elementName = $eventId;
 512         $elementName =~ s/^${pfx_AUE}_/${pfx_adt}_/;
 513         $eventId =~ s/^${pfx_AUE}_/${pfx_adt}_/;
 514         $elementName =~ s/_t$//;
 515
 516         print Hfile "\t\t$eventId","_t\t$elementName;\n";
 517     }
 518     foreach my $header (sort keys %headers) {
 519         if ($outputState[$header]) {
 520             *Hfile = $Hfile[$header];
 521             next unless $Hfile[$header];
 522             print Hfile "};\n";
 523         }
 524     }
 525     foreach my $header (keys %headers) {
 526         next unless $Hfile[$header];
 527         *Hfile = $Hfile[$header];
 528         my $adt_event_n = "_${pfx_ADT}_EVENT_H";
 529         if ($header > 0) {
 530             $adt_event_n = "_${pfx_ADT}_EVENT_".$header."_H";
 531         }
 532         print Hfile <<EOF;
 533
 534
 535 #ifndef ${pfx_ADT}_PRIVATE
 536 #define ${pfx_ADT}_PRIVATE
 537
 538 /*
 539  * These interfaces are project private and will change without
 540  * notice as needed for the Solaris Audit project.
 541  */
 542
 543 extern  void    adt_get_auid(const adt_session_data_t *, au_id_t *);
 544 extern  void    adt_set_auid(const adt_session_data_t *, const au_id_t);
 545
 546 extern  void    adt_get_mask(const adt_session_data_t *, au_mask_t *);
 547 extern  void    adt_set_mask(const adt_session_data_t *, const au_mask_t *);
 548
 549 extern  void    adt_get_termid(const adt_session_data_t *, au_tid_addr_t *);
 550 extern  void    adt_set_termid(const adt_session_data_t *,
 551     const au_tid_addr_t *);
 552
 553 extern  void    adt_get_asid(const adt_session_data_t *, au_asid_t *);
 554 extern  void    adt_set_asid(const adt_session_data_t *, const au_asid_t);
 555 extern  au_asid_t adt_get_unique_id(au_id_t);
 556 extern  void    adt_load_table(const adt_session_data_t *, adt_translation_t **,
 557     void (*preload)(au_event_t, adt_event_data_t *));
 558
 559 extern  void    ${pfx_adt}_preload(au_event_t, adt_event_data_t *);
 560
 561 extern adt_translation_t *${pfx_adt}_xlate_table[];
 562
 563 #endif
 564
 565 #ifdef  __cplusplus
 566 }
 567 #endif
 568
 569 #endif  /* $adt_event_n */
 570 EOF
 571     }
 572     closeHeaderFiles(@Hfile);
 573 }
 574
 575 sub generateTableC {
 576     my $event = shift;
 577     my $eventId = shift;
 578     my $eventType = shift;
 579     my $eventHeader = shift;
 580     my $omit = shift;
 581
 582     my %tokenType = (
 583         #
 584         #       tokenTypes are the ones that are actually defined
 585         #       for use in adt.xml audit records
 586         #
 587
 588         #         'acl'                 => 'AUT_ACL',           # not defined
 589         #         'arbitrary'           => 'AUT_ARBITRARY',     # not defined
 590         #         'arg'                 => 'AUT_ARG',           # not defined
 591         #         'attr'                => 'AUT_ATTR',
 592                   'command'             => 'AUT_CMD',
 593                   'command_alt'         => 'ADT_CMD_ALT',       # dummy token id
 594         #         'date'                => 'AUT_TEXT',          # not used
 595         #         'exec_args'           => 'AUT_EXEC_ARGS',     # not defined
 596         #         'exec_env'            => 'AUT_EXEC_ENV',      # not defined
 597         #         'exit'                => 'AUT_EXIT',          # not defined
 598                   'fmri'                => 'AUT_FMRI',
 599         #         'groups'              => 'AUT_GROUPS',        # not defined
 600         #         'header'              => 'AUT_HEADER',        # not defined
 601                   'in_peer'             => 'ADT_IN_PEER',       # dummy token id
 602                   'in_remote'           => 'ADT_IN_REMOTE',     # dummy token id
 603         #         'ipc'                 => 'AUT_IPC',           # not defined
 604         #         'ipc_perm'            => 'AUT_IPC_PERM',      # not defined
 605                   'iport'               => 'AUT_IPORT',
 606                   'newgroups'           => 'AUT_NEWGROUPS',
 607         #         'opaque'              => 'AUT_OPAQUE',        # not defined
 608                   'path'                => 'AUT_PATH',
 609                   'path_list'           => '-AUT_PATH',         # dummy token id
 610                   'process'             => 'AUT_PROCESS',
 611                   'priv_effective'      => 'ADT_AUT_PRIV_E',    # dummy token id
 612                   'priv_limit'          => 'ADT_AUT_PRIV_L',    # dummy token id
 613                   'priv_inherit'        => 'ADT_AUT_PRIV_I',    # dummy token id
 614                   'return'              => 'AUT_RETURN',
 615                   'secflags'            => 'AUT_SECFLAGS',
 616         #         'seq'                 => 'AUT_SEQ',           # not defined
 617         #         'socket'              => 'AUT_SOCKET',        # not defined
 618         #         'socket-inet'         => 'AUT_SOCKET_INET',
 619                   'subject'             => 'AUT_SUBJECT',
 620                   'text'                => 'AUT_TEXT',
 621                   'tid'                 => 'AUT_TID',
 622         #         'trailer'             => 'AUT_TRAILER',       # not defined
 623                   'uauth'               => 'AUT_UAUTH',
 624                   'user'                => 'AUT_USER',
 625                   'zonename'            => 'AUT_ZONENAME'
 626                  );
 627
 628     my @xlateEntryList = ();
 629
 630     my $external = $event->getExternal();
 631     my $internal = $event->getInternal();
 632
 633     unless ($external) {
 634         print STDERR "No external object captured for event $eventId\n";
 635         return;
 636     }
 637     if ($eventType) {
 638         $nameTranslation{$eventId} = $eventId;
 639     } else {
 640         $nameTranslation{$eventId} = $external->getInternalName();
 641     }
 642     unless ($internal) {
 643         print STDERR "No internal object captured for event $eventId\n";
 644         return;
 645     }
 646     my @entryRef = $internal->getEntries();
 647     my $entryRef;
 648     my @tokenOrder = ();
 649     my $firstTokenIndex = 0; # djdj not used yet, djdj BUG!
 650                              # needs to be used by translate table
 651
 652     if ($internal->isReorder()) { # prescan the entry list to get the token order
 653       my @inputOrder;
 654       foreach $entryRef (@entryRef) {
 655         my ($intEntry, $entry) = @$entryRef;
 656         push (@inputOrder, $intEntry->getAttr('order'));
 657       }
 658
 659       my $i; # walk down the inputOrder list once
 660       my $k = 1; # discover next in line
 661       my $l = 0; # who should point to next in line
 662       for ($i = 0; $i <= $#inputOrder; $i++) {
 663         my $j;
 664         for ($j = 0; $j <= $#inputOrder; $j++) {
 665           if ($k == $inputOrder[$j]) {
 666             if ($k == 1) {
 667                 $firstTokenIndex = $j;
 668             } else {
 669                 $tokenOrder[$l] = "&(selfReference[$j])";
 670             }
 671             $l = $j;
 672             last;
 673           }
 674         }
 675         $k++;
 676       }
 677       $tokenOrder[$l] = 'NULL';
 678     }
 679     else { # default order -- input order same as output
 680       my $i;
 681       my $j;
 682       for ($i = 0; $i < $#entryRef; $i++) {
 683         my $j = $i + 1;
 684         $tokenOrder[$i] = "&(selfReference[$j])";
 685       }
 686       $tokenOrder[$#entryRef] = 'NULL';
 687     }
 688
 689     my $sequence = 0;
 690     foreach $entryRef (@entryRef) {
 691       my ($intEntry, $entry) = @$entryRef;
 692       my $entryId = $entry->getAttr('id');
 693
 694       my ($extEntry, $unusedEntry, $tokenId) =
 695         $external->getEntry($entryId);
 696       my $opt = $extEntry->getAttr('opt');
 697
 698       if ($opt eq 'none') {
 699         if (defined ($doc->getToken($tokenId))) {
 700           if (defined ($tokenType{$tokenId})) {
 701             $tokenId = $tokenType{$tokenId};
 702           }
 703           else {
 704             print STDERR "token id $tokenId not implemented\n";
 705           }
 706         }
 707         else {
 708           print STDERR "token = $tokenId is undefined\n";
 709           $tokenId = 'error';
 710         }
 711         my ($xlate, $jni) =
 712           formatTableEntry ('', $tokenId, $eventId, '', 0,
 713                             $tokenOrder[$sequence], 'NULL', '', $omit);
 714         push (@xlateEntryList, $xlate);
 715       }
 716       else {
 717         my $dataType = $extEntry->getAttr('type');
 718         $dataType =~ s/\s+//g;   # remove blanks (char * => char*)
 719
 720         my $enumGroup = '';
 721         if ($dataType =~ /^msg/i) {
 722             $enumGroup = $dataType;
 723             $enumGroup =~ s/^msg\s*//i;
 724             $enumGroup = "${pfx_adt}_" . $enumGroup;
 725         }
 726         my $required = ($opt eq 'required') ? 1 : 0;
 727         my $tokenId = $intEntry->getAttr('token');
 728         my $token;
 729         my $tokenName;
 730         my $tokenFormat = $intEntry->getAttr('format');
 731         if (defined ($tokenFormat)) {
 732           $tokenFormat = "\"$tokenFormat\"";
 733         }
 734         else {
 735           $tokenFormat = 'NULL';
 736         }
 737
 738         if (defined ($token = $doc->getToken($tokenId))) {
 739           if (defined ($tokenType{$tokenId})) {
 740             $tokenName = $tokenType{$tokenId};
 741           }
 742           else {
 743             print STDERR "token id $tokenId not implemented\n";
 744           }
 745         }
 746         else {
 747           print STDERR
 748             "$tokenId is an unimplemented token ($entryId in $eventId)\n";
 749           $tokenName = 'AUT_TEXT';
 750         }
 751         my ($xlate, $jni) =
 752           formatTableEntry($entryId, $tokenName, $eventId, $dataType, $required,
 753                            $tokenOrder[$sequence], $tokenFormat,
 754                            $enumGroup, $omit);
 755         push (@xlateEntryList, $xlate);
 756       }
 757       $sequence++;
 758     }
 759     $xlateEventTable{$eventId} = [\@xlateEntryList, $eventType, $firstTokenIndex,
 760                                  $eventHeader];
 761 }
 762
 763 sub formatTableEntry {
 764     my ($id, $token, $eventId, $type, $required, $sequence, $format,
 765         $enumGroup, $omitEntry) = @_;
 766
 767
 768     # does this map belong in the xml source?  (at least the defaults?)
 769     # fill in the default value only if it is other than zero.
 770     #                 base type             adt name,   default value
 771     my %entryDef = ( 'au_asid_t'        => ['ADT_UINT32',       ''],
 772                      'uint_t'           => ['ADT_UINT32',       ''],
 773                      'int'              => ['ADT_INT',          ''],
 774                      'int32_t'          => ['ADT_INT32',        ''],
 775                      'uid_t'            => ['ADT_UID',          'AU_NOAUDITID'],
 776                      'gid_t'            => ['ADT_GID',          'AU_NOAUDITID'],
 777                      'uid_t*'           => ['ADT_UIDSTAR',      ''],
 778                      'gid_t*'           => ['ADT_GIDSTAR',      ''],
 779                      'char'             => ['ADT_CHAR',         ''],
 780                      'char*'            => ['ADT_CHARSTAR',     ''],
 781                      'char**'           => ['ADT_CHAR2STAR',    ''],
 782                      'long'             => ['ADT_LONG',         ''],
 783                      'pid_t'            => ['ADT_PID',          ''],
 784                      'priv_set_t*'      => ['ADT_PRIVSTAR',     ''],
 785                      'ulong_t'          => ['ADT_ULONG',        ''],
 786                      'uint16_t',        => ['ADT_UINT16',       ''],
 787                      'uint32_t'         => ['ADT_UINT32',       ''],
 788                      'uint32_t*'        => ['ADT_UINT32STAR',   ''],
 789                      'uint32_t[]'       => ['ADT_UINT32ARRAY',  ''],
 790                      'uint64_t'         => ['ADT_UINT64',       ''],
 791                      'uint64_t*'        => ['ADT_UINT64STAR',   ''],
 792                      'fd_t'             => ['ADT_FD',           '-1'],
 793                     );
 794     my $xlateLabel = $uniLabel.$xlateUniLabelInc;
 795     my $xlateLabelInc = 0;
 796     my $xlateLine = '';
 797     my @jniLine = ();
 798
 799         # the list handling should be a simple loop with a loop of one
 800         # falling out naturally.
 801
 802     unless ($type =~ /,/) {     # if list, then generate sequence of entries
 803       my $dataType;
 804       my $dataSize;
 805       my $xlateLabelRef = '';
 806
 807       my $arraySize = '';
 808       $arraySize = $1 if ($type =~ s/\[(\d+)\]/[]/);
 809
 810       my $entryType = ${$entryDef{$type}}[0];
 811
 812       my @xlateType = ();       # for adt_xlate.c
 813       my $typeCount = 1;
 814
 815       if ($entryType) {
 816         $dataType = $entryType;
 817         $type =~ s/([^*]+)\s*(\*+)/$1 $2/;
 818         $type =~ s/\[\]//;
 819         $dataSize = "sizeof ($type)";
 820         if ($arraySize) {
 821                 $dataSize = "$arraySize * " . $dataSize;
 822         }
 823         $xlateLine = "{{$dataType, $dataSize}}";
 824         push (@jniLine, [$id, $dataType, $format, $enumGroup, $required]);
 825       } elsif ($type eq '') {
 826           $xlateLabelRef = 'NULL';
 827       } elsif ($type =~ /^msg/i) {
 828         $type =~ s/^msg//i;
 829         $dataType = 'ADT_MSG';
 830         my $dataEnum = 'ADT_LIST_' . uc $type;
 831         $xlateLine = "{{$dataType, $dataEnum}}";
 832         push (@jniLine, [$id, $dataType, $format, $enumGroup, $required]);
 833       } elsif ($type =~ /time_t/i) {
 834         $dataType = 'ADT_DATE';
 835         $dataSize = "sizeof (time_t)";
 836         $xlateLine = "{{$dataType, $dataSize}}";
 837         push (@jniLine, [$id, $dataType, $format, $enumGroup, $required]);
 838       } elsif ($type =~ /termid/i) {
 839         $dataType = 'ADT_TERMIDSTAR';
 840         $dataSize = "sizeof (au_tid_addr_t *)";
 841         $xlateLine = "{{$dataType, $dataSize}}";
 842         push (@jniLine, [$id, $dataType, $format, $enumGroup, $required]);
 843       } elsif (uc $omitEntry eq 'JNI') {
 844         $xlateLabelRef = 'NULL';
 845       } else {
 846         print STDERR "$type is not an implemented data type\n";
 847         $xlateLabelRef = 'NULL';
 848       }
 849       if ($xlateLine && !($xlateTypeList{$xlateLine})) {
 850         $xlateTypeList{$xlateLine} = $xlateLabel;
 851         push (@xlateTypeList, "datadef\t$xlateLabel\[1\] =\t$xlateLine;");
 852         $xlateLabelInc = 1;
 853       } else {
 854         $xlateLabel = $xlateTypeList{$xlateLine};
 855       }
 856       $xlateLabelRef = '&' . $xlateLabel . '[0]'
 857         unless $xlateLabelRef eq 'NULL';
 858
 859       # "EOL" is where a comma should go unless end of list
 860       $xlateLine = "{$token,\t1,\t$xlateLabelRef,\t$sequence,\n" .
 861           "\t\t0,\t$required,\t$format}EOL";
 862
 863       if (uc $omitEntry ne 'ALWAYS' && ${$entryDef{$type}}[1]) {
 864           my @list = ();
 865           if ($xlateDefault{$eventId}) {
 866               @list = @{$xlateDefault{$eventId}};
 867           } else {
 868               push (@xlateDefaults, $eventId);
 869           }
 870           push (@list, $id, ${$entryDef{$type}}[1]);
 871           $xlateDefault{$eventId} = \@list;
 872       }
 873     } else {    # is a list
 874       my @type = split(/,/, $type);
 875       my @arraySize = ();
 876       my @id   = split(/,/, $id);
 877       my @jniId  = @id;
 878       my $dataType;
 879       my $typeCount = ($#type + 1);
 880       my @xlateType = ();
 881       my @default = ();
 882
 883       foreach my $dtype (@type) {
 884         my $jniId = shift @jniId;
 885         my $id = shift @id;
 886         my $arraySize = '';
 887         $arraySize = $1 if ($dtype =~ s/\[(\d+)\]/[]/);
 888
 889         my $entryType = ${$entryDef{$dtype}}[0];
 890         if ($entryType) {
 891           my $type = $dtype;
 892           $type =~ s/([^*]+)\s*(\*+)/$1 $2/;
 893           $type =~ s/\[\]//;
 894
 895           my $sizeString = "sizeof";
 896           $sizeString = "$arraySize * " . $sizeString if $arraySize;
 897           push (@xlateType, "\{$entryType, $sizeString ($type)\}");
 898           push (@jniLine, [$jniId, $entryType, $format, $enumGroup, $required]);
 899         } elsif ($type =~ /^msg/i) {
 900           $type =~ s/^msg//i;
 901           $dataType = 'ADT_MSG';
 902           my $dataEnum = 'ADT_LIST_' . uc $type;
 903           push (@xlateType, "\{$dataType, $dataEnum\}};");
 904           push (@jniLine, [$jniId, $dataType, $format, $enumGroup, $required]);
 905         } elsif ($type =~ /time_t/i) {
 906           $dataType = 'ADT_DATE';
 907           push (@xlateType, "\{$entryType, sizeof ($type)\}");
 908           push (@jniLine, [$jniId, $entryType, $format, $enumGroup, $required]);
 909         } elsif ($type =~ /termid/i) {
 910           $dataType = 'ADT_TERMIDSTAR';
 911           push (@xlateType, "\{$dataType, sizeof (au_tid_addr_t *)\}");
 912           push (@jniLine, [$jniId, $dataType, $format, $enumGroup, $required]);
 913         } elsif (uc $omitEntry eq 'JNI') {
 914           # nothing to do.
 915         } else {
 916           print STDERR "$dtype is not an implemented data type\n";
 917         }
 918         if (uc $omitEntry ne 'ALWAYS' && ${$entryDef{$dtype}}[1]) {
 919           push (@default, $id, ${$entryDef{$dtype}}[1]);
 920         }
 921       }
 922       my $xlateArray = "\[$typeCount\] =\t{" . join(",\n\t\t\t\t", @xlateType) . "};";
 923
 924       unless ($xlateTypeList{$xlateArray}) {
 925         $xlateTypeList{$xlateArray} = $xlateLabel;
 926         $xlateArray = "datadef\t$xlateLabel" . $xlateArray;
 927         push (@xlateTypeList, $xlateArray);
 928         $xlateLabelInc = 1;
 929       } else {
 930         $xlateLabel = $xlateTypeList{$xlateArray};
 931       }
 932       $xlateLine =
 933         "{$token,\t$typeCount,\t&$xlateLabel\[0\],\t$sequence,\n" .
 934         "\t\t0,\t$required,\t$format}EOL";
 935       if (@default) {
 936           my @list = ();
 937           if ($xlateDefault{$eventId}) {
 938               @list = @{$xlateDefault{$eventId}};
 939           } else {
 940               push (@xlateDefaults, $eventId);
 941           }
 942           push (@list, @default);
 943           $xlateDefault{$eventId} = \@list;
 944       }
 945     }
 946     $xlateUniLabelInc++ if $xlateLabelInc;
 947     return ($xlateLine, \@jniLine);
 948 }
 949
 950 sub generateAPIFile {
 951     my $event = shift;
 952     my $eventId = shift;
 953     my $eventType = shift;
 954     my $eventHeader = shift;
 955     my $idNo = shift;
 956
 957     my @entryList = ();
 958
 959     my $external = $event->getExternal();
 960
 961     if ($eventType && $debug) {
 962         print STDERR "event $eventId is of type $eventType\n";
 963     }
 964
 965     return unless $external;
 966
 967     my ($extEntry, $entry, $tokenId, $format);
 968     while (($extEntry, $entry, $tokenId, $format) = $external->getNextEntry()) {
 969         last unless $entry;
 970         my $entryId = $entry->getAttr('id');
 971
 972         unless (defined $entryId) {
 973             print STDERR "undefined entry id for external $eventId\n";
 974             next;
 975         }
 976         my $option = $extEntry->getAttr('opt');
 977         next if ($option eq 'none');
 978
 979         $option .= " (format: $format)" if $format;
 980
 981         my $dataType = $extEntry->getAttr('type');
 982         unless (defined $dataType) {
 983           print STDERR "no type defined for external tag for $eventId\n";
 984           $dataType = "error";
 985         }
 986
 987         my $comment = $entry->getContent();
 988
 989         if (($dataType =~ /,/) || ($entryId =~ /,/)) {
 990           my @type = split(/\s*,\s*/, $dataType);
 991           my @id   = split(/\s*,\s*/, $entryId);
 992           if ($#type != $#id) {
 993             print STDERR
 994               "number of data types ($dataType) does not match number of ids ($entryId)",
 995               " for event $eventId\n";
 996             if ($#type < $#id) {
 997               $#id = $#type;
 998             }
 999             else {
1000               $#type = $#id;
1001             }
1002           }
1003
1004           my $i;
1005           my $line = '';
1006           $line = "/* $comment */\n\t" if defined $comment;
1007           for ($i = 0; $i <= $#type; $i++) {
1008             my ($primitive, $dereference) =
1009                 ($type[$i] =~ /([^\*]+)\s*(\**)/);
1010             $id[$i] .= $1 if ($primitive =~ s/(\[\d+\])//);
1011             $line .= "$primitive\t$dereference$id[$i];\t/*  $option  */";
1012             push (@entryList, $line);
1013             $line = '';
1014           }
1015         }
1016         else {
1017           my $line = '';
1018           $line = "/* $comment */\n\t" if defined $comment;
1019           if ($dataType =~ /^msg/i) {
1020               $dataType =~ s/^msg\s*//i;
1021               $line .= "enum ${pfx_adt}_$dataType" . "\t$entryId;\t/*  $option  */";
1022           }
1023           elsif ($dataType =~ /time_t/i) {
1024               $line .= "time_t\t$entryId;\t/* $option */";
1025           }
1026           else {
1027             my ($primitive, $dereference) =
1028                 ($dataType =~ /([^\*]+)\s*(\**)/);
1029             $entryId .= $1 if ($primitive =~ s/(\[\d+\])//);
1030             $line .= "$primitive\t$dereference$entryId;\t/* $option */";
1031           }
1032           push (@entryList, $line);
1033         }
1034     }
1035     $eventExtra{$eventId} = [$eventHeader, $idNo];
1036     $eventAPI{$eventId} = \@entryList;
1037 }
1038
1039 sub generateMsgLists {
1040     my $textList = shift;
1041
1042     my $textName = $textList->getId();
1043     my $header = $textList->getHeader();
1044     my $start = $textList->getMsgStart();
1045     my $public = $textList->getMsgPublic();
1046     my $deprecated = $textList->getDeprecated();
1047
1048     addHeader($header);
1049     print "$textName starts at $start\n" if $debug;
1050
1051     my $entry;
1052     my @entry;
1053     while ($entry = $textList->getNextMsg()) {
1054         if ($debug) {
1055             my ($id, $text) = split(/\s*::\s*/, $entry);
1056             print "   $id = $text\n";
1057         }
1058         unshift (@entry, $entry);
1059     }
1060     $msg_list{$textName} =
1061         [\@entry, [$header, $start, $public, $deprecated]];
1062 }
1063
1064 sub addHeader {
1065     my $header_index = shift;
1066
1067     die "invalid adt_event_N.h index: $header_index\n"
1068         unless ($header_index =~ /^\d+$/);
1069
1070     $headers{$header_index} = $header_index;
1071 }
1072
1073 # $header = 0 is a special case; it is for adt_event.h
1074 # $header > 0 creates adt_event_N.h, where N = $header
1075
1076 sub openHeaderFiles {
1077     my $outfile = shift;        # path to an adt_event_N.h file
1078
1079     my $header;
1080     my @Hfile = (); # potentially sparse array of file handles
1081     my @HfileName = (); # parallel array to Hfile, file name (not path)
1082     foreach $header (sort keys %headers) {
1083         my $file = $outfile;
1084         if ($header > 0) {
1085             $file =~ s/_N/_$header/;
1086         } else {
1087             $file =~ s/_N//;
1088         }
1089         unless (open($Hfile[$header], ">$file")) {
1090             print STDERR "can't open output ($file): $!\n";
1091             $HfileName[$header] = '';
1092             $Hfile[$header] = '';
1093         } else {
1094             my @tmp = split(/\//, $file);
1095             $HfileName[$header] = $tmp[$#tmp];
1096         }
1097     }
1098     return (@Hfile);
1099 }
1100
1101 sub closeHeaderFiles {
1102     my @Hfile = @_;
1103
1104     my $header;
1105     foreach $header (sort keys %headers) {
1106         close $Hfile[$header] if $Hfile[$header];
1107     }
1108 }