COMPILATION LISTING OF SEGMENT mseg_mbx_ms_gate_target_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 08/06/87 1020.1 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 /****^ HISTORY COMMENTS: 14* 1) change(85-05-29,Palter), approve(86-02-20,MCR7345), 15* audit(86-02-21,MSharpe), install(86-07-11,MR12.0-1092): 16* Changed to not call mseg_$delete_seg after calling mseg_$close_seg on the 17* target of the copy operation. Said call would cause fatal process errors 18* if the copy operation failed because the user did not have sufficient 19* access to create the target. 20* 2) change(85-06-12,Palter), approve(86-02-20,MCR7345), 21* audit(86-02-21,MSharpe), install(86-07-11,MR12.0-1092): 22* Fix the bug in ex_acl_list which would trash the user's area when the 23* mseg's ACL is empty and the user asks to list the entire ACL. 24* 3) change(85-07-19,Palter), approve(86-02-20,MCR7345), 25* audit(86-02-21,MSharpe), install(86-07-11,MR12.0-1092): 26* Fix wakeup_add_index and wakeup_aim_add_index to properly censor the 27* results of sending the wakeup and to return the message ID whenever the 28* message is added regardless of the success/failure of sending the wakeup. 29* 4) change(85-07-24,Palter), approve(86-02-20,MCR7345), 30* audit(86-02-21,MSharpe), install(86-07-11,MR12.0-1092): 31* Fix the old style read entrypoints to not change the caller's 32* mseg_return_args structure if an appropriate message is not found. 33* 5) change(86-03-21,MSharpe), approve(86-05-12,MCR7403), 34* audit(86-08-04,Lippard), install(86-08-06,MR12.0-1118): 35* Fixed ms_acl_list entry to return the acl terms for caller-specified 36* user_ids (when area_ptr = null). If the caller has specified a null 37* user_acl_ptr or a user_acl_count < 1, error_table_$argerr is returned. 38* 6) change(86-09-10,Dickson), approve(86-09-10,MCR7480), 39* audit(86-09-12,Lippard), install(86-09-15,MR12.0-1156): 40* Moved some initialization lines to before the clean_up handler is set in 41* the $copy entrypoint so that the variable error_on_target gets set upon an 42* early exit. 43* 7) change(86-09-30,Lippard), approve(86-11-24,MCR7578), 44* audit(87-07-13,Dickson), install(87-08-06,MR12.1-1067): 45* Changed to correctly diagnose entry names without valid suffixes and to 46* use error_table_$bad_file_name instead of $badstar. 47* END HISTORY COMMENTS */ 48 49 /* format: style3,idind30,linecom */ 50 mseg_mbx_ms_gate_target_: 51 procedure; 52 53 /* Modified for version 3 message segments by J. Stern, 11/01/74 */ 54 /* Modified to add mbx_wakeup_add_index and mbx_accept_wakeups_index 55* and mbx_set_max_length entries by Steve Herbst on 2/16/76 */ 56 /* Modified 5/77 for the installation of version 4 message segments */ 57 /* MCR 4171 Change default access on new mailboxes 12/14/79 S. Herbst */ 58 /* Modified by Benson Margulies for conversion to unaligned character strings */ 59 /* Modified 4/82 by E. N. Kittlitz to not delete through links */ 60 /* Modified: February 1983 by G. Palter to add validation, copy and compaction entrypoints */ 61 /* Modified: October 1983 by G. Palter to add get_uid_file and get_uid_index entrypoints */ 62 /* Modified: November 1983 by G. Palter to make get_mode_file use hcs_$get_user_access_modes */ 63 /* Modified: 84-05-07 BIM for get_process_access_class_ versus authorization */ 64 /* Modified: August 1984 by G. Palter to fix the following errors from the message segment error list: 65* #0001 -- mailbox_$create and message_segment_$create will add the ring-1 IACL to the ACL of the newly created 66* mailbox/message segment. The entries from the IACL will have null extended access. These gates should ignore 67* the ring-1 IACL; 68* #0003 -- mailbox_$get_uid_file, mailbox_$get_mode_file, mailbox_$set_safety_switch, and 69* mesage_segment_$set_safety_switch do not validate that their target is a mailbox or message segment as 70* appropriate; 71* #0005 -- When given a new ACL count of -1 or zero, mailbox_$mbx_acl_replace and message_segment_$ms_acl_replace will 72* incorrectly attempt to allocate a local copy of the input ACL array using the new ACL count as the size for the 73* array. This attempted allocation causes an area condition and, eventually, a fatal process error; and 74* #0006 -- mailbox_$copy and message_segment_$copy will create the target mailbox/message segment before validating 75* that the user has sufficient access to copy the segment */ 76 /* Modified 1984-10-11 BIM for new entrypoints, V5 */ 77 /* Modified February 1985 by M. Pandolf to add calls to mseg_check_access_ */ 78 /* Modified March 1985 by M. Pandolf to get mseg_ptr as soon as possible due to undependability of pathnames */ 79 /* Modified April 1985 by M. Pandolf to get and hold access information */ 80 /* Modified 1985-04-16, BIM: simplify get_mode, 81* reduce use of validation level setting. 82* MERGE MBX_MSEG_ with QUEUE_MSEG_ */ 83 84 /****^ Gate target procedure for the mailbox_ and message_segment_ gates. 85* This procedure is responsible for: 86* 87* argument copying 88* access checking except for per-message AIM checks 89* validation level management (for now) 90* 91* 92* BASIC STRATEGY 93* 94* One procedure, "entry_common", is responsible for: 95* 96* copying standard arguments. 97* calling mseg_check_access_ to check access for the operation. 98* setting the validation level down (and suppressing audit). 99* 100* 101* A single entrypoint serves both gates. The callerptr builtin 102* is used to distinguish the calling gate and select accordingly. 103* 104* The entrypoints are classed into four groups: 105* 106* INDEX_ENTRY called with an opening index 107* FILE_ENTRY called with a pathname which is initiated 108* FILE_BRIEF_ENTRY called with a pathname which is passed 109* to mseg_check_access_ and then to mseg_. 110* All neccessary data is returned in 111* the access_info substructure of the 112* mseg_operation structure. 113* FILE_TEMP_ENTRY called with a pathname, only because 114* there is no underlying ring 0 primitive 115* that will accept a pointer. These entries 116* all have windows that allow benign 117* hoaxing. 118* 119* 120* entry_common is called as follows: 121* 122* call entry_common (entry_type, base_operation); 123* 124* entry_common set up the mseg_operation structure 125* and calls mseg_check_access_. After that, the 126* individual entrypoint is on its own. 127* 128**/ 129 130 declare ( 131 INDEX_ENTRY init (1), 132 FILE_ENTRY init (2), 133 FILE_BRIEF_ENTRY init (3), 134 FILE_TEMP_ENTRY init (4) 135 ) int static fixed bin options (constant); 136 137 declare SUFFIX (2) char (8) aligned varying init (".mbx", ".ms") int static options (constant); 138 139 dcl ( 140 a_user_acl_count, /* acl count */ 141 user_acl_count, 142 a_ms_count, /* message count */ 143 ms_count, 144 a_mseg_index, /* message segment index */ 145 i, 146 read_entry_type 147 ) fixed bin; 148 149 dcl (a_max_length, max_length) fixed bin (19); 150 151 dcl a_ms_len fixed bin (24); /* bit length of message */ 152 153 dcl ( 154 a_code, /* error code (argument) */ 155 code, /* error code (internal) */ 156 error_table_$argerr ext, 157 error_table_$noalloc ext, 158 error_table_$no_append ext, 159 error_table_$null_info_ptr ext, 160 error_table_$unimplemented_version 161 ext, 162 error_table_$ai_restricted ext, 163 error_table_$action_not_performed 164 ext, 165 error_table_$bad_file_name ext, 166 error_table_$dirseg ext, 167 error_table_$inconsistent ext, 168 error_table_$invalid_lock_reset 169 ext, 170 error_table_$messages_deferred 171 ext, 172 error_table_$messages_off ext, 173 error_table_$moderr ext, 174 error_table_$no_info ext, 175 error_table_$not_seg_type ext, 176 error_table_$wakeup_denied ext, 177 error_table_$seg_unknown ext 178 ) fixed bin (35); 179 180 dcl (a_event_channel, user_event_channel, event_message) 181 fixed bin (71); 182 183 /* float bin */ 184 185 dcl a_compact_ratio float bin; /* % of garbage in mailbox to force compaction */ 186 187 /* pointers */ 188 189 dcl ( 190 a_area_ptr, /* pointer to user area */ 191 area_ptr, 192 a_arg_ptr, /* pointer to argument structure */ 193 arg_ptr, 194 a_user_acl_ptr, /* pointer to acl structures */ 195 user_acl_ptr, 196 a_ms_ptr, /* pointer to message */ 197 internal_acl_ptr, 198 static_table_ptr (2) int static init ((2) null ()) 199 /* ptr to mseg_table */ 200 ) ptr; 201 202 /* bit strings */ 203 204 dcl ( 205 error_on_target, 206 copy_entry, /* ON if mailbox copying entrypoint */ 207 a_error_on_target, /* set ON/OFF depending on where copy failed */ 208 file_sw, /* ON if file entry called */ 209 a_ms_wanted, /* which incremental message wanted */ 210 ms_wanted, 211 a_salv_bit, /* salvaged bit */ 212 salv_bit, 213 a_safety_switch, 214 safety_switch, 215 a_turn_off, /* ON if to turn off, salvaged bit */ 216 turn_off, 217 return_count, 218 validation_set 219 ) bit (1) aligned; 220 221 dcl ( 222 a_dir, /* direction of incremental read */ 223 dir 224 ) bit (2) aligned; 225 226 dcl ( 227 a_mode aligned, /* extended access mode */ 228 a_sw, /* wakeup control arg */ 229 test_lock_id aligned, /* to test for valid lock id */ 230 sys_info$ring1_privilege aligned external, 231 sys_info$ipc_privilege aligned external 232 ) bit (36); 233 234 dcl a_uid /* mailbox UID */ 235 bit (36) aligned; 236 237 dcl ( 238 a_access_class, 239 a_ms_id, /* message uid */ 240 ms_id 241 ) bit (72) aligned; 242 243 244 /* character strings */ 245 246 dcl ( 247 a_dn, /* directory name */ 248 a_en, /* message segment name */ 249 a_target_dn, /* for copying */ 250 a_target_en, /* for copying */ 251 a_new_en, /* for renaming */ 252 a_old_en /* for renaming */ 253 ) char (*); 254 255 dcl (new_en, old_en) char (32); 256 257 /* structures */ 258 259 dcl 1 operation aligned like mseg_operation; 260 dcl 1 target_operation aligned like mseg_operation; 261 /* spare for copy */ 262 263 264 declare 1 old_read_flags unaligned, 265 2 incremental bit (1), 266 2 incremental_direction bit (2), /* valid if incremental = "1"b */ 267 2 first_or_last bit (1), /* valid if incremental is "0"b */ 268 2 own bit (1), 269 2 delete bit (1), 270 2 pad bit (30); 271 272 /* builtins */ 273 274 dcl (addr, index, length, null, reverse, rtrim, setwordno, string, substr, unspec) 275 builtin; 276 277 /* conditions */ 278 279 dcl area condition; 280 dcl cleanup condition; 281 282 /* area */ 283 284 dcl system_area area based (get_system_free_area_ ()); 285 dcl user_area area based (area_ptr); 286 287 288 /* external entries */ 289 290 dcl admin_gate_$admin_level_no_fs_audit 291 entry (fixed bin (3) aligned); 292 dcl aim_util_$get_access_class entry (bit (72) aligned) returns (bit (72) aligned); 293 dcl aim_util_$get_privileges entry (bit (72) aligned) returns (bit (36) aligned); 294 dcl aim_check_$greater_or_equal entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); 295 dcl aim_check_$greater entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); 296 dcl cu_$caller_ptr entry returns (ptr); 297 dcl get_process_authorization_ entry () returns (bit (72) aligned); 298 dcl get_system_free_area_ ext entry returns (ptr); 299 dcl hcs_$level_get entry returns (fixed binary (3)); 300 dcl hcs_$level_set entry (fixed binary (3)); 301 dcl hcs_$wakeup ext entry (bit (36), fixed bin (71), fixed bin (71), fixed bin (35)); 302 303 304 dcl mseg_check_access_$audit_initiate_failure 305 entry (pointer, fixed binary (35)); 306 dcl mseg_check_access_$check ext entry (ptr, fixed bin (35)); 307 dcl mseg_check_access_$segment ext entry (ptr, fixed bin (35)); 308 309 dcl set_lock_$lock ext entry (bit (36) aligned, fixed bin (17), fixed bin (35)); 310 dcl sub_err_ entry () options (variable); 311 312 313 mseg_mbx_ms_gate_target_$validate: 314 entry (a_dn, a_en, a_code); 315 316 call entry_setup; 317 on cleanup call general_clean_up; 318 call entry_common (FILE_BRIEF_ENTRY, mseg_access_operations_$read_fs_attr_seg); 319 call RETURN (code); 320 321 322 mseg_mbx_ms_gate_target_$create: 323 entry (a_dn, a_en, a_code); 324 325 call entry_setup; 326 on cleanup call general_clean_up; 327 call entry_common (FILE_BRIEF_ENTRY, mseg_access_operations_$create_seg); 328 329 call mseg_$create_seg (addr (operation), null (), code); 330 331 call RETURN (code); 332 333 mseg_mbx_ms_gate_target_$delete_mseg: 334 entry (a_dn, a_en, a_code); 335 336 call entry_setup; 337 on cleanup call general_clean_up; 338 call entry_common (FILE_ENTRY, mseg_access_operations_$delete_seg); 339 340 file_sw = "0"b; /* no need to clean this up */ 341 342 call mseg_$delete_seg (addr (operation), static_table_ptr (operation.type), code); 343 /* it removes from the table, etc. */ 344 345 call RETURN (code); 346 347 mseg_mbx_ms_gate_target_$copy: 348 entry (a_dn, a_en, a_target_dn, a_target_en, a_error_on_target, a_code); 349 350 call entry_setup; 351 352 target_operation = addr (mseg_data_$template_operation) -> mseg_operation; 353 copy_entry = "1"b; /* Set so that when general_clean_up */ 354 /* gets called, error_on_target gets copied */ 355 error_on_target = "0"b; 356 357 on cleanup call general_clean_up; 358 359 call entry_common (FILE_ENTRY, mseg_access_operations_$copy_seg); 360 361 error_on_target = "1"b; /* any problem now is with the target */ 362 363 target_operation.caller = operation.caller; /* copy all fields that apply ... the caller */ 364 target_operation.call_admin_gate = operation.call_admin_gate; 365 /* whether to use multi-class */ 366 target_operation.type = operation.type; /* The type of segment */ 367 target_operation.dir_name = a_target_dn; 368 target_operation.entryname = a_target_en; 369 target_operation.mseg_pathname_valid = "1"b; 370 target_operation.access_operation = mseg_access_operations_$create_seg; 371 call mseg_check_access_$segment (addr (target_operation), code); 372 /* Test those target dir RB's ! */ 373 /* and chase those links */ 374 if code ^= 0 375 then call RETURN (code); 376 377 call mseg_$create_seg (addr (target_operation), null (), code); 378 if code ^= 0 379 then call RETURN (code); 380 381 call mseg_$initiate_seg (addr (target_operation), code); 382 /* mseg_create_ does not initiate since an empty mseg is EMPTY */ 383 if code ^= 0 384 then call RETURN (code); 385 386 call mseg_$copy_seg (addr (operation), addr (target_operation), a_error_on_target, code); 387 388 call RETURN (code); 389 390 mseg_mbx_ms_gate_target_$chname: 391 entry (a_dn, a_en, a_old_en, a_new_en, a_code); 392 393 call entry_setup; 394 on cleanup call general_clean_up; 395 call entry_common (FILE_ENTRY, mseg_access_operations_$modify_fs_attr_seg); 396 397 old_en = a_old_en; 398 new_en = a_new_en; 399 400 if old_en ^= "" 401 then do; 402 call check_name (old_en, code); 403 if code ^= 0 404 then call RETURN (code); 405 end; 406 if new_en ^= "" 407 then do; 408 call check_name (new_en, code); 409 if code ^= 0 410 then call RETURN (code); 411 end; 412 413 call mseg_$chname_seg (addr (operation), old_en, new_en, code); 414 call RETURN (code); 415 416 417 mseg_mbx_ms_gate_target_$get_uid_file: 418 entry (a_dn, a_en, a_uid, a_code); 419 420 call entry_setup; 421 on cleanup call general_clean_up; 422 call entry_common (FILE_BRIEF_ENTRY, mseg_access_operations_$read_fs_attr_seg); 423 424 a_uid = operation.access_info.uid; /* got the UID */ 425 call RETURN (code); 426 427 428 mseg_mbx_ms_gate_target_$get_uid_index: 429 entry (a_mseg_index, a_uid, a_code); 430 431 call entry_setup; 432 on cleanup call general_clean_up; 433 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_fs_attr_seg); 434 435 a_uid = operation.access_info.uid; /* got the UID */ 436 call RETURN (code); 437 438 mseg_mbx_ms_gate_target_$set_max_length_file: 439 entry (a_dn, a_en, a_max_length, a_code); 440 441 call entry_setup; 442 on cleanup call general_clean_up; 443 call entry_common (FILE_ENTRY, mseg_access_operations_$modify_fs_attr_seg); 444 445 max_length = a_max_length; 446 call mseg_$set_max_length_seg (addr (operation), max_length, code); 447 a_max_length = max_length; 448 call RETURN (code); 449 450 451 mseg_mbx_ms_gate_target_$set_safety_switch: 452 entry (a_dn, a_en, a_safety_switch, a_code); 453 454 call entry_setup; 455 on cleanup call general_clean_up; 456 call entry_common (FILE_ENTRY, mseg_access_operations_$modify_fs_attr_seg); 457 458 safety_switch = a_safety_switch; 459 460 call mseg_$set_safety_switch_seg (addr (operation), safety_switch, code); 461 call RETURN (code); 462 463 464 mseg_mbx_ms_gate_target_$compact_file: 465 entry (a_dn, a_en, a_compact_ratio, a_code); 466 467 call entry_setup; 468 on cleanup call general_clean_up; 469 call entry_common (FILE_ENTRY, mseg_access_operations_$compact_seg); 470 compact: 471 call mseg_$compact_seg (addr (operation), a_compact_ratio, code); 472 call RETURN (code); 473 474 475 mseg_mbx_ms_gate_target_$compact_index: 476 entry (a_mseg_index, a_compact_ratio, a_code); 477 478 call entry_setup; 479 on cleanup call general_clean_up; 480 call entry_common (INDEX_ENTRY, mseg_access_operations_$compact_seg); 481 go to compact; 482 483 mseg_mbx_ms_gate_target_$open_if_full: 484 entry (a_dn, a_en, a_salv_bit, a_ms_count, a_mseg_index, a_code); 485 486 call entry_setup; 487 on cleanup call general_clean_up; 488 call entry_common$$return_error (FILE_ENTRY, mseg_access_operations_$get_count_seg); 489 /* error codes analyzed here .... */ 490 491 /**** NOTE 492* If the code is zero, we can return the count and the salv bit 493* and only open if there is a non-zero count. 494* If the code is moderr then we open the mseg 495* and return 0 for the count and salv bit, and error_table_$moderr 496* for the code. 497* If the code is anything else we punt. */ 498 499 if code ^= 0 & code ^= error_table_$moderr 500 then call RETURN (code); 501 502 return_count = (code = 0); 503 salv_bit = "0"b; 504 ms_count = 0; 505 506 if return_count 507 then do; 508 call mseg_$get_salvaged_flag_seg (addr (operation), salv_bit, (0)); 509 a_salv_bit = salv_bit; 510 call mseg_$count_messages (addr (operation), ms_count, (0)); 511 a_ms_count = ms_count; 512 if ms_count = 0 513 then call RETURN (code); /* which will terminate the mseg */ 514 end; 515 516 if ^return_count /* we haven't seen any access yet */ 517 then do; 518 operation.access_operation = mseg_access_operations_$open_seg; 519 call mseg_check_access_$segment (addr (operation), code); 520 if code ^= 0 521 then call RETURN (code); 522 end; 523 524 call mseg_$open_seg (addr (operation), static_table_ptr (operation.type), code); 525 if code ^= 0 526 then call RETURN (code); /* no room at the inn, probably */ 527 file_sw = "0"b; /* don't terminate that pointer! */ 528 529 a_mseg_index = operation.mseg_index; 530 if ^return_count 531 then code = error_table_$moderr; /* no report if the salv bit fails */ 532 533 call RETURN (code); 534 535 mseg_mbx_ms_gate_target_$open: 536 entry (a_dn, a_en, a_mseg_index, a_code); 537 538 call entry_setup; 539 on cleanup call general_clean_up; 540 call entry_common (FILE_ENTRY, mseg_access_operations_$open_seg); 541 call mseg_$open_seg (addr (operation), static_table_ptr (operation.type), code); 542 if code ^= 0 543 then call RETURN (code); 544 file_sw = "0"b; /* don't terminate that pointer */ 545 546 a_mseg_index = operation.mseg_index; 547 call RETURN (code); 548 549 mseg_mbx_ms_gate_target_$close: 550 entry (a_mseg_index, a_code); 551 552 call entry_setup; 553 on cleanup call general_clean_up; 554 call entry_common (INDEX_ENTRY, mseg_access_operations_$close_seg); 555 556 if (operation.access_info.extended_access_modes & D_MBX_ACCESS) ^= ""b 557 then call mseg_$compact_seg (addr (operation), 0.25e0, (0)); 558 call mseg_$close_seg (addr (operation), static_table_ptr (operation.type), code); 559 call RETURN (code); 560 561 562 mseg_mbx_ms_gate_target_$ex_acl_add: 563 entry (a_dn, a_en, a_user_acl_ptr, a_user_acl_count, a_code); 564 565 call entry_setup; 566 on cleanup call general_clean_up; 567 call entry_common (FILE_TEMP_ENTRY, mseg_access_operations_$acl_modify_seg); 568 569 user_acl_ptr = a_user_acl_ptr; 570 user_acl_count = a_user_acl_count; 571 572 call copy_acl (user_acl_ptr, user_acl_count); 573 call mseg_$add_acl_entries_seg (addr (operation), acl_ptr, code); 574 call RETURN (code); 575 576 577 578 mseg_mbx_ms_gate_target_$ex_acl_delete: 579 entry (a_dn, a_en, a_user_acl_ptr, a_user_acl_count, a_area_ptr, a_code); 580 581 call entry_setup; 582 on cleanup call general_clean_up; 583 call entry_common (FILE_TEMP_ENTRY, mseg_access_operations_$acl_modify_seg); 584 585 user_acl_ptr = a_user_acl_ptr; 586 user_acl_count = a_user_acl_count; 587 588 call copy_acl$$delete (user_acl_ptr, user_acl_count); 589 call mseg_$delete_acl_entries_seg (addr (operation), acl_ptr, code); 590 call RETURN (code); 591 592 593 594 mseg_mbx_ms_gate_target_$ex_acl_list: 595 entry (a_dn, a_en, a_user_acl_ptr, a_user_acl_count, a_area_ptr, a_code); 596 597 call entry_setup; 598 on cleanup call general_clean_up; 599 call entry_common (FILE_TEMP_ENTRY, mseg_access_operations_$acl_list_seg); 600 601 user_acl_ptr = a_user_acl_ptr; 602 user_acl_count = a_user_acl_count; 603 area_ptr = a_area_ptr; 604 605 if area_ptr = null () 606 then do; 607 if (user_acl_ptr = null ()) | (user_acl_count < 1) 608 then call RETURN (error_table_$argerr); 609 610 call copy_acl (user_acl_ptr, user_acl_count); 611 call mseg_$list_acl_entries_seg (addr (operation), acl_ptr, code); 612 user_acl_ptr -> segment_acl_array = general_extended_acl.entries; 613 end; 614 else do; 615 call mseg_$list_acl_seg (addr (operation), acl_ptr, code); 616 if code ^= 0 617 then call RETURN (code); 618 acl_count = general_extended_acl.count; 619 on area 620 begin; 621 code = error_table_$noalloc; 622 call RETURN (code); 623 end; 624 allocate segment_acl_array in (user_area) set (user_acl_ptr); 625 revert area; 626 do i = 1 to acl_count; /* PL/I always copies at least 1 even if acl_count = 0 */ 627 user_acl_ptr -> segment_acl_array (i) = general_extended_acl.entries (i); 628 end; 629 a_user_acl_ptr = user_acl_ptr; 630 a_user_acl_count = acl_count; 631 end; 632 call RETURN (code); 633 634 mseg_mbx_ms_gate_target_$ex_acl_replace: 635 entry (a_dn, a_en, a_user_acl_ptr, a_user_acl_count, a_code); 636 637 call entry_setup; 638 on cleanup call general_clean_up; 639 call entry_common (FILE_TEMP_ENTRY, mseg_access_operations_$acl_modify_seg); 640 641 user_acl_ptr = a_user_acl_ptr; 642 user_acl_count = a_user_acl_count; 643 644 if user_acl_count > 0 645 then call copy_acl (user_acl_ptr, user_acl_count); 646 else acl_ptr = null (); 647 648 call mseg_$replace_acl_seg (addr (operation), acl_ptr, code); 649 650 if acl_ptr ^= null () 651 then user_acl_ptr -> segment_acl_array (*).status_code = general_extended_acl.entries (*).status_code; 652 call RETURN (code); 653 654 655 656 mseg_mbx_ms_gate_target_$read_index: 657 entry (a_mseg_index, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 658 659 call entry_setup; 660 on cleanup call general_clean_up; 661 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_message); 662 old_read: 663 area_ptr = a_area_ptr; 664 arg_ptr = a_arg_ptr; 665 ms_wanted = a_ms_wanted; 666 ms_id = ""b; 667 string (old_read_flags) = "0"b; 668 old_read_flags.first_or_last = ms_wanted; 669 call read_for_old_entrypoint (ms_id); 670 call RETURN (code); 671 672 673 mseg_mbx_ms_gate_target_$delete_index: 674 entry (a_mseg_index, a_ms_id, a_code); 675 676 call entry_setup; 677 on cleanup call general_clean_up; 678 call entry_common (INDEX_ENTRY, mseg_access_operations_$delete_message); 679 680 delete: 681 operation.message_info.ms_id = a_ms_id; 682 operation.message_info_valid = "1"b; 683 call mseg_$delete_message (addr (operation), code); 684 call RETURN (code); 685 686 687 mseg_mbx_ms_gate_target_$read_delete_index: 688 entry (a_mseg_index, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 689 690 call entry_setup; 691 on cleanup call general_clean_up; 692 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_delete_message); 693 694 old_read_delete: 695 area_ptr = a_area_ptr; 696 ms_wanted = a_ms_wanted; 697 arg_ptr = a_arg_ptr; 698 string (old_read_flags) = ""b; 699 ms_id = ""b; 700 old_read_flags.first_or_last = ms_wanted; 701 old_read_flags.delete = "1"b; 702 call read_for_old_entrypoint (ms_id); 703 call RETURN (code); 704 705 mseg_mbx_ms_gate_target_$admin_add_index: 706 entry (a_mseg_index, a_arg_ptr, a_ms_id, a_code); 707 708 call entry_setup; 709 on cleanup call general_clean_up; 710 call entry_common$$no_access_check (INDEX_ENTRY, mseg_access_operations_$admin_add_message); 711 /* access check needs message access class */ 712 713 /* This entry point, available through the privileged gate queue_admin_, 714* adds a message with attributes specified in the mseg_message_info structure. */ 715 716 admin_add: 717 mseg_message_info_ptr = a_arg_ptr; 718 operation.message_info = mseg_message_info; 719 operation.message_info_valid = "1"b; 720 operation.add_message_info_all_valid = "1"b; /* This makes mseg_ respect all the fields as input */ 721 if operation.message_info.version ^= MSEG_MESSAGE_INFO_V1 722 then call RETURN (error_table_$unimplemented_version); 723 724 call mseg_check_access_$segment (addr (operation), code); 725 if code ^= 0 726 then call RETURN (code); 727 728 call mseg_$add_message (addr (operation), code); 729 730 if code = 0 731 then do; 732 a_ms_id = operation.message_info.ms_id; 733 mseg_message_info = operation.message_info; 734 end; 735 call RETURN (code); 736 737 mseg_mbx_ms_gate_target_$admin_add_file: 738 entry (a_dn, a_en, a_arg_ptr, a_ms_id, a_code); 739 740 call entry_setup; 741 on cleanup call general_clean_up; 742 call entry_common$$no_access_check (FILE_ENTRY, mseg_access_operations_$admin_add_message); 743 /* access check needs message access class */ 744 745 go to admin_add; 746 747 748 mseg_mbx_ms_gate_target_$add_index: 749 entry (a_mseg_index, a_ms_ptr, a_ms_len, a_ms_id, a_code); 750 751 call entry_setup; 752 on cleanup call general_clean_up; 753 754 call entry_common$$no_access_check (INDEX_ENTRY, mseg_access_operations_$add_message); 755 756 operation.message_info.ms_access_class = aim_util_$get_access_class (operation.caller.authorization); 757 758 add: 759 call mseg_check_access_$segment (addr (operation), code); 760 if code ^= 0 761 then call RETURN (code); 762 operation.message_info.ms_ptr = a_ms_ptr; 763 operation.message_info.ms_len = a_ms_len; 764 operation.message_info_valid = "1"b; 765 call mseg_$add_message (addr (operation), code); 766 if code ^= 0 767 then call RETURN (code); 768 769 a_ms_id = operation.message_info.ms_id; 770 call RETURN (code); 771 772 773 774 /**** WAKEUP entrypoints */ 775 776 /****^ Error codes returned by these entry point: 777* 778* error_table_$ai_restricted 779* an attempt to write down a message 780* or write a message into an AIM inappropriate mseg. 781* error_table_$action_not_performed 782* normals not accepted, by urgents are. 783* error_table_$no_append 784* insufficient access to add a message. 785* error_table_$wakeup_denied 786* insufficient access to send a wakeup. 787* error_table_$messages_deferred 788* recipient has deferred messages. 789* error_table_$messages_off 790* recipient has not initialized for accepting messages. 791* error_table_$no_info 792* no information can be returned because recipient has higher authorization. 793**/ 794 795 mseg_mbx_ms_gate_target_$wakeup_add_index: 796 entry (a_mseg_index, a_ms_ptr, a_ms_len, a_sw, a_ms_id, a_code); 797 798 call entry_setup; 799 on cleanup call general_clean_up; 800 call entry_common$$no_access_check (INDEX_ENTRY, mseg_access_operations_$add_message); 801 operation.message_info.ms_access_class = aim_util_$get_access_class (operation.caller.authorization); 802 operation.message_info_valid = "1"b; 803 call wakeup_add; 804 805 mseg_mbx_ms_gate_target_$wakeup_aim_add_index: 806 entry (a_mseg_index, a_ms_ptr, a_ms_len, a_sw, a_access_class, a_ms_id, a_code); 807 808 call entry_setup; 809 on cleanup call general_clean_up; 810 call entry_common$$no_access_check (INDEX_ENTRY, mseg_access_operations_$add_message); 811 operation.message_info.ms_access_class = a_access_class; 812 operation.message_info_valid = "1"b; 813 call wakeup_add; 814 815 mseg_mbx_ms_gate_target_$wakeup_add_file: 816 entry (a_dn, a_en, a_ms_ptr, a_ms_len, a_sw, a_ms_id, a_code); 817 818 call entry_setup; 819 on cleanup call general_clean_up; 820 call entry_common$$no_access_check (FILE_ENTRY, mseg_access_operations_$add_message); 821 operation.message_info.ms_access_class = aim_util_$get_access_class (operation.caller.authorization); 822 operation.message_info_valid = "1"b; 823 call wakeup_add; 824 825 mseg_mbx_ms_gate_target_$wakeup_aim_add_file: 826 entry (a_dn, a_en, a_ms_ptr, a_ms_len, a_sw, a_access_class, a_ms_id, a_code); 827 828 call entry_setup; 829 on cleanup call general_clean_up; 830 call entry_common$$no_access_check (FILE_ENTRY, mseg_access_operations_$add_message); 831 operation.message_info.ms_access_class = a_access_class; 832 operation.message_info_valid = "1"b; 833 call wakeup_add; 834 835 836 wakeup_add: 837 procedure (); 838 839 declare user_accepting bit (1) aligned; 840 declare censor_wakeup_code bit (1) aligned; 841 declare wakeup bit (1) aligned; 842 declare wakeup_code fixed bin (35); 843 dcl 1 switch aligned, /* wakeup control switches */ 844 2 normal_wakeup bit (1) unaligned, 845 2 urgent_wakeup bit (1) unaligned, 846 2 always_add bit (1) unaligned, 847 2 never_add bit (1) unaligned, 848 2 pad bit (32) unaligned; 849 850 operation.message_info.ms_ptr = a_ms_ptr; 851 operation.message_info.ms_len = a_ms_len; 852 unspec (switch) = a_sw; 853 854 wakeup = switch.normal_wakeup | switch.urgent_wakeup; 855 856 if wakeup 857 then call investigate_acceptance (user_accepting); 858 else user_accepting = "0"b; 859 860 if user_accepting 861 then /* implies that wakeup is set */ 862 if aim_check_$greater_or_equal (operation.wakeup_state.access_class, 863 operation.message_info.ms_access_class) /* acceptor is higher than planned access class of message */ 864 then operation.message_info.ms_access_class = operation.wakeup_state.access_class; 865 /* Upgrade, over-riding any user-specified access class */ 866 867 868 /**** Now we are ready to check access. 869* The user is requesting that we add a message. 870* 871* 1) Test to see if the message can be added. 872* 2) If it cannot be added, quit. 873* 3) If a wakeup is required, test to see if the wakeup can be sent. 874* 4) If it cannot be sent, and always_add is not enabled, then quit. 875* 5) Add the message. 876* 6) If a wakeup can be sent, send it. */ 877 878 879 /**** Has the user "a" access and is the AIM situation plausible ? */ 880 881 operation.access_operation = mseg_access_operations_$add_message; 882 call mseg_check_access_$check (addr (operation), code); 883 884 if code ^= 0 885 then do; 886 if ^switch.never_add 887 then do; /* Never add --> don't do anthing, so we shouldn't audit it. */ 888 call mseg_check_access_$segment (addr (operation), (0)); 889 /* Okay, audit */ 890 end; 891 if code = error_table_$moderr 892 then code = error_table_$no_append; 893 call RETURN (code); /* and punt */ 894 end; 895 896 897 /**** Now, can we send a wakeup? */ 898 899 if wakeup 900 then do; 901 wakeup_code = 0; 902 if switch.normal_wakeup 903 then operation.access_operation = mseg_access_operations_$send_normal_wakeup; 904 else operation.access_operation = mseg_access_operations_$send_urgent_wakeup; 905 906 /**** This just makes the w/u mode checks. It makes NO aim checks */ 907 908 if switch.never_add 909 then call mseg_check_access_$check (addr (operation), code); 910 else call mseg_check_access_$segment (addr (operation), code); 911 912 if code ^= 0 913 then if switch.always_add 914 then wakeup_code = error_table_$wakeup_denied; 915 else call RETURN (error_table_$wakeup_denied); 916 917 918 /**** If the user lacks w/u, that lack governs the error code, as 919* calculated above. If the user has w/u, then the user is entitled 920* to hear that there is noone accepting by getting messages_off. */ 921 922 if ^user_accepting & wakeup_code = 0 923 then if switch.always_add 924 then wakeup_code = error_table_$messages_off; 925 else call RETURN (error_table_$messages_off); 926 927 928 /**** Now we have a little problem. We cannot tell if we will succeed 929* at sending a wakeup on AIM grounds, since it will depend on 930* the receiver's privilege situation. (and, or course, that 931* cannot be investigated via admin gate, and could change at any time.) 932* So we pretend that receiver IPC privilege don't exist, 933* and demand either that we have ipc priv, that no priv is needed, 934* or that always_add be on. This check does NOT audit. Turning off 935* always add means "if I could send without an AIM error, send. 936* If you cannot tell me that, then don't send and return ai_restricted" 937* Note that if always_add is on, and we DO call hcs_$wakeup, 938* it might return 0 due to target IPC priv. */ 939 940 if user_accepting & ^switch.always_add 941 then if ((operation.caller.privileges & sys_info$ipc_privilege) = ""b) 942 then if ^aim_check_$greater_or_equal (operation.wakeup_state.access_class, 943 operation.caller.authorization) 944 then call RETURN (error_table_$ai_restricted); 945 946 /**** From now on, if the acceptor is aim-greater than us, we censor 947* all results to no-info. Why isn't this in the access kernel? 948* Because it's just too hard to arrange. */ 949 950 if user_accepting 951 then censor_wakeup_code = 952 ((operation.caller.privileges & sys_info$ring1_privilege) = ""b) 953 & aim_check_$greater (operation.wakeup_state.access_class, operation.caller.authorization); 954 else censor_wakeup_code = "0"b; 955 956 /**** Okay, now we have passed the per-se access control checks. Now we 957* see if the acceptor of messages is willing to accept a message 958* from this process. */ 959 960 if wakeup_code = 0 & user_accepting 961 then do; 962 963 if (switch.urgent_wakeup & ^operation.wakeup_state.accepting_urgent_wakeups) 964 then if switch.always_add 965 then wakeup_code = error_table_$messages_deferred; 966 else call WAKEUP_RETURN (error_table_$messages_deferred); 967 968 if (switch.normal_wakeup & ^operation.wakeup_state.accepting_normal_wakeups) 969 then do; 970 if operation.wakeup_state.accepting_urgent_wakeups 971 then wakeup_code = error_table_$action_not_performed; 972 else wakeup_code = error_table_$messages_deferred; 973 if ^switch.always_add 974 then call WAKEUP_RETURN (wakeup_code); 975 976 end; 977 end; 978 end; 979 980 981 /**** Okay, we are ready to actually do something. If we cannot send 982* the wakeup, wakeup_code has the reason why, subject to censorship */ 983 984 if switch.never_add 985 then do; 986 operation.message_info.ms_id = ""b; 987 code = 0; 988 end; 989 990 991 else do; 992 993 /* add message */ 994 995 operation.access_operation = mseg_access_operations_$add_message; 996 call mseg_check_access_$segment (addr (operation), (0)); 997 /* audit the add now */ 998 call mseg_$add_message (addr (operation), code); 999 1000 /* send wakeup */ 1001 1002 if wakeup & code = 0 & wakeup_code = 0 & user_accepting 1003 then do; 1004 unspec (event_message) = operation.message_info.ms_id; 1005 call hcs_$wakeup ((operation.wakeup_state.process_id), operation.wakeup_state.event_channel, 1006 event_message, wakeup_code); 1007 if wakeup_code ^= 0 & wakeup_code ^= error_table_$wakeup_denied 1008 then wakeup_code = error_table_$messages_off; 1009 end; 1010 end; 1011 1012 if code = 0 1013 then do; /* the message was added */ 1014 a_ms_id = operation.message_info.ms_id; 1015 if wakeup 1016 then call WAKEUP_RETURN (wakeup_code); /* ... tell the caller what happened to the wakeup (maybe) */ 1017 else call RETURN (0); 1018 end; 1019 1020 else call RETURN (code); 1021 1022 1023 investigate_acceptance: 1024 procedure (accepting); 1025 1026 declare accepting bit (1) aligned; 1027 1028 accepting = "0"b; /* until proven otherwise */ 1029 1030 call mseg_$get_wakeup_state_seg (addr (operation), code); 1031 1032 if (code ^= 0) & (code ^= error_table_$messages_off) 1033 then call RETURN (code); /* message segment kaboom */ 1034 if code = 0 1035 then do; 1036 test_lock_id = operation.wakeup_state.lock_id; 1037 call set_lock_$lock (test_lock_id, 0, code); 1038 if code = 0 | code = error_table_$invalid_lock_reset 1039 then code = error_table_$messages_off; 1040 else code = 0; 1041 end; 1042 if code = 0 1043 then do; 1044 accepting = "1"b; 1045 operation.wakeup_state_valid = "1"b; /* used inside check-access later */ 1046 end; 1047 1048 return; 1049 end investigate_acceptance; 1050 1051 WAKEUP_RETURN: 1052 procedure (w_code); 1053 1054 declare w_code fixed bin (35); 1055 1056 if censor_wakeup_code 1057 then call RETURN (error_table_$no_info); 1058 else call RETURN (w_code); 1059 end WAKEUP_RETURN; 1060 1061 end wakeup_add; 1062 1063 1064 mseg_mbx_ms_gate_target_$accept_wakeups_index: 1065 entry (a_mseg_index, a_event_channel, a_sw, a_code); 1066 1067 call entry_setup; 1068 on cleanup call general_clean_up; 1069 1070 call entry_common$$no_access_check (INDEX_ENTRY, mseg_access_operations_$accept_wakeups_seg); 1071 /* access check requires the segment's wakeup state */ 1072 1073 call accept_wakeups; 1074 call RETURN (code); 1075 1076 1077 accept_wakeups: 1078 procedure (); 1079 1080 dcl 1 switch aligned, /* wakeup control switches */ 1081 2 normal_wakeup bit (1) unaligned, 1082 2 urgent_wakeup bit (1) unaligned; 1083 1084 user_event_channel = a_event_channel; 1085 unspec (switch) = substr(a_sw,1,length(unspec(switch))); 1086 1087 call mseg_$get_wakeup_state_seg (addr (operation), code); 1088 if (code ^= 0) & (code ^= error_table_$messages_off) 1089 then return; 1090 operation.wakeup_state_valid = (code = 0); 1091 1092 call mseg_check_access_$segment (addr (operation), code); 1093 if code ^= 0 1094 then return; 1095 1096 operation.wakeup_state.accepting_normal_wakeups = switch.normal_wakeup; 1097 operation.wakeup_state.accepting_urgent_wakeups = switch.urgent_wakeup; 1098 operation.wakeup_state.event_channel = user_event_channel; 1099 operation.wakeup_state_valid = "1"b; 1100 1101 call mseg_$set_wakeup_state_seg (addr (operation), code); 1102 return; 1103 end accept_wakeups; 1104 1105 1106 mseg_mbx_ms_gate_target_$incremental_read_index: 1107 entry (a_mseg_index, a_area_ptr, a_dir, a_ms_id, a_arg_ptr, a_code); 1108 1109 call entry_setup; 1110 on cleanup call general_clean_up; 1111 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_message); 1112 1113 old_incremental_read: 1114 area_ptr = a_area_ptr; 1115 dir = a_dir; 1116 ms_id = a_ms_id; 1117 arg_ptr = a_arg_ptr; 1118 string (old_read_flags) = ""b; 1119 old_read_flags.incremental = "1"b; 1120 old_read_flags.incremental_direction = dir; 1121 call read_for_old_entrypoint (ms_id); 1122 call RETURN (code); 1123 1124 mseg_mbx_ms_gate_target_$get_message_count_index: 1125 entry (a_mseg_index, a_ms_count, a_code); 1126 1127 call entry_setup; 1128 on cleanup call general_clean_up; 1129 call entry_common (INDEX_ENTRY, mseg_access_operations_$get_count_seg); 1130 1131 get_message_count: 1132 call mseg_$count_messages (addr (operation), ms_count, code); 1133 a_ms_count = ms_count; 1134 call RETURN (code); 1135 1136 1137 mseg_mbx_ms_gate_target_$get_mode_index: 1138 entry (a_mseg_index, a_mode, a_code); 1139 1140 call entry_setup; 1141 on cleanup call general_clean_up; 1142 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_fs_attr_seg); 1143 1144 get_mode: 1145 a_mode = operation.access_info.extended_access_modes; 1146 call RETURN (code); 1147 1148 1149 mseg_mbx_ms_gate_target_$check_salv_bit_index: 1150 entry (a_mseg_index, a_turn_off, a_salv_bit, a_code); 1151 1152 call entry_setup; 1153 on cleanup call general_clean_up; 1154 turn_off = a_turn_off; 1155 1156 if ^turn_off 1157 then call entry_common (INDEX_ENTRY, mseg_access_operations_$read_attr_seg); 1158 else call entry_common (INDEX_ENTRY, mseg_access_operations_$reset_salvage_bit_seg); 1159 1160 check_salv_bit: 1161 call mseg_$get_salvaged_flag_seg (addr (operation), salv_bit, code); 1162 if code ^= 0 1163 then call RETURN (code); 1164 if turn_off 1165 then call mseg_$reset_salvaged_flag_seg (addr (operation), code); 1166 a_salv_bit = salv_bit; 1167 call RETURN (code); 1168 1169 1170 1171 mseg_mbx_ms_gate_target_$update_message_index: 1172 entry (a_mseg_index, a_ms_len, a_ms_id, a_ms_ptr, a_code); 1173 1174 call entry_setup; 1175 on cleanup call general_clean_up; 1176 call entry_common (INDEX_ENTRY, mseg_access_operations_$update_message); 1177 1178 update_message: 1179 operation.message_info.ms_len = a_ms_len; 1180 operation.message_info.ms_id = a_ms_id; 1181 operation.message_info.ms_ptr = a_ms_ptr; 1182 operation.message_info_valid = "1"b; 1183 call mseg_$update_message (addr (operation), code); 1184 call RETURN (code); 1185 1186 1187 mseg_mbx_ms_gate_target_$read_file: 1188 entry (a_dn, a_en, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 1189 1190 call entry_setup; 1191 on cleanup call general_clean_up; 1192 call entry_common (FILE_ENTRY, mseg_access_operations_$read_message); 1193 go to old_read; 1194 1195 1196 mseg_mbx_ms_gate_target_$delete_file: 1197 entry (a_dn, a_en, a_ms_id, a_code); 1198 1199 call entry_setup; 1200 on cleanup call general_clean_up; 1201 call entry_common (FILE_ENTRY, mseg_access_operations_$delete_message); 1202 go to delete; 1203 1204 1205 1206 mseg_mbx_ms_gate_target_$read_delete_file: 1207 entry (a_dn, a_en, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 1208 1209 call entry_setup; 1210 on cleanup call general_clean_up; 1211 call entry_common (FILE_ENTRY, mseg_access_operations_$read_delete_message); 1212 go to old_read_delete; 1213 1214 1215 mseg_mbx_ms_gate_target_$add_file: 1216 entry (a_dn, a_en, a_ms_ptr, a_ms_len, a_ms_id, a_code); 1217 1218 call entry_setup; 1219 on cleanup call general_clean_up; 1220 call entry_common$$no_access_check (FILE_ENTRY, mseg_access_operations_$add_message); 1221 operation.message_info.ms_access_class = aim_util_$get_access_class (operation.caller.authorization); 1222 go to add; 1223 1224 mseg_mbx_ms_gate_target_$accept_wakeups_file: 1225 entry (a_dn, a_en, a_event_channel, a_code); 1226 1227 call entry_setup; 1228 on cleanup call general_clean_up; 1229 1230 call entry_common$$no_access_check (FILE_ENTRY, mseg_access_operations_$accept_wakeups_seg); 1231 /* access check requires segment's wakeup state */ 1232 1233 call accept_wakeups; 1234 call RETURN (code); 1235 1236 mseg_mbx_ms_gate_target_$incremental_read_file: 1237 entry (a_dn, a_en, a_area_ptr, a_dir, a_ms_id, a_arg_ptr, a_code); 1238 1239 call entry_setup; 1240 on cleanup call general_clean_up; 1241 call entry_common (FILE_ENTRY, mseg_access_operations_$read_message); 1242 go to old_incremental_read; 1243 1244 mseg_mbx_ms_gate_target_$get_message_count_file: 1245 entry (a_dn, a_en, a_ms_count, a_code); 1246 1247 call entry_setup; 1248 on cleanup call general_clean_up; 1249 call entry_common (FILE_ENTRY, mseg_access_operations_$get_count_seg); 1250 go to get_message_count; 1251 1252 mseg_mbx_ms_gate_target_$get_mode_file: 1253 entry (a_dn, a_en, a_mode, a_code); 1254 1255 call entry_setup; 1256 on cleanup call general_clean_up; 1257 call entry_common (FILE_BRIEF_ENTRY, mseg_access_operations_$read_fs_attr_seg); 1258 go to get_mode; 1259 1260 1261 mseg_mbx_ms_gate_target_$check_salv_bit_file: 1262 entry (a_dn, a_en, a_turn_off, a_salv_bit, a_code); 1263 1264 turn_off = a_turn_off; 1265 call entry_setup; 1266 on cleanup call general_clean_up; 1267 1268 if ^turn_off 1269 then call entry_common (FILE_ENTRY, mseg_access_operations_$read_attr_seg); 1270 else call entry_common (FILE_ENTRY, mseg_access_operations_$reset_salvage_bit_seg); 1271 1272 go to check_salv_bit; 1273 1274 mseg_mbx_ms_gate_target_$update_message_file: 1275 entry (a_dn, a_en, a_ms_len, a_ms_id, a_ms_ptr, a_code); 1276 1277 call entry_setup; 1278 on cleanup call general_clean_up; 1279 call entry_common (FILE_ENTRY, mseg_access_operations_$update_message); 1280 go to update_message; 1281 1282 mseg_mbx_ms_gate_target_$o_read_index: 1283 entry (a_mseg_index, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 1284 1285 call entry_setup; 1286 on cleanup call general_clean_up; 1287 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_own_message); 1288 1289 old_o_read: 1290 area_ptr = a_area_ptr; 1291 ms_wanted = a_ms_wanted; 1292 arg_ptr = a_arg_ptr; 1293 string (old_read_flags) = ""b; 1294 old_read_flags.first_or_last = ms_wanted; 1295 old_read_flags.own = "1"b; 1296 ms_id = ""b; 1297 call read_for_old_entrypoint (ms_id); 1298 call RETURN (code); 1299 1300 1301 mseg_mbx_ms_gate_target_$o_incremental_read_index: 1302 entry (a_mseg_index, a_area_ptr, a_dir, a_ms_id, a_arg_ptr, a_code); 1303 1304 call entry_setup; 1305 on cleanup call general_clean_up; 1306 call entry_common (INDEX_ENTRY, mseg_access_operations_$read_own_message); 1307 1308 old_o_incremental_read: 1309 area_ptr = a_area_ptr; 1310 dir = a_dir; 1311 ms_id = a_ms_id; 1312 arg_ptr = a_arg_ptr; 1313 string (old_read_flags) = ""b; 1314 old_read_flags.incremental = "1"b; 1315 old_read_flags.incremental_direction = dir; 1316 old_read_flags.own = "1"b; 1317 call read_for_old_entrypoint (ms_id); 1318 call RETURN (code); 1319 1320 mseg_mbx_ms_gate_target_$o_read_file: 1321 entry (a_dn, a_en, a_area_ptr, a_ms_wanted, a_arg_ptr, a_code); 1322 1323 call entry_setup; 1324 on cleanup call general_clean_up; 1325 call entry_common (FILE_ENTRY, mseg_access_operations_$read_own_message); 1326 go to old_o_read; 1327 1328 1329 1330 mseg_mbx_ms_gate_target_$o_incremental_read_file: 1331 entry (a_dn, a_en, a_area_ptr, a_dir, a_ms_id, a_arg_ptr, a_code); 1332 1333 call entry_setup; 1334 on cleanup call general_clean_up; 1335 call entry_common (FILE_ENTRY, mseg_access_operations_$read_own_message); 1336 go to old_o_incremental_read; 1337 1338 mseg_mbx_ms_gate_target_$general_read_index: 1339 entry (a_mseg_index, a_area_ptr, a_arg_ptr, a_code); 1340 1341 call entry_setup; 1342 on cleanup call general_clean_up; 1343 read_entry_type = INDEX_ENTRY; 1344 1345 read: 1346 area_ptr = a_area_ptr; 1347 mseg_message_info_ptr = a_arg_ptr; 1348 operation.message_info = mseg_message_info; 1349 if operation.message_info.version ^= MSEG_MESSAGE_INFO_V1 1350 then do; 1351 code = error_table_$unimplemented_version; 1352 call RETURN (code); 1353 end; 1354 1355 if operation.message_info.delete & operation.message_info.own 1356 then call entry_common (read_entry_type, mseg_access_operations_$read_delete_own_message); 1357 else if operation.message_info.delete 1358 then call entry_common (read_entry_type, mseg_access_operations_$read_delete_message); 1359 else if operation.message_info.own 1360 then call entry_common (read_entry_type, mseg_access_operations_$read_own_message); 1361 else call entry_common (read_entry_type, mseg_access_operations_$read_message); 1362 1363 operation.message_info_valid = "1"b; 1364 call mseg_$read_message (addr (operation), area_ptr, code); 1365 mseg_message_info = operation.message_info; 1366 call RETURN (code); 1367 1368 mseg_mbx_ms_gate_target_$general_read_file: 1369 entry (a_dn, a_en, a_area_ptr, a_arg_ptr, a_code); 1370 1371 call entry_setup; 1372 on cleanup call general_clean_up; 1373 1374 read_entry_type = FILE_ENTRY; 1375 go to read; 1376 1377 check_name: 1378 proc (entryname, code); 1379 1380 dcl entryname char (32); 1381 dcl code fixed bin (35); 1382 dcl slength fixed bin; 1383 dcl sindex fixed bin; 1384 1385 code = 0; 1386 slength = length (rtrim (entryname)); 1387 sindex = index (reverse (rtrim (entryname)), "."); 1388 if sindex ^= 0 then 1389 if substr (entryname, slength - sindex + 1) = SUFFIX (operation.type) then; 1390 else code = error_table_$bad_file_name; 1391 else code = error_table_$bad_file_name; 1392 return; 1393 end check_name; 1394 1395 copy_acl: 1396 proc (p_acl_ptr, p_acl_count); 1397 1398 dcl p_acl_ptr ptr; 1399 dcl p_acl_count fixed bin; 1400 1401 if p_acl_count = 0 | p_acl_ptr = null () 1402 then do; 1403 acl_count = 0; 1404 acl_ptr = null (); 1405 end; 1406 1407 acl_count = p_acl_count; 1408 allocate general_extended_acl set (internal_acl_ptr); 1409 acl_ptr = internal_acl_ptr; 1410 1411 general_extended_acl.version = GENERAL_EXTENDED_ACL_VERSION_1; 1412 general_extended_acl.entries = p_acl_ptr -> segment_acl_array; 1413 1414 return; 1415 1416 copy_acl$$delete: 1417 entry (p_acl_ptr, p_acl_count); 1418 1419 if p_acl_ptr = null () | p_acl_count = 0 1420 then call RETURN (error_table_$null_info_ptr); 1421 1422 if p_acl_count = -1 1423 then do; 1424 acl_ptr, internal_acl_ptr = null (); /* null to the primitive means "delete all" */ 1425 acl_count = 0; /* never looked at */ 1426 return; 1427 end; 1428 1429 acl_count = p_acl_count; 1430 allocate general_delete_acl set (internal_acl_ptr); 1431 acl_ptr = internal_acl_ptr; 1432 1433 general_delete_acl.version = GENERAL_DELETE_ACL_VERSION_1; 1434 general_delete_acl.entries = p_acl_ptr -> delete_acl_array; 1435 return; 1436 1437 end copy_acl; 1438 1439 1440 1441 free: 1442 procedure; 1443 1444 if internal_acl_ptr ^= null 1445 then free internal_acl_ptr -> general_extended_acl in (system_area); 1446 return; 1447 1448 end free; 1449 1450 1451 set_admin_level: 1452 procedure; 1453 1454 validation_set = "1"b; 1455 if operation.call_admin_gate 1456 then call admin_gate_$admin_level_no_fs_audit ((0)); 1457 /* we already stored the caller level */ 1458 else call hcs_$level_set (mseg_data_$execution_ring); 1459 return; 1460 end set_admin_level; 1461 1462 reset_admin_level: 1463 procedure; 1464 1465 if validation_set 1466 then call hcs_$level_set (operation.caller.validation_level); 1467 validation_set = "0"b; 1468 return; 1469 end reset_admin_level; 1470 1471 general_clean_up: 1472 procedure; 1473 1474 if file_sw 1475 then call mseg_$close_seg (addr (operation), table_ptr, (0)); 1476 if copy_entry 1477 then call clean_up_copy; 1478 if internal_acl_ptr ^= null () 1479 then do; 1480 if general_extended_acl.version = GENERAL_EXTENDED_ACL_VERSION_1 1481 then user_acl_ptr -> segment_acl_array (*).status_code = general_extended_acl.entries (*).status_code; 1482 else if general_delete_acl.version = GENERAL_DELETE_ACL_VERSION_1 1483 then user_acl_ptr -> delete_acl_array (*).status_code = general_delete_acl.entries (*).status_code; 1484 call free; 1485 end; 1486 call reset_admin_level (); 1487 1488 clean_up_copy: 1489 procedure; 1490 1491 call mseg_$close_seg (addr (target_operation), table_ptr, (0)); 1492 a_error_on_target = error_on_target; 1493 return; 1494 end clean_up_copy; 1495 1496 end general_clean_up; 1497 1498 1499 RETURN_: 1500 call general_clean_up; 1501 if code = error_table_$dirseg 1502 then code = error_table_$not_seg_type; 1503 a_code = code; 1504 return; 1505 1506 1507 EARLY_RETURN: 1508 if code = error_table_$dirseg 1509 then code = error_table_$not_seg_type; 1510 a_code = code; 1511 1512 return; 1513 1514 read_for_old_entrypoint: 1515 procedure (a_ms_id); 1516 1517 declare 1 mra aligned like mseg_return_args; 1518 declare a_ms_id bit (72) aligned; 1519 1520 operation.message_info.ms_id = a_ms_id; 1521 1522 if ^old_read_flags.incremental 1523 then do; 1524 if old_read_flags.first_or_last 1525 then operation.message_info.message_code = MSEG_READ_LAST; 1526 else operation.message_info.message_code = MSEG_READ_FIRST; 1527 end; 1528 else if old_read_flags.incremental_direction = "00"b 1529 then operation.message_info.message_code = MSEG_READ_SPECIFIED; 1530 else if old_read_flags.incremental_direction = "10"b 1531 then operation.message_info.message_code = MSEG_READ_BEFORE_SPECIFIED; 1532 else if old_read_flags.incremental_direction = "01"b 1533 then operation.message_info.message_code = MSEG_READ_AFTER_SPECIFIED; 1534 else call RETURN (error_table_$inconsistent); /* incr with bad direction */ 1535 1536 operation.message_info.own = old_read_flags.own; 1537 operation.message_info.delete = old_read_flags.delete; 1538 operation.message_info_valid = "1"b; 1539 call mseg_$read_message (addr (operation), area_ptr, code); 1540 if code = 0 1541 then do; 1542 mra.ms_ptr = operation.message_info.ms_ptr; 1543 mra.ms_len = operation.message_info.ms_len; 1544 mra.sender_id = operation.message_info.sender_id; 1545 mra.level = operation.message_info.sender_level; 1546 mra.ms_id = operation.message_info.ms_id; 1547 mra.sender_authorization = operation.message_info.sender_authorization; 1548 mra.access_class = operation.message_info.ms_access_class; 1549 arg_ptr -> mseg_return_args = mra; 1550 end; 1551 return; 1552 end read_for_old_entrypoint; 1553 1554 1555 entry_setup: 1556 procedure; 1557 1558 declare ( 1559 message_segment_$, 1560 mailbox_$, 1561 queue_admin_$ 1562 ) bit (36) aligned ext static; 1563 1564 operation = addr (mseg_data_$template_operation) -> mseg_operation; 1565 1566 1567 /**** Callers may not have access to queue_admin_, so the following 1568* avoids touching it unneccessarily. */ 1569 1570 if setwordno (cu_$caller_ptr (), 0) = addr (mailbox_$) 1571 then operation.type = MSEG_TYPE_MBX; 1572 else if setwordno (cu_$caller_ptr (), 0) = addr (message_segment_$) 1573 then operation.type = MSEG_TYPE_MS; 1574 else if setwordno (cu_$caller_ptr (), 0) = addr (queue_admin_$) 1575 then operation.type = MSEG_TYPE_MS; 1576 else call sub_err_ (0, "mseg_mbx_ms_gate_target_", ACTION_CANT_RESTART, null (), (0), 1577 "Caller was not mailbox_, message_segment_, or queue_admin_"); 1578 1579 operation.caller.validation_level = hcs_$level_get (); 1580 operation.caller.authorization = get_process_authorization_ (); 1581 operation.caller.max_authorization = mseg_data_$process_max_authorization; 1582 operation.caller.privileges = 1583 substr(aim_util_$get_privileges (operation.caller.authorization),1,length(operation.caller.privileges)); 1584 operation.caller.group_id = mseg_data_$group_id; 1585 validation_set = "0"b; /* no need to reset the level */ 1586 operation.call_admin_gate = (mseg_data_$execution_ring = mseg_data_$admin_ring); 1587 copy_entry = "0"b; 1588 internal_acl_ptr = null (); 1589 file_sw = "0"b; 1590 1591 return; 1592 end entry_setup; 1593 1594 1595 entry_common: 1596 procedure (entry_type, base_operation); 1597 1598 declare entry_type fixed bin; 1599 declare base_operation fixed bin; 1600 declare (return_code, dont_call_mca) bit (1) aligned; 1601 1602 dont_call_mca = "0"b; 1603 return_code = "0"b; 1604 go to COMMON; 1605 1606 1607 entry_common$$no_access_check: 1608 entry (entry_type, base_operation); 1609 1610 dont_call_mca = "1"b; 1611 return_code = "0"b; /* not that it will ever be used */ 1612 go to COMMON; 1613 1614 1615 entry_common$$return_error: 1616 entry (entry_type, base_operation); 1617 1618 dont_call_mca = "0"b; 1619 return_code = "1"b; 1620 1621 1622 COMMON: 1623 operation.access_operation = base_operation; 1624 1625 /**** This next line sets the validation level to the ring of execution. 1626* If the ring of execution is 1, it also suppresses ring zero file 1627* system auditing. It would be better coding practice to reduce 1628* the scope of this to the minimum neccessary. However, this entire 1629* subsystem would need to be restructured to support that. */ 1630 1631 call set_admin_level (); 1632 1633 if entry_type = INDEX_ENTRY 1634 then call index_setup; 1635 else if entry_type = FILE_ENTRY 1636 then call file_setup; 1637 else if entry_type = FILE_BRIEF_ENTRY 1638 then call file_brief_setup; 1639 else if entry_type = FILE_TEMP_ENTRY 1640 then call file_temp_setup; 1641 1642 if dont_call_mca /* caller isn't ready for mseg_check_access_ yet */ 1643 then return; 1644 1645 call mseg_check_access_$segment (addr (operation), code); 1646 if code ^= 0 1647 then if return_code 1648 then return; 1649 else call RETURN (code); 1650 1651 return; 1652 1653 1654 index_setup: 1655 procedure (); 1656 1657 operation.mseg_index = a_mseg_index; /* copy the parameter, all such gates have it */ 1658 1659 table_ptr = static_table_ptr (operation.type); 1660 if table_ptr = null () 1661 then call RETURN (error_table_$seg_unknown); 1662 1663 if operation.mseg_index < 1 | operation.mseg_index > mseg_table.table_length 1664 then call RETURN (error_table_$seg_unknown); 1665 1666 operation.mseg_ptr = mseg_table.mseg_ptr (operation.mseg_index); 1667 1668 if operation.mseg_ptr = null () 1669 then call RETURN (error_table_$seg_unknown); 1670 1671 operation.mseg_ptr_valid = "1"b; 1672 operation.mseg_index_valid = "1"b; 1673 1674 return; 1675 1676 end index_setup; 1677 1678 1679 file_setup: 1680 procedure (); 1681 1682 file_sw = "1"b; 1683 1684 operation.dir_name = a_dn; /* copy the parameters */ 1685 operation.entryname = a_en; 1686 operation.mseg_pathname_valid = "1"b; 1687 1688 call check_name (operation.entryname, code); 1689 if code ^= 0 1690 then call RETURN (code); 1691 1692 call mseg_$initiate_seg (addr (operation), code); 1693 if code ^= 0 1694 then do; 1695 call mseg_check_access_$audit_initiate_failure (addr (operation), code); 1696 call RETURN (code); /* must be sure to audit failure and censor code if needed */ 1697 end; 1698 1699 return; 1700 1701 end file_setup; 1702 1703 1704 file_brief_setup: 1705 procedure (); 1706 1707 operation.dir_name = a_dn; /* copy the parameters */ 1708 operation.entryname = a_en; 1709 operation.mseg_pathname_valid = "1"b; 1710 1711 call check_name (operation.entryname, code); 1712 if code ^= 0 1713 then call RETURN (code); 1714 1715 return; 1716 1717 end file_brief_setup; 1718 1719 1720 file_temp_setup: 1721 procedure (); 1722 1723 operation.dir_name = a_dn; /* copy the parameters */ 1724 operation.entryname = a_en; 1725 operation.mseg_pathname_valid = "1"b; 1726 1727 call check_name (operation.entryname, code); 1728 if code ^= 0 1729 then call RETURN (code); 1730 1731 return; 1732 1733 end file_temp_setup; 1734 1735 end entry_common; 1736 1737 1738 RETURN: 1739 procedure (return_error_code); 1740 1741 declare return_error_code fixed bin (35); 1742 1743 code = return_error_code; 1744 go to RETURN_; 1745 1746 end RETURN; 1747 1748 /* format: off */ 1749 /* Begin include file mseg_data_.incl.pl1 BIM 1985-04-15 */ 1 2 /* format: style4 */ 1 3 1 4 declare mseg_data_$lock_id bit (72) aligned external; 1 5 declare mseg_data_$block_size fixed bin (35) ext static; 1 6 declare mseg_data_$max_message_size fixed bin (35) ext static; 1 7 declare mseg_data_$template_operation bit (36) aligned external static; /* like mseg_operation */ 1 8 declare mseg_data_$admin_ring fixed binary (3) external; 1 9 declare mseg_data_$execution_ring fixed bin (3) ext static; 1 10 declare mseg_data_$process_max_authorization bit (72) aligned ext static; 1 11 declare mseg_data_$group_id char (32) unaligned external static; 1 12 1 13 /* End include file mseg_data_.incl.pl1 */ 1749 1750 /* BEGIN INCLUDE FILE . . . mseg_return_args.incl.pl1 */ 2 2 2 3 2 4 /* structure returned when message is read from a message segment */ 2 5 2 6 2 7 dcl ms_arg_ptr ptr; 2 8 2 9 dcl 1 mseg_return_args based (ms_arg_ptr) aligned, 2 10 2 ms_ptr ptr, /* pointer to message */ 2 11 2 ms_len fixed bin (24), /* length of message in bits */ 2 12 2 sender_id char (32) unaligned, /* process-group ID of sender */ 2 13 2 level fixed bin, /* validation level of sender */ 2 14 2 ms_id bit (72), /* unique ID of message */ 2 15 2 sender_authorization bit (72), /* access authorization of message sender */ 2 16 2 access_class bit (72); /* message access class */ 2 17 2 18 2 19 /* END INCLUDE FILE . . . mseg_return_args.incl.pl1 */ 1750 1751 /* BEGIN INCLUDE FILE . . . mseg_message_info.incl.pl1 BIM 1984-10-10 */ 3 2 /* format: style3,idind30 */ 3 3 3 4 /* structure returned when message is read from a message segment */ 3 5 3 6 3 7 dcl mseg_message_info_ptr pointer; 3 8 3 9 dcl 1 mseg_message_info based (mseg_message_info_ptr) aligned, 3 10 2 version char (8) aligned, 3 11 2 message_code fixed bin, 3 12 2 control_flags unaligned, 3 13 3 own bit (1), 3 14 3 delete bit (1), 3 15 3 pad bit (34), 3 16 2 ms_ptr ptr, /* pointer to message */ 3 17 2 ms_len fixed bin (24), /* length of message in bits */ 3 18 2 ms_id bit (72), /* unique ID of message */ 3 19 /* input in some cases */ 3 20 2 ms_access_class bit (72), /* message access class */ 3 21 2 sender_id char (32) unaligned,/* process-group ID of sender */ 3 22 2 sender_process_id bit (36) aligned, /* if nonzero, process that sent */ 3 23 2 sender_level fixed bin, /* validation level of sender */ 3 24 2 sender_authorization bit (72), /* access authorization of message sender */ 3 25 2 sender_max_authorization bit (72), /* max authorization of sending process */ 3 26 2 sender_audit bit (36) aligned; /* audit flags */ 3 27 3 28 declare MSEG_MESSAGE_INFO_V1 char (8) aligned init ("msegmi01") int static options (constant); 3 29 3 30 declare ( 3 31 MSEG_READ_FIRST init (1), 3 32 MSEG_READ_LAST init (2), 3 33 MSEG_READ_SPECIFIED init (3), 3 34 MSEG_READ_BEFORE_SPECIFIED init (4), 3 35 MSEG_READ_AFTER_SPECIFIED init (5)) 3 36 fixed bin int static options (constant); 3 37 3 38 declare (MSEG_READ_OWN init ("1"b), 3 39 MSEG_READ_DELETE init ("01"b) 3 40 ) bit (36) aligned internal static options (constant); 3 41 3 42 /* END INCLUDE FILE . . . mseg_message_info.incl.pl1 */ 1751 1752 /* BEGIN INCLUDE FILE ... mseg_operation.incl.pl1 */ 4 2 4 3 /* format: style3,idind30,linecom */ 4 4 4 5 /**** Created 1985-04-16, BIM: from Pandolf's mseg_access_operation */ 4 6 4 7 /**** NOTES: 4 8* The caller of mseg_ must set mseg_operation.access_operation to record 4 9* the type of access checking it has performed and which mseg_ should 4 10* perform when needed (i.e., for those entrypoints which operate on 4 11* messages like mseg_$read_message). 4 12* 4 13* mseg_operation.operation is reserved explicitly for use by mseg_ and 4 14* its underlying modules. 4 15* 4 16* You must also include entry_access_info, mseg_message_info, and 4 17* mbx_wakeup_state along with this include file. */ 4 18 4 19 dcl mseg_operation_ptr pointer; 4 20 dcl MSEG_OPERATION_VERSION_1 fixed bin internal static options (constant) init (1); 4 21 dcl MSEG_TYPE_MBX fixed bin init (1) internal static options (constant); 4 22 dcl MSEG_TYPE_MS fixed bin init (2) internal static options (constant); 4 23 4 24 dcl 1 mseg_operation based (mseg_operation_ptr) aligned, 4 25 2 version fixed binary, /* current version is MSEG_OPERATION_VERSION_1 */ 4 26 2 type fixed binary, /* MBX or MS */ 4 27 2 access_operation fixed binary, /* type of access checks required for the operation */ 4 28 2 operation bit (36) aligned, /* for use by mseg_ and underlying modules */ 4 29 2 caller aligned, /* always collected in gate target */ 4 30 3 validation_level fixed bin (3), 4 31 3 privileges bit (18) aligned, /* factored for speed */ 4 32 3 pad_align_double fixed bin (71), /* just to force alignment */ 4 33 3 authorization bit (72) aligned, /* must be 2word aligned */ 4 34 3 max_authorization bit (72) aligned, 4 35 3 group_id char (32) unaligned, 4 36 2 flags aligned, 4 37 3 mseg_pathname_valid bit (1) unaligned, 4 38 3 mseg_ptr_valid bit (1) unaligned, 4 39 3 mseg_index_valid bit (1) unaligned, 4 40 3 access_info_valid bit (1) unaligned, 4 41 3 md_ptr_valid bit (1) unaligned, 4 42 3 message_info_valid bit (1) unaligned, /* note -- for some operations not all fields are used */ 4 43 3 wakeup_state_valid bit (1) unaligned, 4 44 3 suppress_access_checks bit (1) unaligned, /* set by privileged interfaces, suppresses ALL access checking */ 4 45 3 call_admin_gate bit (1) unaligned, /* we is in ring 1, boss */ 4 46 3 only_own_access bit (1) unaligned, /* the user had o rather than r/d */ 4 47 3 add_message_info_all_valid 4 48 bit (1) unaligned, /* Believe ALL the fields in message info on an add */ 4 49 3 pad bit (24) unaligned, 4 50 2 dir_name char (168) unaligned, 4 51 2 entryname char (32) unaligned, 4 52 2 mseg_ptr pointer, 4 53 2 md_ptr pointer, /* message descriptor */ 4 54 2 mseg_index fixed bin, 4 55 2 access_info aligned like entry_access_info, 4 56 2 message_info aligned like mseg_message_info, 4 57 2 wakeup_state aligned like mseg_wakeup_state; 4 58 4 59 /* END INCLUDE FILE ... mseg_operation.incl.pl1 */ 1752 1753 /* BEGIN INCLUDE FILE ... mseg_wakeup_state.incl.pl1 */ 5 2 /* Created: April 1985 by G. Palter */ 5 3 5 4 /* format: style3,linecom */ 5 5 5 6 /* Description of the wakeup state of a message segment -- 5 7* 5 8* The wakeup state defines which process, if any, is willing to receive normal or urgent IPC wakeups when a message which 5 9* requests such a wakeup is added to a message segment. The process is allowed to separately accept or defer normal and 5 10* urgent wakeups. Note that deferring a wakeup is not the same as not accepting wakeups. A process is not allowed to 5 11* stop accepting wakeups once it has accepted them as to do so would introduce a relatively high badnwidth covert 5 12* channel. (In the present implementation, urgent wakeups are really no different from normal wakeups. Eventually, 5 13* urgent wakeups should be implemented using an IPS signal along with the IPC wakeup). 5 14* 5 15* mseg_$get_wakeup_state_seg requires that the caller supply the proper value for mseg_wakeup_state.version in the 5 16* mseg_operation. If there is no wakeup state recorded in the message segment, mseg_$get_wakeup_state_seg will return 5 17* the status code error_table_$messages_off. 5 18* 5 19* mseg_$set_wakeup_state_seg ignores the values of the access_class, process_id, and lock_id elements supplied by the 5 20* caller in the mseg_operation. mseg_$set_wakeup_state_seg will, instead, furnish the values of the process making the 5 21* call for these elements and will return these values to its caller. In other words, mseg_$set_wakeup_state_seg can not 5 22* be used by one process to accept/defer wakeups on behalf of another process. */ 5 23 5 24 declare 1 mseg_wakeup_state aligned based (mseg_wakeup_state_ptr), 5 25 2 version character (8) unaligned, 5 26 2 flags aligned, 5 27 3 accepting_normal_wakeups /* ON => process has accepted normal wakeups */ 5 28 bit (1) unaligned, /* OFF => process has deferred normal wakeups */ 5 29 3 accepting_urgent_wakeups /* ON => process has accepted urgent wakeups */ 5 30 bit (1) unaligned, /* OFF => process has deferred urgent wakeups */ 5 31 3 pad bit (34) unaligned, 5 32 2 pad bit (36) aligned, 5 33 2 event_channel fixed binary (71), /* IPC event channel on which to send normal/urgent wakeups */ 5 34 2 access_class bit (72) aligned, /* AIM access class of the process accepting wakeups */ 5 35 2 process_id bit (36) aligned, /* ID of the process accepting wakeups */ 5 36 2 lock_id bit (36) aligned; /* lock ID used to test if said process is still alive */ 5 37 5 38 declare mseg_wakeup_state_ptr 5 39 pointer; 5 40 5 41 declare MSEG_WAKEUP_STATE_VERSION_1 5 42 character (8) static options (constant) initial ("msegwkp1"); 5 43 5 44 /* END INCLUDE FILE ... mseg_wakeup_state.incl.pl1 */ 1753 1754 /* BEGIN INCLUDE FILE ... entry_access_info.incl.pl1 */ 6 2 6 3 /* 6 4* Written 03/22/85 by M. Pandolf 6 5* Modified 1985-04-19, BIM: added parent access class. 6 6**/ 6 7 6 8 dcl entry_access_info_ptr pointer; 6 9 dcl ENTRY_ACCESS_INFO_VERSION_1 char (8) internal static options (constant) 6 10 init ("eainf001"); 6 11 6 12 dcl 1 entry_access_info aligned based (entry_access_info_ptr), 6 13 2 version char (8), /* = ENTRY_ACCESS_INFO_VERSION_1 */ 6 14 2 type fixed bin, /* see status_structures.incl.pl1 */ 6 15 2 dir_name char (168) unaligned, /* parent of this entry */ 6 16 2 entryname char (32) unaligned, /* primary name of this entry */ 6 17 2 uid bit (36) aligned, 6 18 2 ring_brackets (3) fixed bin (3), /* for dirs, the dir ring brackets are here */ 6 19 2 extended_ring_brackets (3) fixed bin (3), /* not-yet-implemented x-rb's */ 6 20 2 effective_access_modes bit (36) aligned, /* for dirs, dir mode is here */ 6 21 2 extended_access_modes bit (36) aligned, /* always null for dirs */ 6 22 2 access_class bit (72) aligned, /* for multiclass, max access class */ 6 23 2 parent_access_class bit (72) aligned, /* for multiclass, this is effectively the min access class */ 6 24 2 multiclass bit (1) aligned; 6 25 6 26 /* END INCLUDE FILE ... entry_access_info.incl.pl1 */ 1754 1755 /* Begin include file mseg_access_operations_.incl.pl1 BIM 1985-04-19 */ 7 2 /* format: style4 */ 7 3 7 4 declare ( 7 5 mseg_access_operations_$accept_wakeups_seg, 7 6 mseg_access_operations_$acl_list_seg, 7 7 mseg_access_operations_$acl_modify_seg, 7 8 mseg_access_operations_$admin_add_message, 7 9 mseg_access_operations_$add_message, 7 10 mseg_access_operations_$close_seg, 7 11 mseg_access_operations_$compact_seg, 7 12 mseg_access_operations_$create_seg, 7 13 mseg_access_operations_$delete_message, 7 14 mseg_access_operations_$delete_seg, 7 15 mseg_access_operations_$get_count_seg, 7 16 mseg_access_operations_$modify_attr_seg, 7 17 mseg_access_operations_$modify_fs_attr_seg, 7 18 mseg_access_operations_$read_fs_attr_seg, 7 19 mseg_access_operations_$reset_salvage_bit_seg, 7 20 mseg_access_operations_$open_seg, 7 21 mseg_access_operations_$read_attr_seg, 7 22 mseg_access_operations_$read_delete_message, 7 23 mseg_access_operations_$read_message, 7 24 mseg_access_operations_$read_own_message, 7 25 mseg_access_operations_$read_delete_own_message, 7 26 mseg_access_operations_$send_normal_wakeup, 7 27 mseg_access_operations_$send_urgent_wakeup, 7 28 mseg_access_operations_$update_message, 7 29 mseg_access_operations_$copy_seg) fixed binary external static; 7 30 7 31 /* End include file mseg_access_operations_.incl.pl1 */ 1755 1756 /* BEGIN INCLUDE FILE ... mlsys_mailbox_modes.incl.pl1 */ 8 2 /* Created: June 1983 by G. Palter */ 8 3 8 4 /* Extended access modes (and combinations thereof) defined for a mailbox */ 8 5 8 6 dcl (N_MBX_ACCESS initial ("0000000"b), /* no access */ 8 7 8 8 A_MBX_ACCESS initial ("1000000"b), /* add messages */ 8 9 D_MBX_ACCESS initial ("0100000"b), /* delete any message (also indicates owner of mailbox) */ 8 10 R_MBX_ACCESS initial ("0010000"b), /* read any message */ 8 11 O_MBX_ACCESS initial ("0001000"b), /* read/delete any message sent by yourself */ 8 12 S_MBX_ACCESS initial ("0000100"b), /* get count of messages in the mailbox */ 8 13 W_MBX_ACCESS initial ("0000010"b), /* can send a wakeup to this mailbox (interactive messages and 8 14* mail notifications) */ 8 15 U_MBX_ACCESS initial ("0000001"b), /* can send an urgent wakeup (unused today) */ 8 16 8 17 ADROSW_MBX_ACCESS initial ("1111110"b), /* access granted to creator/owner of a mailbox */ 8 18 AOW_MBX_ACCESS initial ("1001010"b)) /* access granted to all other users */ 8 19 bit (36) aligned static options (constant); 8 20 8 21 /* END INCLUDE FILE ... mlsys_mailbox_modes.incl.pl1 */ 1756 1757 /* Begin include file mseg_index_table.incl.pl1 BIM 1985-04-17 */ 9 2 /* format: style4,linecom */ 9 3 9 4 9 5 dcl table_ptr pointer; 9 6 dcl 1 mseg_table aligned based (table_ptr), /* table of open message segments */ 9 7 2 table_length fixed bin, 9 8 2 table (tlength refer (mseg_table.table_length)) aligned, 9 9 3 mseg_ptr ptr unaligned, 9 10 3 ref_count fixed bin; 9 11 9 12 declare tlength fixed bin; 9 13 9 14 /* End include file mseg_index_table.incl.pl1 */ 1757 1758 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 10 2 /* format: style3 */ 10 3 10 4 /* These constants are to be used for the flags argument of sub_err_ */ 10 5 /* They are just "string (condition_info_header.action_flags)" */ 10 6 10 7 declare ( 10 8 ACTION_CAN_RESTART init (""b), 10 9 ACTION_CANT_RESTART init ("1"b), 10 10 ACTION_DEFAULT_RESTART 10 11 init ("01"b), 10 12 ACTION_QUIET_RESTART 10 13 init ("001"b), 10 14 ACTION_SUPPORT_SIGNAL 10 15 init ("0001"b) 10 16 ) bit (36) aligned internal static options (constant); 10 17 10 18 /* End include file */ 1758 1759 /* BEGIN INCLUDE FILE ... mseg_entries.incl.pl1 */ 11 2 /* Created: April 1985 by G. Palter */ 11 3 11 4 /* format: style3,linecom,idind30 */ 11 5 11 6 /* Message segment primitive operations -- 11 7* 11 8* The first argument of all of these entrypoints is a pointer to the mseg_operation describing the segment and, when 11 9* appropriate, the message to be manipulated by the operation. (See mseg_operation.incl.pl1 for additional information.) 11 10* 11 11* The last argument is always a standard system status code. 11 12* 11 13* For each operation defined below, the fields in the mseg_operation which must be supplied by the caller are listed 11 14* along with a brief description of the additional arguments, if any. For greater detail on the use of these 11 15* entrypoints, refer to mseg_mbx_ms_gate_target_.pl1 which is the classic user of these entrypoints. */ 11 16 11 17 11 18 declare 11 19 /*** Add (or update) ACL entries -- OP.mseg_pathname; general_extended_acl_ptr (I) */ 11 20 mseg_$add_acl_entries_seg entry (pointer, pointer, fixed binary (35)); 11 21 11 22 declare 11 23 /*** Add a message -- OP.mseg_ptr, OP.access_info, OP.message_info */ 11 24 mseg_$add_message entry (pointer, fixed binary (35)); 11 25 11 26 declare 11 27 /*** Change the names -- OP.mseg_pathname or OP.mseg_ptr; old_name_to_delete (I), new_name_to_add (I) */ 11 28 mseg_$chname_seg entry (pointer, character (*), character (*), fixed binary (35)); 11 29 11 30 declare 11 31 /*** Close the segment -- OP.mseg_ptr (optional), OP.mseg_index (optional); mseg_index_table_ptr (I/O) 11 32* mseg_index_table_ptr must be an internal/external static variable initialized once per-process to null() */ 11 33 mseg_$close_seg entry (pointer, pointer, fixed binary (35)); 11 34 11 35 declare 11 36 /*** Compact the segment -- OP.mseg_ptr; compaction_ratio (I) */ 11 37 mseg_$compact_seg entry (pointer, float binary, fixed binary (35)); 11 38 11 39 declare 11 40 /*** Copy the segment -- OP.mseg_ptr; target_mseg_operation_ptr (I) (TOP.mseg_ptr), error_on_target (O) */ 11 41 mseg_$copy_seg entry (pointer, pointer, bit (1) aligned, fixed binary (35)); 11 42 11 43 declare 11 44 /*** Count the accessible messages -- OP.mseg_ptr, OP.access_info; n_messages (O) */ 11 45 mseg_$count_messages entry (pointer, fixed binary, fixed binary (35)); 11 46 11 47 declare 11 48 /*** Create the segment -- OP.mseg_pathname; general_extended_acl_ptr (I) -- 11 49* If general_extended_acl_ptr is null, the default ACL for the type of segment to be created will be used */ 11 50 mseg_$create_seg entry (pointer, pointer, fixed binary (35)); 11 51 11 52 declare 11 53 /*** Delete ACL entries -- OP.mseg_pathname; general_delete_acl_ptr (I) -- 11 54* If general_delete_acl_ptr is null, the entire ACL will be deleted */ 11 55 mseg_$delete_acl_entries_seg entry (pointer, pointer, fixed binary (35)); 11 56 11 57 declare 11 58 /*** Delete a message -- OP.mseg_ptr, OP.access_info, OP.message_info */ 11 59 mseg_$delete_message entry (pointer, fixed binary (35)); 11 60 11 61 declare 11 62 /*** Delete the segment -- OP.mseg_ptr (surprise); mseg_index_table_ptr (I/O) 11 63* mseg_index_table_ptr must be an internal/external static variable initialized once per-process to null() */ 11 64 mseg_$delete_seg entry (pointer, pointer, fixed binary (35)); 11 65 11 66 declare 11 67 /*** Get the salvaged flag -- OP.mseg_ptr; segment_was_salvaged (O) */ 11 68 mseg_$get_salvaged_flag_seg entry (pointer, bit (1) aligned, fixed binary (35)); 11 69 11 70 declare 11 71 /*** Get the wakeup acceptance state -- OP.mseg_ptr, OP.wakeup_state.version */ 11 72 mseg_$get_wakeup_state_seg entry (pointer, fixed binary (35)); 11 73 11 74 declare 11 75 /*** Initiate the segment -- OP.mseg_pathname */ 11 76 mseg_$initiate_seg entry (pointer, fixed binary (35)); 11 77 11 78 declare 11 79 /*** List the entire ACL -- OP.mseg_pathname; general_extended_acl_ptr (O) 11 80* The general_extended_acl is allocated in the system free area */ 11 81 mseg_$list_acl_seg entry (pointer, pointer, fixed binary (35)); 11 82 11 83 declare 11 84 /*** List individual ACL entries -- OP.mseg_pathname; general_extended_acl_ptr (I) */ 11 85 mseg_$list_acl_entries_seg entry (pointer, pointer, fixed binary (35)); 11 86 11 87 declare 11 88 /*** Open the segment -- OP.mseg_ptr; mseg_index_table_ptr (I/O) 11 89* mseg_index_table_ptr must be an internal/external static variable initialized once per-process to null() */ 11 90 mseg_$open_seg entry (pointer, pointer, fixed binary (35)); 11 91 11 92 declare 11 93 /*** Read (and optionally delete) a message -- OP.mseg_ptr, OP.access_info, OP.message_info; users_area_ptr (I) */ 11 94 mseg_$read_message entry (pointer, pointer, fixed binary (35)); 11 95 11 96 declare 11 97 /*** Replace the ACL -- OP.mseg_pathname; general_extended_acl_ptr (I) -- 11 98* If general_extended_acl_ptr is null, the new ACL will be empty */ 11 99 mseg_$replace_acl_seg entry (pointer, pointer, fixed binary (35)); 11 100 11 101 declare 11 102 /*** Reset the salvaged flag -- OP.mseg_ptr, OP.access_info */ 11 103 mseg_$reset_salvaged_flag_seg entry (pointer, fixed binary (35)); 11 104 11 105 declare 11 106 /*** Reset wakeup acceptance (i.e., turn it off) -- OP.mseg_ptr */ 11 107 mseg_$reset_wakeup_state_seg entry (pointer, fixed binary (35)); 11 108 11 109 declare 11 110 /*** Set the max length -- OP.mseg_ptr (surprise); new_max_length (I) */ 11 111 mseg_$set_max_length_seg entry (pointer, fixed binary (19), fixed binary (35)); 11 112 11 113 declare 11 114 /*** Set the safety switch -- OP.mseg_pathname or OP.mseg_ptr; new_safety_switch (I) */ 11 115 mseg_$set_safety_switch_seg entry (pointer, bit (1) aligned, fixed binary (35)); 11 116 11 117 declare 11 118 /*** Set the wakeup acceptance state -- OP.mseg_ptr, OP.wakeup_state */ 11 119 mseg_$set_wakeup_state_seg entry (pointer, fixed binary (35)); 11 120 11 121 declare 11 122 /*** Update a message -- OP.mseg_ptr, OP.access_info, OP.message_info */ 11 123 mseg_$update_message entry (pointer, fixed binary (35)); 11 124 11 125 /* END INCLUDE FILE ... mseg_entries.incl.pl1 */ 1759 1760 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 12 2 /* format: style3,indcomtxt,idind30 */ 12 3 12 4 declare acl_ptr pointer; 12 5 declare acl_count fixed bin; 12 6 12 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 12 8 2 version char (8) aligned, 12 9 2 count fixed bin, 12 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 12 11 12 12 declare 1 general_acl_entry based, 12 13 2 access_name character (32) unaligned, 12 14 2 mode bit (36) aligned, 12 15 2 status_code fixed bin (35); 12 16 12 17 12 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 12 19 2 version char (8) aligned, 12 20 2 count fixed bin, 12 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 12 22 12 23 declare 1 general_extended_acl_entry aligned based, 12 24 2 access_name character (32) unaligned, 12 25 2 mode bit (36) aligned, 12 26 2 extended_mode bit (36) aligned, 12 27 2 status_code fixed bin (35); 12 28 12 29 12 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 12 31 2 version char (8) aligned, 12 32 2 count fixed bin, 12 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 12 34 12 35 declare 1 general_delete_acl_entry aligned based, 12 36 2 access_name character (32) unaligned, 12 37 2 status_code fixed bin (35); 12 38 12 39 12 40 declare 1 segment_acl aligned based (acl_ptr), 12 41 2 version fixed bin, 12 42 2 count fixed bin, 12 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 12 44 12 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 12 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 12 47 12 48 12 49 declare 1 directory_acl aligned based (acl_ptr), 12 50 2 version fixed bin, 12 51 2 count fixed bin, 12 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 12 53 12 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 12 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 12 56 12 57 12 58 declare 1 delete_acl based (acl_ptr) aligned, 12 59 2 version fixed bin, 12 60 2 count fixed bin, 12 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 12 62 12 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 12 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 12 65 12 66 12 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 12 68 DIR_ACL_VERSION_1 init ("dra1"), 12 69 DELETE_ACL_VERSION_1 init ("dla1")) 12 70 char (4) int static options (constant); 12 71 12 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 12 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 12 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 12 75 char (8) internal static options (constant); 12 76 12 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 12 78 12 79 /* End include file acl_structures.incl.pl1 */ 1760 1761 end mseg_mbx_ms_gate_target_; 1762 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 08/06/87 1020.1 mseg_mbx_ms_gate_target_.pl1 >spec>install>1067>mseg_mbx_ms_gate_target_.pl1 1749 1 05/17/85 0619.0 mseg_data_.incl.pl1 >ldd>include>mseg_data_.incl.pl1 1750 2 05/17/82 1411.5 mseg_return_args.incl.pl1 >ldd>include>mseg_return_args.incl.pl1 1751 3 01/10/85 2002.8 mseg_message_info.incl.pl1 >ldd>include>mseg_message_info.incl.pl1 1752 4 05/17/85 0615.6 mseg_operation.incl.pl1 >ldd>include>mseg_operation.incl.pl1 1753 5 05/17/85 0615.7 mseg_wakeup_state.incl.pl1 >ldd>include>mseg_wakeup_state.incl.pl1 1754 6 05/17/85 0615.5 entry_access_info.incl.pl1 >ldd>include>entry_access_info.incl.pl1 1755 7 05/17/85 0615.6 mseg_access_operations_.incl.pl1 >ldd>include>mseg_access_operations_.incl.pl1 1756 8 10/27/83 2104.2 mlsys_mailbox_modes.incl.pl1 >ldd>include>mlsys_mailbox_modes.incl.pl1 1757 9 05/17/85 0615.6 mseg_index_table.incl.pl1 >ldd>include>mseg_index_table.incl.pl1 1758 10 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.incl.pl1 1759 11 05/17/85 0615.6 mseg_entries.incl.pl1 >ldd>include>mseg_entries.incl.pl1 1760 12 10/14/83 1606.6 acl_structures.incl.pl1 >ldd>include>acl_structures.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. ACTION_CANT_RESTART 000020 constant bit(36) initial dcl 10-7 set ref 1576* D_MBX_ACCESS constant bit(36) initial dcl 8-6 ref 556 FILE_BRIEF_ENTRY 000043 constant fixed bin(17,0) initial dcl 130 set ref 318* 327* 422* 1257* 1637 FILE_ENTRY 000032 constant fixed bin(17,0) initial dcl 130 set ref 338* 359* 395* 443* 456* 469* 488* 540* 742* 820* 830* 1192* 1201* 1211* 1220* 1230* 1241* 1249* 1268* 1270* 1279* 1325* 1335* 1374 1635 FILE_TEMP_ENTRY 000041 constant fixed bin(17,0) initial dcl 130 set ref 567* 583* 599* 639* 1639 GENERAL_DELETE_ACL_VERSION_1 000000 constant char(8) initial unaligned dcl 12-72 ref 1433 1482 GENERAL_EXTENDED_ACL_VERSION_1 000002 constant char(8) initial unaligned dcl 12-72 ref 1411 1480 INDEX_ENTRY 000024 constant fixed bin(17,0) initial dcl 130 set ref 433* 480* 554* 661* 678* 692* 710* 754* 800* 810* 1070* 1111* 1129* 1142* 1156* 1158* 1176* 1287* 1306* 1343 1633 MSEG_MESSAGE_INFO_V1 000004 constant char(8) initial dcl 3-28 ref 721 1349 MSEG_READ_AFTER_SPECIFIED constant fixed bin(17,0) initial dcl 3-30 ref 1532 MSEG_READ_BEFORE_SPECIFIED constant fixed bin(17,0) initial dcl 3-30 ref 1530 MSEG_READ_FIRST constant fixed bin(17,0) initial dcl 3-30 ref 1526 MSEG_READ_LAST constant fixed bin(17,0) initial dcl 3-30 ref 1524 MSEG_READ_SPECIFIED constant fixed bin(17,0) initial dcl 3-30 ref 1528 MSEG_TYPE_MBX constant fixed bin(17,0) initial dcl 4-21 ref 1570 MSEG_TYPE_MS constant fixed bin(17,0) initial dcl 4-22 ref 1572 1574 SUFFIX 000006 constant varying char(8) initial array dcl 137 ref 1388 a_access_class parameter bit(72) dcl 237 ref 805 811 825 831 a_area_ptr parameter pointer dcl 189 ref 578 594 603 656 662 687 694 1106 1113 1187 1206 1236 1282 1289 1301 1308 1320 1330 1338 1345 1368 a_arg_ptr parameter pointer dcl 189 ref 656 664 687 697 705 716 737 1106 1117 1187 1206 1236 1282 1292 1301 1312 1320 1330 1338 1347 1368 a_code parameter fixed bin(35,0) dcl 153 set ref 313 322 333 347 390 417 428 438 451 464 475 483 535 549 562 578 594 634 656 673 687 705 737 748 795 805 815 825 1064 1106 1124 1137 1149 1171 1187 1196 1206 1215 1224 1236 1244 1252 1261 1274 1282 1301 1320 1330 1338 1368 1503* 1510* a_compact_ratio parameter float bin(27) dcl 185 set ref 464 470* 475 a_dir parameter bit(2) dcl 221 ref 1106 1115 1236 1301 1310 1330 a_dn parameter char unaligned dcl 246 ref 313 322 333 347 390 417 438 451 464 483 535 562 578 594 634 737 815 825 1187 1196 1206 1215 1224 1236 1244 1252 1261 1274 1320 1330 1368 1684 1707 1723 a_en parameter char unaligned dcl 246 ref 313 322 333 347 390 417 438 451 464 483 535 562 578 594 634 737 815 825 1187 1196 1206 1215 1224 1236 1244 1252 1261 1274 1320 1330 1368 1685 1708 1724 a_error_on_target parameter bit(1) dcl 204 set ref 347 386* 1492* a_event_channel parameter fixed bin(71,0) dcl 180 ref 1064 1084 1224 a_max_length parameter fixed bin(19,0) dcl 149 set ref 438 445 447* a_mode parameter bit(36) dcl 226 set ref 1137 1144* 1252 a_ms_count parameter fixed bin(17,0) dcl 139 set ref 483 511* 1124 1133* 1244 a_ms_id parameter bit(72) dcl 237 in procedure "mseg_mbx_ms_gate_target_" set ref 673 680 705 732* 737 748 769* 795 805 815 825 1014* 1106 1116 1171 1180 1196 1215 1236 1274 1301 1311 1330 a_ms_id parameter bit(72) dcl 1518 in procedure "read_for_old_entrypoint" ref 1514 1520 a_ms_len parameter fixed bin(24,0) dcl 151 ref 748 763 795 805 815 825 851 1171 1178 1215 1274 a_ms_ptr parameter pointer dcl 189 ref 748 762 795 805 815 825 850 1171 1181 1215 1274 a_ms_wanted parameter bit(1) dcl 204 ref 656 665 687 696 1187 1206 1282 1291 1320 a_mseg_index parameter fixed bin(17,0) dcl 139 set ref 428 475 483 529* 535 546* 549 656 673 687 705 748 795 805 1064 1106 1124 1137 1149 1171 1282 1301 1338 1657 a_new_en parameter char unaligned dcl 246 ref 390 398 a_old_en parameter char unaligned dcl 246 ref 390 397 a_safety_switch parameter bit(1) dcl 204 ref 451 458 a_salv_bit parameter bit(1) dcl 204 set ref 483 509* 1149 1166* 1261 a_sw parameter bit(36) unaligned dcl 226 ref 795 805 815 825 852 1064 1085 a_target_dn parameter char unaligned dcl 246 ref 347 367 a_target_en parameter char unaligned dcl 246 ref 347 368 a_turn_off parameter bit(1) dcl 204 ref 1149 1154 1261 1264 a_uid parameter bit(36) dcl 234 set ref 417 424* 428 435* a_user_acl_count parameter fixed bin(17,0) dcl 139 set ref 562 570 578 586 594 602 630* 634 642 a_user_acl_ptr parameter pointer dcl 189 set ref 562 569 578 585 594 601 629* 634 641 accepting parameter bit(1) dcl 1026 set ref 1023 1028* 1044* accepting_normal_wakeups 254 000160 automatic bit(1) level 4 packed unaligned dcl 259 set ref 968 1096* accepting_urgent_wakeups 254(01) 000160 automatic bit(1) level 4 packed unaligned dcl 259 set ref 963 970 1097* access_class 20 001120 automatic bit(72) level 2 in structure "mra" dcl 1517 in procedure "read_for_old_entrypoint" set ref 1548* access_class 260 000160 automatic bit(72) level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 860* 860 940* 950* access_info 115 000160 automatic structure level 2 dcl 259 access_operation 2 000444 automatic fixed bin(17,0) level 2 in structure "target_operation" dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 370* access_operation 2 000160 automatic fixed bin(17,0) level 2 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 518* 881* 902* 904* 995* 1622* acl_count 000754 automatic fixed bin(17,0) dcl 12-5 set ref 612 618* 624 626 630 650 1403* 1407* 1408 1408 1412 1425* 1429* 1430 1430 1434 1480 1482 acl_ptr 000752 automatic pointer dcl 12-4 set ref 573* 589* 611* 612 615* 618 627 646* 648* 650 650 1404* 1409* 1411 1412 1424* 1431* 1433 1434 1480 1480 1482 1482 add_message_info_all_valid 24(10) 000160 automatic bit(1) level 3 packed unaligned dcl 259 set ref 720* addr builtin function dcl 274 ref 329 329 342 342 352 371 371 377 377 381 381 386 386 386 386 413 413 446 446 460 460 470 470 508 508 510 510 519 519 524 524 541 541 556 556 558 558 573 573 589 589 611 611 615 615 648 648 683 683 724 724 728 728 758 758 765 765 882 882 888 888 908 908 910 910 996 996 998 998 1030 1030 1087 1087 1092 1092 1101 1101 1131 1131 1160 1160 1164 1164 1183 1183 1364 1364 1474 1474 1491 1491 1539 1539 1564 1570 1572 1574 1645 1645 1692 1692 1695 1695 admin_gate_$admin_level_no_fs_audit 000064 constant entry external dcl 290 ref 1455 aim_check_$greater 000074 constant entry external dcl 295 ref 950 aim_check_$greater_or_equal 000072 constant entry external dcl 294 ref 860 940 aim_util_$get_access_class 000066 constant entry external dcl 292 ref 756 801 821 1221 aim_util_$get_privileges 000070 constant entry external dcl 293 ref 1582 always_add 0(02) 001036 automatic bit(1) level 2 packed unaligned dcl 843 set ref 912 922 940 963 973 area 000732 stack reference condition dcl 279 ref 619 625 area_ptr 000112 automatic pointer dcl 189 set ref 603* 605 624 662* 694* 1113* 1289* 1308* 1345* 1364* 1539* arg_ptr 000114 automatic pointer dcl 189 set ref 664* 697* 1117* 1292* 1312* 1549 authorization 10 000160 automatic bit(72) level 3 dcl 259 set ref 756* 801* 821* 940* 950* 1221* 1580* 1582* base_operation parameter fixed bin(17,0) dcl 1599 ref 1595 1607 1615 1622 call_admin_gate 24(08) 000444 automatic bit(1) level 3 in structure "target_operation" packed unaligned dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 364* call_admin_gate 24(08) 000160 automatic bit(1) level 3 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 364 1455 1586* caller 4 000160 automatic structure level 2 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 363 caller 4 000444 automatic structure level 2 in structure "target_operation" dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 363* censor_wakeup_code 001033 automatic bit(1) dcl 840 set ref 950* 954* 1056 cleanup 000740 stack reference condition dcl 280 ref 317 326 337 357 394 421 432 442 455 468 479 487 539 553 566 582 598 638 660 677 691 709 741 752 799 809 819 829 1068 1110 1128 1141 1153 1175 1191 1200 1210 1219 1228 1240 1248 1256 1266 1278 1286 1305 1324 1334 1342 1372 code parameter fixed bin(35,0) dcl 1381 in procedure "check_name" set ref 1377 1385* 1390* 1391* code 000105 automatic fixed bin(35,0) dcl 153 in procedure "mseg_mbx_ms_gate_target_" set ref 319* 329* 331* 342* 345* 371* 374 374* 377* 378 378* 381* 383 383* 386* 388* 402* 403 403* 408* 409 409* 413* 414* 425* 436* 446* 448* 460* 461* 470* 472* 499 499 499* 502 512* 519* 520 520* 524* 525 525* 530* 533* 541* 542 542* 547* 558* 559* 573* 574* 589* 590* 611* 615* 616 616* 621* 622* 632* 648* 652* 670* 683* 684* 703* 724* 725 725* 728* 730 735* 758* 760 760* 765* 766 766* 770* 882* 884 891 891* 893* 908* 910* 912 987* 998* 1002 1012 1020* 1030* 1032 1032 1032* 1034 1037* 1038 1038 1038* 1040* 1042 1074* 1087* 1088 1088 1090 1092* 1093 1101* 1122* 1131* 1134* 1146* 1160* 1162 1162* 1164* 1167* 1183* 1184* 1234* 1298* 1318* 1351* 1352* 1364* 1366* 1501 1501* 1503 1507 1507* 1510 1539* 1540 1645* 1646 1649* 1688* 1689 1689* 1692* 1693 1695* 1696* 1711* 1712 1712* 1727* 1728 1728* 1743* control_flags 223 000160 automatic structure level 3 packed unaligned dcl 259 copy_entry 000123 automatic bit(1) dcl 204 set ref 353* 1476 1587* count 2 based fixed bin(17,0) level 2 in structure "general_delete_acl" dcl 12-30 in procedure "mseg_mbx_ms_gate_target_" set ref 1430* 1434 1482 count 2 based fixed bin(17,0) level 2 in structure "general_extended_acl" dcl 12-18 in procedure "mseg_mbx_ms_gate_target_" set ref 612 618 650 1408* 1412 1444 1480 cu_$caller_ptr 000076 constant entry external dcl 296 ref 1570 1572 1574 delete 0(05) 000730 automatic bit(1) level 2 in structure "old_read_flags" packed unaligned dcl 264 in procedure "mseg_mbx_ms_gate_target_" set ref 701* 1537 delete 223(01) 000160 automatic bit(1) level 4 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1355 1357 1537* delete_acl_array based structure array level 1 dcl 12-64 set ref 1434 delete_acl_entry based structure level 1 dcl 12-63 dir 000133 automatic bit(2) dcl 221 set ref 1115* 1120 1310* 1315 dir_name 25 000160 automatic char(168) level 2 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1684* 1707* 1723* dir_name 25 000444 automatic char(168) level 2 in structure "target_operation" packed unaligned dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 367* directory_acl_entry based structure level 1 dcl 12-54 dont_call_mca 001157 automatic bit(1) dcl 1600 set ref 1602* 1610* 1618* 1642 entries 3 based structure array level 2 in structure "general_extended_acl" dcl 12-18 in procedure "mseg_mbx_ms_gate_target_" set ref 612 627 1412* entries 3 based structure array level 2 in structure "general_delete_acl" dcl 12-30 in procedure "mseg_mbx_ms_gate_target_" set ref 1434* entry_access_info based structure level 1 dcl 6-12 entry_type parameter fixed bin(17,0) dcl 1598 ref 1595 1607 1615 1633 1635 1637 1639 entryname 77 000160 automatic char(32) level 2 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1685* 1688* 1708* 1711* 1724* 1727* entryname 77 000444 automatic char(32) level 2 in structure "target_operation" packed unaligned dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 368* entryname parameter char(32) unaligned dcl 1380 in procedure "check_name" ref 1377 1386 1387 1388 error_on_target 000122 automatic bit(1) dcl 204 set ref 355* 361* 1492 error_table_$action_not_performed 000030 external static fixed bin(35,0) dcl 153 ref 970 error_table_$ai_restricted 000026 external static fixed bin(35,0) dcl 153 set ref 940* error_table_$argerr 000014 external static fixed bin(35,0) dcl 153 set ref 607* error_table_$bad_file_name 000032 external static fixed bin(35,0) dcl 153 ref 1390 1391 error_table_$dirseg 000034 external static fixed bin(35,0) dcl 153 ref 1501 1507 error_table_$inconsistent 000036 external static fixed bin(35,0) dcl 153 set ref 1534* error_table_$invalid_lock_reset 000040 external static fixed bin(35,0) dcl 153 ref 1038 error_table_$messages_deferred 000042 external static fixed bin(35,0) dcl 153 set ref 963 966* 972 error_table_$messages_off 000044 external static fixed bin(35,0) dcl 153 set ref 922 925* 1007 1032 1038 1088 error_table_$moderr 000046 external static fixed bin(35,0) dcl 153 ref 499 530 891 error_table_$no_append 000020 external static fixed bin(35,0) dcl 153 ref 891 error_table_$no_info 000050 external static fixed bin(35,0) dcl 153 set ref 1056* error_table_$noalloc 000016 external static fixed bin(35,0) dcl 153 ref 621 error_table_$not_seg_type 000052 external static fixed bin(35,0) dcl 153 ref 1501 1507 error_table_$null_info_ptr 000022 external static fixed bin(35,0) dcl 153 set ref 1419* error_table_$seg_unknown 000056 external static fixed bin(35,0) dcl 153 set ref 1660* 1663* 1668* error_table_$unimplemented_version 000024 external static fixed bin(35,0) dcl 153 set ref 721* 1351 error_table_$wakeup_denied 000054 external static fixed bin(35,0) dcl 153 set ref 912 915* 1007 event_channel 256 000160 automatic fixed bin(71,0) level 3 dcl 259 set ref 1005* 1098* event_message 000110 automatic fixed bin(71,0) dcl 180 set ref 1004* 1005* extended_access_modes 212 000160 automatic bit(36) level 3 dcl 259 set ref 556 1144 file_sw 000124 automatic bit(1) dcl 204 set ref 340* 527* 544* 1474 1589* 1682* first_or_last 0(03) 000730 automatic bit(1) level 2 packed unaligned dcl 264 set ref 668* 700* 1294* 1524 flags 24 000444 automatic structure level 2 in structure "target_operation" dcl 260 in procedure "mseg_mbx_ms_gate_target_" flags 254 000160 automatic structure level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" flags 24 000160 automatic structure level 2 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" general_acl_entry based structure level 1 unaligned dcl 12-12 general_delete_acl based structure level 1 dcl 12-30 set ref 1430 general_delete_acl_entry based structure level 1 dcl 12-35 general_extended_acl based structure level 1 dcl 12-18 set ref 1408 1444 general_extended_acl_entry based structure level 1 dcl 12-23 get_process_authorization_ 000100 constant entry external dcl 297 ref 1580 get_system_free_area_ 000102 constant entry external dcl 298 ref 1444 group_id 14 000160 automatic char(32) level 3 packed unaligned dcl 259 set ref 1584* hcs_$level_get 000104 constant entry external dcl 299 ref 1579 hcs_$level_set 000106 constant entry external dcl 300 ref 1458 1465 hcs_$wakeup 000110 constant entry external dcl 301 ref 1005 i 000102 automatic fixed bin(17,0) dcl 139 set ref 626* 627 627* incremental 000730 automatic bit(1) level 2 packed unaligned dcl 264 set ref 1119* 1314* 1522 incremental_direction 0(01) 000730 automatic bit(2) level 2 packed unaligned dcl 264 set ref 1120* 1315* 1528 1530 1532 index builtin function dcl 274 ref 1387 internal_acl_ptr 000120 automatic pointer dcl 189 set ref 1408* 1409 1424* 1430* 1431 1444 1444 1478 1588* length builtin function dcl 274 ref 1085 1386 1582 level 13 001120 automatic fixed bin(17,0) level 2 dcl 1517 set ref 1545* lock_id 263 000160 automatic bit(36) level 3 dcl 259 set ref 1036 mailbox_$ 000300 external static bit(36) dcl 1558 set ref 1570 max_authorization 12 000160 automatic bit(72) level 3 dcl 259 set ref 1581* max_length 000104 automatic fixed bin(19,0) dcl 149 set ref 445* 446* 447 message_code 222 000160 automatic fixed bin(17,0) level 3 dcl 259 set ref 1524* 1526* 1528* 1530* 1532* message_info 220 000160 automatic structure level 2 dcl 259 set ref 718* 733 1348* 1365 message_info_valid 24(05) 000160 automatic bit(1) level 3 packed unaligned dcl 259 set ref 682* 719* 764* 802* 812* 822* 832* 1182* 1363* 1538* message_segment_$ 000276 external static bit(36) dcl 1558 set ref 1572 mra 001120 automatic structure level 1 dcl 1517 set ref 1549 ms_access_class 231 000160 automatic bit(72) level 3 dcl 259 set ref 756* 801* 811* 821* 831* 860* 860* 1221* 1548 ms_count 000101 automatic fixed bin(17,0) dcl 139 set ref 504* 510* 511 512 1131* 1133 ms_id 14 001120 automatic bit(72) level 2 in structure "mra" dcl 1517 in procedure "read_for_old_entrypoint" set ref 1546* ms_id 227 000160 automatic bit(72) level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 680* 732 769 986* 1004 1014 1180* 1520* 1546 ms_id 000136 automatic bit(72) dcl 237 in procedure "mseg_mbx_ms_gate_target_" set ref 666* 669* 699* 702* 1116* 1121* 1296* 1297* 1311* 1317* ms_len 2 001120 automatic fixed bin(24,0) level 2 in structure "mra" dcl 1517 in procedure "read_for_old_entrypoint" set ref 1543* ms_len 226 000160 automatic fixed bin(24,0) level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 763* 851* 1178* 1543 ms_ptr 001120 automatic pointer level 2 in structure "mra" dcl 1517 in procedure "read_for_old_entrypoint" set ref 1542* ms_ptr 224 000160 automatic pointer level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 762* 850* 1181* 1542 ms_wanted 000125 automatic bit(1) dcl 204 set ref 665* 668 696* 700 1291* 1294 mseg_$add_acl_entries_seg 000216 constant entry external dcl 11-18 ref 573 mseg_$add_message 000220 constant entry external dcl 11-22 ref 728 765 998 mseg_$chname_seg 000222 constant entry external dcl 11-26 ref 413 mseg_$close_seg 000224 constant entry external dcl 11-30 ref 558 1474 1491 mseg_$compact_seg 000226 constant entry external dcl 11-35 ref 470 556 mseg_$copy_seg 000230 constant entry external dcl 11-39 ref 386 mseg_$count_messages 000232 constant entry external dcl 11-43 ref 510 1131 mseg_$create_seg 000234 constant entry external dcl 11-47 ref 329 377 mseg_$delete_acl_entries_seg 000236 constant entry external dcl 11-52 ref 589 mseg_$delete_message 000240 constant entry external dcl 11-57 ref 683 mseg_$delete_seg 000242 constant entry external dcl 11-61 ref 342 mseg_$get_salvaged_flag_seg 000244 constant entry external dcl 11-66 ref 508 1160 mseg_$get_wakeup_state_seg 000246 constant entry external dcl 11-70 ref 1030 1087 mseg_$initiate_seg 000250 constant entry external dcl 11-74 ref 381 1692 mseg_$list_acl_entries_seg 000254 constant entry external dcl 11-83 ref 611 mseg_$list_acl_seg 000252 constant entry external dcl 11-78 ref 615 mseg_$open_seg 000256 constant entry external dcl 11-87 ref 524 541 mseg_$read_message 000260 constant entry external dcl 11-92 ref 1364 1539 mseg_$replace_acl_seg 000262 constant entry external dcl 11-96 ref 648 mseg_$reset_salvaged_flag_seg 000264 constant entry external dcl 11-101 ref 1164 mseg_$set_max_length_seg 000266 constant entry external dcl 11-109 ref 446 mseg_$set_safety_switch_seg 000270 constant entry external dcl 11-113 ref 460 mseg_$set_wakeup_state_seg 000272 constant entry external dcl 11-117 ref 1101 mseg_$update_message 000274 constant entry external dcl 11-121 ref 1183 mseg_access_operations_$accept_wakeups_seg 000136 external static fixed bin(17,0) dcl 7-4 set ref 1070* 1230* mseg_access_operations_$acl_list_seg 000140 external static fixed bin(17,0) dcl 7-4 set ref 599* mseg_access_operations_$acl_modify_seg 000142 external static fixed bin(17,0) dcl 7-4 set ref 567* 583* 639* mseg_access_operations_$add_message 000146 external static fixed bin(17,0) dcl 7-4 set ref 754* 800* 810* 820* 830* 881 995 1220* mseg_access_operations_$admin_add_message 000144 external static fixed bin(17,0) dcl 7-4 set ref 710* 742* mseg_access_operations_$close_seg 000150 external static fixed bin(17,0) dcl 7-4 set ref 554* mseg_access_operations_$compact_seg 000152 external static fixed bin(17,0) dcl 7-4 set ref 469* 480* mseg_access_operations_$copy_seg 000214 external static fixed bin(17,0) dcl 7-4 set ref 359* mseg_access_operations_$create_seg 000154 external static fixed bin(17,0) dcl 7-4 set ref 327* 370 mseg_access_operations_$delete_message 000156 external static fixed bin(17,0) dcl 7-4 set ref 678* 1201* mseg_access_operations_$delete_seg 000160 external static fixed bin(17,0) dcl 7-4 set ref 338* mseg_access_operations_$get_count_seg 000162 external static fixed bin(17,0) dcl 7-4 set ref 488* 1129* 1249* mseg_access_operations_$modify_fs_attr_seg 000164 external static fixed bin(17,0) dcl 7-4 set ref 395* 443* 456* mseg_access_operations_$open_seg 000172 external static fixed bin(17,0) dcl 7-4 set ref 518 540* mseg_access_operations_$read_attr_seg 000174 external static fixed bin(17,0) dcl 7-4 set ref 1156* 1268* mseg_access_operations_$read_delete_message 000176 external static fixed bin(17,0) dcl 7-4 set ref 692* 1211* 1357* mseg_access_operations_$read_delete_own_message 000204 external static fixed bin(17,0) dcl 7-4 set ref 1355* mseg_access_operations_$read_fs_attr_seg 000166 external static fixed bin(17,0) dcl 7-4 set ref 318* 422* 433* 1142* 1257* mseg_access_operations_$read_message 000200 external static fixed bin(17,0) dcl 7-4 set ref 661* 1111* 1192* 1241* 1361* mseg_access_operations_$read_own_message 000202 external static fixed bin(17,0) dcl 7-4 set ref 1287* 1306* 1325* 1335* 1359* mseg_access_operations_$reset_salvage_bit_seg 000170 external static fixed bin(17,0) dcl 7-4 set ref 1158* 1270* mseg_access_operations_$send_normal_wakeup 000206 external static fixed bin(17,0) dcl 7-4 ref 902 mseg_access_operations_$send_urgent_wakeup 000210 external static fixed bin(17,0) dcl 7-4 ref 904 mseg_access_operations_$update_message 000212 external static fixed bin(17,0) dcl 7-4 set ref 1176* 1279* mseg_check_access_$audit_initiate_failure 000112 constant entry external dcl 304 ref 1695 mseg_check_access_$check 000114 constant entry external dcl 306 ref 882 908 mseg_check_access_$segment 000116 constant entry external dcl 307 ref 371 519 724 758 888 910 996 1092 1645 mseg_data_$admin_ring 000126 external static fixed bin(3,0) dcl 1-8 ref 1586 mseg_data_$execution_ring 000130 external static fixed bin(3,0) dcl 1-9 set ref 1458* 1586 mseg_data_$group_id 000134 external static char(32) unaligned dcl 1-11 ref 1584 mseg_data_$process_max_authorization 000132 external static bit(72) dcl 1-10 ref 1581 mseg_data_$template_operation 000124 external static bit(36) dcl 1-7 set ref 352 1564 mseg_index 114 000160 automatic fixed bin(17,0) level 2 dcl 259 set ref 529 546 1657* 1663 1663 1666 mseg_index_valid 24(02) 000160 automatic bit(1) level 3 packed unaligned dcl 259 set ref 1672* mseg_message_info based structure level 1 dcl 3-9 set ref 718 733* 1348 1365* mseg_message_info_ptr 000746 automatic pointer dcl 3-7 set ref 716* 718 733 1347* 1348 1365 mseg_operation based structure level 1 dcl 4-24 ref 352 1564 mseg_pathname_valid 24 000444 automatic bit(1) level 3 in structure "target_operation" packed unaligned dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 369* mseg_pathname_valid 24 000160 automatic bit(1) level 3 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1686* 1709* 1725* mseg_ptr 1 based pointer array level 3 in structure "mseg_table" packed unaligned dcl 9-6 in procedure "mseg_mbx_ms_gate_target_" ref 1666 mseg_ptr 110 000160 automatic pointer level 2 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1666* 1668 mseg_ptr_valid 24(01) 000160 automatic bit(1) level 3 packed unaligned dcl 259 set ref 1671* mseg_return_args based structure level 1 dcl 2-9 set ref 1549* mseg_table based structure level 1 dcl 9-6 mseg_wakeup_state based structure level 1 dcl 5-24 never_add 0(03) 001036 automatic bit(1) level 2 packed unaligned dcl 843 set ref 886 908 984 new_en 000140 automatic char(32) unaligned dcl 255 set ref 398* 406 408* 413* normal_wakeup 001062 automatic bit(1) level 2 in structure "switch" packed unaligned dcl 1080 in procedure "accept_wakeups" set ref 1096 normal_wakeup 001036 automatic bit(1) level 2 in structure "switch" packed unaligned dcl 843 in procedure "wakeup_add" set ref 854 902 968 null builtin function dcl 274 ref 329 329 377 377 605 607 646 650 1401 1404 1419 1424 1444 1478 1576 1576 1588 1660 1668 old_en 000150 automatic char(32) unaligned dcl 255 set ref 397* 400 402* 413* old_read_flags 000730 automatic structure level 1 packed unaligned dcl 264 set ref 667* 698* 1118* 1293* 1313* operation 000160 automatic structure level 1 dcl 259 set ref 329 329 342 342 386 386 413 413 446 446 460 460 470 470 508 508 510 510 519 519 524 524 541 541 556 556 558 558 573 573 589 589 611 611 615 615 648 648 683 683 724 724 728 728 758 758 765 765 882 882 888 888 908 908 910 910 996 996 998 998 1030 1030 1087 1087 1092 1092 1101 1101 1131 1131 1160 1160 1164 1164 1183 1183 1364 1364 1474 1474 1539 1539 1564* 1645 1645 1692 1692 1695 1695 own 223 000160 automatic bit(1) level 4 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1355 1359 1536* own 0(04) 000730 automatic bit(1) level 2 in structure "old_read_flags" packed unaligned dcl 264 in procedure "mseg_mbx_ms_gate_target_" set ref 1295* 1316* 1536 p_acl_count parameter fixed bin(17,0) dcl 1399 ref 1395 1401 1407 1416 1419 1422 1429 p_acl_ptr parameter pointer dcl 1398 ref 1395 1401 1412 1416 1419 1434 privileges 5 000160 automatic bit(18) level 3 dcl 259 set ref 940 950 1582* 1582 process_id 262 000160 automatic bit(36) level 3 dcl 259 set ref 1005 queue_admin_$ 000302 external static bit(36) dcl 1558 set ref 1574 read_entry_type 000103 automatic fixed bin(17,0) dcl 139 set ref 1343* 1355* 1357* 1359* 1361* 1374* return_code 001156 automatic bit(1) dcl 1600 set ref 1603* 1611* 1619* 1646 return_count 000131 automatic bit(1) dcl 204 set ref 502* 506 516 530 return_error_code parameter fixed bin(35,0) dcl 1741 ref 1738 1743 reverse builtin function dcl 274 ref 1387 rtrim builtin function dcl 274 ref 1386 1387 safety_switch 000127 automatic bit(1) dcl 204 set ref 458* 460* salv_bit 000126 automatic bit(1) dcl 204 set ref 503* 508* 509 1160* 1166 segment_acl_array based structure array level 1 dcl 12-46 set ref 612* 624 627* 1412 segment_acl_entry based structure level 1 dcl 12-45 sender_authorization 245 000160 automatic bit(72) level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1547 sender_authorization 16 001120 automatic bit(72) level 2 in structure "mra" dcl 1517 in procedure "read_for_old_entrypoint" set ref 1547* sender_id 233 000160 automatic char(32) level 3 in structure "operation" packed unaligned dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 1544 sender_id 3 001120 automatic char(32) level 2 in structure "mra" packed unaligned dcl 1517 in procedure "read_for_old_entrypoint" set ref 1544* sender_level 244 000160 automatic fixed bin(17,0) level 3 dcl 259 set ref 1545 set_lock_$lock 000120 constant entry external dcl 309 ref 1037 setwordno builtin function dcl 274 ref 1570 1572 1574 sindex 001073 automatic fixed bin(17,0) dcl 1383 set ref 1387* 1388 1388 slength 001072 automatic fixed bin(17,0) dcl 1382 set ref 1386* 1388 static_table_ptr 000010 internal static pointer initial array dcl 189 set ref 342* 524* 541* 558* 1659 status_code 13 based fixed bin(35,0) array level 3 in structure "general_delete_acl" dcl 12-30 in procedure "mseg_mbx_ms_gate_target_" set ref 1482 status_code 12 based fixed bin(35,0) array level 2 in structure "segment_acl_array" dcl 12-46 in procedure "mseg_mbx_ms_gate_target_" set ref 650* 1480* status_code 10 based fixed bin(35,0) array level 2 in structure "delete_acl_array" dcl 12-64 in procedure "mseg_mbx_ms_gate_target_" set ref 1482* status_code 15 based fixed bin(35,0) array level 3 in structure "general_extended_acl" dcl 12-18 in procedure "mseg_mbx_ms_gate_target_" set ref 650 1480 string builtin function dcl 274 set ref 667* 698* 1118* 1293* 1313* sub_err_ 000122 constant entry external dcl 310 ref 1576 substr builtin function dcl 274 ref 1085 1388 1582 switch 001036 automatic structure level 1 dcl 843 in procedure "wakeup_add" set ref 852* switch 001062 automatic structure level 1 dcl 1080 in procedure "accept_wakeups" set ref 1085* 1085 sys_info$ipc_privilege 000062 external static bit(36) dcl 226 ref 940 sys_info$ring1_privilege 000060 external static bit(36) dcl 226 ref 950 system_area based area(1024) dcl 284 ref 1444 table 1 based structure array level 2 dcl 9-6 table_length based fixed bin(17,0) level 2 dcl 9-6 ref 1663 table_ptr 000750 automatic pointer dcl 9-5 set ref 1474* 1491* 1659* 1660 1663 1666 target_operation 000444 automatic structure level 1 dcl 260 set ref 352* 371 371 377 377 381 381 386 386 1491 1491 test_lock_id 000134 automatic bit(36) dcl 226 set ref 1036* 1037* turn_off 000130 automatic bit(1) dcl 204 set ref 1154* 1156 1164 1264* 1268 type 1 000160 automatic fixed bin(17,0) level 2 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 342 366 524 541 558 1388 1570* 1572* 1574* 1659 type 1 000444 automatic fixed bin(17,0) level 2 in structure "target_operation" dcl 260 in procedure "mseg_mbx_ms_gate_target_" set ref 366* uid 202 000160 automatic bit(36) level 3 dcl 259 set ref 424 435 unspec builtin function dcl 274 set ref 852* 1004* 1085* 1085 urgent_wakeup 0(01) 001036 automatic bit(1) level 2 in structure "switch" packed unaligned dcl 843 in procedure "wakeup_add" set ref 854 963 urgent_wakeup 0(01) 001062 automatic bit(1) level 2 in structure "switch" packed unaligned dcl 1080 in procedure "accept_wakeups" set ref 1097 user_accepting 001032 automatic bit(1) dcl 839 set ref 856* 858* 860 922 940 950 960 1002 user_acl_count 000100 automatic fixed bin(17,0) dcl 139 set ref 570* 572* 586* 588* 602* 607 610* 642* 644 644* user_acl_ptr 000116 automatic pointer dcl 189 set ref 569* 572* 585* 588* 601* 607 610* 612 624* 627 629 641* 644* 650 1480 1482 user_area based area(1024) dcl 285 ref 624 user_event_channel 000106 automatic fixed bin(71,0) dcl 180 set ref 1084* 1098 validation_level 4 000160 automatic fixed bin(3,0) level 3 dcl 259 set ref 1465* 1579* validation_set 000132 automatic bit(1) dcl 204 set ref 1454* 1465 1467* 1585* version based char(8) level 2 in structure "general_extended_acl" dcl 12-18 in procedure "mseg_mbx_ms_gate_target_" set ref 1411* 1480 version 220 000160 automatic char(8) level 3 in structure "operation" dcl 259 in procedure "mseg_mbx_ms_gate_target_" set ref 721 1349 version based char(8) level 2 in structure "general_delete_acl" dcl 12-30 in procedure "mseg_mbx_ms_gate_target_" set ref 1433* 1482 w_code parameter fixed bin(35,0) dcl 1054 set ref 1051 1058* wakeup 001034 automatic bit(1) dcl 841 set ref 854* 856 899 1002 1015 wakeup_code 001035 automatic fixed bin(35,0) dcl 842 set ref 901* 912* 922 922* 960 963* 970* 972* 973* 1002 1005* 1007 1007 1007* 1015* wakeup_state 252 000160 automatic structure level 2 dcl 259 wakeup_state_valid 24(06) 000160 automatic bit(1) level 3 packed unaligned dcl 259 set ref 1045* 1090* 1099* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 12-77 ACTION_CAN_RESTART internal static bit(36) initial dcl 10-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 10-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 10-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 10-7 ADROSW_MBX_ACCESS internal static bit(36) initial dcl 8-6 AOW_MBX_ACCESS internal static bit(36) initial dcl 8-6 A_MBX_ACCESS internal static bit(36) initial dcl 8-6 DELETE_ACL_VERSION_1 internal static char(4) initial unaligned dcl 12-67 DIR_ACL_VERSION_1 internal static char(4) initial unaligned dcl 12-67 ENTRY_ACCESS_INFO_VERSION_1 internal static char(8) initial unaligned dcl 6-9 GENERAL_ACL_VERSION_1 internal static char(8) initial unaligned dcl 12-72 MSEG_OPERATION_VERSION_1 internal static fixed bin(17,0) initial dcl 4-20 MSEG_READ_DELETE internal static bit(36) initial dcl 3-38 MSEG_READ_OWN internal static bit(36) initial dcl 3-38 MSEG_WAKEUP_STATE_VERSION_1 internal static char(8) initial unaligned dcl 5-41 N_MBX_ACCESS internal static bit(36) initial dcl 8-6 O_MBX_ACCESS internal static bit(36) initial dcl 8-6 R_MBX_ACCESS internal static bit(36) initial dcl 8-6 SEG_ACL_VERSION_1 internal static char(4) initial unaligned dcl 12-67 S_MBX_ACCESS internal static bit(36) initial dcl 8-6 U_MBX_ACCESS internal static bit(36) initial dcl 8-6 W_MBX_ACCESS internal static bit(36) initial dcl 8-6 delete_acl based structure level 1 dcl 12-58 directory_acl based structure level 1 dcl 12-49 directory_acl_array based structure array level 1 dcl 12-55 entry_access_info_ptr automatic pointer dcl 6-8 general_acl based structure level 1 dcl 12-7 ms_arg_ptr automatic pointer dcl 2-7 mseg_$reset_wakeup_state_seg 000000 constant entry external dcl 11-105 mseg_access_operations_$modify_attr_seg external static fixed bin(17,0) dcl 7-4 mseg_data_$block_size external static fixed bin(35,0) dcl 1-5 mseg_data_$lock_id external static bit(72) dcl 1-4 mseg_data_$max_message_size external static fixed bin(35,0) dcl 1-6 mseg_operation_ptr automatic pointer dcl 4-19 mseg_wakeup_state_ptr automatic pointer dcl 5-38 segment_acl based structure level 1 dcl 12-40 tlength automatic fixed bin(17,0) dcl 9-12 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 012115 constant label dcl 1622 ref 1604 1612 EARLY_RETURN 007767 constant label dcl 1507 RETURN 012433 constant entry internal dcl 1738 ref 319 331 345 374 378 383 388 403 409 414 425 436 448 461 472 499 512 520 525 533 542 547 559 574 590 607 616 622 632 652 670 684 703 721 725 735 760 766 770 893 915 925 940 1017 1020 1032 1056 1058 1074 1122 1134 1146 1162 1167 1184 1234 1298 1318 1352 1366 1419 1534 1649 1660 1663 1668 1689 1696 1712 1728 RETURN_ 007753 constant label dcl 1499 ref 1744 WAKEUP_RETURN 010632 constant entry internal dcl 1051 ref 966 973 1015 accept_wakeups 010655 constant entry internal dcl 1077 ref 1073 1233 add 004310 constant label dcl 758 ref 1222 admin_add 004021 constant label dcl 716 set ref 745 check_name 010762 constant entry internal dcl 1377 ref 402 408 1688 1711 1727 check_salv_bit 005517 constant label dcl 1160 ref 1272 clean_up_copy 011465 constant entry internal dcl 1488 ref 1476 compact 001614 constant label dcl 470 ref 481 copy_acl 011045 constant entry internal dcl 1395 ref 572 610 644 copy_acl$$delete 011140 constant entry internal dcl 1416 ref 588 delete 003577 constant label dcl 680 ref 1202 entry_common 012075 constant entry internal dcl 1595 ref 318 327 338 359 395 422 433 443 456 469 480 540 554 567 583 599 639 661 678 692 1111 1129 1142 1156 1158 1176 1192 1201 1211 1241 1249 1257 1268 1270 1279 1287 1306 1325 1335 1355 1357 1359 1361 entry_common$$no_access_check 012102 constant entry internal dcl 1607 ref 710 742 754 800 810 820 830 1070 1220 1230 entry_common$$return_error 012110 constant entry internal dcl 1615 ref 488 entry_setup 011651 constant entry internal dcl 1555 ref 316 325 336 350 393 420 431 441 454 467 478 486 538 552 565 581 597 637 659 676 690 708 740 751 798 808 818 828 1067 1109 1127 1140 1152 1174 1190 1199 1209 1218 1227 1239 1247 1255 1265 1277 1285 1304 1323 1333 1341 1371 file_brief_setup 012350 constant entry internal dcl 1704 ref 1637 file_setup 012257 constant entry internal dcl 1679 ref 1635 file_temp_setup 012401 constant entry internal dcl 1720 ref 1639 free 011244 constant entry internal dcl 1441 ref 1484 general_clean_up 011337 constant entry internal dcl 1471 ref 317 326 337 357 394 421 432 442 455 468 479 487 539 553 566 582 598 638 660 677 691 709 741 752 799 809 819 829 1068 1110 1128 1141 1153 1175 1191 1200 1210 1219 1228 1240 1248 1256 1266 1278 1286 1305 1324 1334 1342 1372 1499 get_message_count 005311 constant label dcl 1131 ref 1250 get_mode 005411 constant label dcl 1144 ref 1258 index_setup 012174 constant entry internal dcl 1654 ref 1633 investigate_acceptance 010537 constant entry internal dcl 1023 ref 856 mseg_mbx_ms_gate_target_ 000100 constant entry external dcl 50 mseg_mbx_ms_gate_target_$accept_wakeups_file 006277 constant entry external dcl 1224 mseg_mbx_ms_gate_target_$accept_wakeups_index 005031 constant entry external dcl 1064 mseg_mbx_ms_gate_target_$add_file 006173 constant entry external dcl 1215 mseg_mbx_ms_gate_target_$add_index 004223 constant entry external dcl 748 mseg_mbx_ms_gate_target_$admin_add_file 004132 constant entry external dcl 737 mseg_mbx_ms_gate_target_$admin_add_index 003747 constant entry external dcl 705 mseg_mbx_ms_gate_target_$check_salv_bit_file 006643 constant entry external dcl 1261 mseg_mbx_ms_gate_target_$check_salv_bit_index 005427 constant entry external dcl 1149 mseg_mbx_ms_gate_target_$chname 000713 constant entry external dcl 390 mseg_mbx_ms_gate_target_$close 002331 constant entry external dcl 549 mseg_mbx_ms_gate_target_$compact_file 001533 constant entry external dcl 464 mseg_mbx_ms_gate_target_$compact_index 001644 constant entry external dcl 475 mseg_mbx_ms_gate_target_$copy 000425 constant entry external dcl 347 mseg_mbx_ms_gate_target_$create 000202 constant entry external dcl 322 mseg_mbx_ms_gate_target_$delete_file 006013 constant entry external dcl 1196 mseg_mbx_ms_gate_target_$delete_index 003527 constant entry external dcl 673 mseg_mbx_ms_gate_target_$delete_mseg 000311 constant entry external dcl 333 mseg_mbx_ms_gate_target_$ex_acl_add 002455 constant entry external dcl 562 mseg_mbx_ms_gate_target_$ex_acl_delete 002576 constant entry external dcl 578 mseg_mbx_ms_gate_target_$ex_acl_list 002715 constant entry external dcl 594 mseg_mbx_ms_gate_target_$ex_acl_replace 003237 constant entry external dcl 634 mseg_mbx_ms_gate_target_$general_read_file 007676 constant entry external dcl 1368 mseg_mbx_ms_gate_target_$general_read_index 007462 constant entry external dcl 1338 mseg_mbx_ms_gate_target_$get_message_count_file 006470 constant entry external dcl 1244 mseg_mbx_ms_gate_target_$get_message_count_index 005241 constant entry external dcl 1124 mseg_mbx_ms_gate_target_$get_mode_file 006554 constant entry external dcl 1252 mseg_mbx_ms_gate_target_$get_mode_index 005341 constant entry external dcl 1137 mseg_mbx_ms_gate_target_$get_uid_file 001115 constant entry external dcl 417 mseg_mbx_ms_gate_target_$get_uid_index 001213 constant entry external dcl 428 mseg_mbx_ms_gate_target_$incremental_read_file 006376 constant entry external dcl 1236 mseg_mbx_ms_gate_target_$incremental_read_index 005121 constant entry external dcl 1106 mseg_mbx_ms_gate_target_$o_incremental_read_file 007365 constant entry external dcl 1330 mseg_mbx_ms_gate_target_$o_incremental_read_index 007155 constant entry external dcl 1301 mseg_mbx_ms_gate_target_$o_read_file 007275 constant entry external dcl 1320 mseg_mbx_ms_gate_target_$o_read_index 007044 constant entry external dcl 1282 mseg_mbx_ms_gate_target_$open 002203 constant entry external dcl 535 mseg_mbx_ms_gate_target_$open_if_full 001723 constant entry external dcl 483 mseg_mbx_ms_gate_target_$read_delete_file 006077 constant entry external dcl 1206 mseg_mbx_ms_gate_target_$read_delete_index 003632 constant entry external dcl 687 mseg_mbx_ms_gate_target_$read_file 005720 constant entry external dcl 1187 mseg_mbx_ms_gate_target_$read_index 003415 constant entry external dcl 656 mseg_mbx_ms_gate_target_$set_max_length_file 001301 constant entry external dcl 438 mseg_mbx_ms_gate_target_$set_safety_switch 001417 constant entry external dcl 451 mseg_mbx_ms_gate_target_$update_message_file 006754 constant entry external dcl 1274 mseg_mbx_ms_gate_target_$update_message_index 005600 constant entry external dcl 1171 mseg_mbx_ms_gate_target_$validate 000112 constant entry external dcl 313 mseg_mbx_ms_gate_target_$wakeup_add_file 004607 constant entry external dcl 815 mseg_mbx_ms_gate_target_$wakeup_add_index 004407 constant entry external dcl 795 mseg_mbx_ms_gate_target_$wakeup_aim_add_file 004722 constant entry external dcl 825 mseg_mbx_ms_gate_target_$wakeup_aim_add_index 004510 constant entry external dcl 805 old_incremental_read 005177 constant label dcl 1113 ref 1242 old_o_incremental_read 007233 constant label dcl 1308 ref 1336 old_o_read 007120 constant label dcl 1289 ref 1326 old_read 003471 constant label dcl 662 set ref 1193 old_read_delete 003706 constant label dcl 694 ref 1212 read 007525 constant label dcl 1345 ref 1375 read_for_old_entrypoint 011513 constant entry internal dcl 1514 ref 669 702 1121 1297 1317 reset_admin_level 011320 constant entry internal dcl 1462 ref 1486 set_admin_level 011271 constant entry internal dcl 1451 ref 1631 update_message 005654 constant label dcl 1178 set ref 1280 wakeup_add 007777 constant entry internal dcl 836 ref 803 813 823 833 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 16500 17004 12515 16510 Length 20276 12515 304 1256 3762 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mseg_mbx_ms_gate_target_ 888 external procedure is an external procedure. on unit on line 317 64 on unit on unit on line 326 64 on unit on unit on line 337 64 on unit on unit on line 357 64 on unit on unit on line 394 64 on unit on unit on line 421 64 on unit on unit on line 432 64 on unit on unit on line 442 64 on unit on unit on line 455 64 on unit on unit on line 468 64 on unit on unit on line 479 64 on unit on unit on line 487 64 on unit on unit on line 539 64 on unit on unit on line 553 64 on unit on unit on line 566 64 on unit on unit on line 582 64 on unit on unit on line 598 64 on unit on unit on line 619 70 on unit on unit on line 638 64 on unit on unit on line 660 64 on unit on unit on line 677 64 on unit on unit on line 691 64 on unit on unit on line 709 64 on unit on unit on line 741 64 on unit on unit on line 752 64 on unit on unit on line 799 64 on unit on unit on line 809 64 on unit on unit on line 819 64 on unit on unit on line 829 64 on unit wakeup_add internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. investigate_acceptance internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. WAKEUP_RETURN internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. on unit on line 1068 64 on unit accept_wakeups internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. on unit on line 1110 64 on unit on unit on line 1128 64 on unit on unit on line 1141 64 on unit on unit on line 1153 64 on unit on unit on line 1175 64 on unit on unit on line 1191 64 on unit on unit on line 1200 64 on unit on unit on line 1210 64 on unit on unit on line 1219 64 on unit on unit on line 1228 64 on unit on unit on line 1240 64 on unit on unit on line 1248 64 on unit on unit on line 1256 64 on unit on unit on line 1266 64 on unit on unit on line 1278 64 on unit on unit on line 1286 64 on unit on unit on line 1305 64 on unit on unit on line 1324 64 on unit on unit on line 1334 64 on unit on unit on line 1342 64 on unit on unit on line 1372 64 on unit check_name internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. copy_acl internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. free internal procedure shares stack frame of internal procedure general_clean_up. set_admin_level internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. reset_admin_level internal procedure shares stack frame of internal procedure general_clean_up. general_clean_up 118 internal procedure is called by several nonquick procedures. clean_up_copy internal procedure shares stack frame of internal procedure general_clean_up. read_for_old_entrypoint internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. entry_setup internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. entry_common internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. index_setup internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. file_setup internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. file_brief_setup internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. file_temp_setup internal procedure shares stack frame of external procedure mseg_mbx_ms_gate_target_. RETURN 64 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 static_table_ptr mseg_mbx_ms_gate_target_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME mseg_mbx_ms_gate_target_ 000100 user_acl_count mseg_mbx_ms_gate_target_ 000101 ms_count mseg_mbx_ms_gate_target_ 000102 i mseg_mbx_ms_gate_target_ 000103 read_entry_type mseg_mbx_ms_gate_target_ 000104 max_length mseg_mbx_ms_gate_target_ 000105 code mseg_mbx_ms_gate_target_ 000106 user_event_channel mseg_mbx_ms_gate_target_ 000110 event_message mseg_mbx_ms_gate_target_ 000112 area_ptr mseg_mbx_ms_gate_target_ 000114 arg_ptr mseg_mbx_ms_gate_target_ 000116 user_acl_ptr mseg_mbx_ms_gate_target_ 000120 internal_acl_ptr mseg_mbx_ms_gate_target_ 000122 error_on_target mseg_mbx_ms_gate_target_ 000123 copy_entry mseg_mbx_ms_gate_target_ 000124 file_sw mseg_mbx_ms_gate_target_ 000125 ms_wanted mseg_mbx_ms_gate_target_ 000126 salv_bit mseg_mbx_ms_gate_target_ 000127 safety_switch mseg_mbx_ms_gate_target_ 000130 turn_off mseg_mbx_ms_gate_target_ 000131 return_count mseg_mbx_ms_gate_target_ 000132 validation_set mseg_mbx_ms_gate_target_ 000133 dir mseg_mbx_ms_gate_target_ 000134 test_lock_id mseg_mbx_ms_gate_target_ 000136 ms_id mseg_mbx_ms_gate_target_ 000140 new_en mseg_mbx_ms_gate_target_ 000150 old_en mseg_mbx_ms_gate_target_ 000160 operation mseg_mbx_ms_gate_target_ 000444 target_operation mseg_mbx_ms_gate_target_ 000730 old_read_flags mseg_mbx_ms_gate_target_ 000746 mseg_message_info_ptr mseg_mbx_ms_gate_target_ 000750 table_ptr mseg_mbx_ms_gate_target_ 000752 acl_ptr mseg_mbx_ms_gate_target_ 000754 acl_count mseg_mbx_ms_gate_target_ 001032 user_accepting wakeup_add 001033 censor_wakeup_code wakeup_add 001034 wakeup wakeup_add 001035 wakeup_code wakeup_add 001036 switch wakeup_add 001062 switch accept_wakeups 001072 slength check_name 001073 sindex check_name 001120 mra read_for_old_entrypoint 001156 return_code entry_common 001157 dont_call_mca entry_common THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 bound_ck_signal enable_op ext_entry ext_entry_desc int_entry op_alloc_ alloc_storage op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. admin_gate_$admin_level_no_fs_audit aim_check_$greater aim_check_$greater_or_equal aim_util_$get_access_class aim_util_$get_privileges cu_$caller_ptr get_process_authorization_ get_system_free_area_ hcs_$level_get hcs_$level_set hcs_$wakeup mseg_$add_acl_entries_seg mseg_$add_message mseg_$chname_seg mseg_$close_seg mseg_$compact_seg mseg_$copy_seg mseg_$count_messages mseg_$create_seg mseg_$delete_acl_entries_seg mseg_$delete_message mseg_$delete_seg mseg_$get_salvaged_flag_seg mseg_$get_wakeup_state_seg mseg_$initiate_seg mseg_$list_acl_entries_seg mseg_$list_acl_seg mseg_$open_seg mseg_$read_message mseg_$replace_acl_seg mseg_$reset_salvaged_flag_seg mseg_$set_max_length_seg mseg_$set_safety_switch_seg mseg_$set_wakeup_state_seg mseg_$update_message mseg_check_access_$audit_initiate_failure mseg_check_access_$check mseg_check_access_$segment set_lock_$lock sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$ai_restricted error_table_$argerr error_table_$bad_file_name error_table_$dirseg error_table_$inconsistent error_table_$invalid_lock_reset error_table_$messages_deferred error_table_$messages_off error_table_$moderr error_table_$no_append error_table_$no_info error_table_$noalloc error_table_$not_seg_type error_table_$null_info_ptr error_table_$seg_unknown error_table_$unimplemented_version error_table_$wakeup_denied mailbox_$ message_segment_$ mseg_access_operations_$accept_wakeups_seg mseg_access_operations_$acl_list_seg mseg_access_operations_$acl_modify_seg mseg_access_operations_$add_message mseg_access_operations_$admin_add_message mseg_access_operations_$close_seg mseg_access_operations_$compact_seg mseg_access_operations_$copy_seg mseg_access_operations_$create_seg mseg_access_operations_$delete_message mseg_access_operations_$delete_seg mseg_access_operations_$get_count_seg mseg_access_operations_$modify_fs_attr_seg mseg_access_operations_$open_seg mseg_access_operations_$read_attr_seg mseg_access_operations_$read_delete_message mseg_access_operations_$read_delete_own_message mseg_access_operations_$read_fs_attr_seg mseg_access_operations_$read_message mseg_access_operations_$read_own_message mseg_access_operations_$reset_salvage_bit_seg mseg_access_operations_$send_normal_wakeup mseg_access_operations_$send_urgent_wakeup mseg_access_operations_$update_message mseg_data_$admin_ring mseg_data_$execution_ring mseg_data_$group_id mseg_data_$process_max_authorization mseg_data_$template_operation queue_admin_$ sys_info$ipc_privilege sys_info$ring1_privilege LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 50 000077 313 000105 316 000135 317 000136 318 000160 319 000171 322 000177 325 000225 326 000226 327 000250 329 000261 331 000300 333 000306 336 000334 337 000335 338 000357 340 000370 342 000371 345 000410 347 000416 350 000462 352 000463 353 000470 355 000472 357 000473 359 000515 361 000526 363 000530 364 000533 366 000537 367 000541 368 000547 369 000554 370 000556 371 000561 374 000573 377 000603 378 000622 381 000632 383 000645 386 000655 388 000677 390 000705 393 000750 394 000751 395 000773 397 001004 398 001012 400 001017 402 001023 403 001025 406 001035 408 001041 409 001043 413 001053 414 001101 417 001107 420 001142 421 001143 422 001165 424 001176 425 001200 428 001206 431 001227 432 001230 433 001252 435 001263 436 001265 438 001273 441 001324 442 001325 443 001347 445 001360 446 001363 447 001400 448 001403 451 001411 454 001442 455 001443 456 001465 458 001476 460 001502 461 001517 464 001525 467 001560 468 001561 469 001603 470 001614 472 001631 475 001637 478 001660 479 001661 480 001703 481 001714 483 001715 486 001754 487 001755 488 001777 499 002010 502 002023 503 002026 504 002027 506 002030 508 002031 509 002047 510 002052 511 002070 512 002072 516 002101 518 002103 519 002106 520 002120 524 002130 525 002147 527 002157 529 002160 530 002162 533 002167 535 002175 538 002230 539 002231 540 002253 541 002264 542 002303 544 002313 546 002314 547 002316 549 002324 552 002343 553 002344 554 002366 556 002377 558 002422 559 002441 562 002447 565 002500 566 002501 567 002523 569 002534 570 002540 572 002542 573 002544 574 002561 578 002567 581 002623 582 002624 583 002646 585 002657 586 002663 588 002665 589 002667 590 002704 594 002712 597 002742 598 002743 599 002765 601 002776 602 003002 603 003004 605 003007 607 003013 610 003031 611 003033 612 003050 613 003110 615 003111 616 003126 618 003136 619 003141 621 003155 622 003160 623 003167 624 003170 625 003176 626 003177 627 003207 628 003217 629 003221 630 003224 632 003226 634 003234 637 003262 638 003263 639 003305 641 003316 642 003322 644 003324 646 003330 648 003332 650 003347 652 003401 656 003407 659 003435 660 003436 661 003460 662 003471 664 003474 665 003477 666 003502 667 003504 668 003505 669 003512 670 003514 673 003522 676 003543 677 003544 678 003566 680 003577 682 003604 683 003606 684 003621 687 003627 690 003652 691 003653 692 003675 694 003706 696 003711 697 003714 698 003717 699 003720 700 003722 701 003727 702 003731 703 003733 705 003741 708 003765 709 003766 710 004010 716 004021 718 004024 719 004027 720 004031 721 004033 724 004045 725 004060 728 004070 730 004103 732 004105 733 004112 735 004116 737 004124 740 004161 741 004162 742 004204 745 004215 748 004216 751 004243 752 004244 754 004266 756 004277 758 004310 760 004323 762 004333 763 004336 764 004340 765 004342 766 004355 769 004365 770 004372 795 004400 798 004431 799 004432 800 004454 801 004465 802 004476 803 004500 805 004501 808 004534 809 004535 810 004557 811 004570 812 004575 813 004577 815 004600 818 004642 819 004643 820 004665 821 004676 822 004707 823 004711 825 004712 828 004757 829 004760 830 005002 831 005013 832 005020 833 005022 1064 005023 1067 005047 1068 005050 1070 005072 1073 005103 1074 005104 1106 005112 1109 005143 1110 005144 1111 005166 1113 005177 1115 005202 1116 005205 1117 005211 1118 005214 1119 005215 1120 005217 1121 005224 1122 005226 1124 005234 1127 005255 1128 005256 1129 005300 1131 005311 1133 005326 1134 005330 1137 005336 1140 005355 1141 005356 1142 005400 1144 005411 1146 005413 1149 005421 1152 005445 1153 005446 1154 005470 1156 005473 1158 005506 1160 005517 1162 005534 1164 005544 1166 005561 1167 005564 1171 005572 1174 005620 1175 005621 1176 005643 1178 005654 1180 005656 1181 005663 1182 005666 1183 005670 1184 005703 1187 005711 1190 005751 1191 005752 1192 005774 1193 006005 1196 006006 1199 006040 1200 006041 1201 006063 1202 006074 1206 006075 1209 006130 1210 006131 1211 006153 1212 006164 1215 006165 1218 006224 1219 006225 1220 006247 1221 006260 1222 006271 1224 006272 1227 006324 1228 006325 1230 006347 1233 006360 1234 006361 1236 006367 1239 006431 1240 006432 1241 006454 1242 006465 1244 006466 1247 006515 1248 006516 1249 006540 1250 006551 1252 006552 1255 006601 1256 006602 1257 006624 1258 006635 1261 006636 1264 006672 1265 006675 1266 006676 1268 006720 1270 006734 1272 006745 1274 006746 1277 007005 1278 007006 1279 007030 1280 007041 1282 007042 1285 007064 1286 007065 1287 007107 1289 007120 1291 007123 1292 007126 1293 007131 1294 007132 1295 007136 1296 007140 1297 007142 1298 007144 1301 007152 1304 007177 1305 007200 1306 007222 1308 007233 1310 007236 1311 007241 1312 007245 1313 007250 1314 007251 1315 007253 1316 007260 1317 007262 1318 007264 1320 007272 1323 007326 1324 007327 1325 007351 1326 007362 1330 007363 1333 007420 1334 007421 1335 007443 1336 007454 1338 007455 1341 007500 1342 007501 1343 007523 1345 007525 1347 007530 1348 007533 1349 007536 1351 007541 1352 007544 1355 007552 1357 007576 1359 007612 1361 007626 1363 007637 1364 007641 1365 007656 1366 007662 1368 007670 1371 007725 1372 007726 1374 007750 1375 007752 1499 007753 1501 007757 1503 007765 1504 007766 1507 007767 1510 007775 1512 007776 836 007777 850 010000 851 010003 852 010005 854 010011 856 010021 858 010025 860 010026 881 010052 882 010055 884 010067 886 010071 888 010074 891 010110 893 010116 899 010124 901 010126 902 010127 904 010136 908 010141 910 010157 912 010171 915 010202 922 010211 925 010225 940 010234 950 010272 954 010322 960 010323 963 010330 966 010345 968 010354 970 010362 972 010371 973 010374 984 010401 986 010404 987 010407 988 010410 995 010411 996 010414 998 010427 1002 010442 1004 010453 1005 010456 1007 010475 1012 010504 1014 010506 1015 010513 1017 010520 1018 010527 1020 010530 1061 010536 1023 010537 1028 010541 1030 010542 1032 010555 1034 010570 1036 010572 1037 010574 1038 010610 1040 010621 1042 010622 1044 010624 1045 010627 1048 010631 1051 010632 1056 010634 1058 010646 1059 010654 1077 010655 1084 010656 1085 010660 1087 010665 1088 010700 1090 010706 1092 010714 1093 010727 1096 010732 1097 010736 1098 010742 1099 010744 1101 010746 1102 010761 1377 010762 1385 010764 1386 010765 1387 011000 1388 011014 1390 011035 1391 011041 1392 011044 1395 011045 1401 011047 1403 011055 1404 011056 1407 011060 1408 011062 1409 011072 1411 011073 1412 011077 1414 011137 1416 011140 1419 011142 1422 011160 1424 011164 1425 011167 1426 011170 1429 011171 1430 011172 1431 011202 1433 011203 1434 011207 1435 011243 1441 011244 1444 011245 1446 011270 1451 011271 1454 011272 1455 011274 1458 011310 1459 011317 1462 011320 1465 011321 1467 011333 1468 011335 1471 011336 1474 011344 1476 011364 1478 011370 1480 011375 1482 011431 1484 011462 1486 011463 1496 011464 1488 011465 1491 011466 1492 011506 1493 011512 1514 011513 1520 011515 1522 011522 1524 011525 1526 011533 1527 011535 1528 011536 1530 011546 1532 011553 1534 011560 1536 011567 1537 011574 1538 011601 1539 011603 1540 011620 1542 011622 1543 011624 1544 011626 1545 011631 1546 011633 1547 011636 1548 011641 1549 011644 1551 011650 1555 011651 1564 011652 1570 011657 1572 011700 1574 011722 1576 011744 1579 012015 1580 012024 1581 012033 1582 012040 1584 012053 1585 012060 1586 012061 1587 012070 1588 012071 1589 012073 1591 012074 1595 012075 1602 012077 1603 012100 1604 012101 1607 012102 1610 012104 1611 012106 1612 012107 1615 012110 1618 012112 1619 012113 1622 012115 1631 012120 1633 012121 1635 012127 1637 012133 1639 012137 1642 012142 1645 012145 1646 012160 1649 012165 1651 012173 1654 012174 1657 012175 1659 012177 1660 012204 1663 012216 1666 012232 1668 012237 1671 012252 1672 012254 1674 012256 1679 012257 1682 012260 1684 012262 1685 012270 1686 012275 1688 012277 1689 012301 1692 012311 1693 012324 1695 012326 1696 012341 1699 012347 1704 012350 1707 012351 1708 012357 1709 012364 1711 012366 1712 012370 1715 012400 1720 012401 1723 012402 1724 012410 1725 012415 1727 012417 1728 012421 1731 012431 1738 012432 1743 012440 1744 012444 ----------------------------------------------------------- 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