COMPILATION LISTING OF SEGMENT acl_commands_ Compiled by: Multics PL/I Compiler, Release 30, of February 16, 1988 Compiled at: Honeywell Bull, Phoenix AZ, SysM Compiled on: 10/06/88 1035.6 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 6* * * 7* *********************************************************** */ 8 9 10 /****^ HISTORY COMMENTS: 11* 1) change(86-10-02,TLNguyen), approve(86-10-23,MCR7555), 12* audit(86-10-29,GWMay), install(86-10-29,MR12.0-1201): 13* Modified all IACL commands to correctly process a directory type 14* and omit or reject non-directory types. 15* 2) change(87-08-21,TLNguyen), approve(87-08-21,MCR7755), 16* audit(87-09-08,Lippard), install(87-12-07,MR12.2-1009): 17* Change the list_accessible and list_not_accessible to work with the ROOT 18* directory. 19* 3) change(87-08-27,TLNguyen), approve(87-08-27,MCR7757), 20* audit(87-09-08,Lippard), install(87-12-07,MR12.2-1009): 21* Change list_acl command to return error_table_$noentry for a non-existent 22* target of a link. 23* 4) change(87-08-27,TLNguyen), approve(87-08-27,MCR7763), 24* audit(87-09-08,Lippard), install(87-12-07,MR12.2-1009): 25* Change acl_commands_.pl1 to display a correct error message when 26* -directory or -segment control arguments is specified for IACL commands. 27* 5) change(88-03-01,Lippard), approve(88-03-28,MCR7869), 28* audit(88-04-26,Parisek), install(88-05-03,MR12.2-1044): 29* Modified to give more informative error message when inconsistent 30* ACL modes are specified. 31* 6) change(88-09-20,TLNguyen), approve(88-09-20,MCR7983), 32* audit(88-10-03,Parisek), install(88-10-06,MR12.2-1134): 33* Change the list_acl command to print out the pathname in the error 34* message when the ACL list is empty. 35* END HISTORY COMMENTS */ 36 37 38 /* format: style3,linecom,ifthenstmt,ifthendo,ifthen,^indnoniterdo,indnoniterend,indcomtxt,^inditerdo,indend,idind30 */ 39 acl_commands_: 40 procedure () options (variable); 41 42 /*^* ACL COMMANDS -- completely rewritten, 1/28/83 Jay Pattin 43* * Fixed set_acl to work on DM files (if ^xacl_allowed & si.type_name ^= "DM file") 06/06/83 S. Herbst 44* * Added lac and lnac 8/27/83 Jay Pattin 45* * Updated for fs_util_, 2 October 1983, W. Olin Sibert 46* * Modified to prevent freeing of same block twice through 2 separate pointers, 1984.01.25, MAP 47* * Modified to use Person.*.* for default mbx acls, instead of Person.Project.*, 1984.02.02, MAP 48* * Modified to check for mbx type from suffix as well as from invocation method, 1984.02.02, MAP 49* * Modified to use fs_util_ object type instead of hcs_ entry type, 1984.02.17, MAP 50* * Modified to set ACL on non-standard object only if given suffix is nt starname, 1984.03.12, MAP 51* * Modified to report "Empty ACL" when original ACL count = 0, 1984.03.12, MAP 52* * Modified to not delete *.SysDaemon.* for da foo -all, 1984.10.24, MAP 53* * Modified to delete *.SysDaemon.* when explicitly instructed to do so. 54* * Also to give error message if -sysdaemon or -no_sysdaemon is used 55* * without -replace. Also to fix bugs with implementation of -slet; 56* * And to use the raw acl of extended entries for reporting acls 57* * when -inase is used. 1/14/85, M. Sharpe. 58* * Modified star name processing when more than one entry type is 59* * requested. 3/13/85, M.Sharpe. 60* */ 61 62 /* This procedure implements all the ACL setting, changing, deleting, and listing 63* * commands for Multics. It includes the following commands, listed in the order 64* * in which they appear in the code: 65* 66* NAME ALTERNATE NAMES ACL TYPE PRIVILEGE 67* 68* set_acl setacl, sa branch normal 69* l_set_acl lset_acl, lsetacl, lsa branch library 70* hp_set_acl hpsetacl, hpsa branch hphcs 71* 72* delete_acl deleteacl, da branch normal 73* l_delete_acl ldelete_acl, ldeleteacl, lda branch library 74* hp_delete_acl hpdeleteacl, hpda branch hphcs 75* 76* ms_set_acl mssa message segment normal 77* mbx_set_acl mbsa mailbox normal 78* ms_delete_acl msda message segment normal 79* mbx_delete_acl mbda mailbox normal 80* 81* set_iacl_seg sis segment iacl normal 82* set_iacl_dir sid directory iacl normal 83* delete_iacl_seg dis segment iacl normal 84* delete_iacl_dir did directory iacl normal 85* 86* list_acl listacl, la branch acl normal 87* list_iacl_seg lis segment iacl normal 88* list_iacl_dir lid directory iacl normal 89* 90* ms_list_acl msla message segment normal 91* mbx_list_acl mbla mailbox normal 92* 93* and poor, unrelated list_accessible and list_not_accessible */ 94 95 /* */ 96 97 /* format: off */ 98 99 declare error_table_$action_not_performed fixed bin (35) external static; 100 declare error_table_$active_function fixed bin (35) external static; 101 declare error_table_$bad_conversion fixed bin (35) external static; 102 declare error_table_$bad_name fixed bin (35) external static; 103 declare error_table_$bad_ring_brackets fixed bin (35) external static; 104 declare error_table_$badopt fixed bin (35) external static; 105 declare error_table_$inconsistent fixed bin (35) external static; 106 declare error_table_$noarg fixed bin (35) external static; 107 declare error_table_$noentry fixed bin (35) external static; 108 declare error_table_$nomatch fixed bin (35) external static; 109 declare error_table_$nostars fixed bin (35) external static; 110 declare error_table_$notadir fixed bin (35) external static; 111 declare error_table_$not_seg_type fixed bin (35) external static; 112 declare error_table_$root fixed bin (35) external static; 113 declare error_table_$unsupported_operation fixed bin (35) external static; 114 declare error_table_$user_not_found fixed bin (35) external static; 115 116 declare active_fnc_err_ entry options (variable); 117 declare check_star_name_$entry entry (char (*), fixed bin (35)); 118 declare com_err_ entry options (variable); 119 declare convert_authorization_$to_string_short 120 entry (bit (72) aligned, char (*), fixed bin (35)); 121 declare cu_$af_return_arg_rel entry (fixed bin, pointer, fixed bin (21), fixed bin (35), pointer); 122 declare cu_$arg_list_ptr entry (pointer); 123 declare cu_$arg_ptr_rel entry (fixed bin, pointer, fixed bin (21), fixed bin (35), pointer); 124 declare cu_$generate_call entry (entry, pointer); 125 declare cu_$level_get entry (fixed bin (3)); 126 declare cv_acl_type_$create entry (pointer, fixed bin, pointer, char (32), char (32), pointer); 127 declare expand_pathname_$add_suffix entry (char (*), char (*), char (*), char (*), fixed bin (35)); 128 declare get_group_id_$tag_star entry returns (char (32)); 129 declare get_system_free_area_ entry returns (ptr); 130 declare get_wdir_ entry returns (char (168)); 131 declare hcs_$get_access_class entry (char (*), char (*), bit (72) aligned, fixed bin (35)); 132 declare hcs_$get_dir_ring_brackets entry (char (*), char (*), (2) fixed bin (3), fixed bin (35)); 133 declare hcs_$get_ring_brackets entry (char (*), char (*), (*) fixed bin (3), fixed bin (35)); 134 declare hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, fixed bin (35)); 135 declare hcs_$status_minf entry (char (*), char (*), fixed bin (1), 136 fixed bin (2), fixed bin (24), fixed bin (35)); 137 declare ioa_ entry options (variable); 138 declare match_star_name_ entry (char(*), char(*), fixed bin(35)); 139 declare msf_manager_$close entry (ptr); 140 declare msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 141 declare pathname_ entry (char (*), char (*)) returns (char (168)); 142 143 declare fs_util_$get_ring_brackets entry (char (*), char (*), (*) fixed bin (3), fixed bin (35)); 144 declare fs_util_$make_entry_for_type entry (char (*), char (*), entry, fixed bin (35)); 145 declare fs_util_$suffix_info entry (char (*), char (*), ptr, fixed bin (35)); 146 declare fs_util_$suffix_info_for_type entry (char (*), ptr, fixed bin (35)); 147 148 declare hcs_$get_user_access_modes entry (char (*), char (*), char (*), fixed bin, 149 bit (36) aligned, bit (36) aligned, fixed bin (35)); 150 declare fs_util_$get_user_access_modes entry (char (*), char (*), char (*), fixed bin, 151 bit (36) aligned, bit (36) aligned, fixed bin (35)); 152 153 declare fs_util_$list_acl entry (char (*), char (*), char (*), pointer, pointer, fixed bin (35)); 154 155 declare hcs_$list_inacl entry (char (*), char (*), ptr, ptr, ptr, fixed bin, fixed bin (3), fixed bin (35)); 156 declare hcs_$list_dir_inacl entry (char (*), char (*), ptr, ptr, ptr, fixed bin, fixed bin (3), fixed bin (35)); 157 158 declare hcs_$replace_dir_acl entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 159 declare hcs_$replace_acl entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 160 declare hphcs_$replace_acl entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 161 declare hphcs_$replace_dir_acl entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 162 declare installation_tools_$replace_acl entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 163 declare installation_tools_$replace_dir_acl 164 entry (char (*), char (*), pointer, fixed bin, bit (1) aligned, fixed bin (35)); 165 declare fs_util_$replace_acl entry (char (*), char (*), pointer, bit (1) aligned, fixed bin (35)); 166 167 declare hcs_$replace_inacl entry (char (*), char (*), 168 pointer, fixed bin, bit (1) aligned, fixed bin (3), fixed bin (35)); 169 declare hcs_$replace_dir_inacl entry (char (*), char (*), 170 pointer, fixed bin, bit (1) aligned, fixed bin (3), fixed bin (35)); 171 172 declare (cleanup, linkage_error) condition; 173 174 declare (abs, addr, after, before, char, copy, divide, index, length, max, 175 null, reverse, rtrim, search, string, substr, sum, unspec, verify) 176 builtin; 177 178 /* */ 179 180 declare ON init ("1"b) bit (1) aligned internal static options (constant); 181 declare OFF init ("0"b) bit (1) aligned internal static options (constant); 182 183 declare DIRECTORY init (2) fixed bin (2) internal static options (constant); 184 /* Possible values for the type parameter */ 185 186 declare BRANCH_ACL init (101) fixed bin (10) internal static options (constant); 187 declare MSEG_ACL init (102) fixed bin (10) internal static options (constant); 188 declare MBX_ACL init (103) fixed bin (10) internal static options (constant); 189 declare SEGMENT_IACL init (104) fixed bin (10) internal static options (constant); 190 declare DIRECTORY_IACL init (105) fixed bin (10) internal static options (constant); 191 192 /* Possible values for the operation parameter */ 193 194 declare LIST init (201) fixed bin (11) internal static options (constant); 195 declare SET init (202) fixed bin (11) internal static options (constant); 196 declare DELETE init (203) fixed bin (11) internal static options (constant); 197 declare ACCESSIBLE init (204) fixed bin (11) internal static options (constant); 198 199 /* Possible values for the privilege parameter */ 200 201 declare NORMAL init (301) fixed bin (12) internal static options (constant); 202 declare LIBRARY init (302) fixed bin (12) internal static options (constant); 203 declare HPHCS init (303) fixed bin (12) internal static options (constant); 204 205 /* */ 206 207 /* Now, the entrypoints. Each one calls the common procedure to get its work done, and exits by goto ACL_COMMANDS_RETURN */ 208 209 ACL_COMMANDS_RETURN: /* This is the only return statement in this program. */ 210 return; /* The "common" procedure always exits by a goto to here */ 211 212 213 set_acl: setacl: sa: /* Normal, unprivileged, user ACL setting command */ 214 entry () options (variable); 215 call common ("set_acl", BRANCH_ACL, SET, NORMAL); 216 217 l_set_acl: lset_acl: lsetacl: lsa: /* Ring 1, privileged entry for library maintenance */ 218 entry () options (variable); 219 call common ("l_set_acl", BRANCH_ACL, SET, LIBRARY); 220 221 hp_set_acl: hpsetacl: hpsa: /* Ring 0, highly privileged entry for systems programmers */ 222 entry () options (variable); 223 call common ("hp_set_acl", BRANCH_ACL, SET, HPHCS); 224 225 delete_acl: deleteacl: da: /* Normal, unprivileged, user ACL deletion command */ 226 entry () options (variable); 227 call common ("delete_acl", BRANCH_ACL, DELETE, NORMAL); 228 229 l_delete_acl: ldelete_acl: ldeleteacl: lda: /* Ring 1, privileged entry for library maintenance */ 230 entry () options (variable); 231 call common ("l_delete_acl", BRANCH_ACL, DELETE, LIBRARY); 232 233 hp_delete_acl: hpdeleteacl: hpda: /* Ring 0, highly privileged entry for systems programmers */ 234 entry () options (variable); 235 call common ("hp_delete_acl", BRANCH_ACL, DELETE, HPHCS); 236 237 ms_set_acl: mssa: /* User command for setting message segment ACLs */ 238 entry () options (variable); 239 call common ("ms_set_acl", MSEG_ACL, SET, NORMAL); 240 241 mbx_set_acl: mbsa: /* User command for setting mailbox ACLs */ 242 entry () options (variable); 243 call common ("mbx_set_acl", MBX_ACL, SET, NORMAL); 244 245 ms_delete_acl: msda: /* User command for deleting message segment ACLs */ 246 entry () options (variable); 247 call common ("ms_delete_acl", MSEG_ACL, DELETE, NORMAL); 248 249 mbx_delete_acl: mbda: /* User command for deleting mailbox ACLs */ 250 entry () options (variable); 251 call common ("mbx_delete_acl", MBX_ACL, DELETE, NORMAL); 252 253 set_iacl_seg: sis: /* Nonprivileged user command for setting segment IACLs */ 254 entry () options (variable); 255 call common ("set_iacl_seg", SEGMENT_IACL, SET, NORMAL); 256 257 delete_iacl_seg: dis: /* Nonprivileged user command for deleting segment IACLs */ 258 entry () options (variable); 259 call common ("delete_iacl_seg", SEGMENT_IACL, DELETE, NORMAL); 260 261 set_iacl_dir: sid: /* Nonprivileged user command for setting directory IACLs */ 262 entry () options (variable); 263 call common ("set_iacl_dir", DIRECTORY_IACL, SET, NORMAL); 264 265 delete_iacl_dir: did: /* Nonprivileged user command for deleting directory IACLs */ 266 entry () options (variable); 267 call common ("delete_iacl_dir", DIRECTORY_IACL, DELETE, NORMAL); 268 269 list_acl: listacl: la: /* User command for listing ACLs */ 270 entry () options (variable); 271 call common ("list_acl", BRANCH_ACL, LIST, NORMAL); 272 273 list_iacl_seg: lis: /* User command for listing segment IACLs */ 274 entry () options (variable); 275 call common ("list_iacl_seg", SEGMENT_IACL, LIST, NORMAL); 276 277 list_iacl_dir: lid: /* User command for listing directory IACLs */ 278 entry () options (variable); 279 call common ("list_iacl_dir", DIRECTORY_IACL, LIST, NORMAL); 280 281 ms_list_acl: msla: /* User command for listing message segment ACLs */ 282 entry () options (variable); 283 call common ("ms_list_acl", MSEG_ACL, LIST, NORMAL); 284 285 mbx_list_acl: mbla: /* User command for listing mailbox ACLs */ 286 entry () options (variable); 287 call common ("mbx_list_acl", MBX_ACL, LIST, NORMAL); 288 289 list_accessible: lac: /* User command for locating accessable objects */ 290 entry options (variable); 291 call common ("list_accessible", BRANCH_ACL, ACCESSIBLE, NORMAL); 292 293 list_not_accessible: lnac: /* User command for locating inaccessable objects */ 294 entry options (variable); 295 call common ("list_not_accessible", BRANCH_ACL, ACCESSIBLE, NORMAL); 296 297 /* */ 298 299 common: 300 procedure (P_whoami, P_type, P_operation, P_privilege); 301 302 /* In case anyone is wondering why the peculiar precisions, it's in order to ensure that calls to "common" 303* are made with the right arguments in the right places: putting a type constant in the operation slot, 304* for instance, will generate a warning about incompatible datatypes. */ 305 306 declare P_whoami char (32) parameter; /* Command name */ 307 declare P_type fixed bin (10) parameter; /* Type of ACL to operate on; see constants above */ 308 declare P_operation fixed bin (11) parameter; /* Which operation to perform */ 309 declare P_privilege fixed bin (12) parameter; /* What level of privilege to assume */ 310 311 declare arg_list_ptr pointer; 312 313 /* Yes, and if anyone is wondering about this, too, it's an awkward dodge to ensure that 314* the arg_list_ptr gets set properly so that the internal procedures can use it. In order 315* to ensure this, though, the call to cu_$arg_list_ptr has to appear in a quick block 316* immediately contained in the outer block. This is true of "common", but not of 317* "nonquick_common", because it, as the procedure which really does the work, it has 318* to set up a cleanup handler and do various other things that force it to be non-quick. 319* So, there's this first quick procedure which is called by all the entrypoints, and 320* all it does is get the argument list and call the non-quick one (which inherits all the 321* type and operation parameters from this one, its parent). */ 322 323 call cu_$arg_list_ptr (arg_list_ptr); 324 325 call nonquick_common (arg_list_ptr); 326 327 /* There is only one return statement in nonquick_common: it gets us here, and this goto gets us out completely */ 328 329 goto ACL_COMMANDS_RETURN; 330 331 /* */ 332 333 nonquick_common: 334 procedure (P_arg_list_ptr); 335 336 declare P_arg_list_ptr pointer parameter; /* Used to reference command-line arguments */ 337 338 declare whoami char (32); 339 declare type fixed bin (10); 340 declare operation fixed bin (11); 341 declare privilege fixed bin (12); 342 343 declare system_area_ptr ptr; 344 declare system_area area based (system_area_ptr); 345 346 declare code fixed bin (35); 347 348 declare ret_str_ptr ptr; 349 declare ret_str_lth fixed bin (21); 350 declare ret_str char (ret_str_lth) varying based (ret_str_ptr); 351 352 declare entry_type_count fixed bin; 353 declare entry_type_ptr ptr; 354 declare 1 entry_type aligned based (entry_type_ptr), 355 2 count fixed bin, 356 2 suffixes dim (entry_type_count refer (entry_type.count)), 357 3 suffix char (32), 358 3 is_std_type bit (1); 359 360 declare star_match_ptr ptr; 361 declare star_name_count fixed bin; 362 declare star_match dim (star_name_count) bit (1) 363 unaligned based (star_match_ptr); 364 365 declare dname char (168); 366 declare ename char (32); 367 declare hcs_type fixed bin (2); 368 declare object_type char (32); 369 declare 1 si aligned like suffix_info; 370 declare 1 type_info aligned like suffix_info; 371 372 declare access_class bit (72) aligned; 373 declare access_name char (32); 374 declare acl_mask bit (36) aligned; 375 declare buffer char (256); 376 declare bit_count fixed bin (24); 377 declare err_path char (168); 378 declare iacl_ring fixed bin (3); 379 declare pathname char (204); 380 declare star_entry_idx fixed bin; 381 declare star_name_idx fixed bin; 382 declare do_tedious_star bit (1) aligned; 383 declare star_sw bit (1) aligned; 384 declare xacl_allowed bit (1) aligned; 385 declare limit_entry_types bit (1) aligned; 386 387 /* The acl_modes and acl_names structures contain the character string modes and names specified 388* on the command line. The old_acl, new_acl, and used_bits structures are used when building 389* a new ACL for listing, setting, or deleting. They are declared here for ease of cleanup. 390* original_count is used by build_new_acl and list_the_acl, and must be delcared external to both. */ 391 392 declare acl_names_ptr pointer init (null ()); /* Various things checked in the cleanup handler */ 393 declare acl_modes_ptr pointer init (null ()); 394 declare old_acl_ptr pointer init (null ()); 395 declare new_acl_ptr pointer init (null ()); 396 declare other_acl_ptr pointer init (null ()); /* Points to other-format ACL for operation (if any) */ 397 declare used_bits_ptr pointer init (null ()); 398 declare fcb_ptr pointer init (null ()); /* Used if current object is an MSF */ 399 400 declare n_acl_names fixed bin; 401 declare max_acl_names fixed bin; 402 declare acl_names (max_acl_names) char (32) unaligned based (acl_names_ptr); 403 404 declare n_acl_modes fixed bin; 405 declare max_acl_modes fixed bin; 406 declare acl_modes (max_acl_modes) char (36) unaligned based (acl_modes_ptr); 407 408 declare 1 old_acl aligned like general_acl based (old_acl_ptr); 409 declare 1 new_acl aligned like general_acl based (new_acl_ptr); 410 411 declare original_count fixed bin; 412 declare used_bits_count fixed bin; 413 declare used_bits (used_bits_count) bit (1) unaligned based (used_bits_ptr); 414 415 declare empty_acl_overlay (4) fixed bin (71); /* Used for easier manuipulation of empty ACLs */ 416 417 418 declare af_sw bit (1) aligned init ("0"b); 419 declare chase_sw bit (1) aligned init ("0"b); 420 declare no_chase_sw bit (1) aligned init ("0"b); 421 declare brief_sw bit (1) aligned init ("0"b); 422 declare replace_sw bit (1) aligned init ("0"b); 423 declare ring_bracket_sw bit (1) aligned init ("0"b); 424 declare access_class_sw bit (1) aligned init ("0"b); 425 declare all_sw bit (1) aligned init ("0"b); 426 declare force_no_type bit (1) aligned init ("0"b); 427 declare iacl_sw bit (1) aligned init ("0"b); 428 declare no_sysdaemon_sw bit (1) aligned init ("0"b); 429 declare segment_sw bit (1) aligned init ("0"b); 430 declare directory_sw bit (1) aligned init ("0"b); 431 declare starname_suffix bit (1) aligned init ("0"b); 432 declare matched_sw bit (1) aligned init ("0"b); 433 declare accessible bit (1) aligned init ("0"b); 434 declare use_access_modes bit (1) aligned init ("0"b); 435 declare explicit_dr_arg bit (1) aligned init ("0"b); 436 declare explicit_sm_arg bit (1) aligned init ("0"b); 437 438 /* */ 439 440 /* format: on */ 441 whoami = P_whoami; 442 type = P_type; 443 operation = P_operation; 444 privilege = P_privilege; 445 446 /* flag those command interfaces that are going away soon... */ 447 448 if (type = MBX_ACL) | (type = MSEG_ACL) 449 then call ioa_ ("Warning: the ^a command is obsolete and will be deleted next release.^/In the future, please use the ^a command to perform its operation.^/", 450 whoami, after (whoami, "_")); 451 452 if (operation = ACCESSIBLE) then accessible = (whoami = "list_accessible"); 453 454 system_area_ptr = get_system_free_area_ (); 455 star_names_ptr = null (); /* Initialize variables declared in include files */ 456 star_entry_ptr = null (); /* Our own have init clauses, above */ 457 acl_ptr = null (); 458 459 limit_entry_types = "0"b; 460 star_match_ptr = null (); 461 462 on condition (cleanup) call cleanup_handler (); 463 464 iacl_sw = (type = SEGMENT_IACL | type = DIRECTORY_IACL); 465 err_path = ""; 466 467 call process_arguments (); 468 469 if ^star_sw then star_entry_count = 1; 470 else do; /* star name given */ 471 if af_sw then call complain (error_table_$nostars, whoami, "^a", ename); 472 if chase_sw then 473 star_select_sw = star_ALL_ENTRIES; 474 else star_select_sw = star_BRANCHES_ONLY; 475 476 if do_tedious_star then do; 477 call hcs_$star_ (dname, "**", (star_select_sw), system_area_ptr, star_entry_count, star_entry_ptr, 478 star_names_ptr, code); 479 if code ^= 0 then do; 480 call complain (code, whoami, "^a", pathname_ (dname, ename)); 481 goto MAIN_RETURN; 482 end; 483 484 star_name_count = sum (star_entries(*).nnames); 485 call modified_star_processing (); 486 end; 487 else do; 488 call hcs_$star_ (dname, ename, (star_select_sw), system_area_ptr, star_entry_count, star_entry_ptr, 489 star_names_ptr, code); 490 if code ^= 0 then do; 491 call complain (code, whoami, "^a", pathname_ (dname, ename)); 492 goto MAIN_RETURN; 493 end; 494 495 star_name_count = sum (star_entries(*).nnames); 496 allocate star_match in (system_area); 497 string (star_match) = "1"b; /* everyone matches */ 498 end; 499 end; 500 501 if privilege ^= NORMAL then 502 on linkage_error 503 begin; 504 call complain (error_table_$action_not_performed, whoami, 505 "Access to ^[hphcs_^;installation_tools_^] is required.", (privilege = HPHCS)); 506 goto MAIN_RETURN; 507 end; 508 509 do star_entry_idx = 1 to star_entry_count; 510 fcb_ptr = null (); 511 if star_sw 512 then do; 513 if do_tedious_star then do; 514 do star_name_idx = star_entries (star_entry_idx).nindex to star_entries (star_entry_idx).nindex + star_entries (star_entry_idx).nnames -1; 515 if star_match (star_name_idx) then do; 516 ename = star_names (star_name_idx); 517 goto FOUND_MATCH; 518 end; 519 end; 520 goto SKIP_NON_MATCH; 521 end; 522 else ename = star_names (star_entries.nindex (star_entry_idx)); 523 end; 524 525 FOUND_MATCH: err_path = pathname_ (dname, ename); /* for error messages */ 526 527 call get_suffix_info (); 528 529 object_type = si.type; 530 if limit_entry_types 531 then if ^entry_type_selected (entry_type_ptr, object_type) then do; 532 WRONG_TYPE: 533 if ^star_sw then 534 if iacl_sw 535 then call complain (error_table_$notadir, whoami, "^a", err_path); 536 else call complain (0, whoami, 537 "Wrong type of entry. For ^a ^a.", si.type_name, err_path); 538 goto SKIP_MATCH; 539 end; 540 541 else; 542 else if ^(directory_sw | segment_sw) then; /* anything goes */ 543 else if (object_type = FS_OBJECT_TYPE_DIRECTORY) 544 then if ^directory_sw then goto WRONG_TYPE; 545 else; 546 else if (substr (object_type, 1, 1) = "-") 547 then if ^segment_sw /* seg, msf, dmf */ 548 then goto WRONG_TYPE; 549 else; 550 else if (explicit_dr_arg | explicit_sm_arg) /* explicit -dir or -sm */ 551 then goto WRONG_TYPE; /* extended types not selected with -sm or -dr */ 552 553 matched_sw = "1"b; /* found something */ 554 555 if object_type = FS_OBJECT_TYPE_MSF then do; 556 call msf_manager_$open (dname, ename, fcb_ptr, code); 557 if code ^= 0 then do; 558 call complain (code, whoami, "^a", err_path); 559 goto SKIP_MATCH; 560 end; 561 end; 562 563 call build_new_acl (); /* Build whatever new ACL is appropriate */ 564 565 if (operation = SET) | (operation = DELETE) then call replace_the_acl (); 566 else if (operation = LIST) then call list_the_acl (); 567 else if (operation = ACCESSIBLE) then call print_accessible (); 568 569 call check_for_acle_errors (); 570 571 SKIP_MATCH: 572 if object_type = FS_OBJECT_TYPE_MSF then 573 if fcb_ptr ^= null () then call msf_manager_$close (fcb_ptr); 574 SKIP_NON_MATCH: 575 end; 576 577 578 if star_sw & ^matched_sw then call complain (error_table_$nomatch, whoami, "^a", pathname); 579 580 MAIN_RETURN: 581 call cleanup_handler (); 582 return; /* ONLY return statement in this procedure */ 583 584 process_arguments: 585 procedure (); 586 587 /* This procedure implements the argument processing loop. It detects all the possible 588* inconsistencies among control arguments, etc. */ 589 590 dcl (ap, ap1) pointer; 591 dcl (al, al1) fixed bin (21); 592 dcl arg char (al) based (ap); 593 dcl arg1 char (al1) based (ap1); 594 dcl (argno, nargs) fixed bin; 595 dcl min_ring fixed bin (3); 596 dcl idx fixed bin; 597 598 dcl ( 599 all_val, 600 chase_val, 601 brief_val, 602 replace_val, /* record of specified options, used for consistency */ 603 raw_val, 604 ring_bracket_val, 605 sysdaemon_val, 606 access_class_val, /* checks later on */ 607 segment_val, 608 directory_val 609 ) fixed bin init (0); /* INITIALIZED TO ZERO, to get default */ 610 611 declare iacl_ring_arg fixed bin; 612 declare type_name char (32); 613 declare type_suffix char (32); 614 declare have_mode bit (1) aligned; 615 declare want_mode bit (1) aligned; 616 declare all_stars bit (1) aligned; 617 declare ename_suffix char (32); 618 619 call cu_$af_return_arg_rel (nargs, ret_str_ptr, ret_str_lth, code, P_arg_list_ptr); 620 if (code = 0) then do; 621 af_sw = "1"b; 622 brief_val = 1; 623 ret_str = ""; 624 end; 625 else af_sw = "0"b; /* assume we're a command */ 626 627 pathname, type_name = ""; 628 iacl_ring = -1; 629 iacl_ring_arg = 0; 630 631 if operation = SET | operation = ACCESSIBLE then do; 632 /* collect User_ids and modes -- they should come in pairs */ 633 max_acl_names = divide ((nargs + 1), 2, 17, 0); 634 max_acl_modes = max_acl_names; 635 allocate acl_modes in (system_area); 636 end; 637 638 else do; /* other operations only collect userids */ 639 max_acl_names = nargs - 1; /* many as arg count - 1 */ 640 acl_modes_ptr = null (); /* catch errors */ 641 end; 642 643 max_acl_names = max (max_acl_names, 1); /* make sure there's always at least one */ 644 allocate acl_names in (system_area); 645 646 n_acl_names = 0; /* collected nothing so far */ 647 n_acl_modes = 0; 648 acl_names (*) = ""; 649 650 if operation = SET then 651 want_mode = "1"b; /* SET wants a mode first thing after the path */ 652 else want_mode = "0"b; /* Other commands never want modes */ 653 have_mode = "0"b; 654 655 do argno = 1 to nargs; /* now, collect */ 656 call cu_$arg_ptr_rel (argno, ap, al, (0), P_arg_list_ptr); 657 658 if al = 0 then do; 659 NULL_ARG: call complain (0, whoami, "zero-length argument not accepted."); 660 goto MAIN_RETURN; 661 end; 662 663 if char (arg, 1) = "-" then 664 if arg = "-wd" | arg = "-working_dir" | arg = "-working_directory" then do; 665 if pathname ^= "" then do; /* only in first position */ 666 call complain (0, whoami, "^a may only appear in place of the pathname argument.", arg); 667 goto MAIN_RETURN; 668 end; 669 pathname = get_wdir_ (); 670 end; 671 672 else if operation = DELETE & (arg = "-all" | arg = "-a") then call SET_OPTION (all_val, ON); 673 else if type = BRANCH_ACL & (arg = "-interpret_as_standard_entry" | arg = "-inase") then 674 call SET_OPTION (raw_val, ON); 675 else if type = BRANCH_ACL & (arg = "-interpret_as_extended_entry" | arg = "-inaee") then 676 call SET_OPTION (raw_val, OFF); 677 else if arg = "-chase" then call SET_OPTION (chase_val, ON); 678 else if arg = "-no_chase" then call SET_OPTION (chase_val, OFF); 679 else if type = BRANCH_ACL & (arg = "-select_entry_type" | arg = "-slet") then do; 680 if argno = nargs then do; 681 NOARG: 682 call complain (error_table_$noarg, whoami, "Following ^a.", arg); 683 goto MAIN_RETURN; 684 end; 685 argno = argno + 1; 686 call cu_$arg_ptr_rel (argno, ap, al, (0), P_arg_list_ptr); 687 if al = 0 then goto NULL_ARG; 688 689 type_name = arg; 690 call process_entry_type_list (arg, entry_type_ptr, limit_entry_types); 691 if ^limit_entry_types then do; 692 call complain (0, whoami, "One or more invalid entry types specified. ^a", arg); 693 goto MAIN_RETURN; 694 end; 695 end; 696 else if operation = ACCESSIBLE then do; /* collect mode string to match */ 697 if have_mode then do; 698 call complain (0, whoami, "Only one set of modes may be given.", arg); 699 goto MAIN_RETURN; 700 end; 701 702 want_mode, have_mode = "1"b; 703 if pathname = "" then pathname = get_wdir_ (); 704 705 if arg = "-dir_mode" then call SET_OPTION (directory_val, ON); 706 else if arg = "-seg_mode" then call SET_OPTION (segment_val, ON); 707 else if arg ^= "-mode" then call BADOPT (argno); 708 if argno = nargs then goto NOARG; 709 end; 710 else if arg = "-brief" | arg = "-bf" then call SET_OPTION (brief_val, ON); 711 else if arg = "-long" | arg = "-lg" then call SET_OPTION (brief_val, OFF); 712 else if arg = "-directory" | arg = "-dr" then do; 713 if type = DIRECTORY_IACL | type = SEGMENT_IACL 714 then call BADOPT (argno); 715 else call SET_OPTION (directory_val, ON); 716 end; 717 else if arg = "-segment" | arg = "-sm" then do; 718 if type = DIRECTORY_IACL | type = SEGMENT_IACL 719 then call BADOPT (argno); 720 else call SET_OPTION (segment_val, ON); 721 end; 722 else if iacl_sw & (arg = "-ring" | arg = "-rg") then do; 723 iacl_ring_arg = argno; /* remember where we saw it */ 724 ap1 = null (); /* prevent faults */ 725 al1 = 0; 726 727 if argno = nargs then do; 728 code = error_table_$noarg; 729 BAD_IACL_RING: 730 call complain (code, whoami, /* include the offending argument, if it exists */ 731 "^a must be followed by a ring number^[.^;, not ^a^]", arg, (al1 = 0), arg1); 732 goto MAIN_RETURN; 733 end; 734 735 if iacl_ring >= 0 then do; /* only say this once */ 736 call complain (0, whoami, "^a may only be specified once.", arg); 737 goto MAIN_RETURN; 738 end; 739 740 argno = argno + 1; /* get the next argument */ 741 call cu_$arg_ptr_rel (argno, ap1, al1, (0), P_arg_list_ptr); 742 if al = 0 then goto NULL_ARG; 743 744 iacl_ring = index ("01234567", arg1) - 1; 745 746 if iacl_ring < 0 | length (arg1) ^= 1 then do; 747 /* not one of the digits */ 748 code = error_table_$bad_conversion; 749 goto BAD_IACL_RING; 750 end; 751 end; /* of processing -ring */ 752 else if operation = LIST & ^iacl_sw then do; 753 if arg = "-ring_brackets" | arg = "-rb" then call SET_OPTION (ring_bracket_val, ON); 754 else if arg = "-no_ring_brackets" | arg = "-nrb" then call SET_OPTION (ring_bracket_val, OFF); 755 else if arg = "-access_class" | arg = "-acc" then call SET_OPTION (access_class_val, ON); 756 else if arg = "-no_access_class" | arg = "-nacc" then call SET_OPTION (access_class_val, OFF); 757 else call BADOPT (argno); 758 end; /* of list only args */ 759 else if operation = SET then do; 760 if arg = "-replace" | arg = "-rp" then call SET_OPTION (replace_val, ON); 761 else if arg = "-modify" | arg = "-md" then call SET_OPTION (replace_val, OFF); 762 else if (arg = "-sysdaemon") | (arg = "-sd") then call SET_OPTION (sysdaemon_val, ON); 763 else if (arg = "-no_sysdaemon") | (arg = "-nsd") then call SET_OPTION (sysdaemon_val, OFF); 764 else call BADOPT (argno); 765 end; 766 else call BADOPT (argno); /* haven't heard of this one */ 767 768 else if pathname = "" then /* pathname not seen yet, this must be it */ 769 pathname = arg; /* just copy it */ 770 771 else if want_mode then do; /* this can only happen with SET operations */ 772 n_acl_modes = n_acl_modes + 1; /* get to the next entry */ 773 acl_modes (n_acl_modes) = arg; /* save it in the array */ 774 want_mode = "0"b; /* and ask for a name next time around */ 775 end; 776 else do; 777 n_acl_names = n_acl_names + 1; /* prepare to use the next entry */ 778 acl_names (n_acl_names) = arg; /* save the name in the array */ 779 if operation = SET then want_mode = "1"b; 780 end; 781 end; /* of argument loop */ 782 783 /* Now, check the various possibilities for error */ 784 785 if af_sw & operation ^= LIST then do; /* only list can be used as an AF */ 786 call complain (error_table_$active_function, whoami); 787 goto MAIN_RETURN; 788 end; 789 790 if operation ^= LIST & operation ^= ACCESSIBLE & pathname = "" then 791 /* only listing has a default */ 792 call USAGE (error_table_$noarg); 793 794 if operation = SET & n_acl_modes = 0 then /* must have at least one mode */ 795 call USAGE (error_table_$noarg); 796 797 if pathname = "" then /* if nothing supplied, must be the default */ 798 pathname = get_wdir_ (); 799 800 type_suffix = ""; 801 do_tedious_star = "0"b; /* wishful thinking */ 802 if type = MBX_ACL then type_suffix = "mbx"; 803 else if type = MSEG_ACL then type_suffix = "ms"; 804 else if limit_entry_types 805 then if entry_type.count = 1 806 then if ^entry_type.suffixes (1).is_std_type 807 then type_suffix = entry_type.suffixes (1).suffix; 808 else; 809 else do_tedious_star = "1"b; 810 811 dname = ""; /* must initialize for later reference by the "lac" and "lnac" commands */ 812 ename = ""; 813 call expand_pathname_$add_suffix (pathname, type_suffix, dname, ename, code); 814 815 if code ^= 0 then do; /* unacceptable pathname */ 816 817 /* fix bugs for TR # phx19075 */ 818 if code = error_table_$root & operation = ACCESSIBLE & pathname = ">" then do; /* accept the ROOT directory */ 819 code = 0; 820 dname = ">"; 821 822 if type_name = "" then do; 823 if acl_names (1) ^= "" then 824 ename = acl_names (1); 825 else ename = "**"; 826 end; 827 end; 828 /* end of bug fix for TR # phx19075 */ 829 830 else do; 831 call complain (code, whoami, "^a", pathname); 832 goto MAIN_RETURN; 833 end; 834 end; 835 836 if operation ^= ACCESSIBLE & dname = ">" & ename = "" then 837 code = error_table_$root; 838 839 else call check_star_name_$entry (ename, code); 840 if code > 2 then do; 841 call complain (code, whoami, "^a", pathname_ (dname, ename)); 842 goto MAIN_RETURN; 843 end; 844 star_sw = (code > 0); /* remember if it was a starname */ 845 all_stars = (code = 2); /* and whether it's one of the everything names */ 846 847 if operation = ACCESSIBLE then do; 848 star_sw = "1"b; 849 850 if pathname ^= ">" then 851 dname = pathname_ (dname, ename); 852 853 if type_name ^= "" then 854 ename = "**." || rtrim (type_name); 855 else ename = "**"; 856 857 all_stars = (type_name = ""); /* Unless we got as type, it's all entries */ 858 end; 859 860 ename_suffix = reverse (before (reverse (ename), ".")); 861 if search (ename_suffix, "*?") ^= 0 then starname_suffix = "1"b; 862 863 if operation = SET & n_acl_modes > n_acl_names then do; 864 /* Apply the default for the final name */ 865 n_acl_names = n_acl_names + 1; 866 if ename_suffix = "mbx" then 867 acl_names (n_acl_names) = before (get_group_id_$tag_star (), ".") || ".*.*"; 868 else acl_names (n_acl_names) = get_group_id_$tag_star (); 869 end; 870 871 if operation = DELETE & n_acl_names = 0 & all_val = 0 then do; 872 n_acl_names = 1; 873 if ename_suffix = "mbx" then 874 acl_names (1) = before (get_group_id_$tag_star (), ".") || ".*.*"; 875 else acl_names (1) = get_group_id_$tag_star (); 876 end; 877 878 879 if (type = MBX_ACL) then xacl_allowed = "1"b; /* Always extended acls */ 880 else if (type = MSEG_ACL) then xacl_allowed = "1"b; 881 else if (privilege ^= NORMAL) then xacl_allowed = "0"b; /* No hphcs_ or ring one stuff in fs_util_, after all */ 882 else if (raw_val > 0) then xacl_allowed = "0"b; /* And certainly not if we were told -inase */ 883 else if all_stars then xacl_allowed = "0"b; /* Not if we got ** or equivalent, either */ 884 else if (index (ename, ".") = 0) then xacl_allowed = "0"b; /* Single component name */ 885 else if (ename_suffix = "") then xacl_allowed = "0"b; /* The ename ends in a period */ 886 else if starname_suffix then xacl_allowed = "0"b; 887 else if (substr (ename_suffix, 1, 1) = "-") then xacl_allowed = "0"b; /* Reserved object types begin with "-" */ 888 else do; 889 si.version = SUFFIX_INFO_VERSION_1; 890 call fs_util_$suffix_info_for_type (ename_suffix, addr (si), code); 891 if (code = error_table_$unsupported_operation) then 892 xacl_allowed = "0"b; 893 else if (code =0) then 894 xacl_allowed = (^si.standard_object & si.extended_acl); 895 else do; 896 call complain (code, whoami, "^a", pathname_ (dname, ename)); 897 goto MAIN_RETURN; 898 end; 899 end; 900 901 if type_name ^= "" | type ^= BRANCH_ACL then 902 if (directory_val ^= 0) | (segment_val ^= 0) | (raw_val ^= 0) then do; 903 call complain (error_table_$inconsistent, whoami, 904 """-type"" ^[and ""-inase"" ^]^[and ""-seg^[_mode^;ment^]"" ^;^s^]^[and ""-dir^[_mode^;ectory^]""^]" 905 , (raw_val ^= 0), (segment_val ^= 0), (operation = ACCESSIBLE), 906 (directory_val ^= 0), (operation = ACCESSIBLE)); 907 goto MAIN_RETURN; 908 end; 909 910 if iacl_ring >= 0 then do; /* check if we're allowed to */ 911 if operation = LIST then 912 min_ring = 0; /* can list any ring */ 913 else call cu_$level_get (min_ring); /* otherwise, we must put up with what we've got */ 914 915 if iacl_ring < min_ring then do; /* sorry, no dice */ 916 call complain (error_table_$bad_ring_brackets, whoami, 917 "IACL ring number must be between ^d and 7, not ^d.", min_ring, iacl_ring); 918 goto MAIN_RETURN; 919 end; 920 end; 921 922 else call cu_$level_get (iacl_ring); /* otherwise, set the default */ 923 924 if operation = SET & replace_val = 0 & sysdaemon_val ^= 0 then do; 925 call cu_$arg_ptr_rel (abs (sysdaemon_val), ap, al, (0), P_arg_list_ptr); 926 call complain (error_table_$badopt, whoami, 927 "^/^a may only be used in conjunction with -replace", arg); 928 goto MAIN_RETURN; 929 end; 930 931 all_sw = (all_val > 0); /* now, set the flags the main program will use */ 932 chase_sw = (chase_val > 0); 933 no_chase_sw = (chase_val < 0); 934 replace_sw = (replace_val > 0); 935 no_sysdaemon_sw = (sysdaemon_val < 0); 936 brief_sw = (brief_val > 0); 937 force_no_type = (raw_val > 0); 938 ring_bracket_sw = (ring_bracket_val > 0); 939 access_class_sw = (access_class_val > 0); 940 941 segment_sw,explicit_sm_arg = (segment_val > 0); 942 directory_sw,explicit_dr_arg = (directory_val > 0); 943 944 if (operation = SET) & (^replace_sw) then /* Don't add *.SysDaemon if just adding stuff to the ACL */ 945 no_sysdaemon_sw = "1"b; 946 else if (operation = DELETE) then /* Similarly, if deleting, and there isn't one there now, */ 947 no_sysdaemon_sw = "1"b; /* don't add it */ 948 949 if ^(segment_sw | directory_sw) then do; /* figure out if segs or dirs */ 950 if type = BRANCH_ACL & operation = SET & ^xacl_allowed & star_sw then do; 951 do idx = 1 to n_acl_modes while (^segment_sw & ^directory_sw); 952 if acl_modes (idx) ^= "n" & acl_modes (idx) ^= "null" then 953 if search (acl_modes (idx), "sma") > 0 then 954 directory_sw = "1"b; 955 else segment_sw = "1"b; 956 end; 957 if ^segment_sw & ^directory_sw then segment_sw = "1"b; 958 /* default to segs, msfs, and dmfs */ 959 end; 960 else if operation = ACCESSIBLE & type_name = "" & n_acl_modes > 0 then 961 if search (acl_modes (1), "sma") > 0 then 962 directory_sw = "1"b; 963 else segment_sw = "1"b; 964 else; /* all but SET default to everything */ 965 end; 966 967 else xacl_allowed = "0"b; 968 969 if iacl_sw 970 then do; 971 segment_sw = "0"b; 972 directory_sw = "1"b; 973 end; 974 975 if operation = ACCESSIBLE then do; 976 brief_sw = "1"b; /* avoid "no match for .... " messages */ 977 978 if n_acl_modes = 0 then 979 acl_mask = copy ("1"b, 36); 980 else do; 981 si.version = SUFFIX_INFO_VERSION_1; 982 if (type_name ^= "") then 983 call fs_util_$suffix_info_for_type (type_name, addr (si), (0)); 984 else if directory_sw then 985 call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_DIRECTORY, addr (si), (0)); 986 else call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_SEGMENT, addr (si), (0)); 987 988 acl_mask = convert_mode (acl_modes (1)); 989 end; 990 991 if n_acl_names = 0 then do; 992 access_name = get_group_id_$tag_star (); 993 use_access_modes = "1"b; 994 end; 995 else do; 996 access_name = acl_names (1); 997 if index (access_name, ".") = 1 | index (access_name, "..") > 0 998 | substr (access_name, length (rtrim (access_name)), 1) = "." then 999 use_access_modes = "0"b; 1000 else do; 1001 use_access_modes = "1"b; 1002 call set_components (access_name, ("")); 1003 end; 1004 end; 1005 end; 1006 1007 return; /* end of argument processing */ 1008 1009 SET_OPTION: 1010 proc (P_option, P_on_off); 1011 1012 /* This procedure (internal to process_arguments) sets P_option to be the index of the first 1013* occurrence of a control argument to set the specified option. It is set negative to indicate 1014* that the option is to be off, and positive to indicate that it is to be on. */ 1015 1016 dcl ( 1017 P_option fixed bin, 1018 P_on_off bit (1) aligned 1019 ) parameter; 1020 1021 if P_option = 0 then /* never specified so far. Remember argument position */ 1022 if P_on_off = ON then 1023 P_option = argno; /* positive value indicates option ON */ 1024 else P_option = 0 - argno; /* negative value indicates option OFF */ 1025 1026 else do; /* Some form of option already specified */ 1027 if P_option < 0 then /* Already OFF. Must we invert it? */ 1028 if P_on_off = ON then /* Yes, invert, but keep original arg number */ 1029 P_option = 0 - P_option; 1030 1031 if P_option > 0 then /* Already ON. Must we invert it? */ 1032 if P_on_off = OFF then /* Yes, invert, but keep original arg number */ 1033 P_option = 0 - P_option; 1034 end; 1035 1036 return; 1037 end SET_OPTION; 1038 1039 USAGE: 1040 proc (P_code); 1041 1042 /* This procedure prints out a Usage message for each type of command */ 1043 1044 dcl P_code fixed bin (35); 1045 1046 if operation = SET then /* requires at least one mode; Name always defaults */ 1047 call complain (P_code, whoami, "^/Usage:^-^a Path Mode1 {Name1} ... {ModeN {NameN}} {-control_args}", 1048 whoami); 1049 1050 else if operation = DELETE then 1051 call complain (P_code, whoami, "^/Usage:^-^a Path {Name1} ... {NameN} {-control_args}", whoami); 1052 1053 else if operation = LIST then /* special defaults -- sometimes is WDIR */ 1054 if (type = BRANCH_ACL) | iacl_sw then 1055 call complain (P_code, whoami, "^/Usage:^-^a {Path} {Name1} ... {NameN} {-control_args}", whoami); 1056 1057 else call complain (P_code, whoami, "^/Usage:^-^a Path {Name1} ... {NameN} {-control_args}", whoami); 1058 1059 goto MAIN_RETURN; 1060 1061 end USAGE; 1062 1063 BADOPT: 1064 proc (P_argno); 1065 1066 /* This procedure prints an error message for the control argument identified by P_argno, which 1067* is expected to be one of the option flags used in SET_OPTION, above. */ 1068 1069 dcl P_argno fixed bin parameter; 1070 1071 dcl ap pointer; 1072 dcl al fixed bin (21); 1073 dcl arg char (al) based (ap); 1074 1075 call cu_$arg_ptr_rel (abs (P_argno), ap, al, (0), P_arg_list_ptr); /* remember, option values may be signed */ 1076 1077 call complain (error_table_$badopt, whoami, "^a", arg); 1078 1079 goto MAIN_RETURN; 1080 1081 end BADOPT; 1082 1083 process_entry_type_list: proc(entry_type_list, entry_type_struct_ptr, limit_entry_selections); 1084 1085 dcl entry_type_list char (*) parameter; 1086 dcl entry_type_struct_ptr pointer parameter; 1087 dcl limit_entry_selections bit (1) aligned; 1088 1089 dcl types_len fixed bin (24); 1090 dcl types_ptr pointer; 1091 dcl types char (types_len) based (types_ptr); 1092 dcl entry_type_no fixed bin; 1093 dcl this_type char (32); 1094 1095 1096 /* copy entry_type_list into "real" storage */ 1097 1098 types_ptr = null (); 1099 on cleanup 1100 begin; 1101 if types_ptr ^= null () then free types in (system_area); 1102 end; 1103 1104 types_len = length (entry_type_list); 1105 allocate types 1106 set (types_ptr) in (system_area); 1107 types = entry_type_list; 1108 1109 /* to start off, get a count of the number of types in the string */ 1110 1111 do entry_type_count = 1 1112 repeat (entry_type_count + 1) 1113 while (index (types, ",") > 0); 1114 types = after (types, ","); 1115 end; 1116 1117 /* allocate the entry_type structure, to be used later in this command */ 1118 1119 allocate entry_type 1120 set (entry_type_struct_ptr) 1121 in (system_area); 1122 1123 entry_type_struct_ptr -> entry_type.suffixes.suffix (*) = ""; 1124 1125 /* for each potential entry type, validate it and add it to the structure */ 1126 1127 types = entry_type_list; 1128 type_info.version = SUFFIX_INFO_VERSION_1; 1129 entry_type_no = 1; 1130 do while (types ^= ""); 1131 this_type = before (types, ","); 1132 if substr (this_type, 1, 1) ^= "-" then do; 1133 entry_type.suffixes (entry_type_no).is_std_type = "1"b; /* Presumed innocent ... */ 1134 if this_type = "link" then do; 1135 call complain (0, whoami, "This commands does not support links."); 1136 goto MAIN_RETURN; 1137 end; 1138 1139 else if this_type = "segment" then this_type = FS_OBJECT_TYPE_SEGMENT; 1140 else if this_type = "directory" then this_type = FS_OBJECT_TYPE_DIRECTORY; 1141 else if this_type = "multisegment_file" then this_type = FS_OBJECT_TYPE_MSF; 1142 else if this_type = "data_management_file" then this_type = FS_OBJECT_TYPE_DM_FILE; 1143 else entry_type.suffixes (entry_type_no).is_std_type = "0"b; /* ... until proven guilty */ 1144 entry_type_struct_ptr -> entry_type.suffixes.suffix (entry_type_no) = this_type; 1145 call fs_util_$suffix_info_for_type (this_type, addr (type_info), code); 1146 if code = 0 then entry_type_no = entry_type_no + 1; 1147 else goto BAD_TYPE_ERROR; 1148 end; 1149 else do; 1150 BAD_TYPE_ERROR: free types_ptr -> types in (system_area); 1151 limit_entry_selections = "0"b; 1152 return; 1153 end; 1154 1155 types = after (types, ","); 1156 end; 1157 1158 /* free the types variable and set the limit_entry_selections flag */ 1159 1160 free types_ptr -> types 1161 in (system_area); 1162 1163 entry_type_struct_ptr -> entry_type.count = entry_type_no - 1; 1164 if entry_type_struct_ptr -> entry_type.count = 0 1165 then limit_entry_selections = "0"b; 1166 else limit_entry_selections = "1"b; 1167 1168 return; 1169 1170 end process_entry_type_list; 1171 1172 end process_arguments; 1173 1174 1175 entry_type_selected: proc (entry_type_struct_ptr, fs_type) returns (bit (1) aligned); 1176 1177 1178 dcl entry_type_struct_ptr pointer parameter; 1179 dcl fs_type char (32) parameter; 1180 dcl entry_type_no fixed bin; 1181 1182 do entry_type_no = 1 to entry_type_struct_ptr -> entry_type.count; 1183 if entry_type_struct_ptr -> entry_type.suffixes.suffix (entry_type_no) = fs_type then return ("1"b); 1184 end; 1185 return ("0"b); 1186 1187 end entry_type_selected; 1188 1189 1190 modified_star_processing: 1191 procedure (); 1192 /* Routine to do star processing when more than one entry type is specified 1193* by -slet */ 1194 1195 dcl star_idx fixed bin; 1196 dcl type_idx fixed bin; 1197 dcl temp_ename char (32); 1198 dcl std_type bit (1) aligned; 1199 1200 1201 std_type = "0"b; 1202 do type_idx = 1 to entry_type.count; 1203 if entry_type.suffixes (type_idx).is_std_type 1204 then std_type = "1"b; /* at least one std type is specified */ 1205 end; 1206 1207 allocate star_match in (system_area); 1208 1209 si.version = SUFFIX_INFO_VERSION_1; 1210 1211 do star_idx = 1 to star_entry_count; 1212 do type_idx = 1 to entry_type.count; 1213 if ^entry_type.suffixes (type_idx).is_std_type 1214 then do; /* try all extended types first */ 1215 call expand_pathname_$add_suffix (pathname, (entry_type.suffixes(type_idx).suffix), 1216 dname, temp_ename, code); 1217 if code ^= 0 then goto NEXT_TYPE_NAME; 1218 do star_name_idx = star_entries(star_idx).nindex to 1219 star_entries(star_idx).nindex + star_entries(star_idx).nnames -1; 1220 call match_star_name_ (star_names (star_name_idx), temp_ename, code); 1221 if code = 0 then do; 1222 /* really should check type here */ 1223 call fs_util_$suffix_info (dname, star_names (star_name_idx), addr (si), code); 1224 if code = error_table_$not_seg_type then goto TRY_STD; 1225 /* All the names on an extended entry must have same suffix. 1226* This entry is not of the type that this name indicates; 1227* therfore, it cannot be an extended entry */ 1228 else if code = 0 & ^si.flags.standard_object 1229 then star_match (star_name_idx) = "1"b; 1230 goto NEXT_STAR_NAME; 1231 end; 1232 end; 1233 end; 1234 NEXT_TYPE_NAME: 1235 end; 1236 1237 TRY_STD: if std_type /* The name did not fit any extended types AND the 1238* user has requested a standard entry type */ 1239 then do star_name_idx = star_entries(star_idx).nindex to 1240 star_entries(star_idx).nindex + star_entries(star_idx).nnames -1; 1241 call match_star_name_ (star_names (star_name_idx), ename, code); 1242 if code = 0 then do; 1243 call fs_util_$suffix_info (dname, star_names (star_name_idx), addr (si), code); 1244 if code = 0 1245 then if si.flags.standard_object 1246 then star_match (star_name_idx) = "1"b; 1247 goto NEXT_STAR_NAME; 1248 end; 1249 end; 1250 1251 NEXT_STAR_NAME: 1252 end; 1253 return; 1254 end modified_star_processing; 1255 1256 1257 1258 build_new_acl: 1259 procedure (); 1260 1261 /* In this procedure, old_acl and new_acl are two equally large structures, each with 1262* enough entries to have one for each in the object's current ACL and one for each 1263* name specified on the command line. The old_acl entries start out by being a copy 1264* of the object's current ACL, and new_acl is empty. As each of the command line 1265* arguments is examined, all matching old_acl entries are moved to new_acl, and 1266* all non-matching ones without missing components are added to both old_acl and 1267* new_acl. */ 1268 1269 1270 1271 if (operation = SET) & replace_sw then do; /* If doing wholesale replacement, get out early */ 1272 call build_replacement_acl (); 1273 return; 1274 end; 1275 1276 if (operation = ACCESSIBLE) & use_access_modes then return; 1277 /* If listing things accessable just to US, */ 1278 /* don't even bother listing the ACL */ 1279 1280 call get_acl (); /* List the original object ACL */ 1281 original_count = general_acl.count; /* Remember how large it started */ 1282 1283 if (operation = LIST) & (n_acl_names = 0) then return; 1284 /* List the whole ACL, which is ready right now */ 1285 1286 /* Now, allocate the old_acl and new_acl structures, with one entry for each entry from the old ACL 1287* plus one for each name supplied on the command line if the operation is SET. If the operation is 1288* LIST or ACCESSABLE, we know we won't be making the list any larger, so just use the structure 1289* gotten from get_acl as the old_acl. Because of the refer extents in general_acl, we have to 1290* play games with acl_count here. */ 1291 1292 if (operation = SET) then /* Figure out how large to make our copies */ 1293 acl_count = original_count + n_acl_names; 1294 else acl_count = original_count; 1295 1296 if (operation = SET) then /* Allocate a large enough copy if we're going to update it */ 1297 call enlarge_old_acl (); 1298 else old_acl_ptr = acl_ptr; /* Otherwise, recycle the old one */ 1299 1300 call allocate_new_acl (); 1301 1302 if (operation = DELETE) then /* Keep all that don't match */ 1303 call build_nonmatching_acl (); 1304 else if (operation = SET) then /* Keep all that does match, */ 1305 call build_matching_acl ("1"b); /* and anything else from the command line, besides */ 1306 else if (operation = LIST) then /* Keep only things which match */ 1307 call build_matching_acl ("0"b); 1308 else if (operation = ACCESSIBLE) then call build_matching_acl ("0"b); 1309 1310 call free (old_acl_ptr); /* Free the old acl and the used bits */ 1311 call free (used_bits_ptr); 1312 1313 acl_count = new_acl.count; /* Make it available for later uses */ 1314 acl_ptr = new_acl_ptr; /* copy to ones we will use to call primitives */ 1315 new_acl_ptr = null (); /* mark pointer as unused to avoid freeing through it */ 1316 1317 return; 1318 1319 /* */ 1320 1321 enlarge_old_acl: 1322 procedure (); 1323 1324 declare acle_idx fixed bin; 1325 1326 1327 allocate old_acl in (system_area) set (old_acl_ptr); 1328 /* acl_count was set above */ 1329 old_acl.version = GENERAL_ACL_VERSION_1; 1330 old_acl.count = general_acl.count; /* Start with the original count of ACL entries */ 1331 1332 do acle_idx = 1 to old_acl.count; /* Copy the entries from the object's ACL into this ACL */ 1333 old_acl.entries (acle_idx) = general_acl.entries (acle_idx); 1334 end; 1335 1336 call free (acl_ptr); /* Get rid of the original one */ 1337 /* We now have a copy in old_acl */ 1338 return; 1339 end enlarge_old_acl; 1340 1341 1342 1343 allocate_new_acl: 1344 procedure (); 1345 1346 allocate new_acl in (system_area) set (new_acl_ptr); 1347 /* Make a place to put the results */ 1348 new_acl.count = 0; /* starting out empty */ 1349 new_acl.version = GENERAL_ACL_VERSION_1; 1350 1351 used_bits_count = n_acl_names + acl_count; 1352 allocate used_bits in (system_area) set (used_bits_ptr); 1353 unspec (used_bits) = ""b; 1354 1355 return; 1356 end allocate_new_acl; 1357 1358 /* */ 1359 1360 build_replacement_acl: 1361 procedure (); 1362 1363 /* This procedure is used to build a whole replacement ACL for set_acl -replace. 1364* It relies on the harcore's SysDaemon switch to provide or not provide an entry 1365* for *.SysDaemon. */ 1366 1367 declare acle_idx fixed bin; 1368 1369 1370 acl_count = n_acl_names; /* Same size as the number of command-line arguments */ 1371 allocate general_acl in (system_area) set (acl_ptr); 1372 general_acl.count = acl_count; 1373 general_acl.version = GENERAL_ACL_VERSION_1; 1374 1375 do acle_idx = 1 to n_acl_names; /* Fill in names from command arguments */ 1376 call set_components (acl_names (acle_idx), ("")); 1377 /* "Normalize" the supplied access name */ 1378 general_acl.access_name (acle_idx) = acl_names (acle_idx); 1379 general_acl.mode (acle_idx) = convert_mode (acl_modes (acle_idx)); 1380 general_acl.status_code (acle_idx) = 0; 1381 end; 1382 1383 return; 1384 end build_replacement_acl; 1385 1386 /* */ 1387 1388 build_matching_acl: 1389 procedure (add_new_names); 1390 1391 /* Go through the object's ACL, and build a new one. The match_acl procedure will copy any 1392* names that match in the old ACL into the new_acl; the add_new_names switch determines 1393* whether non-matching names from the command line will be added, as well (true for SET) */ 1394 1395 1396 declare add_new_names bit (1) aligned parameter; 1397 1398 declare given_name_idx fixed bin; 1399 declare old_acle_idx fixed bin; 1400 1401 1402 do given_name_idx = 1 to n_acl_names; /* Look at each name requested on the command line */ 1403 if match_acl (given_name_idx, "1"b) then goto CHECK_NEXT_GIVEN_NAME; 1404 /* If there were matches, don't add it */ 1405 1406 if add_new_names then do; 1407 new_acl.count = new_acl.count + 1; /* No matches found, so make a whole new entry */ 1408 new_acl.access_name (new_acl.count) = acl_names (given_name_idx); 1409 new_acl.mode (new_acl.count) = convert_mode (acl_modes (given_name_idx)); 1410 1411 old_acl.count = old_acl.count + 1; /* Also add this entry to the old ACL structure, so */ 1412 old_acl.access_name (old_acl.count) = new_acl.access_name (new_acl.count); 1413 end; /* that later names will match against it */ 1414 1415 CHECK_NEXT_GIVEN_NAME: 1416 end; /* acl_name loop */ 1417 1418 if ^add_new_names then return; /* If not keeping names from original, quit now */ 1419 1420 do old_acle_idx = 1 to original_count; /* Add anything that's left, BUT only from the ACL */ 1421 /* we started with, omitting anything added above */ 1422 if ^used_bits (old_acle_idx) then do; /* Didn't get matched by anything, so keep it */ 1423 new_acl.count = new_acl.count + 1; /* so it's still there in the new ACL */ 1424 new_acl.status_code (new_acl.count) = 0; 1425 new_acl.access_name (new_acl.count) = old_acl.access_name (old_acle_idx); 1426 new_acl.mode (new_acl.count) = old_acl.mode (old_acle_idx); 1427 end; 1428 end; 1429 1430 return; 1431 end build_matching_acl; 1432 1433 /* */ 1434 1435 build_nonmatching_acl: 1436 procedure (); 1437 1438 declare given_name_idx fixed bin; 1439 declare old_acle_idx fixed bin; 1440 declare acle_matched bit (1) aligned; 1441 1442 1443 do given_name_idx = 1 to n_acl_names; /* Look at each name requested on the command line */ 1444 acle_matched = match_acl (given_name_idx, "0"b); 1445 /* Ignore the match result-- match_acl has already done */ 1446 end; /* everything we need done (setting the used_bits bit) */ 1447 1448 if all_sw then 1449 do old_acle_idx = 1 to original_count; 1450 if old_acl.access_name (old_acle_idx) = "*.SysDaemon.*" 1451 then; /* don't touch it! */ 1452 else used_bits (old_acle_idx) = "1"b; 1453 end; 1454 1455 call free (new_acl_ptr); /* clean up after ourselves */ 1456 allocate new_acl in (system_area) set (new_acl_ptr); 1457 /* Make a place to put the results */ 1458 new_acl.count = 0; /* starting out empty */ 1459 new_acl.version = GENERAL_ACL_VERSION_1; 1460 1461 do old_acle_idx = 1 to original_count; /* Add anything that's left, BUT only from the ACL */ 1462 /* we started with, omitting anything added above */ 1463 if ^used_bits (old_acle_idx) /* Didn't get matched by anything */ 1464 then do; 1465 new_acl.count = new_acl.count + 1; /* so it's still there in the new ACL */ 1466 new_acl.status_code (new_acl.count) = 0; 1467 new_acl.access_name (new_acl.count) = old_acl.access_name (old_acle_idx); 1468 new_acl.mode (new_acl.count) = old_acl.mode (old_acle_idx); 1469 end; 1470 end; 1471 1472 return; 1473 end build_nonmatching_acl; 1474 1475 /* */ 1476 1477 match_acl: /* cribbed from old find_common_acl_names_ */ 1478 proc (name_idx, copy_matching_names) returns (bit (1) aligned); 1479 1480 declare name_idx fixed bin parameter; 1481 declare copy_matching_names bit (1) aligned parameter; 1482 1483 declare used bit (1) aligned; 1484 declare old_acle_idx fixed bin; 1485 declare missing_component bit (1) aligned; 1486 declare comp_idx fixed bin; 1487 declare given_comp (3) char (32) aligned; 1488 declare acle_comp (3) char (32) aligned; 1489 1490 1491 used = "0"b; 1492 missing_component = "0"b; /* Missing component in name from command line */ 1493 1494 call set_components (acl_names (name_idx), given_comp); 1495 do comp_idx = 1 to 3 while (^missing_component); 1496 if given_comp (comp_idx) = "" then missing_component = "1"b; 1497 end; 1498 1499 do old_acle_idx = 1 to old_acl.count; 1500 call set_components (old_acl.access_name (old_acle_idx), acle_comp); 1501 1502 do comp_idx = 1 to 3; /* See if the non-null components match the current */ 1503 if given_comp (comp_idx) ^= "" then /* entry from the old ACL */ 1504 if given_comp (comp_idx) ^= acle_comp (comp_idx) then goto TRY_NEXT_OLD_ACLE; 1505 end; 1506 1507 used = "1"b; /* We managed to use this particular command-line ACL name */ 1508 if ^used_bits (old_acle_idx) then do; /* (and this is the first time, if true) */ 1509 used_bits (old_acle_idx) = "1"b; 1510 1511 if copy_matching_names then do; /* For set or list, copy this term into the new ACL */ 1512 new_acl.count = new_acl.count + 1; 1513 new_acl.access_name (new_acl.count) = old_acl.access_name (old_acle_idx); 1514 new_acl.status_code (new_acl.count) = 0; 1515 if (operation = SET) then 1516 new_acl.mode (new_acl.count) = convert_mode (acl_modes (name_idx)); 1517 else new_acl.mode (new_acl.count) = old_acl.mode (old_acle_idx); 1518 end; 1519 end; 1520 TRY_NEXT_OLD_ACLE: 1521 end; 1522 1523 /* Now, we've finished checking this particular command-line name, and we decide what to tell our caller. 1524* For all operations, if the name matched anywhere, quit and return "1"b. Then, for set_acl, if the name 1525* was complete (no missing components, like Klensin..*), return the used bit no matter what its value, 1526* and the caller will add the whole name to the new ACL if it didn't match here. If neither of those 1527* cases apply, there is a genuine non-match, and except in -brief mode, we complain about it. After 1528* complaining, "1"b is always returned, since the name has seen all the use it will ever see. */ 1529 1530 if used then return ("1"b); 1531 1532 if (operation = SET) & (^missing_component) then return (used); 1533 1534 if ^brief_sw & (original_count > 0) then 1535 call complain (0, whoami, 1536 "No match for ^a on ^[I^]ACL of ^a", acl_names (name_idx), iacl_sw, err_path); 1537 1538 return ("1"b); 1539 end match_acl; 1540 1541 end build_new_acl; 1542 1543 convert_mode: 1544 proc (mode_string) returns (bit (36) aligned); 1545 1546 declare mode_string char (36), 1547 (idx, jdx) fixed bin, 1548 mode bit (36) aligned; 1549 1550 if mode_string = "null" | mode_string = "n" then return (""b); 1551 1552 mode = ""b; 1553 do idx = 1 to length (rtrim (mode_string)); 1554 jdx = index (rtrim (si.modes), substr (mode_string, idx, 1)); 1555 if jdx = 0 then do; 1556 call complain (0, whoami, "Invalid mode^[ for ^a^;^s^]. ^a^[ on ^a^]", si.extended_acl, 1557 si.plural_name, mode_string, (err_path ^= ""), err_path); 1558 goto SKIP_MATCH; 1559 end; 1560 substr (mode, jdx, 1) = "1"b; 1561 end; 1562 1563 return (mode); 1564 end convert_mode; 1565 1566 1567 1568 mode_representation: 1569 procedure (mode_bits) returns (char (36) varying); 1570 1571 declare mode_bits bit (36) aligned parameter; 1572 1573 declare bit_idx fixed bin; 1574 declare mode_string char (36) varying; 1575 1576 1577 if (mode_bits = ""b) then return ("null"); 1578 1579 mode_string = ""; 1580 do bit_idx = 1 to length (rtrim (si.modes)); 1581 if (substr (mode_bits, bit_idx, 1) = "1"b) then 1582 mode_string = mode_string || substr (si.modes, bit_idx, 1); 1583 end; 1584 1585 return (mode_string); 1586 end mode_representation; 1587 1588 get_suffix_info: 1589 proc (); 1590 1591 1592 si.version = SUFFIX_INFO_VERSION_1; 1593 1594 if ^(force_no_type | iacl_sw) then do; /* Normal case */ 1595 call fs_util_$suffix_info (dname, ename, addr (si), code); 1596 if (code = error_table_$not_seg_type) & ((type = MBX_ACL) | (type = MSEG_ACL)) then do; 1597 if ^star_sw then 1598 call complain (0, whoami, "^a is not a ^[mailbox^;message segment^].", err_path, 1599 (type = MBX_ACL)); 1600 goto SKIP_MATCH; 1601 end; 1602 1603 else if code = error_table_$unsupported_operation & operation = LIST then 1604 code = error_table_$noentry; 1605 1606 if code ^= 0 then do; 1607 call complain (code, whoami, "^a", err_path); 1608 goto SKIP_MATCH; 1609 end; 1610 1611 if (operation = SET) & starname_suffix & (^si.standard_object) then goto SKIP_MATCH; 1612 end; 1613 1614 else do; /* No-type forcing or IACL */ 1615 call hcs_$status_minf (dname, ename, 1, hcs_type, bit_count, code); 1616 if code ^= 0 then goto SKIP_THIS_ONE; 1617 1618 /* 1619* since we want to reference the current entry as a standard one (seg, dir, 1620* msf, or dmf) and we have been able to get status info, we get info on ACL 1621* modes by calling fs_util_ with a given type. the algorithm to do this is: 1622* 1623* if ENTRY_IS_A_DIRECTORY and WE_WANT_ITS_SEG_IACL 1624* then GET_SUFFIX_INFO_WITH_SEG_MODES_AND_DIRECTORY_TYPE 1625* else if ENTRY_IS_A_DIRECTORY and WE_WANT_ITS_DIR_IACL 1626* then GET_SUFFIX_INFO_WITH_DIR_MODES_AND_DIR_TYPE 1627* else if ENTRY_IS_A_DIRECTORY and WE_WANT_ITS_ACL 1628* then GET_SUFFIX_INFO_FOR_DIRS 1629* else if ENTRY_IS_A_MSF 1630* then GET_SUFFIX_INFO_FOR_MSFS 1631* else ENTRY_IS_A_SEG so GET_SUFFIX_INFO_FOR_SEGS 1632**/ 1633 1634 if (hcs_type = DIRECTORY) & (bit_count = 0) then 1635 if (type = SEGMENT_IACL) then do; 1636 call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_SEGMENT, addr (si), code); 1637 si.type = FS_OBJECT_TYPE_DIRECTORY; 1638 end; 1639 else if (type = DIRECTORY_IACL) then 1640 call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_DIRECTORY, addr (si), code); 1641 else call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_DIRECTORY, addr (si), code); 1642 else if (hcs_type = DIRECTORY) 1643 then call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_MSF, addr (si), code); 1644 else call fs_util_$suffix_info_for_type (FS_OBJECT_TYPE_SEGMENT, addr (si), code); 1645 1646 if (code ^= 0) then do; 1647 SKIP_THIS_ONE: 1648 call complain (code, whoami, "^a", err_path); 1649 goto SKIP_MATCH; 1650 end; 1651 end; 1652 1653 return; 1654 end get_suffix_info; 1655 1656 get_acl: 1657 procedure (); 1658 1659 dcl list_acl_entry entry variable options (variable); 1660 1661 1662 call free (other_acl_ptr); /* Get rid of leftovers */ 1663 call free (acl_ptr); 1664 1665 if (object_type = FS_OBJECT_TYPE_DIRECTORY) & (type = SEGMENT_IACL) then do; 1666 call hcs_$list_inacl (dname, ename, system_area_ptr, other_acl_ptr, (null ()), acl_count, iacl_ring, code); 1667 call make_general_acl ("segment_array"); 1668 end; 1669 1670 else if (object_type = FS_OBJECT_TYPE_DIRECTORY) & (type = DIRECTORY_IACL) then do; 1671 call hcs_$list_dir_inacl (dname, ename, system_area_ptr, other_acl_ptr, (null ()), acl_count, iacl_ring, 1672 code); 1673 call make_general_acl ("directory_array"); 1674 end; 1675 1676 1677 else if force_no_type then do; 1678 call fs_util_$make_entry_for_type (object_type, "list_acl", list_acl_entry, code); 1679 call list_acl_entry (dname, ename, GENERAL_ACL_VERSION_1, system_area_ptr, acl_ptr, code); 1680 1681 end; 1682 1683 else call fs_util_$list_acl (dname, ename, GENERAL_ACL_VERSION_1, system_area_ptr, acl_ptr, code); 1684 1685 if code ^= 0 then do; 1686 call complain (code, whoami, "^a", err_path); 1687 goto SKIP_MATCH; 1688 end; 1689 1690 call free (other_acl_ptr); /* In case we had to allocate it */ 1691 1692 if (acl_ptr = null ()) then do; /* Although the primitives always return a null pointer, */ 1693 acl_ptr = addr (empty_acl_overlay); /* since we loop through ACL entries, this is easier to use */ 1694 acl_ptr -> general_acl.version = GENERAL_ACL_VERSION_1; 1695 acl_ptr -> general_acl.count = 0; 1696 end; 1697 1698 acl_count = general_acl.count; 1699 1700 return; 1701 end get_acl; 1702 1703 replace_the_acl: 1704 proc (); 1705 1706 dcl complained_about_specific_acl bit (1) aligned; 1707 dcl idx fixed bin; 1708 1709 /* This procedure handles the various special cases, converting the ACL 1710* between various formats as needed. */ 1711 1712 1713 other_acl_ptr = null (); 1714 1715 if (object_type = FS_OBJECT_TYPE_DIRECTORY) then do; 1716 if (type = SEGMENT_IACL) then do; 1717 call make_other_acl ("segment_array"); 1718 call hcs_$replace_inacl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, iacl_ring, code); 1719 call copy_acle_status ("segment"); 1720 end; 1721 1722 else if (type = DIRECTORY_IACL) then do; 1723 call make_other_acl ("directory_array"); 1724 call hcs_$replace_dir_inacl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, iacl_ring, code) 1725 ; 1726 call copy_acle_status ("directory"); 1727 end; 1728 1729 else if (privilege = HPHCS) then do; 1730 call make_other_acl ("directory_array"); 1731 call hphcs_$replace_dir_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, code); 1732 call copy_acle_status ("directory"); 1733 end; 1734 1735 else if (privilege = LIBRARY) then do; 1736 call make_other_acl ("directory_array"); 1737 call installation_tools_$replace_dir_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, 1738 code); 1739 call copy_acle_status ("directory"); 1740 end; 1741 1742 else if force_no_type then do; 1743 call make_other_acl ("directory_array"); 1744 call hcs_$replace_dir_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, code); 1745 call copy_acle_status ("directory"); 1746 end; 1747 1748 else call fs_util_$replace_acl (dname, ename, acl_ptr, no_sysdaemon_sw, code); 1749 end; 1750 1751 else if (object_type = FS_OBJECT_TYPE_SEGMENT) then do; 1752 if (privilege = HPHCS) then do; 1753 call make_other_acl ("segment_array"); 1754 call hphcs_$replace_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, code); 1755 call copy_acle_status ("segment"); 1756 end; 1757 1758 else if (privilege = LIBRARY) then do; 1759 call make_other_acl ("segment_array"); 1760 call installation_tools_$replace_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, code); 1761 call copy_acle_status ("segment"); 1762 end; 1763 1764 else if force_no_type then do; 1765 call make_other_acl ("segment_array"); 1766 call hcs_$replace_acl (dname, ename, other_acl_ptr, acl_count, no_sysdaemon_sw, code); 1767 call copy_acle_status ("segment"); 1768 end; 1769 1770 else call fs_util_$replace_acl (dname, ename, acl_ptr, no_sysdaemon_sw, code); 1771 end; 1772 1773 else call fs_util_$replace_acl (dname, ename, acl_ptr, no_sysdaemon_sw, code); 1774 1775 call free (other_acl_ptr); /* If we made one, it's useless now */ 1776 1777 if code ^= 0 then do; 1778 complained_about_specific_acl = "0"b; 1779 if acl_ptr ^= null () then 1780 do idx = 1 to general_acl.count; 1781 if general_acl.status_code (idx) ^= 0 then do; 1782 complained_about_specific_acl = "1"b; 1783 call complain (general_acl.status_code (idx), whoami, "^a ^a on ^a", mode_representation (general_acl.mode (idx)), general_acl.access_name (idx), err_path); 1784 end; 1785 end; 1786 if ^complained_about_specific_acl then 1787 call complain (code, whoami, "^a", err_path); 1788 goto SKIP_MATCH; 1789 end; 1790 1791 return; 1792 end replace_the_acl; 1793 1794 /* */ 1795 1796 list_the_acl: 1797 proc (); 1798 1799 declare acle_idx fixed bin; 1800 declare real_rings (3) fixed bin (3); 1801 declare dir_rings (2) fixed bin (3) based (addr (real_rings)); 1802 declare rings (si.num_ring_brackets) fixed bin (3) based (addr (real_rings)); 1803 1804 1805 if star_sw then call ioa_ (" ^a", err_path); 1806 1807 if ring_bracket_sw then do; 1808 if si.num_ring_brackets = 0 then 1809 call complain (0, whoami, "The ^a object type does not support ring brackets.", si.type_name); 1810 1811 else if ^force_no_type then 1812 call fs_util_$get_ring_brackets (dname, ename, rings, code); 1813 1814 else if (object_type = FS_OBJECT_TYPE_MSF) then do; 1815 call hcs_$get_ring_brackets (err_path, "0", rings, code); 1816 if (code = error_table_$noentry) then 1817 call hcs_$get_dir_ring_brackets (dname, ename, dir_rings, code); 1818 end; 1819 1820 else if (object_type = FS_OBJECT_TYPE_DIRECTORY) then 1821 call hcs_$get_dir_ring_brackets (dname, ename, dir_rings, code); 1822 1823 else call hcs_$get_ring_brackets (dname, ename, rings, code); 1824 1825 if code ^= 0 then call complain (code, whoami, "Getting ring brackets for ^a", err_path); 1826 else if si.num_ring_brackets > 0 then 1827 call ioa_ ("^v(^d, ^)^d", si.num_ring_brackets - 1, rings, rings (si.num_ring_brackets)); 1828 end; 1829 1830 if access_class_sw then do; 1831 call hcs_$get_access_class (dname, ename, access_class, code); 1832 if code ^= 0 then call complain (code, whoami, "^a", err_path); 1833 call convert_authorization_$to_string_short (access_class, buffer, code); 1834 if code ^= 0 then call complain (code, whoami, "^a", err_path); 1835 if buffer = "" then buffer = "system_low"; 1836 call ioa_ ("^a", buffer); 1837 end; 1838 1839 if (original_count = 0) | (acl_ptr = null ()) then 1840 if ^brief_sw then call complain (0, whoami, "Empty ^[^[segment ^;directory ^]I^;^s^]ACL for ^a.", 1841 iacl_sw, (type = SEGMENT_IACL), err_path); 1842 1843 do acle_idx = 1 to general_acl.count; 1844 if (general_acl.status_code (acle_idx) ^= 0) then goto SKIP_THIS_ACLE; 1845 1846 if af_sw then do; 1847 if (length (ret_str) > 0) then ret_str = ret_str || " "; 1848 ret_str = ret_str || mode_representation (general_acl.mode (acle_idx)); 1849 ret_str = ret_str || " "; 1850 ret_str = ret_str || rtrim (general_acl.access_name (acle_idx)); 1851 end; 1852 1853 else call ioa_ ("^va^2x^a", max (4, si.max_mode_len), mode_representation (general_acl.mode (acle_idx)), 1854 general_acl.access_name (acle_idx)); 1855 1856 SKIP_THIS_ACLE: 1857 end; 1858 1859 if ^af_sw & (general_acl.count > 0) then call ioa_ (); 1860 1861 return; 1862 end list_the_acl; 1863 1864 print_accessible: 1865 proc (); 1866 1867 declare acle_idx fixed bin; 1868 declare modes bit (36) aligned; 1869 1870 1871 if use_access_modes then do; 1872 if force_no_type then 1873 call hcs_$get_user_access_modes (dname, ename, access_name, -1, modes, (""b), code); 1874 else call fs_util_$get_user_access_modes (dname, ename, access_name, -1, modes, (""b), code); 1875 1876 if code ^= 0 then do; 1877 call complain (code, whoami, "Listing access for ^a.", err_path); 1878 return; 1879 end; 1880 1881 if accessible = ((modes & acl_mask) ^= ""b) then 1882 call ioa_ ("^va^2x^a", max (4, si.max_mode_len), mode_representation (modes), ename); 1883 end; 1884 1885 else if (acl_count = 0) then do; 1886 if ^accessible then call ioa_ ("^vx^a", si.max_mode_len + 2, ename); 1887 end; 1888 1889 else do; 1890 do acle_idx = 1 to general_acl.count; 1891 if accessible = ((general_acl.mode (acle_idx) & acl_mask) ^= ""b) then 1892 call ioa_ ("^va^2x^32a^a", max (4, si.max_mode_len), 1893 mode_representation (general_acl.mode (acle_idx)), ename, 1894 general_acl.access_name (acle_idx)); 1895 end; 1896 end; 1897 return; 1898 1899 end print_accessible; 1900 1901 /* */ 1902 1903 check_for_acle_errors: 1904 procedure (); 1905 1906 declare acle_idx fixed bin; 1907 1908 1909 if (operation = ACCESSIBLE) then return; /* No errors possible here */ 1910 1911 do acle_idx = 1 to general_acl.count; 1912 if (general_acl.status_code (acle_idx) = 0) then ; 1913 else if brief_sw & (general_acl.status_code (acle_idx) = error_table_$user_not_found) then ; 1914 else call complain (general_acl.status_code (acle_idx), whoami, "^a for ^a.", 1915 general_acl.access_name (acle_idx), err_path); 1916 end; 1917 1918 return; 1919 end check_for_acle_errors; 1920 1921 /* */ 1922 1923 set_components: 1924 proc (sc_access_name, sc_component); 1925 1926 declare sc_access_name char (*), 1927 sc_component (3) char (32) aligned; 1928 1929 declare ( 1930 sc_dot_count init (0), 1931 sc_dot_loc (2) init ((2) 0), 1932 sc_i, 1933 sc_len 1934 ) fixed bin; 1935 1936 sc_component (*) = ""; 1937 if sc_access_name = "." then do; 1938 sc_component (3) = "*"; 1939 sc_access_name = "..*"; 1940 return; 1941 end; 1942 1943 sc_len = index (sc_access_name, " ") - 1; 1944 if sc_len = -1 then sc_len = length (sc_access_name); 1945 else if verify (substr (sc_access_name, sc_len + 1), " ") ^= 0 then do; 1946 BADNAME: 1947 call complain (error_table_$bad_name, whoami, "^a", sc_access_name); 1948 goto MAIN_RETURN; 1949 end; 1950 1951 do sc_i = 1 to sc_len; 1952 if substr (sc_access_name, sc_i, 1) = "." then do; 1953 sc_dot_count = sc_dot_count + 1; 1954 if sc_dot_count > 2 then go to BADNAME; 1955 sc_dot_loc (sc_dot_count) = sc_i; 1956 end; 1957 end; 1958 1959 if sc_dot_count = 0 then do; 1960 sc_component (1) = sc_access_name; 1961 sc_component (2), sc_component (3) = "*"; 1962 substr (sc_access_name, sc_len + 1, 4) = ".*.*"; 1963 end; 1964 1965 else if sc_dot_count = 1 then do; 1966 if sc_dot_loc (1) = 1 then do; 1967 sc_component (2) = substr (sc_access_name, 2, sc_len - 1); 1968 sc_component (3) = "*"; 1969 end; 1970 else do; 1971 sc_component (1) = substr (sc_access_name, 1, sc_dot_loc (1) - 1); 1972 if sc_dot_loc (1) < sc_len then 1973 sc_component (2) = substr (sc_access_name, sc_dot_loc (1) + 1, sc_len - sc_dot_loc (1)); 1974 sc_component (3) = "*"; 1975 end; 1976 substr (sc_access_name, sc_len + 1, 2) = ".*"; 1977 end; 1978 1979 else do; /* sc_dot_count = 2 */ 1980 if sc_dot_loc (1) ^= 1 then sc_component (1) = substr (sc_access_name, 1, sc_dot_loc (1) - 1); 1981 if sc_dot_loc (1) + 1 < sc_dot_loc (2) then 1982 sc_component (2) = substr (sc_access_name, sc_dot_loc (1) + 1, sc_dot_loc (2) - sc_dot_loc (1) - 1); 1983 if sc_dot_loc (2) < sc_len then 1984 sc_component (3) = substr (sc_access_name, sc_dot_loc (2) + 1, sc_len - sc_dot_loc (2)); 1985 end; 1986 1987 return; 1988 1989 end set_components; 1990 1991 /* */ 1992 1993 make_general_acl: 1994 procedure (acl_type); 1995 1996 declare acl_type char (32) parameter; 1997 1998 1999 call cv_acl_type_$create (other_acl_ptr, acl_count, system_area_ptr, acl_type, "general", acl_ptr); 2000 2001 return; 2002 2003 2004 2005 make_other_acl: 2006 entry (acl_type); 2007 2008 2009 acl_count = general_acl.count; 2010 call cv_acl_type_$create (acl_ptr, acl_count, system_area_ptr, "general", acl_type, other_acl_ptr); 2011 2012 return; 2013 end make_general_acl; 2014 2015 2016 2017 copy_acle_status: 2018 procedure (acl_type); 2019 2020 declare acl_type char (32) parameter; 2021 declare acle_idx fixed bin; 2022 2023 2024 do acle_idx = 1 to general_acl.count; 2025 if (acl_type = "directory") then 2026 general_acl.status_code (acle_idx) = other_acl_ptr -> directory_acl_array (acle_idx).status_code; 2027 else general_acl.status_code (acle_idx) = other_acl_ptr -> segment_acl_array (acle_idx).status_code; 2028 end; 2029 2030 return; 2031 end copy_acle_status; 2032 2033 /* */ 2034 2035 complain: 2036 procedure () options (variable); 2037 2038 declare arg_list_ptr pointer; 2039 2040 2041 call cu_$arg_list_ptr (arg_list_ptr); 2042 if af_sw then 2043 call cu_$generate_call (active_fnc_err_, arg_list_ptr); 2044 else call cu_$generate_call (com_err_, arg_list_ptr); 2045 2046 return; 2047 end complain; 2048 2049 /* */ 2050 2051 cleanup_handler: 2052 proc (); 2053 2054 call free (acl_ptr); 2055 call free (old_acl_ptr); 2056 call free (new_acl_ptr); 2057 call free (other_acl_ptr); 2058 2059 call free (used_bits_ptr); 2060 2061 if (fcb_ptr ^= null ()) then call msf_manager_$close (fcb_ptr); 2062 2063 call free (acl_names_ptr); 2064 call free (acl_modes_ptr); 2065 2066 call free (star_names_ptr); 2067 call free (star_entry_ptr); 2068 if star_match_ptr ^= null () then call free (star_match_ptr); 2069 2070 return; 2071 end cleanup_handler; 2072 2073 2074 2075 free: 2076 procedure (freeing_ptr); 2077 2078 declare freeing_ptr pointer parameter; 2079 declare based_stuff_ptr pointer; 2080 declare based_stuff fixed bin based; 2081 2082 /* 2083* we free by using based_stuff, because the freeing mechanism knows how 2084* much there is to free at the address to which the pointer points. 2085**/ 2086 2087 based_stuff_ptr = freeing_ptr; 2088 freeing_ptr = null (); 2089 2090 if (based_stuff_ptr = addr (empty_acl_overlay)) then return; 2091 2092 if (based_stuff_ptr ^= null ()) then free based_stuff_ptr -> based_stuff in (system_area); 2093 2094 return; 2095 end free; 2096 2097 1 1 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 1 2 /* format: style3,indcomtxt,idind30 */ 1 3 1 4 declare acl_ptr pointer; 1 5 declare acl_count fixed bin; 1 6 1 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 1 8 2 version char (8) aligned, 1 9 2 count fixed bin, 1 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 1 11 1 12 declare 1 general_acl_entry based, 1 13 2 access_name character (32) unaligned, 1 14 2 mode bit (36) aligned, 1 15 2 status_code fixed bin (35); 1 16 1 17 1 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 1 19 2 version char (8) aligned, 1 20 2 count fixed bin, 1 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 1 22 1 23 declare 1 general_extended_acl_entry aligned based, 1 24 2 access_name character (32) unaligned, 1 25 2 mode bit (36) aligned, 1 26 2 extended_mode bit (36) aligned, 1 27 2 status_code fixed bin (35); 1 28 1 29 1 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 1 31 2 version char (8) aligned, 1 32 2 count fixed bin, 1 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 1 34 1 35 declare 1 general_delete_acl_entry aligned based, 1 36 2 access_name character (32) unaligned, 1 37 2 status_code fixed bin (35); 1 38 1 39 1 40 declare 1 segment_acl aligned based (acl_ptr), 1 41 2 version fixed bin, 1 42 2 count fixed bin, 1 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 1 44 1 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 1 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 1 47 1 48 1 49 declare 1 directory_acl aligned based (acl_ptr), 1 50 2 version fixed bin, 1 51 2 count fixed bin, 1 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 1 53 1 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 1 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 1 56 1 57 1 58 declare 1 delete_acl based (acl_ptr) aligned, 1 59 2 version fixed bin, 1 60 2 count fixed bin, 1 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 1 62 1 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 1 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 1 65 1 66 1 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 1 68 DIR_ACL_VERSION_1 init ("dra1"), 1 69 DELETE_ACL_VERSION_1 init ("dla1")) 1 70 char (4) int static options (constant); 1 71 1 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 1 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 1 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 1 75 char (8) internal static options (constant); 1 76 1 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 1 78 1 79 /* End include file acl_structures.incl.pl1 */ 2098 2099 2 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 2 2 2 3 /* This include file contains structures for the hcs_$star_, 2 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 2 5* 2 6* Written 23 October 1978 by Monte Davidoff. 2 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 2 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 2 9**/ 2 10 2 11 /* automatic */ 2 12 2 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 2 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 2 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 2 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 2 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 2 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 2 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 2 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 2 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 2 22 2 23 /* based */ 2 24 2 25 /* hcs_$star_ entry structure */ 2 26 2 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 2 28 2 type fixed binary (2) unsigned unaligned, 2 29 /* storage system type */ 2 30 2 nnames fixed binary (16) unsigned unaligned, 2 31 /* number of names of entry that match star_name */ 2 32 2 nindex fixed binary (18) unsigned unaligned; 2 33 /* index of first name in star_names */ 2 34 2 35 /* hcs_$star_ name structure */ 2 36 2 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 2 38 2 39 /* hcs_$star_list_ branch structure */ 2 40 2 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 42 2 type fixed binary (2) unsigned unaligned, 2 43 /* storage system type */ 2 44 2 nnames fixed binary (16) unsigned unaligned, 2 45 /* number of names of entry that match star_name */ 2 46 2 nindex fixed binary (18) unsigned unaligned, 2 47 /* index of first name in star_list_names */ 2 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 2 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 2 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 53 2 pad bit (7) unaligned, 2 54 2 records fixed binary (18) unsigned unaligned; 2 55 /* records used by branch */ 2 56 2 57 /* hcs_$star_dir_list_ branch structure */ 2 58 2 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 60 2 type fixed binary (2) unsigned unaligned, 2 61 /* storage system type */ 2 62 2 nnames fixed binary (16) unsigned unaligned, 2 63 /* number of names of entry that match star_name */ 2 64 2 nindex fixed binary (18) unsigned unaligned, 2 65 /* index of first name in star_list_names */ 2 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 2 67 2 pad bit (36) unaligned, 2 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 71 2 bit_count fixed binary (24) unaligned; 2 72 /* bit count of the branch */ 2 73 2 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 2 75 2 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 77 2 type fixed binary (2) unsigned unaligned, 2 78 /* storage system type */ 2 79 2 nnames fixed binary (16) unsigned unaligned, 2 80 /* number of names of entry that match star_name */ 2 81 2 nindex fixed binary (18) unsigned unaligned, 2 82 /* index of first name in star_list_names */ 2 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 2 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 2 85 2 pathname_len fixed binary (18) unsigned unaligned, 2 86 /* length of the pathname of the link */ 2 87 2 pathname_index fixed binary (18) unsigned unaligned; 2 88 /* index of start of pathname in star_list_names */ 2 89 2 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 2 91 2 92 declare star_list_names char (32) based (star_list_names_ptr) 2 93 dimension (star_links (star_branch_count + star_link_count).nindex 2 94 + star_links (star_branch_count + star_link_count).nnames 2 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 2 96 * binary ( 2 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 2 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 2 99 2 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 2 101 2 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 2 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 2 104 2 105 /* internal static */ 2 106 2 107 /* star_select_sw values */ 2 108 2 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 2 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 2 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 2 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 2 113 fixed binary (3) internal static options (constant) initial (5); 2 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 2 115 fixed binary (3) internal static options (constant) initial (7); 2 116 2 117 /* storage system types */ 2 118 2 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 2 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 2 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 2 122 2 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 2100 2101 3 1 /* BEGIN INCLUDE FILE: suffix_info.incl.pl1 */ 3 2 /* format: style3,indcomtxt,idind30 */ 3 3 /**** Jay Pattin 2/13/83 3 4* M. Pandolf 1984.11.30 to set FS_OBJECT_TYPE_MSF to -multisegment_file 3 5* 3 6* The include file copy_flags.incl.pl1 must be included in any program using this include file. 3 7* 3 8* This structure is returned by the suffix_XXX_$suffix_info subroutines */ 3 9 3 10 declare suffix_info_ptr ptr; 3 11 3 12 declare 1 suffix_info aligned based (suffix_info_ptr), 3 13 2 version char (8), 3 14 2 type char (32) unaligned, 3 15 2 type_name char (32) unaligned, /* Singular name of the object type, e.g. "mailbox" */ 3 16 2 plural_name char (32) unaligned, /* Plural of above, e.g. "mailboxes" */ 3 17 2 flags unaligned, 3 18 3 standard_object bit (1) unaligned, /* ON if not an extended object (no suffix_XXX_) */ 3 19 3 extended_acl bit (1) unaligned, /* ON if uses extended ACLs, off if regular ACLs */ 3 20 3 has_switches bit (1) unaligned, /* ON if supports switches for objects */ 3 21 3 mbz1 bit (33) unaligned, 3 22 2 modes char (36), /* correspondence between bits and chars for extended modes */ 3 23 2 max_mode_len fixed bin, /* maximum number of modes on an object */ 3 24 2 num_ring_brackets fixed bin, /* number of ring brackets on object */ 3 25 2 copy_flags like copy_flags, /* See copy_flags.incl.pl1 */ 3 26 2 info_pathname char (168) unaligned; 3 27 /* pathname of info segment containing more info */ 3 28 3 29 declare SUFFIX_INFO_VERSION_1 char (8) static options (constant) init ("SUFFIX01"); 3 30 3 31 /* This information is returned by the suffix_XXX_$list_switches subroutines */ 3 32 3 33 declare switch_list_ptr ptr, 3 34 alloc_switch_count fixed bin, 3 35 alloc_switch_name_count fixed bin; 3 36 3 37 declare 1 switch_list aligned based (switch_list_ptr), 3 38 2 version char (8), /* SWITCH_LIST_VERSION_1 */ 3 39 2 switch_count fixed bin, /* total number of switches */ 3 40 2 switch_name_count fixed bin, /* total number of names */ 3 41 2 switches (alloc_switch_count refer (switch_list.switch_count)), 3 42 3 name_index fixed bin, /* index of first name for this switch */ 3 43 3 name_count fixed bin, /* number of names for this switch */ 3 44 3 default_value bit (1) aligned, /* default setting for this switch */ 3 45 3 mbz1 bit (36) aligned, /* reserved for future use */ 3 46 2 names (alloc_switch_name_count refer (switch_list.switch_name_count)) char (32); 3 47 3 48 declare SWITCH_LIST_VERSION_1 char (8) static options (constant) init ("SWLIST01"); 3 49 3 50 declare ( 3 51 FS_OBJECT_TYPE_SEGMENT init ("-segment"), 3 52 FS_OBJECT_TYPE_DIRECTORY init ("-directory"), 3 53 FS_OBJECT_TYPE_MSF init ("-multisegment_file"), 3 54 FS_OBJECT_TYPE_DM_FILE init ("-dm_file"), 3 55 FS_OBJECT_TYPE_LINK init ("-link") 3 56 ) char (32) unaligned int static options (constant); 3 57 3 58 /* END INCLUDE FILE: suffix_info.incl.pl1 */ 2102 2103 4 1 /* BEGIN INCLUDE FILE: copy_flags.incl.pl1 */ 4 2 4 3 /* Flags for attributes that should/may be copied by the copy_ subroutine. This include file is 4 4* required by suffix_info.incl.pl1 and copy_options.incl.pl1 4 5* 4 6* Jay Pattin 6/23/83 */ 4 7 4 8 declare 1 copy_flags aligned based, /* ON means that this attribute may be copied by copy_ */ 4 9 2 names bit (1) unaligned, 4 10 2 acl bit (1) unaligned, 4 11 2 ring_brackets bit (1) unaligned, 4 12 2 max_length bit (1) unaligned, 4 13 2 copy_switch bit (1) unaligned, 4 14 2 safety_switch bit (1) unaligned, 4 15 2 dumper_switches bit (1) unaligned, 4 16 2 entry_bound bit (1) unaligned, /* only for vanilla object segments */ 4 17 2 extend bit (1) unaligned, /* copy_ may append to end of existing object */ 4 18 2 update bit (1) unaligned, /* copy_ may replace contents of existing object */ 4 19 2 mbz bit (26) unaligned; 4 20 4 21 /* END INCLUDE FILE: copy_flags.incl.pl1 */ 2104 2105 2106 end nonquick_common; 2107 2108 end common; 2109 2110 end acl_commands_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/06/88 1035.5 acl_commands_.pl1 >spec>install>1134>acl_commands_.pl1 2098 1 10/14/83 1606.6 acl_structures.incl.pl1 >ldd>include>acl_structures.incl.pl1 2100 2 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 2102 3 03/05/85 1807.3 suffix_info.incl.pl1 >ldd>include>suffix_info.incl.pl1 2104 4 10/14/83 1606.7 copy_flags.incl.pl1 >ldd>include>copy_flags.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. ACCESSIBLE 000047 constant fixed bin(11,0) initial dcl 197 set ref 291* 295* 452 567 631 696 790 818 836 847 903 903 960 975 1276 1308 1909 BRANCH_ACL 000057 constant fixed bin(10,0) initial dcl 186 set ref 215* 219* 223* 227* 231* 235* 271* 291* 295* 673 675 679 901 950 1053 DELETE 000050 constant fixed bin(11,0) initial dcl 196 set ref 227* 231* 235* 247* 251* 259* 267* 565 672 871 946 1050 1302 DIRECTORY constant fixed bin(2,0) initial dcl 183 ref 1634 1642 DIRECTORY_IACL 000053 constant fixed bin(10,0) initial dcl 190 set ref 263* 267* 279* 464 713 718 1639 1670 1722 FS_OBJECT_TYPE_DIRECTORY 000020 constant char(32) initial packed unaligned dcl 3-50 set ref 543 984* 1140 1637 1639* 1641* 1665 1670 1715 1820 FS_OBJECT_TYPE_DM_FILE 000000 constant char(32) initial packed unaligned dcl 3-50 ref 1142 FS_OBJECT_TYPE_MSF 000010 constant char(32) initial packed unaligned dcl 3-50 set ref 555 571 1141 1642* 1814 FS_OBJECT_TYPE_SEGMENT 000030 constant char(32) initial packed unaligned dcl 3-50 set ref 986* 1139 1636* 1644* 1751 GENERAL_ACL_VERSION_1 000042 constant char(8) initial packed unaligned dcl 1-72 set ref 1329 1349 1373 1459 1679* 1683* 1694 HPHCS 000044 constant fixed bin(12,0) initial dcl 203 set ref 223* 235* 504 1729 1752 LIBRARY 000045 constant fixed bin(12,0) initial dcl 202 set ref 219* 231* 1735 1758 LIST 000052 constant fixed bin(11,0) initial dcl 194 set ref 271* 275* 279* 283* 287* 566 752 785 790 911 1053 1283 1306 1603 MBX_ACL 000055 constant fixed bin(10,0) initial dcl 188 set ref 243* 251* 287* 448 802 879 1596 1597 MSEG_ACL 000056 constant fixed bin(10,0) initial dcl 187 set ref 239* 247* 283* 448 803 880 1596 NORMAL 000046 constant fixed bin(12,0) initial dcl 201 set ref 215* 227* 239* 243* 247* 251* 255* 259* 263* 267* 271* 275* 279* 283* 287* 291* 295* 501 881 OFF constant bit(1) initial dcl 181 set ref 675* 678* 711* 754* 756* 761* 763* 1031 ON constant bit(1) initial dcl 180 set ref 672* 673* 677* 705* 706* 710* 715* 720* 753* 755* 760* 762* 1021 1027 P_arg_list_ptr parameter pointer dcl 336 set ref 333 619* 656* 686* 741* 925* 1075* P_argno parameter fixed bin(17,0) dcl 1069 ref 1063 1075 1075 P_code parameter fixed bin(35,0) dcl 1044 set ref 1039 1046* 1050* 1053* 1057* P_on_off parameter bit(1) dcl 1016 ref 1009 1021 1027 1031 P_operation parameter fixed bin(11,0) dcl 308 ref 299 443 P_option parameter fixed bin(17,0) dcl 1016 set ref 1009 1021 1021* 1024* 1027 1027* 1027 1031 1031* 1031 P_privilege parameter fixed bin(12,0) dcl 309 ref 299 444 P_type parameter fixed bin(10,0) dcl 307 ref 299 442 P_whoami parameter char(32) packed unaligned dcl 306 ref 299 441 SEGMENT_IACL 000054 constant fixed bin(10,0) initial dcl 189 set ref 255* 259* 275* 464 713 718 1634 1665 1716 1839 SET 000051 constant fixed bin(11,0) initial dcl 195 set ref 215* 219* 223* 239* 243* 255* 263* 565 631 650 759 779 794 863 924 944 950 1046 1271 1292 1296 1304 1515 1532 1611 SUFFIX_INFO_VERSION_1 000040 constant char(8) initial packed unaligned dcl 3-29 ref 889 981 1128 1209 1592 abs builtin function dcl 174 ref 925 925 1075 1075 access_class 000466 automatic bit(72) dcl 372 set ref 1831* 1833* access_class_sw 001010 automatic bit(1) initial dcl 424 set ref 424* 939* 1830 access_class_val 001113 automatic fixed bin(17,0) initial dcl 598 set ref 598* 755* 756* 939 access_name 000470 automatic char(32) packed unaligned dcl 373 in procedure "nonquick_common" set ref 992* 996* 997 997 997 997 1002* 1872* 1874* access_name 3 based char(32) array level 3 in structure "general_acl" packed packed unaligned dcl 1-7 in procedure "nonquick_common" set ref 1378* 1783* 1850 1853* 1891* 1914* access_name 3 based char(32) array level 3 in structure "new_acl" packed packed unaligned dcl 409 in procedure "nonquick_common" set ref 1408* 1412 1425* 1467* 1513* access_name 3 based char(32) array level 3 in structure "old_acl" packed packed unaligned dcl 408 in procedure "nonquick_common" set ref 1412* 1425 1450 1467 1500* 1513 accessible 001021 automatic bit(1) initial dcl 433 set ref 433* 452* 1881 1886 1891 acl_count 001030 automatic fixed bin(17,0) dcl 1-5 set ref 1292* 1294* 1313* 1327 1327 1346 1346 1351 1370* 1371 1371 1372 1456 1456 1666* 1671* 1698* 1718* 1724* 1731* 1737* 1744* 1754* 1760* 1766* 1885 1999* 2009* 2010* acl_mask 000500 automatic bit(36) dcl 374 set ref 978* 988* 1881 1891 acl_modes based char(36) array packed unaligned dcl 406 set ref 635 773* 952 952 952 960 988* 1379* 1409* 1515* acl_modes_ptr 000750 automatic pointer initial dcl 393 set ref 393* 635* 640* 773 952 952 952 960 988 1379 1409 1515 2064* acl_names based char(32) array packed unaligned dcl 402 set ref 644 648* 778* 823 823 866* 868* 873* 875* 996 1376* 1378 1408 1494* 1534* acl_names_ptr 000746 automatic pointer initial dcl 392 set ref 392* 644* 648 778 823 823 866 868 873 875 996 1376 1378 1408 1494 1534 2063* acl_ptr 001026 automatic pointer dcl 1-4 set ref 457* 1281 1298 1314* 1330 1333 1336* 1371* 1372 1373 1378 1379 1380 1663* 1679* 1683* 1692 1693* 1694 1695 1698 1748* 1770* 1773* 1779 1779 1781 1783 1783 1783 1839 1843 1844 1848 1850 1853 1853 1859 1890 1891 1891 1891 1911 1912 1913 1914 1914 1999* 2009 2010* 2024 2025 2027 2054* acl_type parameter char(32) packed unaligned dcl 2020 in procedure "copy_acle_status" ref 2017 2025 acl_type parameter char(32) packed unaligned dcl 1996 in procedure "make_general_acl" set ref 1993 1999* 2005 2010* acle_comp 001370 automatic char(32) array dcl 1488 set ref 1500* 1503 acle_idx 001256 automatic fixed bin(17,0) dcl 1324 in procedure "enlarge_old_acl" set ref 1332* 1333 1333* acle_idx 001602 automatic fixed bin(17,0) dcl 2021 in procedure "copy_acle_status" set ref 2024* 2025 2025 2027 2027* acle_idx 001274 automatic fixed bin(17,0) dcl 1367 in procedure "build_replacement_acl" set ref 1375* 1376 1378 1378 1379 1379 1380* acle_idx 001544 automatic fixed bin(17,0) dcl 1906 in procedure "check_for_acle_errors" set ref 1911* 1912 1913 1914 1914* acle_idx 001516 automatic fixed bin(17,0) dcl 1799 in procedure "list_the_acl" set ref 1843* 1844 1848 1850 1853 1853* acle_idx 001532 automatic fixed bin(17,0) dcl 1867 in procedure "print_accessible" set ref 1890* 1891 1891 1891* acle_matched 001322 automatic bit(1) dcl 1440 set ref 1444* active_fnc_err_ 000050 constant entry external dcl 116 ref 2042 2042 add_new_names parameter bit(1) dcl 1396 ref 1388 1406 1418 addr builtin function dcl 174 ref 890 890 982 982 984 984 986 986 1145 1145 1223 1223 1243 1243 1595 1595 1636 1636 1639 1639 1641 1641 1642 1642 1644 1644 1693 1811 1815 1816 1820 1823 1826 1826 2090 af_sw 001002 automatic bit(1) initial dcl 418 set ref 418* 471 621* 625* 785 1846 1859 2042 after builtin function dcl 174 ref 448 448 1114 1155 al 001202 automatic fixed bin(21,0) dcl 1072 in procedure "BADOPT" set ref 1075* 1077 1077 al 001076 automatic fixed bin(21,0) dcl 591 in procedure "process_arguments" set ref 656* 658 663 663 663 663 666 666 672 672 673 673 675 675 677 678 679 679 681 681 686* 687 689 690 690 692 692 698 698 705 706 707 710 710 711 711 712 712 717 717 722 722 729 729 736 736 742 753 753 754 754 755 755 756 756 760 760 761 761 762 762 763 763 768 773 778 925* 926 926 al1 001077 automatic fixed bin(21,0) dcl 591 set ref 725* 729 729 729 741* 744 746 all_stars 001141 automatic bit(1) dcl 616 set ref 845* 857* 883 all_sw 001011 automatic bit(1) initial dcl 425 set ref 425* 931* 1448 all_val 001104 automatic fixed bin(17,0) initial dcl 598 set ref 598* 672* 871 931 ap 001072 automatic pointer dcl 590 in procedure "process_arguments" set ref 656* 663 663 663 663 666 672 672 673 673 675 675 677 678 679 679 681 686* 689 690 692 698 705 706 707 710 710 711 711 712 712 717 717 722 722 729 736 753 753 754 754 755 755 756 756 760 760 761 761 762 762 763 763 768 773 778 925* 926 ap 001200 automatic pointer dcl 1071 in procedure "BADOPT" set ref 1075* 1077 ap1 001074 automatic pointer dcl 590 set ref 724* 729 741* 744 746 arg based char packed unaligned dcl 1073 in procedure "BADOPT" set ref 1077* arg based char packed unaligned dcl 592 in procedure "process_arguments" set ref 663 663 663 663 666* 672 672 673 673 675 675 677 678 679 679 681* 689 690* 692* 698* 705 706 707 710 710 711 711 712 712 717 717 722 722 729* 736* 753 753 754 754 755 755 756 756 760 760 761 761 762 762 763 763 768 773 778 926* arg1 based char packed unaligned dcl 593 set ref 729* 744 746 arg_list_ptr 000100 automatic pointer dcl 2038 in procedure "complain" set ref 2041* 2042* 2044* arg_list_ptr 000106 automatic pointer dcl 311 in procedure "common" set ref 323* 325* argno 001100 automatic fixed bin(17,0) dcl 594 set ref 655* 656* 680 685* 685 686* 707* 708 713* 718* 723 727 740* 740 741* 757* 764* 766* 1021 1024 based_stuff based fixed bin(17,0) dcl 2080 ref 2092 based_stuff_ptr 000100 automatic pointer dcl 2079 set ref 2087* 2090 2092 2092 before builtin function dcl 174 ref 860 866 873 1131 bit_count 000601 automatic fixed bin(24,0) dcl 376 set ref 1615* 1634 bit_idx 001442 automatic fixed bin(17,0) dcl 1573 set ref 1580* 1581 1581* brief_sw 001005 automatic bit(1) initial dcl 421 set ref 421* 936* 976* 1534 1839 1913 brief_val 001106 automatic fixed bin(17,0) initial dcl 598 set ref 598* 622* 710* 711* 936 buffer 000501 automatic char(256) packed unaligned dcl 375 set ref 1833* 1835 1835* 1836* char builtin function dcl 174 ref 663 chase_sw 001003 automatic bit(1) initial dcl 419 set ref 419* 472 932* chase_val 001105 automatic fixed bin(17,0) initial dcl 598 set ref 598* 677* 678* 932 933 check_star_name_$entry 000052 constant entry external dcl 117 ref 839 cleanup 000000 stack reference condition dcl 172 ref 462 1099 code 000116 automatic fixed bin(35,0) dcl 346 set ref 477* 479 480* 488* 490 491* 556* 557 558* 619* 620 728* 729* 748* 813* 815 818 819* 831* 836* 839* 840 841* 844 845 890* 891 893 896* 1145* 1146 1215* 1217 1220* 1221 1223* 1224 1228 1241* 1242 1243* 1244 1595* 1596 1603 1603* 1606 1607* 1615* 1616 1636* 1639* 1641* 1642* 1644* 1646 1647* 1666* 1671* 1678* 1679* 1683* 1685 1686* 1718* 1724* 1731* 1737* 1744* 1748* 1754* 1760* 1766* 1770* 1773* 1777 1786* 1811* 1815* 1816 1816* 1820* 1823* 1825 1825* 1831* 1832 1832* 1833* 1834 1834* 1872* 1874* 1876 1877* com_err_ 000054 constant entry external dcl 118 ref 2044 2044 comp_idx 001337 automatic fixed bin(17,0) dcl 1486 set ref 1495* 1496* 1502* 1503 1503 1503* complained_about_specific_acl 001504 automatic bit(1) dcl 1706 set ref 1778* 1782* 1786 convert_authorization_$to_string_short 000056 constant entry external dcl 119 ref 1833 copy builtin function dcl 174 ref 978 copy_flags based structure level 1 dcl 4-8 copy_matching_names parameter bit(1) dcl 1481 ref 1477 1511 count 2 based fixed bin(17,0) level 2 in structure "new_acl" dcl 409 in procedure "nonquick_common" set ref 1313 1348* 1407* 1407 1408 1409 1412 1423* 1423 1424 1425 1426 1458* 1465* 1465 1466 1467 1468 1512* 1512 1513 1514 1515 1517 count based fixed bin(17,0) level 2 in structure "entry_type" dcl 354 in procedure "nonquick_common" set ref 804 1119* 1123 1163* 1164 1182 1202 1212 count 2 based fixed bin(17,0) level 2 in structure "old_acl" dcl 408 in procedure "nonquick_common" set ref 1330* 1332 1411* 1411 1412 1499 count 2 based fixed bin(17,0) level 2 in structure "general_acl" dcl 1-7 in procedure "nonquick_common" set ref 1281 1327* 1330 1346* 1371* 1372* 1456* 1695* 1698 1779 1843 1859 1890 1911 2009 2024 cu_$af_return_arg_rel 000060 constant entry external dcl 121 ref 619 cu_$arg_list_ptr 000062 constant entry external dcl 122 ref 323 2041 cu_$arg_ptr_rel 000064 constant entry external dcl 123 ref 656 686 741 925 1075 cu_$generate_call 000066 constant entry external dcl 124 ref 2042 2044 cu_$level_get 000070 constant entry external dcl 125 ref 913 922 cv_acl_type_$create 000072 constant entry external dcl 126 ref 1999 2010 delete_acl_entry based structure level 1 dcl 1-63 dir_rings based fixed bin(3,0) array dcl 1801 set ref 1816* 1820* directory_acl_array based structure array level 1 dcl 1-55 directory_acl_entry based structure level 1 dcl 1-54 directory_sw 001016 automatic bit(1) initial dcl 430 set ref 430* 542 543 942* 949 951 952* 957 960* 972* 984 directory_val 001115 automatic fixed bin(17,0) initial dcl 598 set ref 598* 705* 715* 901 903 942 divide builtin function dcl 174 ref 633 dname 000131 automatic char(168) packed unaligned dcl 365 set ref 477* 480* 480* 488* 491* 491* 525* 556* 811* 813* 820* 836 841* 841* 850* 850* 896* 896* 1215* 1223* 1243* 1595* 1615* 1666* 1671* 1679* 1683* 1718* 1724* 1731* 1737* 1744* 1748* 1754* 1760* 1766* 1770* 1773* 1811* 1816* 1820* 1823* 1831* 1872* 1874* do_tedious_star 000742 automatic bit(1) dcl 382 set ref 476 513 801* 809* empty_acl_overlay 000772 automatic fixed bin(71,0) array dcl 415 set ref 1693 2090 ename 000203 automatic char(32) packed unaligned dcl 366 set ref 471* 480* 480* 488* 491* 491* 516* 522* 525* 556* 812* 813* 823* 825* 836 839* 841* 841* 850* 853* 855* 860 884 896* 896* 1241* 1595* 1615* 1666* 1671* 1679* 1683* 1718* 1724* 1731* 1737* 1744* 1748* 1754* 1760* 1766* 1770* 1773* 1811* 1816* 1820* 1823* 1831* 1872* 1874* 1881* 1886* 1891* ename_suffix 001142 automatic char(32) packed unaligned dcl 617 set ref 860* 861 866 873 885 887 890* entries 3 based structure array level 2 in structure "general_acl" dcl 1-7 in procedure "nonquick_common" set ref 1333 entries 3 based structure array level 2 in structure "old_acl" dcl 408 in procedure "nonquick_common" set ref 1333* entries 3 based structure array level 2 in structure "new_acl" dcl 409 in procedure "nonquick_common" entry_type based structure level 1 dcl 354 set ref 1119 entry_type_count 000123 automatic fixed bin(17,0) dcl 352 set ref 1111* 1115* 1119 1119 entry_type_list parameter char packed unaligned dcl 1085 ref 1083 1104 1107 1127 entry_type_no 001212 automatic fixed bin(17,0) dcl 1180 in procedure "entry_type_selected" set ref 1182* 1183* entry_type_no 000104 automatic fixed bin(17,0) dcl 1092 in procedure "process_entry_type_list" set ref 1129* 1133 1143 1144 1146* 1146 1163 entry_type_ptr 000124 automatic pointer dcl 353 set ref 530* 690* 804 804 804 1133 1143 1202 1203 1212 1213 1215 entry_type_struct_ptr parameter pointer dcl 1178 in procedure "entry_type_selected" ref 1175 1182 1183 entry_type_struct_ptr parameter pointer dcl 1086 in procedure "process_entry_type_list" set ref 1083 1119* 1123 1144 1163 1164 err_path 000602 automatic char(168) packed unaligned dcl 377 set ref 465* 525* 532* 536* 558* 1534* 1556 1556* 1597* 1607* 1647* 1686* 1783* 1786* 1805* 1815* 1825* 1832* 1834* 1839* 1877* 1914* error_table_$action_not_performed 000010 external static fixed bin(35,0) dcl 99 set ref 504* error_table_$active_function 000012 external static fixed bin(35,0) dcl 100 set ref 786* error_table_$bad_conversion 000014 external static fixed bin(35,0) dcl 101 ref 748 error_table_$bad_name 000016 external static fixed bin(35,0) dcl 102 set ref 1946* error_table_$bad_ring_brackets 000020 external static fixed bin(35,0) dcl 103 set ref 916* error_table_$badopt 000022 external static fixed bin(35,0) dcl 104 set ref 926* 1077* error_table_$inconsistent 000024 external static fixed bin(35,0) dcl 105 set ref 903* error_table_$noarg 000026 external static fixed bin(35,0) dcl 106 set ref 681* 728 790* 794* error_table_$noentry 000030 external static fixed bin(35,0) dcl 107 ref 1603 1816 error_table_$nomatch 000032 external static fixed bin(35,0) dcl 108 set ref 578* error_table_$nostars 000034 external static fixed bin(35,0) dcl 109 set ref 471* error_table_$not_seg_type 000040 external static fixed bin(35,0) dcl 111 ref 1224 1596 error_table_$notadir 000036 external static fixed bin(35,0) dcl 110 set ref 532* error_table_$root 000042 external static fixed bin(35,0) dcl 112 ref 818 836 error_table_$unsupported_operation 000044 external static fixed bin(35,0) dcl 113 ref 891 1603 error_table_$user_not_found 000046 external static fixed bin(35,0) dcl 114 ref 1913 expand_pathname_$add_suffix 000074 constant entry external dcl 127 ref 813 1215 explicit_dr_arg 001023 automatic bit(1) initial dcl 435 set ref 435* 550 942* explicit_sm_arg 001024 automatic bit(1) initial dcl 436 set ref 436* 550 941* extended_acl 32(01) 000224 automatic bit(1) level 3 packed packed unaligned dcl 369 set ref 893 1556* fcb_ptr 000762 automatic pointer initial dcl 398 set ref 398* 510* 556* 571 571* 2061 2061* flags 32 000224 automatic structure level 2 packed packed unaligned dcl 369 force_no_type 001012 automatic bit(1) initial dcl 426 set ref 426* 937* 1594 1677 1742 1764 1811 1872 freeing_ptr parameter pointer dcl 2078 set ref 2075 2087 2088* fs_type parameter char(32) packed unaligned dcl 1179 ref 1175 1183 fs_util_$get_ring_brackets 000130 constant entry external dcl 143 ref 1811 fs_util_$get_user_access_modes 000142 constant entry external dcl 150 ref 1874 fs_util_$list_acl 000144 constant entry external dcl 153 ref 1683 fs_util_$make_entry_for_type 000132 constant entry external dcl 144 ref 1678 fs_util_$replace_acl 000166 constant entry external dcl 165 ref 1748 1770 1773 fs_util_$suffix_info 000134 constant entry external dcl 145 ref 1223 1243 1595 fs_util_$suffix_info_for_type 000136 constant entry external dcl 146 ref 890 982 984 986 1145 1636 1639 1641 1642 1644 general_acl based structure level 1 dcl 1-7 set ref 1371 general_acl_entry based structure level 1 unaligned dcl 1-12 general_delete_acl_entry based structure level 1 dcl 1-35 general_extended_acl_entry based structure level 1 dcl 1-23 get_group_id_$tag_star 000076 constant entry external dcl 128 ref 866 868 873 875 992 get_system_free_area_ 000100 constant entry external dcl 129 ref 454 get_wdir_ 000102 constant entry external dcl 130 ref 669 703 797 given_comp 001340 automatic char(32) array dcl 1487 set ref 1494* 1496 1503 1503 given_name_idx 001320 automatic fixed bin(17,0) dcl 1438 in procedure "build_nonmatching_acl" set ref 1443* 1444* given_name_idx 001306 automatic fixed bin(17,0) dcl 1398 in procedure "build_matching_acl" set ref 1402* 1403* 1408 1409* have_mode 001137 automatic bit(1) dcl 614 set ref 653* 697 702* hcs_$get_access_class 000104 constant entry external dcl 131 ref 1831 hcs_$get_dir_ring_brackets 000106 constant entry external dcl 132 ref 1816 1820 hcs_$get_ring_brackets 000110 constant entry external dcl 133 ref 1815 1823 hcs_$get_user_access_modes 000140 constant entry external dcl 148 ref 1872 hcs_$list_dir_inacl 000150 constant entry external dcl 156 ref 1671 hcs_$list_inacl 000146 constant entry external dcl 155 ref 1666 hcs_$replace_acl 000154 constant entry external dcl 159 ref 1766 hcs_$replace_dir_acl 000152 constant entry external dcl 158 ref 1744 hcs_$replace_dir_inacl 000172 constant entry external dcl 169 ref 1724 hcs_$replace_inacl 000170 constant entry external dcl 167 ref 1718 hcs_$star_ 000112 constant entry external dcl 134 ref 477 488 hcs_$status_minf 000114 constant entry external dcl 135 ref 1615 hcs_type 000213 automatic fixed bin(2,0) dcl 367 set ref 1615* 1634 1642 hphcs_$replace_acl 000156 constant entry external dcl 160 ref 1754 hphcs_$replace_dir_acl 000160 constant entry external dcl 161 ref 1731 iacl_ring 000654 automatic fixed bin(3,0) dcl 378 set ref 628* 735 744* 746 910 915 916* 922* 1666* 1671* 1718* 1724* iacl_ring_arg 001116 automatic fixed bin(17,0) dcl 611 set ref 629* 723* iacl_sw 001013 automatic bit(1) initial dcl 427 set ref 427* 464* 532 722 752 969 1053 1534* 1594 1839* idx 001430 automatic fixed bin(17,0) dcl 1546 in procedure "convert_mode" set ref 1553* 1554* idx 001505 automatic fixed bin(17,0) dcl 1707 in procedure "replace_the_acl" set ref 1779* 1781 1783 1783 1783* idx 001103 automatic fixed bin(17,0) dcl 596 in procedure "process_arguments" set ref 951* 952 952 952* index builtin function dcl 174 ref 744 884 997 997 1111 1554 1943 installation_tools_$replace_acl 000162 constant entry external dcl 162 ref 1760 installation_tools_$replace_dir_acl 000164 constant entry external dcl 163 ref 1737 ioa_ 000116 constant entry external dcl 137 ref 448 1805 1826 1836 1853 1859 1881 1886 1891 is_std_type 11 based bit(1) array level 3 dcl 354 set ref 804 1133* 1143* 1203 1213 jdx 001431 automatic fixed bin(17,0) dcl 1546 set ref 1554* 1555 1560 length builtin function dcl 174 ref 746 997 1104 1553 1580 1847 1944 limit_entry_selections parameter bit(1) dcl 1087 set ref 1083 1151* 1164* 1166* limit_entry_types 000745 automatic bit(1) dcl 385 set ref 459* 530 690* 691 804 linkage_error 000000 stack reference condition dcl 172 ref 501 list_acl_entry 001472 automatic entry variable dcl 1659 set ref 1678* 1679 match_star_name_ 000120 constant entry external dcl 138 ref 1220 1241 matched_sw 001020 automatic bit(1) initial dcl 432 set ref 432* 553* 578 max builtin function dcl 174 ref 643 1853 1853 1881 1881 1891 1891 max_acl_modes 000767 automatic fixed bin(17,0) dcl 405 set ref 634* 635 max_acl_names 000765 automatic fixed bin(17,0) dcl 401 set ref 633* 634 639* 643* 643 644 648 max_mode_len 44 000224 automatic fixed bin(17,0) level 2 dcl 369 set ref 1853 1853 1881 1881 1886 1891 1891 min_ring 001102 automatic fixed bin(3,0) dcl 595 set ref 911* 913* 915 916* missing_component 001336 automatic bit(1) dcl 1485 set ref 1492* 1495 1496* 1532 mode 13 based bit(36) array level 3 in structure "general_acl" dcl 1-7 in procedure "nonquick_common" set ref 1379* 1783* 1848* 1853* 1891 1891* mode 001432 automatic bit(36) dcl 1546 in procedure "convert_mode" set ref 1552* 1560* 1563 mode 13 based bit(36) array level 3 in structure "old_acl" dcl 408 in procedure "nonquick_common" set ref 1426 1468 1517 mode 13 based bit(36) array level 3 in structure "new_acl" dcl 409 in procedure "nonquick_common" set ref 1409* 1426* 1468* 1515* 1517* mode_bits parameter bit(36) dcl 1571 ref 1568 1577 1581 mode_string parameter char(36) packed unaligned dcl 1546 in procedure "convert_mode" set ref 1543 1550 1550 1553 1554 1556* mode_string 001443 automatic varying char(36) dcl 1574 in procedure "mode_representation" set ref 1579* 1581* 1581 1585 modes 33 000224 automatic char(36) level 2 in structure "si" dcl 369 in procedure "nonquick_common" set ref 1554 1580 1581 modes 001533 automatic bit(36) dcl 1868 in procedure "print_accessible" set ref 1872* 1874* 1881 1881* msf_manager_$close 000122 constant entry external dcl 139 ref 571 2061 msf_manager_$open 000124 constant entry external dcl 140 ref 556 n_acl_modes 000766 automatic fixed bin(17,0) dcl 404 set ref 647* 772* 772 773 794 863 951 960 978 n_acl_names 000764 automatic fixed bin(17,0) dcl 400 set ref 646* 777* 777 778 863 865* 865 866 868 871 872* 991 1283 1292 1351 1370 1375 1402 1443 name_idx parameter fixed bin(17,0) dcl 1480 ref 1477 1494 1515 1534 nargs 001101 automatic fixed bin(17,0) dcl 594 set ref 619* 633 639 655 680 708 727 new_acl based structure level 1 dcl 409 set ref 1346 1456 new_acl_ptr 000754 automatic pointer initial dcl 395 set ref 395* 1313 1314 1315* 1346* 1348 1349 1407 1407 1408 1408 1409 1409 1412 1412 1423 1423 1424 1424 1425 1425 1426 1426 1455* 1456* 1458 1459 1465 1465 1466 1466 1467 1467 1468 1468 1512 1512 1513 1513 1514 1514 1515 1515 1517 1517 2056* nindex 0(18) based fixed bin(18,0) array level 2 packed packed unsigned unaligned dcl 2-27 ref 514 514 522 1218 1218 1237 1237 nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 2-27 ref 484 495 514 1218 1237 no_chase_sw 001004 automatic bit(1) initial dcl 420 set ref 420* 933* no_sysdaemon_sw 001014 automatic bit(1) initial dcl 428 set ref 428* 935* 944* 946* 1718* 1724* 1731* 1737* 1744* 1748* 1754* 1760* 1766* 1770* 1773* null builtin function dcl 174 ref 392 393 394 395 396 397 398 455 456 457 460 510 571 640 724 1098 1101 1315 1666 1671 1692 1713 1779 1839 2061 2068 2088 2092 num_ring_brackets 45 000224 automatic fixed bin(17,0) level 2 dcl 369 set ref 1808 1811 1815 1823 1826 1826 1826 1826 object_type 000214 automatic char(32) packed unaligned dcl 368 set ref 529* 530* 543 546 555 571 1665 1670 1678* 1715 1751 1814 1820 old_acl based structure level 1 dcl 408 set ref 1327 old_acl_ptr 000752 automatic pointer initial dcl 394 set ref 394* 1298* 1310* 1327* 1329 1330 1332 1333 1411 1411 1412 1412 1425 1426 1450 1467 1468 1499 1500 1513 1517 2055* old_acle_idx 001321 automatic fixed bin(17,0) dcl 1439 in procedure "build_nonmatching_acl" set ref 1448* 1450 1452* 1461* 1463 1467 1468* old_acle_idx 001307 automatic fixed bin(17,0) dcl 1399 in procedure "build_matching_acl" set ref 1420* 1422 1425 1426* old_acle_idx 001335 automatic fixed bin(17,0) dcl 1484 in procedure "match_acl" set ref 1499* 1500 1508 1509 1513 1517* operation 000111 automatic fixed bin(11,0) dcl 340 set ref 443* 452 565 565 566 567 631 631 650 672 696 752 759 779 785 790 790 794 818 836 847 863 871 903 903 911 924 944 946 950 960 975 1046 1050 1053 1271 1276 1283 1292 1296 1302 1304 1306 1308 1515 1532 1603 1611 1909 original_count 000770 automatic fixed bin(17,0) dcl 411 set ref 1281* 1292 1294 1420 1448 1461 1534 1839 other_acl_ptr 000756 automatic pointer initial dcl 396 set ref 396* 1662* 1666* 1671* 1690* 1713* 1718* 1724* 1731* 1737* 1744* 1754* 1760* 1766* 1775* 1999* 2010* 2025 2027 2057* pathname 000655 automatic char(204) packed unaligned dcl 379 set ref 578* 627* 665 669* 703 703* 768 768* 790 797 797* 813* 818 831* 850 1215* pathname_ 000126 constant entry external dcl 141 ref 480 480 491 491 525 841 841 850 896 896 plural_name 22 000224 automatic char(32) level 2 packed packed unaligned dcl 369 set ref 1556* privilege 000112 automatic fixed bin(12,0) dcl 341 set ref 444* 501 504 881 1729 1735 1752 1758 raw_val 001110 automatic fixed bin(17,0) initial dcl 598 set ref 598* 673* 675* 882 901 903 937 real_rings 001517 automatic fixed bin(3,0) array dcl 1800 set ref 1811 1815 1816 1820 1823 1826 1826 replace_sw 001006 automatic bit(1) initial dcl 422 set ref 422* 934* 944 1271 replace_val 001107 automatic fixed bin(17,0) initial dcl 598 set ref 598* 760* 761* 924 934 ret_str based varying char dcl 350 set ref 623* 1847 1847* 1847 1848* 1848 1849* 1849 1850* 1850 ret_str_lth 000122 automatic fixed bin(21,0) dcl 349 set ref 619* 623 1847 1848 1849 1850 ret_str_ptr 000120 automatic pointer dcl 348 set ref 619* 623 1847 1847 1847 1848 1848 1849 1849 1850 1850 reverse builtin function dcl 174 ref 860 860 ring_bracket_sw 001007 automatic bit(1) initial dcl 423 set ref 423* 938* 1807 ring_bracket_val 001111 automatic fixed bin(17,0) initial dcl 598 set ref 598* 753* 754* 938 rings based fixed bin(3,0) array dcl 1802 set ref 1811* 1815* 1823* 1826* 1826* rtrim builtin function dcl 174 ref 853 997 1553 1554 1580 1850 sc_access_name parameter char packed unaligned dcl 1926 set ref 1923 1937 1939* 1943 1944 1945 1946* 1952 1960 1962* 1967 1971 1972 1976* 1980 1981 1983 sc_component parameter char(32) array dcl 1926 set ref 1923 1936* 1938* 1960* 1961* 1961* 1967* 1968* 1971* 1972* 1974* 1980* 1981* 1983* sc_dot_count 001554 automatic fixed bin(17,0) initial dcl 1929 set ref 1929* 1953* 1953 1954 1955 1959 1965 sc_dot_loc 001556 automatic fixed bin(17,0) initial array dcl 1929 set ref 1929* 1929* 1955* 1966 1971 1972 1972 1972 1980 1980 1981 1981 1981 1981 1981 1983 1983 1983 sc_i 001560 automatic fixed bin(17,0) dcl 1929 set ref 1951* 1952 1955* sc_len 001561 automatic fixed bin(17,0) dcl 1929 set ref 1943* 1944 1944* 1945 1951 1962 1967 1972 1972 1976 1983 1983 search builtin function dcl 174 ref 861 952 960 segment_acl_array based structure array level 1 dcl 1-46 segment_acl_entry based structure level 1 dcl 1-45 segment_sw 001015 automatic bit(1) initial dcl 429 set ref 429* 542 546 941* 949 951 955* 957 957* 963* 971* segment_val 001114 automatic fixed bin(17,0) initial dcl 598 set ref 598* 706* 720* 901 903 941 si 000224 automatic structure level 1 dcl 369 set ref 890 890 982 982 984 984 986 986 1223 1223 1243 1243 1595 1595 1636 1636 1639 1639 1641 1641 1642 1642 1644 1644 standard_object 32 000224 automatic bit(1) level 3 packed packed unaligned dcl 369 set ref 893 1228 1244 1611 star_ALL_ENTRIES constant fixed bin(2,0) initial dcl 2-111 ref 472 star_BRANCHES_ONLY constant fixed bin(2,0) initial dcl 2-110 ref 474 star_entries based structure array level 1 dcl 2-27 star_entry_count 001031 automatic fixed bin(17,0) dcl 2-14 set ref 469* 477* 484 488* 495 509 1211 star_entry_idx 000740 automatic fixed bin(17,0) dcl 380 set ref 509* 514 514 514 522* star_entry_ptr 001032 automatic pointer dcl 2-15 set ref 456* 477* 484 488* 495 514 514 514 522 1218 1218 1218 1237 1237 1237 2067* star_idx 001222 automatic fixed bin(17,0) dcl 1195 set ref 1211* 1218 1218 1218 1237 1237 1237* star_match based bit(1) array packed unaligned dcl 362 set ref 496 497* 515 1207 1228* 1244* star_match_ptr 000126 automatic pointer dcl 360 set ref 460* 496* 497 515 1207* 1228 1244 2068 2068* star_name_count 000130 automatic fixed bin(17,0) dcl 361 set ref 484* 495* 496 497 1207 star_name_idx 000741 automatic fixed bin(17,0) dcl 381 set ref 514* 515 516* 1218* 1220 1223 1228* 1237* 1241 1243 1244* star_names based char(32) array packed unaligned dcl 2-37 set ref 516 522 1220* 1223* 1241* 1243* star_names_ptr 001034 automatic pointer dcl 2-19 set ref 455* 477* 488* 516 522 1220 1223 1241 1243 2066* star_select_sw 001036 automatic fixed bin(3,0) dcl 2-21 set ref 472* 474* 477 488 star_sw 000743 automatic bit(1) dcl 383 set ref 469 511 532 578 844* 848* 950 1597 1805 starname_suffix 001017 automatic bit(1) initial dcl 431 set ref 431* 861* 886 1611 status_code 14 based fixed bin(35,0) array level 3 in structure "general_acl" dcl 1-7 in procedure "nonquick_common" set ref 1380* 1781 1783* 1844 1912 1913 1914* 2025* 2027* status_code 14 based fixed bin(35,0) array level 3 in structure "new_acl" dcl 409 in procedure "nonquick_common" set ref 1424* 1466* 1514* status_code 12 based fixed bin(35,0) array level 2 in structure "segment_acl_array" dcl 1-46 in procedure "nonquick_common" ref 2027 status_code 11 based fixed bin(35,0) array level 2 in structure "directory_acl_array" dcl 1-55 in procedure "nonquick_common" ref 2025 std_type 001234 automatic bit(1) dcl 1198 set ref 1201* 1203* 1237 string builtin function dcl 174 set ref 497* substr builtin function dcl 174 set ref 546 887 997 1132 1554 1560* 1581 1581 1945 1952 1962* 1967 1971 1972 1976* 1980 1981 1983 suffix 1 based char(32) array level 3 dcl 354 set ref 804 1123* 1144* 1183 1215 suffix_info based structure level 1 dcl 3-12 suffixes 1 based structure array level 2 dcl 354 sum builtin function dcl 174 ref 484 495 sysdaemon_val 001112 automatic fixed bin(17,0) initial dcl 598 set ref 598* 762* 763* 924 925 925 935 system_area based area(1024) dcl 344 ref 496 635 644 1101 1105 1119 1150 1160 1207 1327 1346 1352 1371 1456 2092 system_area_ptr 000114 automatic pointer dcl 343 set ref 454* 477* 488* 496 635 644 1101 1105 1119 1150 1160 1207 1327 1346 1352 1371 1456 1666* 1671* 1679* 1683* 1999* 2010* 2092 temp_ename 001224 automatic char(32) packed unaligned dcl 1197 set ref 1215* 1220* this_type 000105 automatic char(32) packed unaligned dcl 1093 set ref 1131* 1132 1134 1139 1139* 1140 1140* 1141 1141* 1142 1142* 1144 1145* type 2 000224 automatic char(32) level 2 in structure "si" packed packed unaligned dcl 369 in procedure "nonquick_common" set ref 529 1637* type 000110 automatic fixed bin(10,0) dcl 339 in procedure "nonquick_common" set ref 442* 448 448 464 464 673 675 679 713 713 718 718 802 803 879 880 901 950 1053 1596 1596 1597 1634 1639 1665 1670 1716 1722 1839 type_idx 001223 automatic fixed bin(17,0) dcl 1196 set ref 1202* 1203* 1212* 1213 1215* type_info 000345 automatic structure level 1 dcl 370 set ref 1145 1145 type_name 001117 automatic char(32) packed unaligned dcl 612 in procedure "process_arguments" set ref 627* 689* 822 853 853 857 901 960 982 982* type_name 12 000224 automatic char(32) level 2 in structure "si" packed packed unaligned dcl 369 in procedure "nonquick_common" set ref 536* 1808* type_suffix 001127 automatic char(32) packed unaligned dcl 613 set ref 800* 802* 803* 804* 813* types based char packed unaligned dcl 1091 set ref 1101 1105 1107* 1111 1114* 1114 1127* 1130 1131 1150 1155* 1155 1160 types_len 000100 automatic fixed bin(24,0) dcl 1089 set ref 1101 1101 1104* 1105 1105 1107 1111 1114 1114 1127 1130 1131 1150 1150 1155 1155 1160 1160 types_ptr 000102 automatic pointer dcl 1090 set ref 1098* 1101 1101 1105* 1107 1111 1114 1114 1127 1130 1131 1150 1155 1155 1160 unspec builtin function dcl 174 set ref 1353* use_access_modes 001022 automatic bit(1) initial dcl 434 set ref 434* 993* 997* 1001* 1276 1871 used 001334 automatic bit(1) dcl 1483 set ref 1491* 1507* 1530 1532 used_bits based bit(1) array packed unaligned dcl 413 set ref 1352 1353* 1422 1452* 1463 1508 1509* used_bits_count 000771 automatic fixed bin(17,0) dcl 412 set ref 1351* 1352 1353 used_bits_ptr 000760 automatic pointer initial dcl 397 set ref 397* 1311* 1352* 1353 1422 1452 1463 1508 1509 2059* verify builtin function dcl 174 ref 1945 version based char(8) level 2 in structure "old_acl" dcl 408 in procedure "nonquick_common" set ref 1329* version 000345 automatic char(8) level 2 in structure "type_info" dcl 370 in procedure "nonquick_common" set ref 1128* version based char(8) level 2 in structure "general_acl" dcl 1-7 in procedure "nonquick_common" set ref 1373* 1694* version 000224 automatic char(8) level 2 in structure "si" dcl 369 in procedure "nonquick_common" set ref 889* 981* 1209* 1592* version based char(8) level 2 in structure "new_acl" dcl 409 in procedure "nonquick_common" set ref 1349* 1459* want_mode 001140 automatic bit(1) dcl 615 set ref 650* 652* 702* 771 774* 779* whoami 000100 automatic char(32) packed unaligned dcl 338 set ref 441* 448* 448 448 452 471* 480* 491* 504* 532* 536* 558* 578* 659* 666* 681* 692* 698* 729* 736* 786* 831* 841* 896* 903* 916* 926* 1046* 1046* 1050* 1050* 1053* 1053* 1057* 1057* 1077* 1135* 1534* 1556* 1597* 1607* 1647* 1686* 1783* 1786* 1808* 1825* 1832* 1834* 1839* 1877* 1914* 1946* xacl_allowed 000744 automatic bit(1) dcl 384 set ref 879* 880* 881* 882* 883* 884* 885* 886* 887* 891* 893* 950 967* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 1-77 DELETE_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 1-67 DIR_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 1-67 FS_OBJECT_TYPE_LINK internal static char(32) initial packed unaligned dcl 3-50 GENERAL_DELETE_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 1-72 GENERAL_EXTENDED_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 1-72 SEG_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 1-67 SWITCH_LIST_VERSION_1 internal static char(8) initial packed unaligned dcl 3-48 alloc_switch_count automatic fixed bin(17,0) dcl 3-33 alloc_switch_name_count automatic fixed bin(17,0) dcl 3-33 delete_acl based structure level 1 dcl 1-58 delete_acl_array based structure array level 1 dcl 1-64 directory_acl based structure level 1 dcl 1-49 general_delete_acl based structure level 1 dcl 1-30 general_extended_acl based structure level 1 dcl 1-18 segment_acl based structure level 1 dcl 1-40 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 2-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 2-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 2-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-112 star_SEGMENT internal static fixed bin(2,0) initial unsigned dcl 2-120 star_branch_count automatic fixed bin(17,0) dcl 2-13 star_dir_list_branch based structure array level 1 dcl 2-59 star_link_count automatic fixed bin(17,0) dcl 2-17 star_link_pathname based char packed unaligned dcl 2-102 star_links based structure array level 1 dcl 2-76 star_linkx automatic fixed bin(17,0) dcl 2-18 star_list_branch based structure array level 1 dcl 2-41 star_list_branch_ptr automatic pointer dcl 2-16 star_list_names based char(32) array packed unaligned dcl 2-92 star_list_names_ptr automatic pointer dcl 2-20 suffix_info_ptr automatic pointer dcl 3-10 switch_list based structure level 1 dcl 3-37 switch_list_ptr automatic pointer dcl 3-33 NAMES DECLARED BY EXPLICIT CONTEXT. ACL_COMMANDS_RETURN 001222 constant label dcl 209 ref 329 BADNAME 016437 constant label dcl 1946 ref 1954 BADOPT 007727 constant entry internal dcl 1063 ref 707 713 718 757 764 766 BAD_IACL_RING 005062 constant label dcl 729 ref 749 BAD_TYPE_ERROR 010410 constant label dcl 1150 ref 1146 CHECK_NEXT_GIVEN_NAME 011565 constant label dcl 1415 ref 1403 FOUND_MATCH 003454 constant label dcl 525 ref 517 MAIN_RETURN 004011 constant label dcl 580 ref 481 492 506 660 667 683 693 699 732 737 787 832 842 897 907 918 928 1059 1079 1136 1948 NEXT_STAR_NAME 011114 constant label dcl 1251 ref 1230 1247 NEXT_TYPE_NAME 010766 constant label dcl 1234 ref 1217 NOARG 004453 constant label dcl 681 ref 708 NULL_ARG 004216 constant label dcl 659 ref 687 742 SET_OPTION 007516 constant entry internal dcl 1009 ref 672 673 675 677 678 705 706 710 711 715 720 753 754 755 756 760 761 762 763 SKIP_MATCH 003735 constant label dcl 571 ref 538 559 1558 1600 1608 1611 1649 1687 1788 SKIP_NON_MATCH 003754 constant label dcl 574 ref 520 SKIP_THIS_ACLE 015644 constant label dcl 1856 ref 1844 SKIP_THIS_ONE 013143 constant label dcl 1647 ref 1616 TRY_NEXT_OLD_ACLE 012175 constant label dcl 1520 ref 1503 TRY_STD 010770 constant label dcl 1237 ref 1224 USAGE 007554 constant entry internal dcl 1039 ref 790 794 WRONG_TYPE 003510 constant label dcl 532 ref 543 546 550 acl_commands_ 001215 constant entry external dcl 39 allocate_new_acl 011312 constant entry internal dcl 1343 ref 1300 build_matching_acl 011474 constant entry internal dcl 1388 ref 1304 1306 1308 build_new_acl 011117 constant entry internal dcl 1258 ref 563 build_nonmatching_acl 011634 constant entry internal dcl 1435 ref 1302 build_replacement_acl 011347 constant entry internal dcl 1360 ref 1272 check_for_acle_errors 016234 constant entry internal dcl 1903 ref 569 cleanup_handler 017063 constant entry internal dcl 2051 ref 462 580 common 002463 constant entry internal dcl 299 ref 215 219 223 227 231 235 239 243 247 251 255 259 263 267 271 275 279 283 287 291 295 complain 017010 constant entry internal dcl 2035 ref 471 480 491 504 532 536 558 578 659 666 681 692 698 729 736 786 831 841 896 903 916 926 1046 1050 1053 1057 1077 1135 1534 1556 1597 1607 1647 1686 1783 1786 1808 1825 1832 1834 1839 1877 1914 1946 convert_mode 012274 constant entry internal dcl 1543 ref 988 1379 1409 1515 copy_acle_status 016745 constant entry internal dcl 2017 ref 1719 1726 1732 1739 1745 1755 1761 1767 da 001407 constant entry external dcl 225 delete_acl 001425 constant entry external dcl 225 delete_iacl_dir 002114 constant entry external dcl 265 delete_iacl_seg 002022 constant entry external dcl 257 deleteacl 001416 constant entry external dcl 225 did 002105 constant entry external dcl 265 dis 002013 constant entry external dcl 257 enlarge_old_acl 011242 constant entry internal dcl 1321 ref 1296 entry_type_selected 010466 constant entry internal dcl 1175 ref 530 free 017232 constant entry internal dcl 2075 ref 1310 1311 1336 1455 1662 1663 1690 1775 2054 2055 2056 2057 2059 2063 2064 2066 2067 2068 get_acl 013173 constant entry internal dcl 1656 ref 1280 get_suffix_info 012531 constant entry internal dcl 1588 ref 527 hp_delete_acl 001544 constant entry external dcl 233 hp_set_acl 001361 constant entry external dcl 221 hpda 001526 constant entry external dcl 233 hpdeleteacl 001535 constant entry external dcl 233 hpsa 001343 constant entry external dcl 221 hpsetacl 001352 constant entry external dcl 221 l_delete_acl 001500 constant entry external dcl 229 l_set_acl 001315 constant entry external dcl 217 la 002142 constant entry external dcl 269 lac 002372 constant entry external dcl 289 lda 001453 constant entry external dcl 229 ldelete_acl 001471 constant entry external dcl 229 ldeleteacl 001462 constant entry external dcl 229 lid 002243 constant entry external dcl 277 lis 002206 constant entry external dcl 273 list_accessible 002401 constant entry external dcl 289 list_acl 002160 constant entry external dcl 269 list_iacl_dir 002252 constant entry external dcl 277 list_iacl_seg 002215 constant entry external dcl 273 list_not_accessible 002436 constant entry external dcl 293 list_the_acl 014607 constant entry internal dcl 1796 ref 566 listacl 002151 constant entry external dcl 269 lnac 002427 constant entry external dcl 293 lsa 001270 constant entry external dcl 217 lset_acl 001306 constant entry external dcl 217 lsetacl 001277 constant entry external dcl 217 make_general_acl 016662 constant entry internal dcl 1993 ref 1667 1673 make_other_acl 016712 constant entry internal dcl 2005 ref 1717 1723 1730 1736 1743 1753 1759 1765 match_acl 011770 constant entry internal dcl 1477 ref 1403 1444 mbda 001721 constant entry external dcl 249 mbla 002335 constant entry external dcl 285 mbsa 001627 constant entry external dcl 241 mbx_delete_acl 001730 constant entry external dcl 249 mbx_list_acl 002344 constant entry external dcl 285 mbx_set_acl 001636 constant entry external dcl 241 mode_representation 012447 constant entry internal dcl 1568 ref 1783 1848 1853 1881 1891 modified_star_processing 010523 constant entry internal dcl 1190 ref 485 ms_delete_acl 001673 constant entry external dcl 245 ms_list_acl 002307 constant entry external dcl 281 ms_set_acl 001601 constant entry external dcl 237 msda 001664 constant entry external dcl 245 msla 002300 constant entry external dcl 281 mssa 001572 constant entry external dcl 237 nonquick_common 002504 constant entry internal dcl 333 ref 325 print_accessible 015661 constant entry internal dcl 1864 ref 567 process_arguments 004016 constant entry internal dcl 584 ref 467 process_entry_type_list 010013 constant entry internal dcl 1083 ref 690 replace_the_acl 013552 constant entry internal dcl 1703 ref 565 sa 001224 constant entry external dcl 213 set_acl 001242 constant entry external dcl 213 set_components 016331 constant entry internal dcl 1923 ref 1002 1376 1494 1500 set_iacl_dir 002057 constant entry external dcl 261 set_iacl_seg 001765 constant entry external dcl 253 setacl 001233 constant entry external dcl 213 sid 002050 constant entry external dcl 261 sis 001756 constant entry external dcl 253 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 21524 21720 20136 21534 Length 22470 20136 174 534 1365 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME acl_commands_ 102 external procedure is an external procedure. common internal procedure shares stack frame of external procedure acl_commands_. nonquick_common 1835 internal procedure enables or reverts conditions. on unit on line 462 64 on unit on unit on line 501 100 on unit process_arguments internal procedure shares stack frame of internal procedure nonquick_common. SET_OPTION internal procedure shares stack frame of internal procedure nonquick_common. USAGE internal procedure shares stack frame of internal procedure nonquick_common. BADOPT internal procedure shares stack frame of internal procedure nonquick_common. process_entry_type_list 116 internal procedure enables or reverts conditions. on unit on line 1099 64 on unit entry_type_selected internal procedure shares stack frame of internal procedure nonquick_common. modified_star_processing internal procedure shares stack frame of internal procedure nonquick_common. build_new_acl internal procedure shares stack frame of internal procedure nonquick_common. enlarge_old_acl internal procedure shares stack frame of internal procedure nonquick_common. allocate_new_acl internal procedure shares stack frame of internal procedure nonquick_common. build_replacement_acl internal procedure shares stack frame of internal procedure nonquick_common. build_matching_acl internal procedure shares stack frame of internal procedure nonquick_common. build_nonmatching_acl internal procedure shares stack frame of internal procedure nonquick_common. match_acl internal procedure shares stack frame of internal procedure nonquick_common. convert_mode internal procedure shares stack frame of internal procedure nonquick_common. mode_representation internal procedure shares stack frame of internal procedure nonquick_common. get_suffix_info internal procedure shares stack frame of internal procedure nonquick_common. get_acl internal procedure shares stack frame of internal procedure nonquick_common. replace_the_acl internal procedure shares stack frame of internal procedure nonquick_common. list_the_acl internal procedure shares stack frame of internal procedure nonquick_common. print_accessible internal procedure shares stack frame of internal procedure nonquick_common. check_for_acle_errors internal procedure shares stack frame of internal procedure nonquick_common. set_components internal procedure shares stack frame of internal procedure nonquick_common. make_general_acl internal procedure shares stack frame of internal procedure nonquick_common. copy_acle_status internal procedure shares stack frame of internal procedure nonquick_common. complain 76 internal procedure is declared options(variable). cleanup_handler 70 internal procedure is called by several nonquick procedures. free 68 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME acl_commands_ 000106 arg_list_ptr common complain 000100 arg_list_ptr complain free 000100 based_stuff_ptr free nonquick_common 000100 whoami nonquick_common 000110 type nonquick_common 000111 operation nonquick_common 000112 privilege nonquick_common 000114 system_area_ptr nonquick_common 000116 code nonquick_common 000120 ret_str_ptr nonquick_common 000122 ret_str_lth nonquick_common 000123 entry_type_count nonquick_common 000124 entry_type_ptr nonquick_common 000126 star_match_ptr nonquick_common 000130 star_name_count nonquick_common 000131 dname nonquick_common 000203 ename nonquick_common 000213 hcs_type nonquick_common 000214 object_type nonquick_common 000224 si nonquick_common 000345 type_info nonquick_common 000466 access_class nonquick_common 000470 access_name nonquick_common 000500 acl_mask nonquick_common 000501 buffer nonquick_common 000601 bit_count nonquick_common 000602 err_path nonquick_common 000654 iacl_ring nonquick_common 000655 pathname nonquick_common 000740 star_entry_idx nonquick_common 000741 star_name_idx nonquick_common 000742 do_tedious_star nonquick_common 000743 star_sw nonquick_common 000744 xacl_allowed nonquick_common 000745 limit_entry_types nonquick_common 000746 acl_names_ptr nonquick_common 000750 acl_modes_ptr nonquick_common 000752 old_acl_ptr nonquick_common 000754 new_acl_ptr nonquick_common 000756 other_acl_ptr nonquick_common 000760 used_bits_ptr nonquick_common 000762 fcb_ptr nonquick_common 000764 n_acl_names nonquick_common 000765 max_acl_names nonquick_common 000766 n_acl_modes nonquick_common 000767 max_acl_modes nonquick_common 000770 original_count nonquick_common 000771 used_bits_count nonquick_common 000772 empty_acl_overlay nonquick_common 001002 af_sw nonquick_common 001003 chase_sw nonquick_common 001004 no_chase_sw nonquick_common 001005 brief_sw nonquick_common 001006 replace_sw nonquick_common 001007 ring_bracket_sw nonquick_common 001010 access_class_sw nonquick_common 001011 all_sw nonquick_common 001012 force_no_type nonquick_common 001013 iacl_sw nonquick_common 001014 no_sysdaemon_sw nonquick_common 001015 segment_sw nonquick_common 001016 directory_sw nonquick_common 001017 starname_suffix nonquick_common 001020 matched_sw nonquick_common 001021 accessible nonquick_common 001022 use_access_modes nonquick_common 001023 explicit_dr_arg nonquick_common 001024 explicit_sm_arg nonquick_common 001026 acl_ptr nonquick_common 001030 acl_count nonquick_common 001031 star_entry_count nonquick_common 001032 star_entry_ptr nonquick_common 001034 star_names_ptr nonquick_common 001036 star_select_sw nonquick_common 001072 ap process_arguments 001074 ap1 process_arguments 001076 al process_arguments 001077 al1 process_arguments 001100 argno process_arguments 001101 nargs process_arguments 001102 min_ring process_arguments 001103 idx process_arguments 001104 all_val process_arguments 001105 chase_val process_arguments 001106 brief_val process_arguments 001107 replace_val process_arguments 001110 raw_val process_arguments 001111 ring_bracket_val process_arguments 001112 sysdaemon_val process_arguments 001113 access_class_val process_arguments 001114 segment_val process_arguments 001115 directory_val process_arguments 001116 iacl_ring_arg process_arguments 001117 type_name process_arguments 001127 type_suffix process_arguments 001137 have_mode process_arguments 001140 want_mode process_arguments 001141 all_stars process_arguments 001142 ename_suffix process_arguments 001200 ap BADOPT 001202 al BADOPT 001212 entry_type_no entry_type_selected 001222 star_idx modified_star_processing 001223 type_idx modified_star_processing 001224 temp_ename modified_star_processing 001234 std_type modified_star_processing 001256 acle_idx enlarge_old_acl 001274 acle_idx build_replacement_acl 001306 given_name_idx build_matching_acl 001307 old_acle_idx build_matching_acl 001320 given_name_idx build_nonmatching_acl 001321 old_acle_idx build_nonmatching_acl 001322 acle_matched build_nonmatching_acl 001334 used match_acl 001335 old_acle_idx match_acl 001336 missing_component match_acl 001337 comp_idx match_acl 001340 given_comp match_acl 001370 acle_comp match_acl 001430 idx convert_mode 001431 jdx convert_mode 001432 mode convert_mode 001442 bit_idx mode_representation 001443 mode_string mode_representation 001472 list_acl_entry get_acl 001504 complained_about_specific_acl replace_the_acl 001505 idx replace_the_acl 001516 acle_idx list_the_acl 001517 real_rings list_the_acl 001532 acle_idx print_accessible 001533 modes print_accessible 001544 acle_idx check_for_acle_errors 001554 sc_dot_count set_components 001556 sc_dot_loc set_components 001560 sc_i set_components 001561 sc_len set_components 001602 acle_idx copy_acle_status process_entry_type_list 000100 types_len process_entry_type_list 000102 types_ptr process_entry_type_list 000104 entry_type_no process_entry_type_list 000105 this_type process_entry_type_list THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_g_a r_e_as r_ne_as alloc_char_temp call_ent_var_desc call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry int_entry_desc reverse_cs set_chars_eis index_chars_eis op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. active_fnc_err_ check_star_name_$entry com_err_ convert_authorization_$to_string_short cu_$af_return_arg_rel cu_$arg_list_ptr cu_$arg_ptr_rel cu_$generate_call cu_$level_get cv_acl_type_$create expand_pathname_$add_suffix fs_util_$get_ring_brackets fs_util_$get_user_access_modes fs_util_$list_acl fs_util_$make_entry_for_type fs_util_$replace_acl fs_util_$suffix_info fs_util_$suffix_info_for_type get_group_id_$tag_star get_system_free_area_ get_wdir_ hcs_$get_access_class hcs_$get_dir_ring_brackets hcs_$get_ring_brackets hcs_$get_user_access_modes hcs_$list_dir_inacl hcs_$list_inacl hcs_$replace_acl hcs_$replace_dir_acl hcs_$replace_dir_inacl hcs_$replace_inacl hcs_$star_ hcs_$status_minf hphcs_$replace_acl hphcs_$replace_dir_acl installation_tools_$replace_acl installation_tools_$replace_dir_acl ioa_ match_star_name_ msf_manager_$close msf_manager_$open pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$active_function error_table_$bad_conversion error_table_$bad_name error_table_$bad_ring_brackets error_table_$badopt error_table_$inconsistent error_table_$noarg error_table_$noentry error_table_$nomatch error_table_$nostars error_table_$not_seg_type error_table_$notadir error_table_$root error_table_$unsupported_operation error_table_$user_not_found LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 39 001214 209 001222 213 001223 215 001247 217 001266 219 001322 221 001341 223 001366 225 001405 227 001432 229 001451 231 001505 233 001524 235 001551 237 001570 239 001606 241 001625 243 001643 245 001662 247 001700 249 001717 251 001735 253 001754 255 001772 257 002011 259 002027 261 002046 263 002064 265 002103 267 002121 269 002140 271 002165 273 002204 275 002222 277 002241 279 002257 281 002276 283 002314 285 002333 287 002351 289 002370 291 002406 293 002425 295 002443 2110 002462 299 002463 323 002465 325 002474 329 002502 333 002503 392 002511 393 002513 394 002514 395 002515 396 002516 397 002517 398 002520 418 002521 419 002522 420 002523 421 002524 422 002525 423 002526 424 002527 425 002530 426 002531 427 002532 428 002533 429 002534 430 002535 431 002536 432 002537 433 002540 434 002541 435 002542 436 002543 441 002544 442 002552 443 002554 444 002556 448 002560 452 002632 454 002643 455 002652 456 002654 457 002655 459 002656 460 002657 462 002660 464 002702 465 002712 467 002715 469 002716 471 002723 472 002753 474 002760 476 002762 477 002764 479 003032 480 003034 481 003102 484 003103 485 003127 486 003130 488 003131 490 003175 491 003177 492 003245 495 003246 496 003271 497 003300 501 003304 504 003323 506 003360 509 003363 510 003373 511 003375 513 003377 514 003401 515 003423 516 003430 517 003436 519 003437 520 003441 522 003442 525 003454 527 003474 529 003475 530 003500 532 003510 536 003545 538 003600 541 003601 542 003602 543 003607 545 003615 546 003616 549 003624 550 003625 553 003631 555 003633 556 003637 557 003664 558 003666 559 003714 563 003715 565 003716 566 003725 567 003731 569 003734 571 003735 574 003754 578 003756 580 004011 582 004015 584 004016 598 004017 619 004031 620 004051 621 004053 622 004055 623 004057 624 004060 625 004061 627 004062 628 004070 629 004072 631 004073 633 004100 634 004104 635 004105 636 004113 639 004114 640 004117 643 004121 644 004126 646 004134 647 004135 648 004136 650 004153 652 004161 653 004162 655 004163 656 004173 658 004214 659 004216 660 004242 663 004243 665 004267 666 004273 667 004325 669 004326 670 004340 672 004341 673 004360 675 004401 677 004417 678 004427 679 004436 680 004450 681 004453 683 004507 685 004510 686 004511 687 004532 689 004534 690 004540 691 004562 692 004565 693 004620 695 004621 696 004622 697 004625 698 004627 699 004662 702 004663 703 004666 705 004704 706 004715 707 004724 708 004732 709 004735 710 004736 711 004752 712 004765 713 004775 715 005005 716 005007 717 005010 718 005020 720 005030 721 005032 722 005033 723 005047 724 005051 725 005053 727 005054 728 005057 729 005062 732 005132 735 005133 736 005135 737 005170 740 005171 741 005172 742 005213 744 005215 746 005225 748 005231 749 005234 751 005235 752 005236 753 005243 754 005257 755 005272 756 005305 757 005320 758 005322 759 005323 760 005325 761 005341 762 005354 763 005367 764 005402 765 005404 766 005405 768 005410 771 005420 772 005422 773 005423 774 005433 775 005434 777 005435 778 005436 779 005446 781 005453 785 005455 786 005464 787 005501 790 005502 794 005521 797 005535 800 005553 801 005556 802 005557 803 005566 804 005574 808 005610 809 005611 811 005613 812 005616 813 005621 815 005651 818 005653 819 005665 820 005666 822 005671 823 005675 825 005706 827 005711 831 005712 832 005740 836 005741 839 005760 840 005775 841 006000 842 006046 844 006047 845 006052 847 006055 848 006060 850 006062 853 006106 855 006141 857 006145 860 006152 861 006177 863 006214 865 006222 866 006223 868 006267 871 006302 872 006311 873 006313 875 006352 879 006362 880 006370 881 006375 882 006402 883 006406 884 006412 885 006425 886 006433 887 006437 889 006445 890 006447 891 006472 893 006500 896 006514 897 006561 901 006562 903 006577 907 006664 910 006665 911 006667 913 006674 915 006703 916 006706 918 006741 920 006742 922 006743 924 006752 925 006763 926 007010 928 007043 931 007044 932 007047 933 007052 934 007055 935 007060 936 007063 937 007066 938 007071 939 007074 941 007077 942 007103 944 007107 946 007116 949 007123 950 007127 951 007140 952 007153 955 007204 956 007206 957 007210 959 007216 960 007217 963 007246 965 007250 967 007251 969 007252 971 007255 972 007256 975 007260 976 007263 978 007265 981 007273 982 007275 984 007326 986 007355 988 007401 991 007411 992 007413 993 007422 994 007424 996 007425 997 007431 1001 007473 1002 007475 1007 007515 1009 007516 1021 007520 1024 007531 1027 007535 1031 007544 1036 007553 1039 007554 1046 007556 1050 007610 1053 007641 1057 007700 1059 007726 1063 007727 1075 007731 1077 007757 1079 010011 1083 010012 1098 010026 1099 010030 1101 010044 1102 010056 1104 010057 1105 010065 1107 010075 1111 010104 1114 010123 1115 010146 1119 010151 1123 010165 1127 010206 1128 010215 1129 010221 1130 010223 1131 010232 1132 010242 1133 010246 1134 010253 1135 010260 1136 010305 1139 010310 1140 010320 1141 010330 1142 010340 1143 010350 1144 010351 1145 010360 1146 010403 1148 010407 1150 010410 1151 010415 1152 010417 1155 010420 1156 010445 1160 010446 1163 010453 1164 010460 1166 010463 1168 010465 1175 010466 1182 010470 1183 010501 1184 010516 1185 010520 1190 010523 1201 010524 1202 010525 1203 010535 1205 010542 1207 010544 1209 010553 1211 010555 1212 010565 1213 010575 1215 010600 1217 010636 1218 010640 1220 010661 1221 010707 1223 010711 1224 010745 1228 010751 1230 010763 1232 010764 1234 010766 1237 010770 1241 011013 1242 011041 1243 011043 1244 011077 1247 011111 1249 011112 1251 011114 1253 011116 1258 011117 1271 011120 1272 011125 1273 011126 1276 011127 1280 011134 1281 011135 1283 011140 1292 011146 1294 011155 1296 011157 1298 011164 1300 011165 1302 011166 1304 011173 1306 011202 1308 011211 1310 011217 1311 011225 1313 011233 1314 011236 1315 011237 1317 011241 1321 011242 1327 011243 1329 011254 1330 011257 1332 011262 1333 011271 1334 011301 1336 011303 1338 011311 1343 011312 1346 011313 1348 011324 1349 011325 1351 011330 1352 011333 1353 011342 1355 011346 1360 011347 1370 011350 1371 011352 1372 011363 1373 011365 1375 011370 1376 011377 1378 011435 1379 011451 1380 011466 1381 011471 1383 011473 1388 011474 1402 011476 1403 011505 1406 011514 1407 011520 1408 011522 1409 011535 1411 011550 1412 011552 1415 011565 1418 011567 1420 011574 1422 011603 1423 011610 1424 011612 1425 011615 1426 011626 1428 011631 1430 011633 1435 011634 1443 011635 1444 011645 1446 011651 1448 011653 1450 011665 1452 011675 1453 011702 1455 011704 1456 011712 1458 011723 1459 011724 1461 011727 1463 011737 1465 011744 1466 011746 1467 011751 1468 011762 1470 011765 1472 011767 1477 011770 1491 011772 1492 011773 1494 011774 1495 012015 1496 012025 1497 012035 1499 012037 1500 012047 1502 012070 1503 012075 1505 012111 1507 012113 1508 012115 1509 012123 1511 012126 1512 012132 1513 012134 1514 012147 1515 012150 1517 012171 1520 012175 1530 012177 1532 012205 1534 012216 1538 012270 1543 012274 1550 012276 1552 012311 1553 012312 1554 012331 1555 012356 1556 012357 1558 012435 1560 012436 1561 012441 1563 012443 1568 012447 1577 012451 1579 012461 1580 012462 1581 012501 1583 012517 1585 012521 1588 012531 1592 012532 1594 012534 1595 012541 1596 012570 1597 012601 1600 012642 1603 012643 1606 012653 1607 012655 1608 012703 1611 012704 1612 012714 1615 012715 1616 012754 1634 012756 1636 012766 1637 013011 1638 013014 1639 013015 1641 013043 1642 013067 1644 013116 1646 013141 1647 013143 1649 013171 1653 013172 1656 013173 1662 013174 1663 013202 1665 013210 1666 013221 1667 013266 1668 013273 1670 013274 1671 013301 1673 013346 1674 013353 1677 013354 1678 013356 1679 013405 1681 013440 1683 013441 1685 013475 1686 013477 1687 013525 1690 013526 1692 013534 1693 013540 1694 013542 1695 013545 1698 013546 1700 013551 1703 013552 1713 013553 1715 013555 1716 013561 1717 013564 1718 013571 1719 013632 1720 013637 1722 013640 1723 013642 1724 013647 1726 013710 1727 013715 1729 013716 1730 013721 1731 013726 1732 013763 1733 013770 1735 013771 1736 013773 1737 014000 1739 014035 1740 014042 1742 014043 1743 014045 1744 014052 1745 014107 1746 014114 1748 014115 1749 014146 1751 014147 1752 014153 1753 014156 1754 014163 1755 014220 1756 014225 1758 014226 1759 014230 1760 014235 1761 014272 1762 014277 1764 014300 1765 014302 1766 014307 1767 014344 1768 014351 1770 014352 1771 014403 1773 014404 1775 014435 1777 014443 1778 014445 1779 014446 1781 014463 1782 014470 1783 014472 1785 014553 1786 014555 1788 014605 1791 014606 1796 014607 1805 014610 1807 014631 1808 014633 1811 014665 1814 014725 1815 014731 1816 014770 1818 015020 1820 015021 1823 015053 1825 015110 1826 015142 1830 015214 1831 015216 1832 015243 1833 015273 1834 015314 1835 015344 1836 015353 1839 015372 1843 015445 1844 015455 1846 015462 1847 015464 1848 015476 1849 015522 1850 015531 1851 015571 1853 015572 1856 015644 1859 015646 1861 015660 1864 015661 1871 015662 1872 015664 1874 015732 1876 015775 1877 015777 1878 016031 1881 016032 1883 016075 1885 016076 1886 016100 1887 016130 1890 016131 1891 016141 1895 016231 1897 016233 1903 016234 1909 016235 1911 016241 1912 016251 1913 016257 1914 016265 1916 016326 1918 016330 1923 016331 1929 016342 1936 016352 1937 016370 1938 016376 1939 016401 1940 016404 1943 016405 1944 016415 1945 016422 1946 016437 1948 016470 1951 016471 1952 016501 1953 016507 1954 016510 1955 016513 1957 016516 1959 016520 1960 016522 1961 016531 1962 016537 1963 016543 1965 016544 1966 016546 1967 016551 1968 016561 1969 016564 1971 016565 1972 016574 1974 016605 1976 016610 1977 016614 1980 016615 1981 016627 1983 016645 1987 016661 1993 016662 1999 016664 2001 016711 2005 016712 2009 016714 2010 016717 2012 016744 2017 016745 2024 016747 2025 016757 2027 016774 2028 017004 2030 017006 2035 017007 2041 017015 2042 017023 2044 017044 2046 017061 2051 017062 2054 017070 2055 017100 2056 017110 2057 017120 2059 017130 2061 017140 2063 017154 2064 017164 2066 017174 2067 017204 2068 017214 2070 017230 2075 017231 2087 017237 2088 017243 2090 017245 2092 017254 2094 017262 ----------------------------------------------------------- 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