COMPILATION LISTING OF SEGMENT audit_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-18_1152.63_Tue_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* *********************************************************** */ 8 9 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(89-04-06,Vu), approve(89-04-06,MCR8095), audit(89-04-25,Lee), 14* install(89-05-10,MR12.3-1040): 15* - output modes are returned even if the input modes string contains only 16* audit modes (ie. audit_input). 17* - The following builtin functions: after, before, empty, max, rtrim are 18* now declared explicitly. 19* END HISTORY COMMENTS */ 20 21 22 /* format: style2,ind3 */ 23 audit_: 24 audit_attach: 25 proc (p_iocb_ptr, p_option_array, p_com_err_sw, p_code); 26 27 28 /* This program is the main driver for the "audit" module. It has entries 29* for attachment (which also opens), for reading, writing, and detachment (which also precedes 30* it with a close). The following I/O system calls are provided for this module: 31* 32* attach (open) audit_$audit_attach 33* close audit_$audit_close 34* detach audit_$audit_detach 35* get_chars audit_$audit_get_chars 36* get_line audit_$audit_get_line 37* put_chars audit_$audit_put_chars 38* control audit_$audit_control 39* modes audit_$audit_modes 40* 41* Last Modified: 42* 43* 12/01/78 Written by Lindsey L. Spratt (from existing code by J. Stern, S. Webber, and R. Bratt) 44* 11/26/79 by Lindsey L. Spratt to support prompting in the editor. 45* 05/20/80 by Lindsey L. Spratt to fix -tc option and assume "audit" suffix. 46* 12/22/80 by Lindsey L. Spratt: Change all mode string references from 256 47* char string to 512. 48*03/20/81 by Lindsey L. Spratt: remove "audit_editor_prompt_terminator=" 49* mode. Set default editor_prompt_string to 50* "audit editor^[(^d)^]:^2x". 51*08/05/81 by Lindsey Spratt: Changed modes entry to use the mode_string_$parse 52* and mode_string_$delete entries to manipulate the mode strings. 53* Changed all calls to iox entries to be calls instead of function 54* references. Changed from using the iocbx.incl.pl1 file to 55* iocb.incl.pl1. Changed entry sequences to be calls instead of 56* functions, i.e. the returns (fixed bin(35)) was replaced by 57* including "p_code" in the entry parameters. 58*10/29/81 by Lindsey Spratt: Fixed conversion of ll= and pl= to only be 59* invoked if the respective strings are actually present to be 60* converted. Also, added rtrimming of the unrecognized_modes string 61* in the calls of the before and after builtins. 62* Added initialization of the blk pointers 63* audit_file_header_ptr, temp_seg_ptr, work_area, audit_fcb, 64* begin_ptr, and audit_ptr. Added checks for null pointers and 65* non-zero error codes to the detach entry. 66*11/12/81 by Lindsey Spratt: Changed to call hcs_$assign_linkage as a 67* subroutine instead of a function. 68*06/01/82 by Lindsey Spratt: Was not honoring the maximum length of the audit 69* file when "adjusting" during the audit_detach operation, the 70* current_component and (audit_index - 1) were being used instead of 71* the max_component and max_index (set by the audit_file_size mode). 72* The audit_detach entry now checks the audit_file_header.filled 73* flag to determine if it should use the max component and index 74* (file_limit = "1"b) or the current_component and audit_index (file_limit = 75* "0"b). 76*06/03/82 by Lindsey Spratt: Changed the setting of the bit count in 77* audit_detach to be the value of audit_index*9, instead of 78* audit_index*9-9. 79*06/08/82 by Lindsey Spratt: Removed the code which always set 80* audit_file_header.max_index to sys_info$max_seg_size*4 whenever 81* attaching to an audit file. The max_index and max_componenet 82* values of the audit_file_header are now only set when initializing 83* an empty audit file and when setting the audit_file_size mode. 84* This makes max_index a reliable indicator of whether the "current" 85* audit file is supposed to be circular or not. The setting of the 86* file_limit flag in blk.current_flags in audit_attach relies on 87* this fact. 88*06/09/82 by Lindsey Spratt: Added an any_other handler to audit_detach. 89* Changed detach logic to not use the bit-count-setting feature of 90* msf_manager_$adjust when adjusting the audit file, instead an 91* explicit set_bc_seg is done (when appropriate) to the final 92* component of the audit file. All preceding components will have 93* had their bit counts correctly set by the "next_component" 94* operation of insert_line. 95*10/13/82 by Lindsey Spratt: Moved setting of safety_sw off into the 96* audit_close entry. This makes it possible for the standard 97* process epilogue handler to cause audit files to have their safety 98* switches turned off. Previously, this was done in the 99* audit_detach entry, which does not get invoked during process 100* termination. 101*02/10/83 by Lindsey Spratt: Fixed audit_line to set 102* audit_file_header.max_component to be the highest used component 103* number in the non-file_limit (non-circular file) case. 104* display_audit_file/audit_file_position_ relies on the 105* max_component to know where the audit file ends (in some 106* circumstances). Fixed insert_line to set 107* audit_file_header.max_index to equal audit_file_header.audit_index 108* when working with a non-file_limit audit file. 109*03/02/83 by Lindsey Spratt: More fixes to make all portions of code respect 110* the protocol that for "unlimited" (or non-circular) files 111* afh.max_index always equals afh.audit_index and afh.max_component 112* always equals afh.current_component. For circular files, 113* afh.max_index is > afh.audit_index when afh.max_component = 114* afh.current_component, and afh.max_component is always >= 115* afh.current_component. Also, fixed audit_suspend mode to have no 116* effect when audit is already suspended. 117* */ 118 119 /* Parameters */ 120 121 dcl (p_newmodes, p_oldmodes) 122 char (*); 123 dcl p_real_order char (*); 124 dcl p_code fixed bin (35); 125 dcl (p_iocb_ptr, buff_ptr, p_info_ptr) 126 ptr; 127 dcl (actual_len, buff_len) fixed bin (21); 128 dcl p_option_array (*) char (*) var; 129 dcl p_com_err_sw bit (1) aligned; 130 dcl ptype fixed bin; 131 dcl n fixed bin (21); 132 dcl p_buff_ptr ptr; 133 dcl (p_buff_len, p_actual_len) 134 fixed bin (21); 135 136 /* Entries */ 137 138 dcl cpu_time_and_paging_ entry (fixed bin, fixed bin (71), fixed bin); 139 dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 140 dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 141 dcl decode_clock_value_ entry (fixed bin (71), fixed bin, fixed bin, fixed bin, fixed bin (71), fixed bin, 142 char (3) aligned); 143 dcl audit_editor entry (ptr, fixed bin (21), fixed bin (21), ptr, fixed bin (35)); 144 dcl audit_editor$set_last_return_line_position 145 entry (ptr); 146 dcl audit_file_position_$last 147 entry (ptr, ptr, fixed bin (35)); 148 dcl com_err_ entry options (variable); 149 dcl sub_err_ entry options (variable); 150 dcl expand_pathname_$add_suffix 151 entry (char (*), char (*), char (*), char (*), fixed bin (35)); 152 dcl ioa_$ioa_switch entry options (variable); 153 dcl ioa_$ioa_switch_nnl entry options (variable); 154 dcl date_time_ entry (fixed bin (71), char (*)); 155 dcl user_info_$homedir entry (char (*)); 156 dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); 157 dcl hcs_$set_safety_sw_seg entry (ptr, bit (1), fixed bin (35)); 158 dcl hcs_$status_mins entry (ptr, fixed bin (2), fixed bin (24), fixed bin (35)); 159 dcl hcs_$set_ips_mask entry (fixed bin, fixed bin); 160 dcl hcs_$assign_linkage entry (fixed bin, ptr, fixed bin (35)); 161 dcl abbrev_$expanded_line entry (ptr, fixed bin, ptr, fixed bin, ptr, fixed bin); 162 dcl msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 163 dcl msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin (24), fixed bin (35)); 164 dcl msf_manager_$adjust entry (ptr, fixed bin, fixed bin (24), bit (3), fixed bin (35)); 165 dcl msf_manager_$close entry (ptr); 166 167 dcl mode_string_$parse entry (char (*), ptr, ptr, fixed bin (35)); 168 dcl mode_string_$delete entry (ptr, (*) char (*), char (*), fixed bin (35)); 169 dcl mode_string_$combine entry (ptr, ptr, char (*), fixed bin (35)); 170 171 /* Constants */ 172 173 dcl any_other condition; 174 175 /* Static Variables */ 176 177 dcl SUFFIX char (32) varying init ("audit") internal static options (constant); 178 dcl sio_open_desc char (20) varying init ("stream_input_output") static options (constant); 179 dcl myname char (6) static options (constant) init ("audit_"); 180 dcl NL char (1) aligned static options (constant) init (" 181 "); 182 dcl AUDIT_MODE_NAMES (12) char (32) 183 init ("audit_suspend", "audit_input", "audit_output", "audit_edit", "audit_trace", 184 "audit_use_editor_prompt", "audit_editor_prompt_string", "audit_epstr", 185 "audit_file_size", "audit_meter", "audit_transparent", "audit_trigger") 186 internal static options (constant); 187 188 /* Based */ 189 190 dcl mode_str char (512) varying based; 191 dcl aut_input_string char (actual_len) based (buff_ptr); 192 dcl param_output_string char (p_buff_len) based (p_buff_ptr); 193 dcl param_input_string char (p_actual_len) based (p_buff_ptr); 194 195 /* Automatic Variables */ 196 197 dcl out_ptr ptr; 198 dcl type fixed bin (2); 199 dcl bit_count24 fixed bin (24); 200 dcl mode_idx fixed bin (17); 201 dcl records fixed bin; 202 dcl newmodes char (64) varying; 203 dcl unrecognized_modes char (512); 204 dcl order char (32); 205 dcl (audited_iocb, blkptr, auditing_iocb) 206 ptr; 207 dcl device char (32); 208 dcl i fixed bin; 209 dcl (tc, mask) fixed bin; 210 dcl ename char (32); 211 dcl time char (8); 212 dcl dirname char (168); 213 dcl tactual_len fixed bin (21); 214 dcl extend bit (1); 215 dcl request char (1); 216 dcl set_last_return_line_position 217 bit (1) init ("0"b); 218 dcl ab_buf char (512); 219 dcl ab_len fixed bin; 220 dcl temp_area area (2048); 221 222 /* External Variables */ 223 224 dcl sys_info$max_seg_size fixed bin (24) ext; 225 dcl error_table_$bad_mode_value 226 fixed bin (35) ext; 227 dcl error_table_$bad_mode_syntax 228 fixed bin (35) ext; 229 dcl error_table_$long_record 230 fixed bin (35) ext; 231 dcl error_table_$empty_file 232 fixed bin (35) ext; 233 dcl error_table_$noarg fixed bin (35) ext; 234 dcl error_table_$unimplemented_version 235 fixed bin (35) ext; 236 dcl error_table_$not_detached 237 fixed bin (35) ext; 238 dcl error_table_$noentry fixed bin (35) ext; 239 dcl error_table_$bad_arg fixed bin (35) ext; 240 241 /* Builtins */ 242 243 dcl string builtin; 244 dcl currentsize builtin; 245 dcl clock builtin; 246 dcl mod builtin; 247 dcl (substr, addr, null, divide, hbound, index, length, size) 248 builtin; 249 dcl (after, before, empty, max, rtrim) 250 builtin; 251 252 253 /* */ 254 255 /* attach --- subroutine to attach and open the audit module */ 256 257 258 259 /* Look at option array and collect data */ 260 261 ename = ""; 262 audited_iocb = p_iocb_ptr; 263 extend = "1"b; 264 if hbound (p_option_array, 1) < 1 265 then 266 do; 267 if p_com_err_sw 268 then call com_err_ (error_table_$bad_arg, (myname), "No device name given."); 269 p_code = error_table_$bad_arg; 270 return; 271 end; 272 device = p_option_array (1); /* device name must be first option */ 273 call iox_$find_iocb (device, auditing_iocb, p_code); 274 if p_code ^= 0 275 then 276 do; 277 if p_com_err_sw 278 then call com_err_ (p_code, (myname), "^a", device); 279 return; 280 end; 281 do i = 2 to hbound (p_option_array, 1); /* now search the options */ 282 if p_option_array (i) = "-tc" | p_option_array (i) = "-truncate" 283 then extend = "0"b; 284 else if p_option_array (i) = "-pn" | p_option_array (i) = "-pathname" 285 then 286 do; 287 i = i + 1; 288 if i > hbound (p_option_array, 1) 289 then 290 do; 291 if p_com_err_sw 292 then call 293 com_err_ (error_table_$noarg, (myname), 294 "^/A pathname must be given with the the -pathname control argument."); 295 p_code = error_table_$noarg; 296 return; 297 end; 298 call expand_pathname_$add_suffix ((p_option_array (i)), (SUFFIX), dirname, ename, p_code); 299 if p_code ^= 0 300 then 301 do; 302 if p_com_err_sw 303 then call com_err_ (p_code, (myname), "^a", p_option_array (i)); 304 return; 305 end; 306 end; 307 else 308 do; 309 if p_com_err_sw 310 then call com_err_ (error_table_$bad_arg, (myname), "^/Unsupported option ^a.", p_option_array (i)); 311 p_code = error_table_$bad_arg; 312 return; 313 end; 314 end; 315 if ename = "" 316 then 317 do; 318 call date_time_ (clock, time); /* get time for default file name */ 319 ename = time || ".audit"; 320 call user_info_$homedir (dirname); /* get default dirname */ 321 end; 322 call hcs_$set_ips_mask (0, mask); /* enter critical code */ 323 if audited_iocb -> iocb.attach_descrip_ptr ^= null () 324 then 325 do; 326 call hcs_$set_ips_mask (mask, 0); 327 if p_com_err_sw 328 then call com_err_ (error_table_$not_detached, (myname)); 329 p_code = error_table_$not_detached; 330 return; 331 end; 332 call hcs_$assign_linkage (size (blk), blkptr, p_code); 333 if blkptr = null () 334 then 335 do; /* can't get storage for data */ 336 call hcs_$set_ips_mask (mask, 0); 337 if p_com_err_sw 338 then call com_err_ (p_code, (myname)); 339 return; 340 end; 341 audited_iocb -> iocb.attach_descrip_ptr = addr (blk.attach); 342 audited_iocb -> iocb.attach_data_ptr = blkptr; 343 audited_iocb -> iocb.detach_iocb = audit_detach; 344 audited_iocb -> iocb.open = iox_$err_no_operation; 345 audited_iocb -> iocb.close = audit_close; /* Now fill in some stuff in the block */ 346 tc = index (device, " "); 347 if tc = 0 348 then tc = length (device); 349 blk.attach = "audit_ " || substr (device, 1, tc); 350 do i = 2 to hbound (p_option_array, 1); 351 blk.attach = blk.attach || " "; 352 blk.attach = blk.attach || p_option_array (i); 353 end; 354 blk.auditing_iocb = auditing_iocb; /* fill in target iocb pointer */ 355 blk.default_iocb = audited_iocb; 356 357 358 /* Now the code to open the stream as well */ 359 360 blk.dirname = dirname; 361 blk.ename = ename; 362 blk.audit_file_header_ptr = null; 363 blk.audit_fcb = null; 364 blk.audit_ptr = null; 365 blk.begin_ptr = null; 366 blk.temp_seg_ptr = null; 367 blk.work_space = null; 368 audited_iocb -> iocb.get_line = audit_get_line; 369 audited_iocb -> iocb.control = audit_control; 370 audited_iocb -> iocb.put_chars = audit_put_chars; 371 audited_iocb -> iocb.get_chars = audit_get_chars; 372 audited_iocb -> iocb.open_descrip_ptr = addr (sio_open_desc); 373 audited_iocb -> iocb.open_data_ptr = blkptr; 374 audited_iocb -> iocb.modes = audit_modes; 375 audited_iocb -> iocb.position = audit_position; 376 377 call msf_manager_$open (blk.dirname, blk.ename, blk.audit_fcb, p_code); 378 if p_code ^= 0 379 then if p_code = error_table_$noentry 380 then 381 do; 382 call msf_manager_$get_ptr (blk.audit_fcb, 0, "1"b, blk.audit_ptr, bit_count24, p_code); 383 if p_code ^= 0 384 then 385 do; 386 call hcs_$set_ips_mask (mask, 0); 387 if p_com_err_sw 388 then call 389 com_err_ (p_code, (myname), 390 "While attempting to get a pointer to component 0 of the audit file."); 391 return; 392 end; 393 INIT_AUDIT_FILE: 394 audit_file_header_ptr = blk.audit_ptr; 395 blk.audit_file_header_ptr = blk.audit_ptr; 396 audit_file_header.last_entry_length = impossible_audit_entry_length; 397 audit_file_header.filled = "0"b; 398 audit_file_header.current_component = 0; 399 audit_file_header.unused1 = "0"b; 400 audit_file_header.pad2 = 0; 401 audit_file_header.begin_component = 0; 402 audit_file_header.begin_index = 403 (4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8); 404 blk.begin_ptr = blk.audit_ptr; 405 audit_file_header.version = audit_file_header_version_1; 406 audit_file_header.last_entry_length = -1; 407 call truncate_audit_file; 408 audit_file_header.max_component = audit_file_header.current_component; 409 audit_file_header.max_index = audit_file_header.audit_index; 410 end; 411 else 412 do; 413 call hcs_$set_ips_mask (mask, 0); 414 if p_com_err_sw 415 then call 416 com_err_ (p_code, (myname), "While attempting to open audit file ^a^[>^]^a .", blk.dirname, 417 blk.dirname ^= ">", blk.ename); 418 return; 419 end; 420 else if extend 421 then 422 do; 423 call msf_manager_$get_ptr (blk.audit_fcb, 0, "1"b, audit_file_header_ptr, bit_count24, p_code); 424 if p_code ^= 0 425 then 426 do; 427 call hcs_$set_ips_mask (mask, 0); 428 if p_com_err_sw 429 then call com_err_ (p_code, (myname), "While attempting to get pointer to component 0 of audit file."); 430 return; 431 end; 432 if audit_file_header.version = 0 433 then 434 do; 435 blk.audit_ptr = audit_file_header_ptr; 436 go to INIT_AUDIT_FILE; 437 end; 438 else if audit_file_header.version ^= audit_file_header_version_1 439 then 440 do; 441 call hcs_$set_ips_mask (mask, 0); 442 if p_com_err_sw 443 then call com_err_ (p_code, (myname)); 444 p_code = error_table_$unimplemented_version; 445 return; 446 end; 447 call 448 msf_manager_$get_ptr (blk.audit_fcb, audit_file_header.current_component, "1"b, blk.audit_ptr, bit_count24, 449 p_code); 450 if p_code ^= 0 451 then 452 do; 453 call hcs_$set_ips_mask (mask, 0); 454 if p_com_err_sw 455 then call com_err_ (p_code, (myname), "While attempting to get pointer to audit file."); 456 return; 457 end; 458 call 459 msf_manager_$get_ptr (blk.audit_fcb, audit_file_header.begin_component, "1"b, blk.begin_ptr, bit_count24, 460 p_code); 461 if p_code ^= 0 462 then 463 do; 464 call hcs_$set_ips_mask (mask, 0); 465 if p_com_err_sw 466 then call 467 com_err_ (p_code, (myname), "While attempting to get pointer to component ^d of audit file.", 468 audit_file_header.begin_component); 469 return; 470 end; 471 blk.current_flags.file_limit = 472 audit_file_header.max_index > audit_file_header.audit_index 473 | audit_file_header.max_component > audit_file_header.current_component; 474 end; 475 else 476 do; 477 call msf_manager_$get_ptr (blk.audit_fcb, 0, "1"b, blk.audit_ptr, bit_count24, p_code); 478 if p_code ^= 0 479 then 480 do; 481 call hcs_$set_ips_mask (mask, 0); 482 if p_com_err_sw 483 then call 484 com_err_ (p_code, (myname), "While attempting to get pointer to component ^d of audit file.", 485 audit_file_header.current_component); 486 return; 487 end; 488 audit_file_header_ptr = blk.audit_ptr; 489 blk.audit_file_header_ptr = blk.audit_ptr; 490 audit_file_header.current_component = 0; 491 call 492 msf_manager_$adjust (blk.audit_fcb, 0, 493 ((4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8)) * 9, "110"b, p_code); 494 if p_code ^= 0 495 then 496 do; 497 call hcs_$set_ips_mask (mask, 0); 498 if p_com_err_sw 499 then call com_err_ (p_code, (myname), "While attempting to adjust audit file."); 500 return; 501 end; 502 call truncate_audit_file; 503 audit_file_header.begin_index = audit_file_header.audit_index; 504 audit_file_header.begin_component = 0; 505 audit_file_header.max_component = audit_file_header.current_component; 506 audit_file_header.max_index = audit_file_header.audit_index; 507 audit_file_header.filled = "0"b; 508 blk.begin_ptr = blk.audit_ptr; 509 end; 510 blk.audit_file_header_ptr = audit_file_header_ptr; 511 blk.current_flags.read_audit = "1"b; 512 blk.current_flags.write_audit = "1"b; 513 blk.trigger = "!"; 514 blk.current_flags.edit = "1"b; 515 blk.current_flags.use_editor_prompt = "1"b; 516 blk.editor_prompt_string = "audit editor^[(^d)^]:^2x"; 517 518 blk.work_space = null; 519 blk.work_space_len = 0; 520 521 call hcs_$set_safety_sw_seg (blk.audit_file_header_ptr, "1"b, p_code); 522 /* The audit_file_header_ptr always points at component 0 of the audit file, the safety switch on comp 0 is on when audit is attached and off when audit isn't attached. */ 523 524 call get_temp_segment_ ("audit_", blk.temp_seg_ptr, p_code); 525 if p_code ^= 0 526 then 527 do; 528 call hcs_$set_ips_mask (mask, 0); 529 if p_com_err_sw 530 then call com_err_ (p_code, (myname), "While attempting to get temp seg."); 531 return; 532 end; /* Now propagate through all appropriate IOCB's */ 533 call iox_$propagate (audited_iocb); 534 call hcs_$set_ips_mask (mask, 0); 535 p_code = 0; 536 return; 537 538 539 audit_detach: 540 entry (p_iocb_ptr, p_code); 541 p_code = 0; 542 call hcs_$set_ips_mask (0, mask); 543 blkptr = p_iocb_ptr -> iocb.attach_data_ptr; 544 p_iocb_ptr -> iocb.open_descrip_ptr = null (); 545 p_iocb_ptr -> iocb.open_data_ptr = null (); 546 p_iocb_ptr -> iocb.attach_descrip_ptr, p_iocb_ptr -> iocb.attach_data_ptr = null (); 547 p_iocb_ptr -> iocb.detach_iocb = iox_$err_not_attached; 548 p_iocb_ptr -> iocb.open = iox_$err_not_attached; 549 call iox_$propagate (p_iocb_ptr); 550 551 on any_other 552 begin; 553 call force_audit_suspension; 554 goto RETURN; 555 end; 556 557 if blkptr = null 558 then return; 559 else if blk.audit_file_header_ptr ^= null 560 then 561 do; 562 audit_file_header_ptr = blk.audit_file_header_ptr; 563 if ^(blk.current_flags.file_limit 564 & (audit_file_header.begin_component > audit_file_header.current_component 565 | (audit_file_header.begin_component = audit_file_header.current_component 566 & audit_file_header.begin_index >= audit_file_header.audit_index))) 567 then 568 do; 569 call hcs_$set_bc_seg (blk.audit_ptr, audit_file_header.audit_index * 9, p_code); 570 if p_code ^= 0 571 then goto RETURN; 572 573 /* Can't use the bit count setting feature of msf_manager_$adjust because it 574*will attempt to set the bit counts of the preceding components to max_length, 575*which is not the correct value. In any event, their bit counts have already 576*been set. */ 577 578 call 579 msf_manager_$adjust (blk.audit_fcb, audit_file_header.current_component, 580 9 * audit_file_header.audit_index, "011"b, p_code); 581 if p_code ^= 0 582 then goto RETURN; 583 end; 584 end; 585 if blk.temp_seg_ptr ^= null 586 then 587 do; 588 call release_temp_segment_ ("audit_", blk.temp_seg_ptr, p_code); 589 if p_code ^= 0 590 then goto RETURN; 591 end; 592 593 if blk.audit_fcb ^= null 594 then call msf_manager_$close (blk.audit_fcb); 595 RETURN: 596 revert any_other; 597 call hcs_$set_ips_mask (mask, 0); 598 return; 599 600 audit_close: 601 entry (p_iocb_ptr, p_code); 602 603 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 604 blkptr = p_iocb_ptr -> iocb.attach_data_ptr; 605 if blk.audit_file_header_ptr ^= null 606 then call hcs_$set_safety_sw_seg (blk.audit_file_header_ptr, "0"b, p_code); 607 /* The audit_file_header_ptr always points to the base of component 0 in the audit file. The safety switch on component 0 is on when audit is attached and off when it isn't.*/ 608 call hcs_$set_ips_mask (0, mask); 609 audited_iocb -> iocb.open_descrip_ptr = null (); 610 audited_iocb -> iocb.detach_iocb = audit_detach; 611 call iox_$propagate (audited_iocb); 612 call hcs_$set_ips_mask (mask, 0); 613 p_code = 0; 614 return; 615 616 /* */ 617 618 /* The following are dummy entries that pass on the given request */ 619 620 audit_get_chars: 621 entry (p_iocb_ptr, p_buff_ptr, p_buff_len, p_actual_len, p_code); 622 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 623 blkptr = audited_iocb -> iocb.attach_data_ptr; 624 auditing_iocb = blk.auditing_iocb; 625 call iox_$get_chars (auditing_iocb, p_buff_ptr, p_buff_len, p_actual_len, p_code); 626 if p_code ^= 0 627 then return; 628 if blk.current_flags.read_audit 629 then call audit_line ("IC", param_input_string); 630 p_code = 0; 631 return; 632 633 audit_modes: 634 entry (p_iocb_ptr, p_newmodes, p_oldmodes, p_code); 635 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 636 blkptr = audited_iocb -> iocb.attach_data_ptr; 637 auditing_iocb = blk.auditing_iocb; 638 audit_file_header_ptr = blk.audit_file_header_ptr; 639 if blk.current_flags.trace 640 then call audit_line ("TM", rtrim (p_newmodes) || NL); 641 unrecognized_modes = ""; 642 if length (rtrim (p_newmodes)) = 0 643 then 644 do; 645 call iox_$modes (blk.auditing_iocb, p_newmodes, p_oldmodes, p_code); 646 return; 647 end; 648 649 call mode_string_$parse (p_newmodes, addr (temp_area), mode_string_info_ptr, p_code); 650 if p_code ^= 0 651 then return; 652 653 if mode_string_info.version ^= mode_string_info_version_2 654 then call 655 sub_err_ (error_table_$unimplemented_version, myname, "s", null, 0, 656 "^/Unable to use the mode_string_info structure. Expecting version ^d, 657 received version ^d.", mode_string_info_version_2, mode_string_info.version); 658 if mode_string_info.number > 0 659 then if mode_string_info.modes (1).version ^= mode_value_version_3 660 then call 661 sub_err_ (error_table_$unimplemented_version, myname, "s", null, 0, 662 "^/Unable to use the mode_value structure. Expecting version ^d, 663 received version ^d.", mode_value_version_3, mode_string_info.modes (1).version); 664 665 MODE_LOOP: 666 do mode_idx = 1 to mode_string_info.number; 667 newmodes = mode_string_info.modes (mode_idx).mode_name; 668 if index (newmodes, "audit_") = 1 669 then if newmodes = "audit_suspend" 670 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 671 then 672 do; 673 p_code = error_table_$bad_mode_syntax; 674 return; 675 end; 676 else if mode_string_info.modes (mode_idx).boolean_value 677 then 678 do; 679 if ^blk.suspend 680 then call suspend_auditing ("", null); 681 end; 682 else 683 do; 684 string (blk.current_flags) = string (blk.saved_flags); 685 blk.suspend = "0"b; 686 end; 687 688 else if blk.suspend 689 then call 690 ioa_$ioa_switch (auditing_iocb, 691 "audit_: auditing suspended, no audit_ modes operations allowed except ^^audit_suspend"); 692 else if newmodes = "audit_input" 693 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 694 then 695 do; 696 p_code = error_table_$bad_mode_syntax; 697 return; 698 end; 699 else blk.current_flags.read_audit = mode_string_info.modes (mode_idx).flags.boolean_value; 700 else if newmodes = "audit_transparent" 701 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 702 then 703 do; 704 p_code = error_table_$bad_mode_syntax; 705 return; 706 end; 707 else if mode_string_info.modes (mode_idx).flags.boolean_value 708 then blk.default_iocb = auditing_iocb; 709 else blk.default_iocb = audited_iocb; 710 711 else if newmodes = "audit_file_size" 712 then if mode_string_info.modes (mode_idx).flags.boolean_valuep 713 then 714 do; 715 p_code = error_table_$bad_mode_syntax; 716 return; 717 end; 718 else if mode_string_info.modes (mode_idx).flags.char_valuep 719 then if mode_string_info.modes (mode_idx).char_value = "unlimited" 720 then 721 do; 722 blk.begin_ptr = audit_file_header_ptr; 723 audit_file_header.begin_component = 0; 724 audit_file_header.begin_index = 725 size (audit_file_header) * 4 + 7 - mod (size (audit_file_header) * 4 + 7, 8); 726 audit_file_header.max_index = audit_file_header.audit_index; 727 audit_file_header.max_component = audit_file_header.current_component; 728 audit_file_header.filled = "0"b; 729 blk.current_flags.file_limit = "0"b; 730 end; 731 else 732 do; 733 p_code = error_table_$bad_mode_value; 734 return; 735 end; 736 737 else 738 do; 739 records = mode_string_info.modes (mode_idx).numeric_value; 740 if records <= 0 741 then 742 do; 743 p_code = error_table_$bad_mode_value; 744 return; 745 end; 746 audit_file_header.max_component = divide (records, 256, 17, 0); 747 audit_file_header.max_index = 4096 * (records - audit_file_header.max_component * 256); 748 blk.current_flags.file_limit = "1"b; 749 end; 750 751 else if newmodes = "audit_output" 752 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 753 then 754 do; 755 p_code = error_table_$bad_mode_syntax; 756 return; 757 end; 758 else blk.current_flags.write_audit = mode_string_info.modes (mode_idx).flags.boolean_value; 759 else if newmodes = "audit_edit" 760 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 761 then 762 do; 763 p_code = error_table_$bad_mode_syntax; 764 return; 765 end; 766 else blk.current_flags.edit = mode_string_info.modes (mode_idx).flags.boolean_value; 767 else if newmodes = "audit_trace" 768 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 769 then 770 do; 771 p_code = error_table_$bad_mode_syntax; 772 return; 773 end; 774 else blk.current_flags.trace = mode_string_info.modes (mode_idx).flags.boolean_value; 775 else if newmodes = "audit_meter" 776 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 777 then 778 do; 779 p_code = error_table_$bad_mode_syntax; 780 return; 781 end; 782 else blk.current_flags.meter = mode_string_info.modes (mode_idx).flags.boolean_value; 783 else if newmodes = "audit_trigger" 784 then if ^mode_string_info.modes (mode_idx).flags.char_valuep 785 then 786 do; 787 p_code = error_table_$bad_mode_syntax; 788 return; 789 end; 790 else blk.trigger = mode_string_info.modes (mode_idx).char_value; 791 else if newmodes = "audit_use_editor_prompt" 792 then if ^mode_string_info.modes (mode_idx).flags.boolean_valuep 793 then 794 do; 795 p_code = error_table_$bad_mode_syntax; 796 return; 797 end; 798 else blk.current_flags.use_editor_prompt = mode_string_info.modes (mode_idx).flags.boolean_value; 799 else if newmodes = "audit_editor_prompt_string" | newmodes = "audit_epstr" 800 then if ^mode_string_info.modes (mode_idx).flags.char_valuep 801 then 802 do; 803 p_code = error_table_$bad_mode_syntax; 804 return; 805 end; 806 else blk.editor_prompt_string = mode_string_info.modes (mode_idx).char_value; 807 end MODE_LOOP; 808 call mode_string_$delete (mode_string_info_ptr, AUDIT_MODE_NAMES, unrecognized_modes, p_code); 809 if unrecognized_modes ^= "" & unrecognized_modes ^= "." 810 then 811 do; 812 813 /*** It is necessary to convert ll=NN and pl=NN, which mode_string_ produces, 814*into llNN and plNN, which is the only form the tty_ dim currently understands. 815*Hopefully, any other io module under audit_ which gets ll= and pl= modes will 816*also understand the other forms. 817**/ 818 if index (unrecognized_modes, "ll=") > 0 819 then unrecognized_modes = 820 before (rtrim (unrecognized_modes), "ll=") || "ll" || after (rtrim (unrecognized_modes), "ll="); 821 if index (unrecognized_modes, "pl=") > 0 822 then unrecognized_modes = 823 before (rtrim (unrecognized_modes), "pl=") || "pl" || after (rtrim (unrecognized_modes), "pl="); 824 825 call iox_$modes (blk.auditing_iocb, (unrecognized_modes), p_oldmodes, p_code); 826 end; 827 828 /**** vp: tr phx19369 , display old modes when input modes are only audit modes ****/ 829 830 else call iox_$modes (blk.auditing_iocb, "", p_oldmodes, p_code); 831 832 return; 833 834 835 836 audit_get_line: 837 entry (p_iocb_ptr, p_buff_ptr, p_buff_len, p_actual_len, p_code); 838 dcl file_char_array (0:sys_info$max_seg_size * 4) char (1) based (buff_ptr); 839 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 840 blkptr = audited_iocb -> iocb.attach_data_ptr; 841 auditing_iocb = blk.auditing_iocb; 842 buff_ptr = p_buff_ptr; 843 buff_len = p_buff_len; 844 GET_LINE: 845 if blk.work_space ^= null 846 then 847 do; /* set up input_string on temp_seg. */ 848 buff_ptr = blk.work_space; 849 actual_len = blk.work_space_len; 850 buff_len = sys_info$max_seg_size * 4; /* if input_string bigger than p_string, fill p_string and return long_record */ 851 /* if input_string smaller than p_string, fill p_string and return. */ 852 if actual_len > p_buff_len 853 then 854 do; 855 p_actual_len = p_buff_len; 856 param_input_string = substr (aut_input_string, 1, p_buff_len); 857 blk.work_space = addr (file_char_array (p_buff_len)); 858 blk.work_space_len = actual_len - p_buff_len; 859 p_code = error_table_$long_record; 860 return; 861 end; 862 else 863 do; 864 p_actual_len = actual_len; 865 param_input_string = aut_input_string; 866 blk.work_space = null; 867 blk.work_space_len = 0; 868 p_code = 0; 869 return; 870 end; 871 end; 872 873 else 874 do; 875 call iox_$get_line (auditing_iocb, p_buff_ptr, p_buff_len, p_actual_len, p_code); 876 if p_code ^= 0 877 then if p_code = error_table_$long_record 878 then 879 do; 880 blk.work_space = blk.temp_seg_ptr; 881 blk.work_space_len = sys_info$max_seg_size * 4; 882 buff_len = blk.work_space_len; 883 buff_ptr = blk.work_space; 884 actual_len = p_buff_len; 885 substr (aut_input_string, 1, actual_len) = substr (param_input_string, 1, p_actual_len); 886 buff_ptr = addr (file_char_array (actual_len)); 887 buff_len = buff_len - actual_len; 888 call iox_$get_line (auditing_iocb, buff_ptr, buff_len, actual_len, p_code); 889 if p_code ^= 0 890 then return; 891 buff_ptr = blk.temp_seg_ptr; 892 actual_len = actual_len + p_actual_len; 893 buff_len = blk.work_space_len; 894 blk.work_space_len = actual_len; 895 end; 896 else return; 897 898 else actual_len = p_actual_len; 899 MORE_GET_LINE: 900 if ^(blk.current_flags.edit & (actual_len > 2)) 901 then 902 do; 903 if blk.current_flags.read_audit 904 then call audit_line ("IL", aut_input_string); 905 end; 906 else if (substr (aut_input_string, actual_len - 2, 1) = blk.trigger) 907 then 908 do; 909 request = substr (aut_input_string, actual_len - 1, 1); 910 if request = "." 911 then 912 do; 913 if blk.current_flags.read_audit & (blk.default_iocb ^= blk.auditing_iocb) 914 then call audit_line ("IL", aut_input_string); 915 call 916 ioa_$ioa_switch (blk.default_iocb, "audit ^[input^]^[/^]^[output^]", 917 blk.current_flags.read_audit, blk.current_flags.read_audit & blk.current_flags.write_audit, 918 blk.current_flags.write_audit); 919 substr (aut_input_string, 1, actual_len - 2) = substr (aut_input_string, 1, actual_len - 3) || NL; 920 actual_len = actual_len - 2; 921 end; 922 else if request = "?" 923 then 924 do; 925 if blk.current_flags.read_audit & (blk.default_iocb ^= blk.auditing_iocb) 926 then call audit_line ("IL", aut_input_string); 927 call ioa_$ioa_switch (blk.default_iocb, "REQUESTS:"); 928 call ioa_$ioa_switch (blk.default_iocb, "^a. -> who am I", blk.trigger); 929 call ioa_$ioa_switch (blk.default_iocb, "^a? -> what can I do", blk.trigger); 930 call ioa_$ioa_switch (blk.default_iocb, "^ae -> enter editor", blk.trigger); 931 call 932 ioa_$ioa_switch (blk.default_iocb, "^aE -> enter editor, process input line as edit requests", 933 blk.trigger); 934 call ioa_$ioa_switch (blk.default_iocb, "^aa -> abbrev expand input line", blk.trigger); 935 call ioa_$ioa_switch (blk.default_iocb, "^ar -> replay input line", blk.trigger); 936 call 937 ioa_$ioa_switch (blk.default_iocb, "^at -> transparent input line (do not log)", blk.trigger); 938 call ioa_$ioa_switch (blk.default_iocb, "^ad -> delete line", blk.trigger); 939 call ioa_$ioa_switch (blk.default_iocb, "^an -> no operation", blk.trigger); 940 call 941 ioa_$ioa_switch (blk.default_iocb, "NOTE: above requests recognized only in audit_edit mode"); 942 substr (aut_input_string, 1, actual_len - 2) = substr (aut_input_string, 1, actual_len - 3) || NL; 943 actual_len = actual_len - 2; 944 end; 945 else if request = "r" 946 then 947 do; 948 call ioa_$ioa_switch_nnl (blk.default_iocb, "^a", substr (aut_input_string, 1, actual_len - 3)); 949 call 950 iox_$get_line (auditing_iocb, addr (file_char_array (actual_len - 3)), 951 buff_len - actual_len + 3, tactual_len, p_code); 952 if p_code ^= 0 953 then if p_code ^= error_table_$long_record 954 then return; 955 else if blk.work_space ^= null 956 then return; 957 else 958 do; 959 blk.work_space = blk.temp_seg_ptr; 960 blk.work_space_len = sys_info$max_seg_size * 4; 961 buff_ptr = blk.temp_seg_ptr; 962 buff_len = blk.work_space_len; 963 actual_len = tactual_len + actual_len - 3; 964 substr (aut_input_string, 1, actual_len) = substr (param_input_string, 1, actual_len); 965 966 buff_ptr = addr (file_char_array (actual_len)); 967 buff_len = buff_len - actual_len; 968 call iox_$get_line (default_iocb, buff_ptr, buff_len, tactual_len, p_code); 969 if p_code ^= 0 970 then return; 971 buff_ptr = blk.temp_seg_ptr; 972 buff_len = blk.work_space_len; 973 actual_len = actual_len + tactual_len; 974 blk.work_space_len = actual_len; 975 end; 976 else actual_len = actual_len + tactual_len - 3; 977 goto MORE_GET_LINE; 978 end; 979 else if request = "e" | request = "E" 980 then 981 do; 982 if blk.current_flags.read_audit & (blk.default_iocb ^= blk.auditing_iocb) 983 then call audit_line ("IL", aut_input_string); 984 blk.work_space = null; 985 call audit_editor (buff_ptr, buff_len, actual_len, audited_iocb, p_code); 986 if p_code ^= 0 987 then if p_code = error_table_$empty_file 988 then call ioa_$ioa_switch (blk.default_iocb, "audit_: Can't edit, the audit file is empty."); 989 else call ioa_$ioa_switch (blk.default_iocb, "audit_: Error attempting to use editor."); 990 else 991 do; 992 set_last_return_line_position = "1"b; 993 if blk.current_flags.read_audit 994 then call audit_line ("EL", aut_input_string); 995 end; 996 end; 997 else if request = "a" 998 then 999 do; 1000 if blk.current_flags.read_audit & (blk.default_iocb ^= blk.auditing_iocb) 1001 then call audit_line ("IL", aut_input_string); 1002 substr (aut_input_string, 1, actual_len - 2) = substr (aut_input_string, 1, actual_len - 3) || NL; 1003 actual_len = actual_len - 2; 1004 call abbrev_$expanded_line (buff_ptr, (actual_len), addr (ab_buf), 512, out_ptr, ab_len); 1005 if ab_len > 512 1006 then if ab_len > buff_len 1007 then 1008 do; 1009 buff_ptr = blk.temp_seg_ptr; 1010 buff_len = ab_len; 1011 actual_len = ab_len; 1012 buff_ptr -> aut_input_string = out_ptr -> aut_input_string; 1013 free out_ptr -> aut_input_string; 1014 end; 1015 else 1016 do; 1017 buff_len = ab_len; 1018 actual_len = ab_len; 1019 buff_ptr -> aut_input_string = out_ptr -> aut_input_string; 1020 free out_ptr -> aut_input_string; 1021 end; 1022 else if ab_len > buff_len 1023 then 1024 do; 1025 buff_ptr = blk.temp_seg_ptr; 1026 buff_len = ab_len; 1027 actual_len = ab_len; 1028 aut_input_string = substr (ab_buf, 1, ab_len); 1029 end; 1030 else 1031 do; 1032 actual_len = ab_len; 1033 substr (aut_input_string, 1, ab_len) = substr (ab_buf, 1, ab_len); 1034 end; 1035 end; 1036 else if request = "d" 1037 then 1038 do; 1039 blk.work_space = null; 1040 blk.work_space_len = 0; 1041 buff_ptr = p_buff_ptr; 1042 buff_len = p_buff_len; 1043 actual_len = 0; 1044 goto GET_LINE; 1045 end; 1046 else if request = "n" 1047 then 1048 do; 1049 if blk.current_flags.read_audit & (blk.default_iocb ^= blk.auditing_iocb) 1050 then call audit_line ("IL", aut_input_string); 1051 actual_len = actual_len - 2; 1052 substr (aut_input_string, actual_len, 1) = NL; 1053 end; 1054 else if request = "t" 1055 then 1056 do; 1057 actual_len = actual_len - 2; 1058 substr (aut_input_string, actual_len, 1) = NL; 1059 end; 1060 else if blk.current_flags.read_audit 1061 then call audit_line ("IL", aut_input_string); 1062 end; 1063 else if blk.current_flags.read_audit 1064 then call audit_line ("IL", aut_input_string); 1065 1066 if actual_len > p_buff_len 1067 then 1068 do; 1069 p_actual_len = p_buff_len; 1070 param_input_string = substr (aut_input_string, 1, p_buff_len); 1071 blk.work_space = addr (file_char_array (p_buff_len)); 1072 blk.work_space_len = actual_len - p_buff_len; 1073 p_code = error_table_$long_record; 1074 return; 1075 end; 1076 else 1077 do; 1078 p_actual_len = actual_len; 1079 param_input_string = substr (aut_input_string, 1, actual_len); 1080 blk.work_space = null; 1081 blk.work_space_len = 0; 1082 p_code = 0; 1083 return; 1084 end; 1085 p_code = 0; 1086 return; 1087 end; 1088 1089 1090 audit_put_chars: 1091 entry (p_iocb_ptr, p_buff_ptr, p_buff_len, p_code); 1092 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 1093 blkptr = audited_iocb -> iocb.attach_data_ptr; 1094 auditing_iocb = blk.auditing_iocb; 1095 call iox_$put_chars (auditing_iocb, p_buff_ptr, p_buff_len, p_code); 1096 if p_code ^= 0 1097 then return; 1098 if blk.current_flags.write_audit 1099 then call audit_line ("OC", param_output_string); 1100 p_code = 0; 1101 return; 1102 1103 1104 audit_position: 1105 entry (p_iocb_ptr, ptype, n, p_code); 1106 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 1107 blkptr = audited_iocb -> iocb.attach_data_ptr; 1108 auditing_iocb = blk.auditing_iocb; 1109 call iox_$position (auditing_iocb, ptype, n, p_code); 1110 return; 1111 1112 1113 audit_control: 1114 entry (p_iocb_ptr, p_real_order, p_info_ptr, p_code); 1115 1116 audited_iocb = p_iocb_ptr -> iocb.actual_iocb_ptr; 1117 blkptr = audited_iocb -> iocb.attach_data_ptr; 1118 audit_file_header_ptr = blk.audit_file_header_ptr; 1119 if blk.current_flags.trace 1120 then call audit_line ("TC", p_real_order || NL); 1121 order = p_real_order; 1122 if substr (order, 1, 6) = "audit_" 1123 then 1124 do; 1125 order = substr (order, 7); 1126 if order = "truncate" 1127 then 1128 do; 1129 audit_file_header.current_component = 0; 1130 call 1131 msf_manager_$adjust (blk.audit_fcb, 0, 1132 ((4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8)) * 9, "110"b, 1133 p_code); 1134 call truncate_audit_file; 1135 audit_file_header.begin_index = audit_file_header.audit_index; 1136 audit_file_header.begin_component = 0; 1137 audit_file_header.filled = "0"b; 1138 blk.begin_ptr = blk.audit_ptr; 1139 end; 1140 else if order = "modes" 1141 then 1142 do; 1143 p_info_ptr -> mode_str = mode_string (p_code); 1144 end; 1145 else 1146 do; 1147 call iox_$control (blk.auditing_iocb, p_real_order, p_info_ptr, p_code); 1148 return; 1149 end; 1150 end; 1151 else if order = "io_call" 1152 then if p_info_ptr -> io_call_info.order_name = "audit_modes" 1153 then 1154 do; 1155 call p_info_ptr -> io_call_info.report ("audit modes: ^a", mode_string (p_code)); 1156 return; 1157 end; 1158 else 1159 do; 1160 call iox_$control (blk.auditing_iocb, p_real_order, p_info_ptr, p_code); 1161 return; 1162 end; 1163 else if order = "resetread" | order = "abort" 1164 then 1165 do; 1166 blk.work_space = null; 1167 blk.work_space_len = 0; 1168 call iox_$control (blk.auditing_iocb, p_real_order, p_info_ptr, p_code); 1169 return; 1170 end; 1171 else 1172 do; 1173 call iox_$control (blk.auditing_iocb, p_real_order, p_info_ptr, p_code); 1174 return; 1175 end; 1176 p_code = 0; 1177 return; 1178 1179 /* */ 1180 1181 audit_line: 1182 proc (p_tag, p_string); 1183 dcl 1 position like position_template; 1184 dcl 1 previous_position like position_template; 1185 dcl 1 position_info like position_info_template; 1186 dcl bytes_required fixed bin (24); 1187 dcl max_entry_size fixed bin (24); 1188 dcl room_for_insertion fixed bin (24); 1189 dcl trim_entry bit (1) init ("0"b); 1190 dcl p_tag char (*); 1191 dcl p_string char (*); 1192 1193 call hcs_$set_ips_mask (0, mask); 1194 1195 on any_other 1196 begin; 1197 call force_audit_suspension; 1198 goto RETURN; 1199 end; 1200 1201 audit_file_header_ptr = blk.audit_file_header_ptr; 1202 position.aep = null; 1203 bytes_required = length (p_string) + 7 - mod (length (p_string) + 7, 8) + (4 * size (audit_entry)); 1204 1205 call set_max_entry_size; 1206 if bytes_required > max_entry_size 1207 then 1208 do; 1209 bytes_required = max_entry_size; 1210 trim_entry = "1"b; 1211 end; 1212 1213 call get_room_for_insertion; 1214 do while (bytes_required > room_for_insertion); 1215 call adjust_indices; 1216 call get_room_for_insertion; 1217 end; 1218 1219 call set_position_info; 1220 1221 call insert (p_tag, p_string); 1222 if set_last_return_line_position 1223 then 1224 do; 1225 set_last_return_line_position = "0"b; 1226 call audit_editor$set_last_return_line_position (addr (position)); 1227 end; 1228 1229 RETURN: 1230 revert any_other; 1231 call hcs_$set_ips_mask (mask, 0); 1232 return; 1233 1234 set_max_entry_size: 1235 proc; 1236 if ^blk.current_flags.file_limit 1237 then max_entry_size = sys_info$max_seg_size * 4; 1238 else if audit_file_header.max_component > 1 1239 then max_entry_size = sys_info$max_seg_size * 4; 1240 else if audit_file_header.max_component = 1 1241 then max_entry_size = 1242 max (audit_file_header.max_index, 1243 sys_info$max_seg_size * 4 1244 - ((4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8))); 1245 else max_entry_size = 1246 audit_file_header.max_index 1247 - ((4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8)); 1248 end; 1249 1250 get_room_for_insertion: 1251 proc; 1252 if ^blk.current_flags.file_limit 1253 then room_for_insertion = sys_info$max_seg_size * 4 - audit_file_header.audit_index; 1254 else if (audit_file_header.begin_component = audit_file_header.current_component) 1255 & (audit_file_header.begin_index >= audit_file_header.audit_index) & audit_file_header.filled 1256 then room_for_insertion = audit_file_header.begin_index - audit_file_header.audit_index; 1257 else if audit_file_header.current_component = audit_file_header.max_component 1258 then room_for_insertion = audit_file_header.max_index - audit_file_header.audit_index; 1259 else room_for_insertion = sys_info$max_seg_size * 4 - audit_file_header.audit_index; 1260 end; 1261 1262 adjust_indices: 1263 proc; 1264 if ^blk.current_flags.file_limit 1265 then call next_component (audit_file_header.current_component, audit_file_header.audit_index, blk.audit_ptr); 1266 else if audit_file_header.begin_component = audit_file_header.current_component 1267 & audit_file_header.begin_index >= audit_file_header.audit_index & audit_file_header.filled 1268 then 1269 do; 1270 position.aep = addr (blk.begin_ptr -> file_char_array (audit_file_header.begin_index)); 1271 call hcs_$status_mins (blk.begin_ptr, type, bit_count24, p_code); 1272 if audit_file_header.begin_index + (4 * currentsize (position.aep -> audit_entry)) + 7 1273 - mod ((4 * currentsize (position.aep -> audit_entry)) + 7, 8) >= divide (bit_count24, 9, 24, 0) 1274 then call next_component (audit_file_header.begin_component, audit_file_header.begin_index, blk.begin_ptr); 1275 else audit_file_header.begin_index = 1276 audit_file_header.begin_index + (4 * currentsize (position.aep -> audit_entry)) + 7 1277 - mod ((4 * currentsize (position.aep -> audit_entry)) + 7, 8); 1278 end; 1279 else call next_component (audit_file_header.current_component, audit_file_header.audit_index, blk.audit_ptr); 1280 end; 1281 1282 next_component: 1283 proc (p_component_number, p_component_index, p_component_ptr); 1284 dcl p_component_number fixed bin (17); 1285 dcl p_component_index fixed bin (24); 1286 dcl p_component_ptr ptr; 1287 1288 call hcs_$set_bc_seg (blk.audit_ptr, audit_file_header.audit_index * 9, p_code); 1289 if p_component_number = audit_file_header.max_component & blk.current_flags.file_limit 1290 then 1291 do; 1292 p_component_number = 0; 1293 p_component_index = (4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8); 1294 p_component_ptr = audit_file_header_ptr; 1295 audit_file_header.filled = "1"b; 1296 end; 1297 else 1298 do; 1299 p_component_number = p_component_number + 1; 1300 if ^blk.current_flags.file_limit 1301 then audit_file_header.max_component = p_component_number; 1302 p_component_index = 0; 1303 call msf_manager_$get_ptr (blk.audit_fcb, p_component_number, "1"b, p_component_ptr, bit_count24, p_code); 1304 end; 1305 end; 1306 1307 set_position_info: 1308 proc; 1309 position_info.last_entry_length = audit_file_header.last_entry_length; 1310 position_info.max_component = audit_file_header.max_component; 1311 position_info.max_index = audit_file_header.max_index; 1312 position_info.begin_component = audit_file_header.begin_component; 1313 position_info.begin_index = audit_file_header.begin_index; 1314 position_info.current_component = audit_file_header.current_component; 1315 position_info.audit_index = audit_file_header.audit_index; 1316 position_info.audit_fcb = blk.audit_fcb; 1317 position_info.audit_ptr = blk.audit_ptr; 1318 position_info.default_search_tag = ""; 1319 position_info.any_tag = "1"b; 1320 position_info.dirname = blk.dirname; 1321 position_info.ename = blk.ename; 1322 position_info.file_limit = audit_file_header.filled; 1323 position.char_index = audit_file_header.audit_index; 1324 position.component_number = audit_file_header.current_component; 1325 position.component_ptr = blk.audit_ptr; 1326 if position.component_number = audit_file_header.max_component & blk.current_flags.file_limit 1327 then position.component_max_char_index = audit_file_header.max_index; 1328 else position.component_max_char_index = sys_info$max_seg_size * 4; 1329 position.search_tag = ""; 1330 position.entry_number = 0; 1331 end; 1332 1333 insert: 1334 proc (p_tag, p_string); 1335 dcl p_string char (*); 1336 dcl p_tag char (*); 1337 dcl virtual_time fixed bin (71); 1338 dcl paging fixed bin; 1339 dcl dev_paging fixed bin; 1340 dcl month fixed bin; 1341 dcl day fixed bin; 1342 dcl year fixed bin; 1343 dcl dow fixed bin; 1344 dcl zone char (3) aligned; 1345 dcl file_char_array (0:sys_info$max_seg_size * 4) char (1) unaligned based (blk.audit_ptr); 1346 position.aep = addr (file_char_array (audit_file_header.audit_index)); 1347 1348 if blk.current_flags.meter 1349 then 1350 do; 1351 call cpu_time_and_paging_ (paging, virtual_time, dev_paging); 1352 previous_position = position; 1353 call audit_file_position_$last (addr (previous_position), addr (position_info), p_code); 1354 if p_code = 0 1355 then 1356 do; 1357 previous_position.aep -> audit_entry.virtual_time = virtual_time - blk.virtual_time; 1358 previous_position.aep -> audit_entry.paging = paging - blk.paging; 1359 end; 1360 1361 call decode_clock_value_ (clock, day, month, year, position.aep -> audit_entry.time, dow, zone); 1362 blk.virtual_time = virtual_time; 1363 blk.paging = paging; 1364 end; 1365 else position.aep -> audit_entry.time = -1; 1366 1367 position.aep -> audit_entry.last_entry_length = audit_file_header.last_entry_length; 1368 if trim_entry 1369 then p_string = substr (p_string, 1, bytes_required - (4 * size (position.aep -> audit_entry))); 1370 position.aep -> audit_entry.entry_length = length (p_string); 1371 position.aep -> audit_entry.tag = p_tag; 1372 position.aep -> audit_entry.string = p_string; 1373 position.aep -> audit_entry.virtual_time = -1; 1374 position.aep -> audit_entry.paging = -1; 1375 audit_file_header.last_entry_length = position.aep -> audit_entry.entry_length; 1376 audit_file_header.audit_index = audit_file_header.audit_index + 4 * currentsize (position.aep -> audit_entry); 1377 audit_file_header.audit_index = audit_file_header.audit_index + 7 - mod (audit_file_header.audit_index + 7, 8); 1378 if ^blk.current_flags.file_limit 1379 then audit_file_header.max_index = audit_file_header.audit_index; 1380 return; 1381 end; 1382 1383 end audit_line; 1384 1385 /* */ 1386 1387 force_audit_suspension: 1388 proc; 1389 dcl 1 info aligned, 1 1 /* BEGIN INCLUDE FILE ... cond_info.incl.pl1 1 2* coded by M. Weaver 12 July 1973 */ 1 3 1 4 2 mcptr ptr, /* ptr to machine conditions at time of fault */ 1 5 2 version fixed bin, /* version of this structure (now=1) */ 1 6 2 condition_name char(32) var, /* name of condition */ 1 7 2 infoptr ptr, /* ptr to software info structure */ 1 8 2 wcptr ptr, /* ptr to wall crossing machine conditions */ 1 9 2 loc_ptr ptr, /* ptr to location where condition occurred */ 1 10 2 flags aligned, 1 11 3 crawlout bit(1) unal, /* = "1"b if condition occurred in inner ring */ 1 12 3 pad1 bit(35) unal, 1 13 2 pad_word bit(36) aligned, 1 14 2 user_loc_ptr ptr, /* ptr to last non-support loc before condition */ 1 15 2 pad (4) bit(36) aligned; 1 16 1 17 /* END INCLUDE FILE ... cond_info.incl.pl1 */ 1390 1391 1392 dcl find_condition_info_ entry (ptr, ptr, fixed bin (35)); 1393 1394 call find_condition_info_ (null (), addr (info), p_code); 1395 call suspend_auditing (info.condition_name, info.loc_ptr); 1396 end force_audit_suspension; 1397 1398 suspend_auditing: 1399 proc (condition, p_ptr); 1400 dcl condition char (32) varying; 1401 dcl p_ptr ptr; 1402 if blk.suspend 1403 then return; 1404 blk.suspend = "1"b; 1405 string (blk.saved_flags) = string (blk.current_flags); 1406 string (blk.current_flags) = "0"b; 1407 if condition ^= "" 1408 then call ioa_$ioa_switch (p_iocb_ptr, "audit_: ^a on audit file by ^p, auditing suspended.", condition, p_ptr); 1409 return; 1410 end suspend_auditing; 1411 1412 mode_string: 1413 proc (p_code) returns (char (512) varying); 1414 dcl p_code fixed bin (35); 1415 dcl modes char (512); 1416 dcl mode_idx fixed bin (17); 1417 1418 audit_file_header_ptr = blk.audit_file_header_ptr; 1419 modes = ""; 1420 number_of_modes = 10; 1421 alloc mode_string_info in (temp_area); 1422 mode_string_info.version = mode_string_info_version_2; 1423 MODE_LOOP: 1424 do mode_idx = 1 to hbound (mode_string_info.modes, 1); 1425 mode_value_ptr = addr (mode_string_info.modes (mode_idx)); 1426 mode_value.flags = "0"b; 1427 mode_value.boolean_value = "0"b; 1428 mode_value.char_value = ""; 1429 mode_value.numeric_value = 0; 1430 goto MODE (mode_idx); 1431 1432 MODE (1): 1433 mode_value.mode_name = "audit_input"; 1434 mode_value.flags.boolean_valuep = "1"b; 1435 mode_value.boolean_value = blk.current_flags.read_audit; 1436 goto NEXT_MODE; 1437 1438 MODE (2): 1439 mode_value.mode_name = "audit_output"; 1440 mode_value.flags.boolean_valuep = "1"b; 1441 mode_value.boolean_value = blk.current_flags.write_audit; 1442 goto NEXT_MODE; 1443 1444 MODE (3): 1445 mode_value.mode_name = "audit_edit"; 1446 mode_value.flags.boolean_valuep = "1"b; 1447 mode_value.boolean_value = blk.current_flags.edit; 1448 goto NEXT_MODE; 1449 1450 MODE (4): 1451 mode_value.mode_name = "audit_trace"; 1452 mode_value.flags.boolean_valuep = "1"b; 1453 mode_value.boolean_value = blk.current_flags.trace; 1454 goto NEXT_MODE; 1455 1456 MODE (5): 1457 mode_value.mode_name = "audit_meter"; 1458 mode_value.flags.boolean_valuep = "1"b; 1459 mode_value.boolean_value = blk.current_flags.meter; 1460 goto NEXT_MODE; 1461 1462 MODE (6): 1463 mode_value.mode_name = "audit_transparent"; 1464 mode_value.flags.boolean_valuep = "1"b; 1465 mode_value.boolean_value = (blk.default_iocb = blk.auditing_iocb); 1466 goto NEXT_MODE; 1467 1468 MODE (7): 1469 mode_value.mode_name = "audit_trigger"; 1470 mode_value.flags.char_valuep = "1"b; 1471 mode_value.char_value = blk.trigger; 1472 goto NEXT_MODE; 1473 1474 MODE (8): 1475 mode_value.mode_name = "audit_file_size"; 1476 if blk.current_flags.file_limit 1477 then 1478 do; 1479 mode_value.flags.numeric_valuep = "1"b; 1480 mode_value.numeric_value = 1481 (audit_file_header.max_component * 256) + divide (audit_file_header.max_index, 4096, 17, 0); 1482 end; 1483 else 1484 do; 1485 mode_value.flags.char_valuep = "1"b; 1486 mode_value.char_value = "unlimited"; 1487 end; 1488 goto NEXT_MODE; 1489 1490 MODE (9): 1491 mode_value.mode_name = "audit_use_editor_prompt"; 1492 mode_value.flags.boolean_valuep = "1"b; 1493 mode_value.boolean_value = blk.current_flags.use_editor_prompt; 1494 goto NEXT_MODE; 1495 1496 MODE (10): 1497 mode_value.mode_name = "audit_editor_prompt_string"; 1498 mode_value.flags.char_valuep = "1"b; 1499 mode_value.char_value = blk.editor_prompt_string; 1500 goto NEXT_MODE; 1501 1502 NEXT_MODE: 1503 end MODE_LOOP; 1504 1505 call mode_string_$combine (mode_string_info_ptr, null, modes, p_code); 1506 1507 return (modes); 1508 1509 end mode_string; 1510 1511 truncate_audit_file: 1512 proc; 1513 1514 /* This program always sets up afh and blk.audit_ptr for 1515* afh.current_component = 0. 1516**/ 1517 1518 audit_file_header_ptr = blk.audit_file_header_ptr; 1519 call msf_manager_$get_ptr (blk.audit_fcb, 0, "1"b, blk.audit_ptr, bit_count24, p_code); 1520 if p_code ^= 0 1521 then 1522 do; 1523 call com_err_ (p_code, "audit_"); 1524 return; 1525 end; 1526 audit_file_header.audit_index = (4 * size (audit_file_header)) + 7 - mod ((4 * size (audit_file_header)) + 7, 8); 1527 audit_file_header.last_entry_length = impossible_audit_entry_length; 1528 end truncate_audit_file; 1529 1530 /* */ 1531 2 1 /* BEGIN INCLUDE FILE audit_block.incl.pl1 */ 2 2 2 3 /* 2 4* 12/08/78 Written by Lindsey L. Spratt 2 5* Modified: 2 6* 11/26/79 by Lindsey L. Spratt to add editor prompting info, 2 7* use_editor_prompt, 2 8* editor_prompt_string, and 2 9* editor_prompt_terminator. 2 10* 03/20/81 by Lindsey L. Spratt to remove editor_prompt_terminator. 2 11**/ 2 12 2 13 2 14 /* format: style2 */ 2 15 dcl 1 blk based (blkptr) aligned, 2 16 2 auditing_iocb ptr, /* Points to iocb of dummy switch. */ 2 17 2 attach char (128) var, /* For the attach description. */ 2 18 2 suspend bit (1), /* Indicates suspension of auditing. */ 2 19 2 current_flags, /* These switches indicate the modes for audit_. */ 2 20 3 read_audit bit (1) unaligned, /* Set by audit_input. */ 2 21 3 file_limit bit (1) unaligned, /* Set by audit_file_size=n. */ 2 22 3 write_audit bit (1) unaligned, /* Set by write_audit. */ 2 23 3 edit bit (1) unaligned, /* Set by audit_edit. */ 2 24 3 trace bit (1) unaligned, /* Set by audit_trace. */ 2 25 3 meter bit (1) unaligned, /* Set by audit_meter. */ 2 26 3 use_editor_prompt 2 27 bit (1) unaligned, /* Indicates whether to prompt in the audit editor. */ 2 28 3 unused bit (29) unaligned, 2 29 2 saved_flags like blk.current_flags, /* Copy of old current_flags, prior to suspension. */ 2 30 2 dirname char (168) unal, /* Directory of audit_file. */ 2 31 2 ename char (32) unal, /* Entryname of audit_file. */ 2 32 2 paging fixed bin (35), /* Total page faults in process since attachment. */ 2 33 2 pad bit (36), 2 34 2 virtual_time fixed bin (71), /* Total virtual cpu time since attachment. */ 2 35 2 audit_fcb ptr, /* File control block pointer for the audit_file. */ 2 36 2 audit_ptr ptr, /* Points to current segment in audit_file. */ 2 37 2 begin_ptr ptr, 2 38 2 audit_file_header_ptr 2 39 ptr, /* Points to audit_file_header (in audit_file) */ 2 40 2 trigger char (1), /* Character used to indicate an audit_ request. */ 2 41 2 editor_prompt_string 2 42 char (32) varying, /* This an ioa_ control string taking 2 43* two arguments, 1) bit(1) indicating level > 1; 2 44* 2) level. 2 45* */ 2 46 2 default_iocb ptr, /* Points to the iocb to be used for input and output. */ 2 47 2 temp_seg_ptr ptr, /* Points to the temp seg used as a buffer for input. */ 2 48 2 work_space ptr, /* Points to the beginning of buffer for get_line. */ 2 49 2 work_space_len fixed bin (24); /* Length of string in work_space buffer. */ 2 50 2 51 2 52 /* END INCLUDE FILE audit_block.incl.pl1 */ 1532 1533 3 1 /* ****************************************************** 3 2* * * 3 3* * * 3 4* * Copyright (c) 1972 by Massachusetts Institute of * 3 5* * Technology and Honeywell Information Systems, Inc. * 3 6* * * 3 7* * * 3 8* ****************************************************** */ 3 9 3 10 /* BEGIN INCLUDE FILE audit_entry.incl.pl1 */ 3 11 3 12 /* 3 13* This structure is the format of an entry in the audit file. It is not intended to be 3 14* allocated, but overlayed (note the 0 refer for string). 3 15* 3 16* 12/08/78 Written by Lindsey L. Spratt 3 17* 3 18**/ 3 19 3 20 dcl impossible_audit_entry_length fixed bin (24) aligned static init (9999999) options (constant), 3 21 audit_entry_header_length fixed bin aligned static init (32) options (constant); 3 22 3 23 dcl aep ptr; 3 24 dcl 1 audit_entry aligned based (aep), 3 25 2 time fixed bin (71), /* Value is either time of day of entry, or -1. */ 3 26 2 virtual_time fixed bin (71), /* Virtual cpu time from this entry to the next. */ 3 27 2 paging fixed bin (24), /* Paging from this entry to the next. */ 3 28 2 last_entry_length fixed bin (24), /* Length of last entry's string. */ 3 29 2 entry_length fixed bin (24), /* Length of this entry's string. */ 3 30 2 tag char (2), /* Denotes class of entry (e.g., "IL"). */ 3 31 2 string char (0 refer (audit_entry.entry_length)); /* Text of this entry. */ 3 32 3 33 /* END INCLUDE FILE audit_entry.incl.pl1 */ 1534 1535 4 1 /* ****************************************************** 4 2* * * 4 3* * * 4 4* * Copyright (c) 1972 by Massachusetts Institute of * 4 5* * Technology and Honeywell Information Systems, Inc. * 4 6* * * 4 7* * * 4 8* ****************************************************** */ 4 9 4 10 /* BEGIN INCLUDE FILE audit_file_header.incl.pl1 */ 4 11 4 12 /* 4 13* This structure is recorded in the audit_file starting at byte 0. It describes 4 14* the length of the file, the length of the last entry string and where the 4 15* beginning of the file is. 4 16* 4 17* Written 09/12/78 by Lindsey Spratt 4 18* Modified: 4 19* 01/15/79 by Lindsey L. Spratt to align structure, increase size 4 20* of byte offset variables to fixed bin(24), and add 4 21* pad1 and pad2. 4 22**/ 4 23 4 24 dcl audit_file_header_length fixed bin init (64) options (constant) int static; 4 25 dcl audit_file_header_version_1 fixed bin init (1) options (constant) int static; 4 26 dcl audit_file_header_ptr ptr; 4 27 dcl 1 audit_file_header based (audit_file_header_ptr) aligned, 4 28 2 version fixed bin (17), 4 29 2 audit_index fixed bin (24), /* The offset in bytes of where the next entry would start. */ 4 30 2 current_component fixed bin (17), /* The largest component number used. */ 4 31 2 begin_index fixed bin (24), /* The byte offset of the beginning of the file. */ 4 32 2 begin_component fixed bin (17), /* Component containing beginning of file. */ 4 33 2 max_index fixed bin (24), /* Byte offset of the largest possible position. */ 4 34 2 max_component fixed bin (17), /* Component containing largest possible position. */ 4 35 2 last_entry_length fixed bin (24), /* The length of the last entry string. */ 4 36 2 filled bit (1) unal, 4 37 2 unused1 bit (35) unal, 4 38 2 pad2 (7) fixed bin (35); 4 39 4 40 4 41 /* END INCLUDE FILE audit_file_header.incl.pl1 */ 1536 1537 5 1 /* BEGIN INCLUDE FILE audit_position.incl.pl1 */ 5 2 5 3 5 4 5 5 /* 5 6* 12/08/78 Written by Lindsey L. Spratt 5 7**/ 5 8 5 9 /* format: style2 */ 5 10 dcl 1 position_template, 5 11 2 aep ptr, /* points to an entry. Base of audit_entry struc. */ 5 12 2 char_index fixed bin (24), /* Offset in bytes in audit_file of aep. */ 5 13 2 entry_number fixed bin (35), /* Count of entry from beginning of file. */ 5 14 2 search_tag char (32) varying, /* Search tag in effect when this entry found. */ 5 15 2 component_ptr ptr, /* Points to component of audit_file containing entry. */ 5 16 2 component_number fixed bin, /* NUmber of component containing entry. */ 5 17 2 component_max_char_index 5 18 fixed bin (24); /* Max allowed byte offset in current component. */ 5 19 5 20 5 21 dcl 1 position_info_template, 5 22 2 max_component fixed bin (17), /* Max allowed component number of audit_file. */ 5 23 2 max_index fixed bin (24), /* Max possible byte offset in max component. */ 5 24 2 current_component fixed bin (17), /* Component currently in use by audit_. */ 5 25 2 audit_fcb ptr, /* File control block pointer for audit_file. */ 5 26 2 audit_ptr ptr, /* Points to audit_file component currently in use by audit. */ 5 27 2 audit_index fixed bin (24), /* Byte offset in current component of next entry by audit_. */ 5 28 2 last_entry_length fixed bin (24), /* Length of last entry made by audit_. */ 5 29 2 begin_index fixed bin (24), /* Byte offset in begin component of begining of file. */ 5 30 2 begin_component fixed bin (17), /* Component containing beginning of file. */ 5 31 2 dirname char (168), /* Directory name of audit file. */ 5 32 2 ename char (32), /* Entry name of audit file. */ 5 33 2 file_limit bit (1), /* Indicates the audit_file is of limited size. */ 5 34 2 default_search_tag char (32) varying, /* Is the search_tag to use in looking at entries. */ 5 35 2 any_tag bit (1); /* Says to ignore the tags of the entries. */ 5 36 5 37 5 38 /* END INCLUDE FILE audit_position.incl.pl1 */ 1538 1539 6 1 /* Begin include file ..... io_call_info.incl.pl1 */ 6 2 6 3 /* This include file defines the info_structure used by an I/O module to perform an "io_call" order 6 4* on behalf of the io_call command. */ 6 5 /* Coded April 1976 by Larry Johnson */ 6 6 /* Changed June 1977 by Larry Johnson for "io_call_af" order */ 6 7 6 8 dcl io_call_infop ptr; 6 9 6 10 dcl 1 io_call_info aligned based (io_call_infop), 6 11 2 version fixed bin, 6 12 2 caller_name char (32), /* Caller name for error messages */ 6 13 2 order_name char (32), /* Actual name of the order to be performed */ 6 14 2 report entry variable options (variable), 6 15 /* Entry to ioa_ like procedure to report results */ 6 16 2 error entry variable options (variable), 6 17 /* Entry to com_err_ like procedure to report results */ 6 18 2 af_returnp ptr, /* Pointer to return string if "io_call_af" order */ 6 19 2 af_returnl fixed bin, /* Length of string */ 6 20 2 fill (5) bit (36) aligned, 6 21 2 nargs fixed bin, /* Number of additional command arguments provided */ 6 22 2 max_arglen fixed bin, /* Length of longest argument (used to define array) */ 6 23 2 args (0 refer (io_call_info.nargs)) char (0 refer (io_call_info.max_arglen)) varying; 6 24 6 25 dcl io_call_af_ret char (io_call_info.af_returnl) based (io_call_info.af_returnp) varying; 6 26 /* Return string for active function */ 6 27 6 28 /* End include file ..... io_call_info.incl.pl1 */ 1540 1541 7 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 7 2 /* Modified 11/29/82 by S. Krupp to add new entries and to change 7 3* version number to IOX2. */ 7 4 /* format: style2 */ 7 5 7 6 dcl 1 iocb aligned based, /* I/O control block. */ 7 7 2 version character (4) aligned, /* IOX2 */ 7 8 2 name char (32), /* I/O name of this block. */ 7 9 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 7 10 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 7 11 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 7 12 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 7 13 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 7 14 2 reserved bit (72), /* Reserved for future use. */ 7 15 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 7 16 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 7 17 /* open(p,mode,not_used,s) */ 7 18 2 close entry (ptr, fixed (35)),/* close(p,s) */ 7 19 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 7 20 /* get_line(p,bufptr,buflen,actlen,s) */ 7 21 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 7 22 /* get_chars(p,bufptr,buflen,actlen,s) */ 7 23 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 7 24 /* put_chars(p,bufptr,buflen,s) */ 7 25 2 modes entry (ptr, char (*), char (*), fixed (35)), 7 26 /* modes(p,newmode,oldmode,s) */ 7 27 2 position entry (ptr, fixed, fixed (21), fixed (35)), 7 28 /* position(p,u1,u2,s) */ 7 29 2 control entry (ptr, char (*), ptr, fixed (35)), 7 30 /* control(p,order,infptr,s) */ 7 31 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 7 32 /* read_record(p,bufptr,buflen,actlen,s) */ 7 33 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 7 34 /* write_record(p,bufptr,buflen,s) */ 7 35 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 7 36 /* rewrite_record(p,bufptr,buflen,s) */ 7 37 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 7 38 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 7 39 /* seek_key(p,key,len,s) */ 7 40 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 7 41 /* read_key(p,key,len,s) */ 7 42 2 read_length entry (ptr, fixed (21), fixed (35)), 7 43 /* read_length(p,len,s) */ 7 44 2 open_file entry (ptr, fixed bin, char (*), bit (1) aligned, fixed bin (35)), 7 45 /* open_file(p,mode,desc,not_used,s) */ 7 46 2 close_file entry (ptr, char (*), fixed bin (35)), 7 47 /* close_file(p,desc,s) */ 7 48 2 detach entry (ptr, char (*), fixed bin (35)); 7 49 /* detach(p,desc,s) */ 7 50 7 51 declare iox_$iocb_version_sentinel 7 52 character (4) aligned external static; 7 53 7 54 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 1542 1543 8 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 8 2 8 3 /* Written 05/04/78 by C. D. Tavares */ 8 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 8 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 8 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 8 7 8 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 8 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 8 10 iox_$close entry (pointer, fixed bin (35)), 8 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 8 12 iox_$delete_record entry (pointer, fixed bin (35)), 8 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 8 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 8 15 iox_$err_not_attached entry options (variable), 8 16 iox_$err_not_closed entry options (variable), 8 17 iox_$err_no_operation entry options (variable), 8 18 iox_$err_not_open entry options (variable), 8 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 8 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 8 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 8 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 8 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 8 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 8 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 8 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 8 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 8 28 iox_$propagate entry (pointer), 8 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 8 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 8 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 8 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 8 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 8 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 8 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 8 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 8 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 8 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 8 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 8 40 8 41 dcl (iox_$user_output, 8 42 iox_$user_input, 8 43 iox_$user_io, 8 44 iox_$error_output) external static pointer; 8 45 8 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 1544 1545 9 1 /* BEGIN INCLUDE FILE mode_string_info.incl.pl1 */ 9 2 9 3 /* Structure for parse_mode_string_ JRDavis 20 October 1980 9 4* Last modified 12 January 1981 by J. Spencer Love for version 2, make char_value varying string */ 9 5 9 6 declare mode_value_ptr ptr, 9 7 number_of_modes fixed bin; 9 8 9 9 declare 1 mode_string_info aligned based (mode_string_info_ptr), 9 10 2 version fixed bin, 9 11 2 number fixed bin, 9 12 2 modes (number_of_modes refer (mode_string_info.number)) like mode_value; 9 13 9 14 declare mode_string_info_ptr ptr; 9 15 9 16 declare 1 mode_value aligned based (mode_value_ptr), 9 17 2 version fixed bin, 9 18 2 mode_name char (32) unaligned, 9 19 2 flags, 9 20 3 boolean_valuep bit (1) unaligned, 9 21 3 numeric_valuep bit (1) unaligned, 9 22 3 char_valuep bit (1) unaligned, 9 23 3 boolean_value bit (1) unaligned, 9 24 3 pad1 bit (32) unaligned, 9 25 2 numeric_value fixed bin (35), 9 26 2 char_value char (32) varying, 9 27 2 code fixed bin (35), 9 28 2 pad2 bit (36); 9 29 9 30 declare mode_string_info_version_2 fixed bin static options (constant) initial (2), 9 31 mode_value_version_3 fixed bin static options (constant) initial (3); 9 32 9 33 /* END INCLUDE FILE mode_string_info.incl.pl1 */ 1546 1547 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/18/00 1152.6 audit_.pl1 >udd>sm>ds>w>ml>audit_.pl1 1390 1 05/06/74 1841.0 cond_info.incl.pl1 >ldd>incl>cond_info.incl.pl1 1532 2 05/18/81 1656.5 audit_block.incl.pl1 >ldd>incl>audit_block.incl.pl1 1534 3 05/03/79 1613.2 audit_entry.incl.pl1 >ldd>incl>audit_entry.incl.pl1 1536 4 05/03/79 1613.2 audit_file_header.incl.pl1 >ldd>incl>audit_file_header.incl.pl1 1538 5 05/18/81 1656.5 audit_position.incl.pl1 >ldd>incl>audit_position.incl.pl1 1540 6 07/19/79 1647.1 io_call_info.incl.pl1 >ldd>incl>io_call_info.incl.pl1 1542 7 05/20/83 1946.4 iocb.incl.pl1 >ldd>incl>iocb.incl.pl1 1544 8 05/23/83 1016.6 iox_dcls.incl.pl1 >ldd>incl>iox_dcls.incl.pl1 1546 9 03/19/81 1306.8 mode_string_info.incl.pl1 >ldd>incl>mode_string_info.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. AUDIT_MODE_NAMES 000013 constant char(32) initial array packed unaligned dcl 182 set ref 808* NL 012452 constant char(1) initial dcl 180 ref 639 919 942 1002 1052 1058 1119 SUFFIX 000164 constant varying char(32) initial dcl 177 ref 298 ab_buf 000464 automatic char(512) packed unaligned dcl 218 set ref 1004 1004 1028 1033 ab_len 000664 automatic fixed bin(17,0) dcl 219 set ref 1004* 1005 1005 1010 1011 1017 1018 1022 1026 1027 1028 1032 1033 1033 abbrev_$expanded_line 000056 constant entry external dcl 161 ref 1004 actual_iocb_ptr 12 based pointer level 2 dcl 7-6 ref 603 622 635 839 1092 1106 1116 actual_len 000102 automatic fixed bin(21,0) dcl 127 set ref 849* 852 856 858 864 865 884* 885 885 886 887 888* 892* 892 894 898* 899 903 903 906 906 909 909 913 913 919 919 919 919 920* 920 925 925 942 942 942 942 943* 943 948 948 948 948 949 949 949 963* 963 964 964 964 966 967 973* 973 974 976* 976 982 982 985* 993 993 1000 1000 1002 1002 1002 1002 1003* 1003 1004 1011* 1012 1012 1013 1013 1018* 1019 1019 1020 1020 1027* 1028 1032* 1033 1043* 1049 1049 1051* 1051 1052 1052 1057* 1057 1058 1058 1060 1060 1063 1063 1066 1070 1072 1078 1079 1079 addr builtin function dcl 247 ref 341 372 649 649 857 886 949 949 966 1004 1004 1071 1226 1226 1270 1346 1353 1353 1353 1353 1394 1394 1425 aep 000100 automatic pointer level 2 in structure "position" dcl 1183 in procedure "audit_line" set ref 1202* 1270* 1272 1272 1275 1275 1346* 1361 1365 1367 1368 1370 1371 1372 1373 1374 1375 1376 aep 000122 automatic pointer level 2 in structure "previous_position" dcl 1184 in procedure "audit_line" set ref 1357 1358 aep automatic pointer dcl 3-23 in procedure "audit_attach" ref 1203 after builtin function dcl 249 ref 818 821 any_other 000104 stack reference condition dcl 173 ref 551 595 1195 1229 any_tag 110 000144 automatic bit(1) level 2 packed packed unaligned dcl 1185 set ref 1319* attach 2 based varying char(128) level 2 dcl 2-15 set ref 341 349* 351* 351 352* 352 attach_data_ptr 16 based pointer level 2 dcl 7-6 set ref 342* 543 546* 604 623 636 840 1093 1107 1117 attach_descrip_ptr 14 based pointer level 2 dcl 7-6 set ref 323 341* 546* audit_editor 000020 constant entry external dcl 143 ref 985 audit_editor$set_last_return_line_position 000022 constant entry external dcl 144 ref 1226 audit_entry based structure level 1 dcl 3-24 set ref 1203 1272 1272 1275 1275 1368 1376 audit_fcb 134 based pointer level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 363* 377* 382* 423* 447* 458* 477* 491* 578* 593 593* 1130* 1303* 1316 1519* audit_fcb 4 000144 automatic pointer level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1316* audit_file_header based structure level 1 dcl 4-27 set ref 402 402 491 491 724 724 1130 1130 1240 1240 1245 1245 1293 1293 1526 1526 audit_file_header_ptr 004666 automatic pointer dcl 4-26 in procedure "audit_attach" set ref 393* 396 397 398 399 400 401 402 402 402 405 406 408 408 409 409 423* 432 435 438 447 458 465 471 471 471 471 482 488* 490 491 491 503 503 504 505 505 506 506 507 510 562* 563 563 563 563 563 563 569 578 578 638* 722 723 724 724 724 726 726 727 727 728 746 747 747 1118* 1129 1130 1130 1135 1135 1136 1137 1201* 1238 1240 1240 1240 1240 1245 1245 1245 1252 1254 1254 1254 1254 1254 1254 1254 1257 1257 1257 1257 1259 1264 1264 1266 1266 1266 1266 1266 1270 1272 1272 1272 1275 1275 1279 1279 1288 1289 1293 1293 1294 1295 1300 1309 1310 1311 1312 1313 1314 1315 1322 1323 1324 1326 1326 1346 1367 1375 1376 1376 1377 1377 1377 1378 1378 1418* 1480 1480 1518* 1526 1526 1526 1527 audit_file_header_ptr 142 based pointer level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 362* 395* 489* 510* 521* 559 562 605 605* 638 1118 1201 1418 1518 audit_file_header_version_1 constant fixed bin(17,0) initial dcl 4-25 ref 405 438 audit_file_position_$last 000024 constant entry external dcl 146 ref 1353 audit_index 10 000144 automatic fixed bin(24,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1315* audit_index 1 based fixed bin(24,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 409 471 503 506 563 569 578 726 1135 1252 1254 1254 1257 1259 1264* 1266 1279* 1288 1315 1323 1346 1376* 1376 1377* 1377 1377 1378 1526* audit_ptr 6 000144 automatic pointer level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1317* audit_ptr 136 based pointer level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 364* 382* 393 395 404 435* 447* 477* 488 489 508 569* 1138 1264* 1279* 1288* 1317 1325 1346 1519* audited_iocb 000352 automatic pointer dcl 205 set ref 262* 323 341 342 343 344 345 355 368 369 370 371 372 373 374 375 533* 603* 609 610 611* 622* 623 635* 636 709 839* 840 985* 1092* 1093 1106* 1107 1116* 1117 auditing_iocb based pointer level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 354* 624 637 645* 825* 830* 841 913 925 982 1000 1049 1094 1108 1147* 1160* 1168* 1173* 1465 auditing_iocb 000356 automatic pointer dcl 205 in procedure "audit_attach" set ref 273* 354 624* 625* 637* 688* 707 841* 875* 888* 949* 1094* 1095* 1108* 1109* aut_input_string based char packed unaligned dcl 191 set ref 856 865 885* 903* 906 909 913* 919* 919 925* 942* 942 948 948 964* 982* 993* 1000* 1002* 1002 1012* 1012 1013 1019* 1019 1020 1028* 1033* 1049* 1052* 1058* 1060* 1063* 1070 1079 before builtin function dcl 249 ref 818 821 begin_component 4 based fixed bin(17,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 401* 458* 465* 504* 563 563 723* 1136* 1254 1266 1272* 1312 begin_component 13 000144 automatic fixed bin(17,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1312* begin_index 12 000144 automatic fixed bin(24,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1313* begin_index 3 based fixed bin(24,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 402* 503* 563 724* 1135* 1254 1254 1266 1270 1272 1272* 1275* 1275 1313 begin_ptr 140 based pointer level 2 dcl 2-15 set ref 365* 404* 458* 508* 722* 1138* 1270 1271* 1272* bit_count24 000115 automatic fixed bin(24,0) dcl 199 set ref 382* 423* 447* 458* 477* 1271* 1272 1303* 1519* blk based structure level 1 dcl 2-15 set ref 332 332 blkptr 000354 automatic pointer dcl 205 set ref 332 332 332* 333 341 342 349 351 351 352 352 354 355 360 361 362 363 364 365 366 367 373 377 377 377 382 382 393 395 395 404 404 414 414 414 423 435 447 447 458 458 471 477 477 488 489 489 491 508 508 510 511 512 513 514 515 516 518 519 521 524 543* 557 559 562 563 569 578 585 588 593 593 604* 605 605 623* 624 628 636* 637 638 639 645 679 684 684 685 688 699 707 709 722 729 748 758 766 774 782 790 798 806 825 830 840* 841 844 848 849 857 858 866 867 880 880 881 882 883 891 893 894 899 903 906 913 913 913 915 915 915 915 915 925 925 925 927 928 928 929 929 930 930 931 931 934 934 935 935 936 936 938 938 939 939 940 948 955 959 959 960 961 962 968 971 972 974 982 982 982 984 986 989 993 1000 1000 1000 1009 1025 1039 1040 1049 1049 1049 1060 1063 1071 1072 1080 1081 1093* 1094 1098 1107* 1108 1117* 1118 1119 1130 1138 1138 1147 1160 1166 1167 1168 1173 1201 1236 1252 1264 1264 1270 1271 1272 1279 1288 1289 1300 1303 1316 1317 1320 1321 1325 1326 1346 1348 1357 1358 1362 1363 1378 1402 1404 1405 1405 1406 1418 1435 1441 1447 1453 1459 1465 1465 1471 1476 1493 1499 1518 1519 1519 boolean_value 13(03) based bit(1) array level 4 in structure "mode_string_info" packed packed unaligned dcl 9-9 in procedure "audit_attach" set ref 676 699 707 758 766 774 782 798 boolean_value 11(03) based bit(1) level 3 in structure "mode_value" packed packed unaligned dcl 9-16 in procedure "audit_attach" set ref 1427* 1435* 1441* 1447* 1453* 1459* 1465* 1493* boolean_valuep 13 based bit(1) array level 4 in structure "mode_string_info" packed packed unaligned dcl 9-9 in procedure "audit_attach" set ref 668 692 700 711 751 759 767 775 791 boolean_valuep 11 based bit(1) level 3 in structure "mode_value" packed packed unaligned dcl 9-16 in procedure "audit_attach" set ref 1434* 1440* 1446* 1452* 1458* 1464* 1492* buff_len 000103 automatic fixed bin(21,0) dcl 127 set ref 843* 850* 882* 887* 887 888* 893* 949 962* 967* 967 968* 972* 985* 1005 1010* 1017* 1022 1026* 1042* buff_ptr 000100 automatic pointer dcl 125 set ref 842* 848* 856 857 865 883* 885 886* 886 888* 891* 903 906 909 913 919 919 925 942 942 948 948 949 949 961* 964 966* 966 968* 971* 982 985* 993 1000 1002 1002 1004* 1009* 1012 1019 1025* 1028 1033 1041* 1049 1052 1058 1060 1063 1070 1071 1079 bytes_required 000255 automatic fixed bin(24,0) dcl 1186 set ref 1203* 1206 1209* 1214 1368 char_index 2 000100 automatic fixed bin(24,0) level 2 dcl 1183 set ref 1323* char_value 13 based varying char(32) level 2 in structure "mode_value" dcl 9-16 in procedure "audit_attach" set ref 1428* 1471* 1486* 1499* char_value 15 based varying char(32) array level 3 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" set ref 718 790 806 char_valuep 13(02) based bit(1) array level 4 in structure "mode_string_info" packed packed unaligned dcl 9-9 in procedure "audit_attach" set ref 718 783 799 char_valuep 11(02) based bit(1) level 3 in structure "mode_value" packed packed unaligned dcl 9-16 in procedure "audit_attach" set ref 1470* 1485* 1498* clock builtin function dcl 245 ref 318 318 1361 1361 close 36 based entry variable level 2 dcl 7-6 set ref 345* com_err_ 000026 constant entry external dcl 148 ref 267 277 291 302 309 327 337 387 414 428 442 454 465 482 498 529 1523 component_max_char_index 21 000100 automatic fixed bin(24,0) level 2 dcl 1183 set ref 1326* 1328* component_number 20 000100 automatic fixed bin(17,0) level 2 dcl 1183 set ref 1324* 1326 component_ptr 16 000100 automatic pointer level 2 dcl 1183 set ref 1325* condition parameter varying char(32) dcl 1400 set ref 1398 1407 1407* condition_name 3 000100 automatic varying char(32) level 2 dcl 1389 set ref 1395* control 66 based entry variable level 2 dcl 7-6 set ref 369* cpu_time_and_paging_ 000010 constant entry external dcl 138 ref 1351 current_component 2 000144 automatic fixed bin(17,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1314* current_component 2 based fixed bin(17,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 398* 408 447* 471 482* 490* 505 563 563 578* 727 1129* 1254 1257 1264* 1266 1279* 1314 1324 current_flags 44 based structure level 2 dcl 2-15 set ref 684* 1405 1406* currentsize builtin function dcl 244 ref 1272 1272 1275 1275 1376 date_time_ 000040 constant entry external dcl 154 ref 318 day 000341 automatic fixed bin(17,0) dcl 1341 set ref 1361* decode_clock_value_ 000016 constant entry external dcl 141 ref 1361 default_iocb 156 based pointer level 2 dcl 2-15 set ref 355* 707* 709* 913 915* 925 927* 928* 929* 930* 931* 934* 935* 936* 938* 939* 940* 948* 968* 982 986* 989* 1000 1049 1465 default_search_tag 77 000144 automatic varying char(32) level 2 dcl 1185 set ref 1318* detach_iocb 26 based entry variable level 2 dcl 7-6 set ref 343* 547* 610* dev_paging 000337 automatic fixed bin(17,0) dcl 1339 set ref 1351* device 000360 automatic char(32) packed unaligned dcl 207 set ref 272* 273* 277* 346 347 349 dirname 000406 automatic char(168) packed unaligned dcl 212 in procedure "audit_attach" set ref 298* 320* 360 dirname 46 based char(168) level 2 in structure "blk" packed packed unaligned dcl 2-15 in procedure "audit_attach" set ref 360* 377* 414* 414 1320 dirname 14 000144 automatic char(168) level 2 in structure "position_info" packed packed unaligned dcl 1185 in procedure "audit_line" set ref 1320* divide builtin function dcl 247 ref 746 1272 1480 dow 000343 automatic fixed bin(17,0) dcl 1343 set ref 1361* edit 44(03) based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 514* 766* 899 1447 editor_prompt_string 145 based varying char(32) level 2 dcl 2-15 set ref 516* 806* 1499 empty builtin function dcl 249 ref 220 ename 000373 automatic char(32) packed unaligned dcl 210 in procedure "audit_attach" set ref 261* 298* 315 319* 361 ename 120 based char(32) level 2 in structure "blk" packed packed unaligned dcl 2-15 in procedure "audit_attach" set ref 361* 377* 414* 1321 ename 66 000144 automatic char(32) level 2 in structure "position_info" packed packed unaligned dcl 1185 in procedure "audit_line" set ref 1321* entry_length 6 based fixed bin(24,0) level 2 dcl 3-24 set ref 1272 1272 1275 1275 1370* 1372 1375 1376 entry_number 3 000100 automatic fixed bin(35,0) level 2 dcl 1183 set ref 1330* error_table_$bad_arg 000120 external static fixed bin(35,0) dcl 239 set ref 267* 269 309* 311 error_table_$bad_mode_syntax 000102 external static fixed bin(35,0) dcl 227 ref 673 696 704 715 755 763 771 779 787 795 803 error_table_$bad_mode_value 000100 external static fixed bin(35,0) dcl 225 ref 733 743 error_table_$empty_file 000106 external static fixed bin(35,0) dcl 231 ref 986 error_table_$long_record 000104 external static fixed bin(35,0) dcl 229 ref 859 876 952 1073 error_table_$noarg 000110 external static fixed bin(35,0) dcl 233 set ref 291* 295 error_table_$noentry 000116 external static fixed bin(35,0) dcl 238 ref 378 error_table_$not_detached 000114 external static fixed bin(35,0) dcl 236 set ref 327* 329 error_table_$unimplemented_version 000112 external static fixed bin(35,0) dcl 234 set ref 444 653* 658* expand_pathname_$add_suffix 000032 constant entry external dcl 150 ref 298 extend 000461 automatic bit(1) packed unaligned dcl 214 set ref 263* 282* 420 file_char_array based char(1) array packed unaligned dcl 1345 in procedure "insert" set ref 1346 file_char_array based char(1) array packed unaligned dcl 838 in procedure "audit_attach" set ref 857 886 949 949 966 1071 1270 file_limit 76 000144 automatic bit(1) level 2 in structure "position_info" packed packed unaligned dcl 1185 in procedure "audit_line" set ref 1322* file_limit 44(01) based bit(1) level 3 in structure "blk" packed packed unaligned dcl 2-15 in procedure "audit_attach" set ref 471* 563 729* 748* 1236 1252 1264 1289 1300 1326 1378 1476 filled 10 based bit(1) level 2 packed packed unaligned dcl 4-27 set ref 397* 507* 728* 1137* 1254 1266 1295* 1322 find_condition_info_ 000146 constant entry external dcl 1392 ref 1394 flags 13 based structure array level 3 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" flags 11 based structure level 2 in structure "mode_value" dcl 9-16 in procedure "audit_attach" set ref 1426* get_chars 46 based entry variable level 2 dcl 7-6 set ref 371* get_line 42 based entry variable level 2 dcl 7-6 set ref 368* get_temp_segment_ 000012 constant entry external dcl 139 ref 524 hbound builtin function dcl 247 ref 264 281 288 350 1423 hcs_$assign_linkage 000054 constant entry external dcl 160 ref 332 hcs_$set_bc_seg 000044 constant entry external dcl 156 ref 569 1288 hcs_$set_ips_mask 000052 constant entry external dcl 159 ref 322 326 336 386 413 427 441 453 464 481 497 528 534 542 597 608 612 1193 1231 hcs_$set_safety_sw_seg 000046 constant entry external dcl 157 ref 521 605 hcs_$status_mins 000050 constant entry external dcl 158 ref 1271 i 000370 automatic fixed bin(17,0) dcl 208 set ref 281* 282 282 284 284 287* 287 288 298 302 309* 350* 352* impossible_audit_entry_length 000012 constant fixed bin(24,0) initial dcl 3-20 ref 396 1527 index builtin function dcl 247 ref 346 668 818 821 info 000100 automatic structure level 1 dcl 1389 set ref 1394 1394 io_call_info based structure level 1 dcl 6-10 ioa_$ioa_switch 000034 constant entry external dcl 152 ref 688 915 927 928 929 930 931 934 935 936 938 939 940 986 989 1407 ioa_$ioa_switch_nnl 000036 constant entry external dcl 153 ref 948 iocb based structure level 1 dcl 7-6 iox_$control 000122 constant entry external dcl 8-8 ref 1147 1160 1168 1173 iox_$err_no_operation 000126 constant entry external dcl 8-8 ref 344 iox_$err_not_attached 000124 constant entry external dcl 8-8 ref 547 548 iox_$find_iocb 000130 constant entry external dcl 8-8 ref 273 iox_$get_chars 000132 constant entry external dcl 8-8 ref 625 iox_$get_line 000134 constant entry external dcl 8-8 ref 875 888 949 968 iox_$modes 000136 constant entry external dcl 8-8 ref 645 825 830 iox_$position 000140 constant entry external dcl 8-8 ref 1109 iox_$propagate 000142 constant entry external dcl 8-8 ref 533 549 611 iox_$put_chars 000144 constant entry external dcl 8-8 ref 1095 last_entry_length 11 000144 automatic fixed bin(24,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1309* last_entry_length 5 based fixed bin(24,0) level 2 in structure "audit_entry" dcl 3-24 in procedure "audit_attach" set ref 1367* last_entry_length 7 based fixed bin(24,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 396* 406* 1309 1367 1375* 1527* length builtin function dcl 247 ref 347 642 1203 1203 1370 loc_ptr 20 000100 automatic pointer level 2 dcl 1389 set ref 1395* mask 000372 automatic fixed bin(17,0) dcl 209 set ref 322* 326* 336* 386* 413* 427* 441* 453* 464* 481* 497* 528* 534* 542* 597* 608* 612* 1193* 1231* max builtin function dcl 249 ref 1240 max_component 6 based fixed bin(17,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 408* 471 505* 727* 746* 747 1238 1240 1257 1289 1300* 1310 1326 1480 max_component 000144 automatic fixed bin(17,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1310* max_entry_size 000256 automatic fixed bin(24,0) dcl 1187 set ref 1206 1209 1236* 1238* 1240* 1245* max_index 1 000144 automatic fixed bin(24,0) level 2 in structure "position_info" dcl 1185 in procedure "audit_line" set ref 1311* max_index 5 based fixed bin(24,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 409* 471 506* 726* 747* 1240 1245 1257 1311 1326 1378* 1480 meter 44(05) based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 782* 1348 1459 mod builtin function dcl 246 ref 402 491 724 1130 1203 1240 1245 1272 1275 1293 1377 1526 mode_idx 000116 automatic fixed bin(17,0) dcl 200 in procedure "audit_attach" set ref 665* 667 668 676 692 699 700 707 711 718 718 739 751 758 759 766 767 774 775 782 783 790 791 798 799 806* mode_idx 005246 automatic fixed bin(17,0) dcl 1416 in procedure "mode_string" set ref 1423* 1425 1430* mode_name 3 based char(32) array level 3 in structure "mode_string_info" packed packed unaligned dcl 9-9 in procedure "audit_attach" set ref 667 mode_name 1 based char(32) level 2 in structure "mode_value" packed packed unaligned dcl 9-16 in procedure "audit_attach" set ref 1432* 1438* 1444* 1450* 1456* 1462* 1468* 1474* 1490* 1496* mode_str based varying char(512) dcl 190 set ref 1143* mode_string_$combine 000074 constant entry external dcl 169 ref 1505 mode_string_$delete 000072 constant entry external dcl 168 ref 808 mode_string_$parse 000070 constant entry external dcl 167 ref 649 mode_string_info based structure level 1 dcl 9-9 set ref 1421 mode_string_info_ptr 005030 automatic pointer dcl 9-14 set ref 649* 653 653 658 658 658 665 667 668 676 692 699 700 707 711 718 718 739 751 758 759 766 767 774 775 782 783 790 791 798 799 806 808* 1421* 1422 1423 1425 1505* mode_string_info_version_2 000262 constant fixed bin(17,0) initial dcl 9-30 set ref 653 653* 1422 mode_value based structure level 1 dcl 9-16 mode_value_ptr 005024 automatic pointer dcl 9-6 set ref 1425* 1426 1427 1428 1429 1432 1434 1435 1438 1440 1441 1444 1446 1447 1450 1452 1453 1456 1458 1459 1462 1464 1465 1468 1470 1471 1474 1479 1480 1485 1486 1490 1492 1493 1496 1498 1499 mode_value_version_3 000260 constant fixed bin(17,0) initial dcl 9-30 set ref 658 658* modes 2 based structure array level 2 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" set ref 1423 1425 modes 56 based entry variable level 2 in structure "iocb" dcl 7-6 in procedure "audit_attach" set ref 374* modes 005046 automatic char(512) packed unaligned dcl 1415 in procedure "mode_string" set ref 1419* 1505* 1507 month 000340 automatic fixed bin(17,0) dcl 1340 set ref 1361* msf_manager_$adjust 000064 constant entry external dcl 164 ref 491 578 1130 msf_manager_$close 000066 constant entry external dcl 165 ref 593 msf_manager_$get_ptr 000062 constant entry external dcl 163 ref 382 423 447 458 477 1303 1519 msf_manager_$open 000060 constant entry external dcl 162 ref 377 myname 000154 constant char(6) initial packed unaligned dcl 179 set ref 267 277 291 302 309 327 337 387 414 428 442 454 465 482 498 529 653* 658* n parameter fixed bin(21,0) dcl 131 set ref 1104 1109* newmodes 000120 automatic varying char(64) dcl 202 set ref 667* 668 668 692 700 711 751 759 767 775 783 791 799 799 null builtin function dcl 247 ref 323 333 362 363 364 365 366 367 518 544 545 546 557 559 585 593 605 609 653 653 658 658 679 679 844 866 955 984 1039 1080 1166 1202 1394 1394 1505 1505 number 1 based fixed bin(17,0) level 2 dcl 9-9 set ref 658 665 1421* 1423 number_of_modes 005026 automatic fixed bin(17,0) dcl 9-6 set ref 1420* 1421 1421 numeric_value 12 based fixed bin(35,0) level 2 in structure "mode_value" dcl 9-16 in procedure "audit_attach" set ref 1429* 1480* numeric_value 14 based fixed bin(35,0) array level 3 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" set ref 739 numeric_valuep 11(01) based bit(1) level 3 packed packed unaligned dcl 9-16 set ref 1479* open 32 based entry variable level 2 dcl 7-6 set ref 344* 548* open_data_ptr 22 based pointer level 2 dcl 7-6 set ref 373* 545* open_descrip_ptr 20 based pointer level 2 dcl 7-6 set ref 372* 544* 609* order 000341 automatic char(32) packed unaligned dcl 204 set ref 1121* 1122 1125* 1125 1126 1140 1151 1163 1163 order_name 11 based char(32) level 2 dcl 6-10 ref 1151 out_ptr 000112 automatic pointer dcl 197 set ref 1004* 1012 1013 1019 1020 p_actual_len parameter fixed bin(21,0) dcl 133 set ref 620 625* 628 628 836 855* 856 864* 865 875* 885 885 892 898 964 1069* 1070 1078* 1079 p_buff_len parameter fixed bin(21,0) dcl 133 set ref 620 625* 836 843 852 855 856 857 858 875* 884 1042 1066 1069 1070 1071 1072 1090 1095* 1098 1098 p_buff_ptr parameter pointer dcl 132 set ref 620 625* 628 836 842 856 865 875* 885 964 1041 1070 1079 1090 1095* 1098 p_code parameter fixed bin(35,0) dcl 124 in procedure "audit_attach" set ref 23 23 269* 273* 274 277* 295* 298* 299 302* 311* 329* 332* 337* 377* 378 378 382* 383 387* 414* 423* 424 428* 442* 444* 447* 450 454* 458* 461 465* 477* 478 482* 491* 494 498* 521* 524* 525 529* 535* 539 541* 569* 570 578* 581 588* 589 600 605* 613* 620 625* 626 630* 633 645* 649* 650 673* 696* 704* 715* 733* 743* 755* 763* 771* 779* 787* 795* 803* 808* 825* 830* 836 859* 868* 875* 876 876 888* 889 949* 952 952 968* 969 985* 986 986 1073* 1082* 1085* 1090 1095* 1096 1100* 1104 1109* 1113 1130* 1143* 1147* 1155* 1160* 1168* 1173* 1176* 1271* 1288* 1303* 1353* 1354 1394* 1519* 1520 1523* p_code parameter fixed bin(35,0) dcl 1414 in procedure "mode_string" set ref 1412 1505* p_com_err_sw parameter bit(1) dcl 129 ref 23 23 267 277 291 302 309 327 337 387 414 428 442 454 465 482 498 529 p_component_index parameter fixed bin(24,0) dcl 1285 set ref 1282 1293* 1302* p_component_number parameter fixed bin(17,0) dcl 1284 set ref 1282 1289 1292* 1299* 1299 1300 1303* p_component_ptr parameter pointer dcl 1286 set ref 1282 1294* 1303* p_info_ptr parameter pointer dcl 125 set ref 1113 1143 1147* 1151 1155 1160* 1168* 1173* p_iocb_ptr parameter pointer dcl 125 set ref 23 23 262 539 543 544 545 546 546 547 548 549* 600 603 604 620 622 633 635 836 839 1090 1092 1104 1106 1113 1116 1407* p_newmodes parameter char packed unaligned dcl 121 set ref 633 639 642 645* 649* p_oldmodes parameter char packed unaligned dcl 121 set ref 633 645* 825* 830* p_option_array parameter varying char array dcl 128 set ref 23 23 264 272 281 282 282 284 284 288 298 302* 309* 350 352 p_ptr parameter pointer dcl 1401 set ref 1398 1407* p_real_order parameter char packed unaligned dcl 123 set ref 1113 1119 1121 1147* 1160* 1168* 1173* p_string parameter char packed unaligned dcl 1191 in procedure "audit_line" set ref 1181 1203 1203 1221* p_string parameter char packed unaligned dcl 1335 in procedure "insert" set ref 1333 1368* 1368 1370 1372 p_tag parameter char packed unaligned dcl 1336 in procedure "insert" ref 1333 1371 p_tag parameter char packed unaligned dcl 1190 in procedure "audit_line" set ref 1181 1221* pad2 11 based fixed bin(35,0) array level 2 dcl 4-27 set ref 400* paging 000336 automatic fixed bin(17,0) dcl 1338 in procedure "insert" set ref 1351* 1358 1363 paging 130 based fixed bin(35,0) level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 1358 1363* paging 4 based fixed bin(24,0) level 2 in structure "audit_entry" dcl 3-24 in procedure "audit_attach" set ref 1358* 1374* param_input_string based char packed unaligned dcl 193 set ref 628* 856* 865* 885 964 1070* 1079* param_output_string based char packed unaligned dcl 192 set ref 1098* position 62 based entry variable level 2 in structure "iocb" dcl 7-6 in procedure "audit_attach" set ref 375* position 000100 automatic structure level 1 unaligned dcl 1183 in procedure "audit_line" set ref 1226 1226 1352 position_info 000144 automatic structure level 1 unaligned dcl 1185 set ref 1353 1353 position_info_template 004712 automatic structure level 1 unaligned dcl 5-21 position_template 004670 automatic structure level 1 unaligned dcl 5-10 previous_position 000122 automatic structure level 1 unaligned dcl 1184 set ref 1352* 1353 1353 ptype parameter fixed bin(17,0) dcl 130 set ref 1104 1109* put_chars 52 based entry variable level 2 dcl 7-6 set ref 370* read_audit 44 based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 511* 628 699* 903 913 915* 915 925 982 993 1000 1049 1060 1063 1435 records 000117 automatic fixed bin(17,0) dcl 201 set ref 739* 740 746 747 release_temp_segment_ 000014 constant entry external dcl 140 ref 588 report 22 based entry variable level 2 dcl 6-10 ref 1155 request 000462 automatic char(1) packed unaligned dcl 215 set ref 909* 910 922 945 979 979 997 1036 1046 1054 room_for_insertion 000257 automatic fixed bin(24,0) dcl 1188 set ref 1214 1252* 1254* 1257* 1259* rtrim builtin function dcl 249 ref 639 642 818 818 821 821 saved_flags 45 based structure level 2 dcl 2-15 set ref 684 1405* search_tag 4 000100 automatic varying char(32) level 2 dcl 1183 set ref 1329* set_last_return_line_position 000463 automatic bit(1) initial packed unaligned dcl 216 set ref 216* 992* 1222 1225* sio_open_desc 000156 constant varying char(20) initial dcl 178 set ref 372 size builtin function dcl 247 ref 332 332 402 402 491 491 724 724 1130 1130 1203 1240 1240 1245 1245 1293 1293 1368 1526 1526 string 10 based char level 2 in structure "audit_entry" dcl 3-24 in procedure "audit_attach" set ref 1372* string builtin function dcl 243 in procedure "audit_attach" set ref 684* 684 1405* 1405 1406* sub_err_ 000030 constant entry external dcl 149 ref 653 658 substr builtin function dcl 247 set ref 349 856 885* 885 906 909 919* 919 942* 942 948 948 964* 964 1002* 1002 1028 1033* 1033 1052* 1058* 1070 1079 1122 1125 1368 suspend 43 based bit(1) level 2 dcl 2-15 set ref 679 685* 688 1402 1404* sys_info$max_seg_size 000076 external static fixed bin(24,0) dcl 224 ref 850 881 960 1236 1238 1240 1252 1259 1328 tactual_len 000460 automatic fixed bin(21,0) dcl 213 set ref 949* 963 968* 973 976 tag 7 based char(2) level 2 dcl 3-24 set ref 1371* tc 000371 automatic fixed bin(17,0) dcl 209 set ref 346* 347 347* 349 temp_area 000666 automatic area(2048) dcl 220 set ref 220* 649 649 1421 temp_seg_ptr 160 based pointer level 2 dcl 2-15 set ref 366* 524* 585 588* 880 891 959 961 971 1009 1025 time 000404 automatic char(8) packed unaligned dcl 211 in procedure "audit_attach" set ref 318* 319 time based fixed bin(71,0) level 2 in structure "audit_entry" dcl 3-24 in procedure "audit_attach" set ref 1361* 1365* trace 44(04) based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 639 774* 1119 1453 trigger 144 based char(1) level 2 dcl 2-15 set ref 513* 790* 906 928* 929* 930* 931* 934* 935* 936* 938* 939* 1471 trim_entry 000260 automatic bit(1) initial packed unaligned dcl 1189 set ref 1189* 1210* 1368 type 000114 automatic fixed bin(2,0) dcl 198 set ref 1271* unrecognized_modes 000141 automatic char(512) packed unaligned dcl 203 set ref 641* 808* 809 809 818 818* 818 818 821 821* 821 821 825 unused1 10(01) based bit(35) level 2 packed packed unaligned dcl 4-27 set ref 399* use_editor_prompt 44(06) based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 515* 798* 1493 user_info_$homedir 000042 constant entry external dcl 155 ref 320 version 2 based fixed bin(17,0) array level 3 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" set ref 658 658* version based fixed bin(17,0) level 2 in structure "audit_file_header" dcl 4-27 in procedure "audit_attach" set ref 405* 432 438 version based fixed bin(17,0) level 2 in structure "mode_string_info" dcl 9-9 in procedure "audit_attach" set ref 653 653* 1422* virtual_time 000334 automatic fixed bin(71,0) dcl 1337 in procedure "insert" set ref 1351* 1357 1362 virtual_time 132 based fixed bin(71,0) level 2 in structure "blk" dcl 2-15 in procedure "audit_attach" set ref 1357 1362* virtual_time 2 based fixed bin(71,0) level 2 in structure "audit_entry" dcl 3-24 in procedure "audit_attach" set ref 1357* 1373* work_space 162 based pointer level 2 dcl 2-15 set ref 367* 518* 844 848 857* 866* 880* 883 955 959* 984* 1039* 1071* 1080* 1166* work_space_len 164 based fixed bin(24,0) level 2 dcl 2-15 set ref 519* 849 858* 867* 881* 882 893 894* 960* 962 972 974* 1040* 1072* 1081* 1167* write_audit 44(02) based bit(1) level 3 packed packed unaligned dcl 2-15 set ref 512* 758* 915 915* 1098 1441 year 000342 automatic fixed bin(17,0) dcl 1342 set ref 1361* zone 000344 automatic char(3) dcl 1344 set ref 1361* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. audit_entry_header_length internal static fixed bin(17,0) initial dcl 3-20 audit_file_header_length internal static fixed bin(17,0) initial dcl 4-24 io_call_af_ret based varying char dcl 6-25 io_call_infop automatic pointer dcl 6-8 iox_$attach_loud 000000 constant entry external dcl 8-8 iox_$attach_name 000000 constant entry external dcl 8-8 iox_$attach_ptr 000000 constant entry external dcl 8-8 iox_$close 000000 constant entry external dcl 8-8 iox_$close_file 000000 constant entry external dcl 8-8 iox_$delete_record 000000 constant entry external dcl 8-8 iox_$destroy_iocb 000000 constant entry external dcl 8-8 iox_$detach 000000 constant entry external dcl 8-8 iox_$detach_iocb 000000 constant entry external dcl 8-8 iox_$err_not_closed 000000 constant entry external dcl 8-8 iox_$err_not_open 000000 constant entry external dcl 8-8 iox_$error_output external static pointer dcl 8-41 iox_$find_iocb_n 000000 constant entry external dcl 8-8 iox_$iocb_version_sentinel external static char(4) dcl 7-51 iox_$look_iocb 000000 constant entry external dcl 8-8 iox_$move_attach 000000 constant entry external dcl 8-8 iox_$open 000000 constant entry external dcl 8-8 iox_$open_file 000000 constant entry external dcl 8-8 iox_$read_key 000000 constant entry external dcl 8-8 iox_$read_length 000000 constant entry external dcl 8-8 iox_$read_record 000000 constant entry external dcl 8-8 iox_$rewrite_record 000000 constant entry external dcl 8-8 iox_$seek_key 000000 constant entry external dcl 8-8 iox_$user_input external static pointer dcl 8-41 iox_$user_io external static pointer dcl 8-41 iox_$user_output external static pointer dcl 8-41 iox_$write_record 000000 constant entry external dcl 8-8 NAMES DECLARED BY EXPLICIT CONTEXT. GET_LINE 005761 constant label dcl 844 ref 1044 INIT_AUDIT_FILE 002437 constant label dcl 393 set ref 436 MODE 000000 constant label array(10) dcl 1432 ref 1430 MODE_LOOP 012050 constant label dcl 1423 in procedure "mode_string" MODE_LOOP 004665 constant label dcl 665 in procedure "audit_attach" MORE_GET_LINE 006153 constant label dcl 899 ref 977 NEXT_MODE 012313 constant label dcl 1502 ref 1436 1442 1448 1454 1460 1466 1472 1488 1494 1500 RETURN 010726 constant label dcl 1229 in procedure "audit_line" ref 1198 RETURN 004057 constant label dcl 595 in procedure "audit_attach" ref 554 570 581 589 adjust_indices 011074 constant entry internal dcl 1262 ref 1215 audit_ 001176 constant entry external dcl 23 audit_attach 001154 constant entry external dcl 23 audit_close 004075 constant entry external dcl 600 ref 345 audit_control 010122 constant entry external dcl 1113 ref 369 audit_detach 003604 constant entry external dcl 539 ref 343 610 audit_get_chars 004207 constant entry external dcl 620 ref 371 audit_get_line 005732 constant entry external dcl 836 ref 368 audit_line 010545 constant entry internal dcl 1181 ref 628 639 903 913 925 982 993 1000 1049 1060 1063 1098 1119 audit_modes 004310 constant entry external dcl 633 ref 374 audit_position 010055 constant entry external dcl 1104 ref 375 audit_put_chars 007756 constant entry external dcl 1090 ref 370 force_audit_suspension 011707 constant entry internal dcl 1387 ref 553 1197 get_room_for_insertion 011025 constant entry internal dcl 1250 ref 1213 1216 insert 011440 constant entry internal dcl 1333 ref 1221 mode_string 012023 constant entry internal dcl 1412 ref 1143 1155 next_component 011233 constant entry internal dcl 1282 ref 1264 1272 1279 set_max_entry_size 010743 constant entry internal dcl 1234 ref 1205 set_position_info 011344 constant entry internal dcl 1307 ref 1219 suspend_auditing 011746 constant entry internal dcl 1398 ref 679 1395 truncate_audit_file 012354 constant entry internal dcl 1511 ref 407 502 1134 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 13400 13550 12461 13410 Length 14314 12461 150 527 716 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME audit_attach 3162 external procedure is an external procedure. on unit on line 551 64 on unit audit_line 326 internal procedure is called during a stack extension, and enables or reverts conditions. on unit on line 1195 64 on unit set_max_entry_size internal procedure shares stack frame of internal procedure audit_line. get_room_for_insertion internal procedure shares stack frame of internal procedure audit_line. adjust_indices internal procedure shares stack frame of internal procedure audit_line. next_component internal procedure shares stack frame of internal procedure audit_line. set_position_info internal procedure shares stack frame of internal procedure audit_line. insert internal procedure shares stack frame of internal procedure audit_line. force_audit_suspension 102 internal procedure is called by several nonquick procedures. suspend_auditing 96 internal procedure is called by several nonquick procedures. mode_string internal procedure shares stack frame of external procedure audit_attach. truncate_audit_file internal procedure shares stack frame of external procedure audit_attach. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME audit_attach 000100 buff_ptr audit_attach 000102 actual_len audit_attach 000103 buff_len audit_attach 000112 out_ptr audit_attach 000114 type audit_attach 000115 bit_count24 audit_attach 000116 mode_idx audit_attach 000117 records audit_attach 000120 newmodes audit_attach 000141 unrecognized_modes audit_attach 000341 order audit_attach 000352 audited_iocb audit_attach 000354 blkptr audit_attach 000356 auditing_iocb audit_attach 000360 device audit_attach 000370 i audit_attach 000371 tc audit_attach 000372 mask audit_attach 000373 ename audit_attach 000404 time audit_attach 000406 dirname audit_attach 000460 tactual_len audit_attach 000461 extend audit_attach 000462 request audit_attach 000463 set_last_return_line_position audit_attach 000464 ab_buf audit_attach 000664 ab_len audit_attach 000666 temp_area audit_attach 004666 audit_file_header_ptr audit_attach 004670 position_template audit_attach 004712 position_info_template audit_attach 005024 mode_value_ptr audit_attach 005026 number_of_modes audit_attach 005030 mode_string_info_ptr audit_attach 005046 modes mode_string 005246 mode_idx mode_string audit_line 000100 position audit_line 000122 previous_position audit_line 000144 position_info audit_line 000255 bytes_required audit_line 000256 max_entry_size audit_line 000257 room_for_insertion audit_line 000260 trim_entry audit_line 000334 virtual_time insert 000336 paging insert 000337 dev_paging insert 000340 month insert 000341 day insert 000342 year insert 000343 dow insert 000344 zone insert force_audit_suspension 000100 info force_audit_suspension THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as r_ne_as alloc_char_temp cat_realloc_chars call_ent_var_desc call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return_mac tra_ext_1 mdfx1 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_chars_eis index_chars_eis op_alloc_ op_freen_ op_empty_ index_before_cs index_after_cs clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. abbrev_$expanded_line audit_editor audit_editor$set_last_return_line_position audit_file_position_$last com_err_ cpu_time_and_paging_ date_time_ decode_clock_value_ expand_pathname_$add_suffix find_condition_info_ get_temp_segment_ hcs_$assign_linkage hcs_$set_bc_seg hcs_$set_ips_mask hcs_$set_safety_sw_seg hcs_$status_mins ioa_$ioa_switch ioa_$ioa_switch_nnl iox_$control iox_$err_no_operation iox_$err_not_attached iox_$find_iocb iox_$get_chars iox_$get_line iox_$modes iox_$position iox_$propagate iox_$put_chars mode_string_$combine mode_string_$delete mode_string_$parse msf_manager_$adjust msf_manager_$close msf_manager_$get_ptr msf_manager_$open release_temp_segment_ sub_err_ user_info_$homedir THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$bad_mode_syntax error_table_$bad_mode_value error_table_$empty_file error_table_$long_record error_table_$noarg error_table_$noentry error_table_$not_detached error_table_$unimplemented_version sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 216 001141 220 001142 23 001147 261 001215 262 001220 263 001224 264 001226 267 001233 269 001267 270 001272 272 001273 273 001305 274 001326 277 001330 279 001365 281 001366 282 001377 284 001426 287 001440 288 001441 291 001444 295 001475 296 001500 298 001501 299 001556 302 001561 304 001631 306 001632 309 001633 311 001677 312 001702 314 001703 315 001705 318 001711 319 001730 320 001743 322 001755 323 001767 326 001774 327 002006 329 002031 330 002034 332 002035 333 002052 336 002056 337 002070 339 002113 341 002114 342 002120 343 002122 344 002126 345 002132 346 002135 347 002146 349 002151 350 002171 351 002203 352 002213 353 002240 354 002242 355 002244 360 002247 361 002252 362 002255 363 002257 364 002260 365 002261 366 002262 367 002263 368 002264 369 002270 370 002273 371 002276 372 002301 373 002303 374 002304 375 002307 377 002312 378 002337 382 002344 383 002370 386 002372 387 002404 391 002436 393 002437 395 002442 396 002444 397 002447 398 002451 399 002452 400 002454 401 002465 402 002466 404 002476 405 002502 406 002504 407 002506 408 002507 409 002512 410 002514 413 002515 414 002526 418 002602 419 002603 420 002604 423 002606 424 002633 427 002635 428 002647 430 002701 432 002702 435 002704 436 002707 438 002710 441 002712 442 002724 444 002747 445 002752 447 002753 450 003000 453 003002 454 003014 456 003046 458 003047 461 003074 464 003076 465 003110 469 003147 471 003150 474 003166 477 003167 478 003214 481 003216 482 003230 486 003267 488 003270 489 003273 490 003275 491 003277 494 003332 497 003334 498 003346 500 003400 502 003401 503 003402 504 003405 505 003406 506 003410 507 003412 508 003414 510 003420 511 003423 512 003425 513 003427 514 003431 515 003433 516 003435 518 003442 519 003444 521 003445 524 003462 525 003506 528 003510 529 003522 531 003554 533 003555 534 003564 535 003576 536 003577 539 003600 541 003615 542 003616 543 003630 544 003635 545 003637 546 003642 547 003651 548 003660 549 003662 551 003670 553 003704 554 003711 557 003714 559 003720 562 003725 563 003727 569 003741 570 003757 578 003761 581 004007 585 004011 588 004016 589 004041 593 004043 595 004057 597 004060 598 004072 600 004073 603 004106 604 004113 605 004115 608 004136 609 004150 610 004153 611 004157 612 004166 613 004200 614 004201 620 004202 622 004220 623 004225 624 004227 625 004231 626 004250 628 004252 630 004301 631 004302 633 004303 635 004334 636 004341 637 004343 638 004345 639 004347 641 004420 642 004424 645 004441 646 004467 649 004470 650 004517 653 004521 658 004600 665 004665 667 004675 668 004706 673 004732 674 004735 676 004736 679 004741 681 004757 684 004760 685 004763 686 004764 688 004765 692 005011 696 005024 697 005027 699 005030 700 005036 704 005051 705 005054 707 005055 709 005063 711 005066 715 005077 716 005102 718 005103 722 005114 723 005116 724 005117 726 005127 727 005131 728 005133 729 005135 730 005137 733 005140 734 005143 735 005144 739 005145 740 005147 743 005150 744 005153 746 005154 747 005157 748 005165 749 005167 751 005170 755 005203 756 005206 758 005207 759 005215 763 005230 764 005233 766 005234 767 005241 771 005254 772 005257 774 005260 775 005266 779 005301 780 005304 782 005305 783 005313 787 005326 788 005331 790 005332 791 005341 795 005354 796 005357 798 005360 799 005366 803 005406 804 005411 806 005412 807 005420 808 005422 809 005447 818 005457 821 005551 825 005644 826 005677 830 005700 832 005727 836 005730 839 005743 840 005750 841 005752 842 005754 843 005757 844 005761 848 005766 849 005770 850 005772 852 005776 855 006002 856 006004 857 006012 858 006015 859 006020 860 006022 864 006023 865 006024 866 006031 867 006033 868 006034 869 006035 875 006036 876 006056 880 006063 881 006067 882 006072 883 006073 884 006074 885 006077 886 006105 887 006110 888 006112 889 006130 891 006132 892 006135 893 006140 894 006143 895 006145 896 006146 898 006150 899 006153 903 006162 905 006206 906 006207 909 006214 910 006220 913 006223 915 006253 919 006321 920 006345 921 006350 922 006351 925 006353 927 006403 928 006425 929 006455 930 006505 931 006532 934 006557 935 006604 936 006634 938 006661 939 006711 940 006736 942 006757 943 007003 944 007006 945 007007 948 007011 949 007044 952 007076 955 007103 959 007110 960 007112 961 007115 962 007117 963 007120 964 007124 966 007132 967 007135 968 007137 969 007155 971 007157 972 007162 973 007165 974 007167 975 007171 976 007172 977 007176 979 007177 982 007203 984 007233 985 007236 986 007255 989 007303 992 007324 993 007326 996 007353 997 007354 1000 007356 1002 007406 1003 007432 1004 007435 1005 007464 1009 007471 1010 007474 1011 007475 1012 007476 1013 007502 1014 007506 1017 007507 1018 007510 1019 007511 1020 007516 1021 007522 1022 007523 1025 007525 1026 007530 1027 007531 1028 007532 1029 007535 1032 007536 1033 007537 1035 007543 1036 007544 1039 007546 1040 007550 1041 007551 1042 007555 1043 007557 1044 007560 1046 007561 1049 007563 1051 007613 1052 007615 1053 007622 1054 007623 1057 007625 1058 007627 1059 007633 1060 007634 1062 007657 1063 007660 1066 007703 1069 007707 1070 007711 1071 007720 1072 007724 1073 007727 1074 007732 1078 007733 1079 007734 1080 007742 1081 007745 1082 007746 1083 007747 1090 007750 1092 007767 1093 007774 1094 007776 1095 010000 1096 010015 1098 010017 1100 010046 1101 010047 1104 010050 1106 010066 1107 010073 1108 010075 1109 010077 1110 010114 1113 010115 1116 010141 1117 010146 1118 010150 1119 010152 1121 010211 1122 010220 1125 010225 1126 010230 1129 010234 1130 010236 1134 010272 1135 010273 1136 010276 1137 010277 1138 010301 1139 010305 1140 010306 1143 010312 1144 010324 1147 010325 1148 010352 1150 010353 1151 010354 1155 010366 1156 010423 1160 010424 1161 010451 1163 010452 1166 010462 1167 010465 1168 010466 1169 010513 1173 010514 1174 010541 1176 010542 1177 010543 1181 010544 1189 010565 1193 010566 1195 010600 1197 010614 1198 010621 1201 010624 1202 010631 1203 010633 1205 010653 1206 010654 1209 010657 1210 010661 1213 010663 1214 010664 1215 010667 1216 010670 1217 010671 1219 010672 1221 010673 1222 010711 1225 010714 1226 010715 1229 010726 1231 010727 1232 010742 1234 010743 1236 010744 1238 010756 1240 010767 1245 011011 1248 011024 1250 011025 1252 011026 1254 011042 1257 011057 1259 011066 1260 011073 1262 011074 1264 011075 1266 011116 1270 011130 1271 011133 1272 011151 1275 011214 1278 011217 1279 011220 1280 011232 1282 011233 1288 011235 1289 011256 1292 011272 1293 011273 1294 011303 1295 011304 1296 011307 1299 011310 1300 011312 1302 011317 1303 011320 1305 011343 1307 011344 1309 011345 1310 011351 1311 011353 1312 011355 1313 011357 1314 011361 1315 011363 1316 011365 1317 011370 1318 011373 1319 011374 1320 011376 1321 011402 1322 011405 1323 011411 1324 011413 1325 011415 1326 011417 1328 011431 1329 011435 1330 011436 1331 011437 1333 011440 1346 011456 1348 011465 1351 011471 1352 011504 1353 011507 1354 011527 1357 011532 1358 011537 1361 011545 1362 011572 1363 011576 1364 011600 1365 011601 1367 011603 1368 011607 1370 011627 1371 011635 1372 011644 1373 011651 1374 011653 1375 011655 1376 011660 1377 011666 1378 011677 1380 011705 1387 011706 1394 011714 1395 011733 1396 011744 1398 011745 1402 011753 1404 011757 1405 011761 1406 011763 1407 011764 1409 012022 1412 012023 1418 012025 1419 012030 1420 012033 1421 012035 1422 012046 1423 012050 1425 012057 1426 012063 1427 012075 1428 012077 1429 012100 1430 012101 1432 012103 1434 012106 1435 012110 1436 012116 1438 012117 1440 012122 1441 012124 1442 012132 1444 012133 1446 012136 1447 012140 1448 012145 1450 012146 1452 012151 1453 012153 1454 012161 1456 012162 1458 012165 1459 012167 1460 012175 1462 012176 1464 012201 1465 012203 1466 012214 1468 012215 1470 012220 1471 012222 1472 012230 1474 012231 1476 012234 1479 012240 1480 012242 1482 012252 1485 012253 1486 012255 1488 012262 1490 012263 1492 012266 1493 012270 1494 012276 1496 012277 1498 012302 1499 012304 1500 012312 1502 012313 1505 012315 1507 012344 1511 012354 1518 012355 1519 012360 1520 012405 1523 012407 1524 012426 1526 012427 1527 012440 1528 012442 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved