COMPILATION LISTING OF SEGMENT imft_util_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-05-04_1651.43_Thu_mdt Options: optimize map 1 /****^ ******************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* ******************************************** */ 6 7 /* format: style1,^inddcls,insnl,delnl,indend,indnoniterend,indbeginend,indthenbeginend,tree,^case */ 8 9 /****^ HISTORY COMMENTS: 10* 1) change(88-08-11,Beattie), approve(88-08-01,MCR7948), 11* audit(88-10-11,Farley), install(88-10-14,MR12.2-1165): 12* Created to support IMFT access checking. 13* 2) change(88-10-26,Beattie), approve(88-08-01,PBF7948), 14* audit(88-10-27,Farley), install(88-10-27,MR12.2-1195): 15* Changed check_object_acl entry to be able to chase nonstar links. 16* END HISTORY COMMENTS */ 17 18 imft_util_: 19 procedure; 20 21 return; /* not an entry point */ 22 23 check_object_acl: 24 entry (p_check_acl_ptr, p_code); 25 26 ME = "imft_util_$check_object_acl"; 27 checking_subtree = "0"b; 28 29 afs_ptr = null (); 30 star_optionsP = null (); 31 on cleanup call CLEANUP (); 32 33 call init_check_acl (); 34 35 star_paths.value (1) = pathname_ ((imft_check_acl.dirname), (imft_check_acl.ename)); 36 star_options.entry_type.links = ENTRY_RETURN | ENTRY_CHASE_NONSTAR_LINKS; 37 star_options.entry_type.dirs = ENTRY_RETURN | ENTRY_DONT_LIST_SUBENTRIES; 38 go to COMMON; 39 40 check_subtree_acl: 41 entry (p_check_acl_ptr, p_code); 42 43 ME = "imft_util_$check_subtree_acl"; 44 checking_subtree = "1"b; 45 46 afs_ptr = null (); 47 star_optionsP = null (); 48 on cleanup call CLEANUP (); 49 50 call init_check_acl (); 51 52 /**** Set up file to collect error messages */ 53 54 call expand_pathname_ ((imft_check_acl.accessfile_pathname), accessfile_dname, accessfile_ename, ignore_code); 55 call hcs_$truncate_file (accessfile_dname, accessfile_ename, 0, ignore_code); 56 call hcs_$set_bc (accessfile_dname, accessfile_ename, 0, ignore_code); 57 call ioa_$rsnnl ("vfile_ ^a -extend -ssf", attach_desc, message_len, accessfile_pathname); 58 call iox_$find_iocb ("accessfile_switch", afs_ptr, code); 59 if code ^= 0 60 then do; 61 call convert_status_code_ (code, shortinfo, longinfo); 62 call ioa_$rsnnl ("Tried to find an IOCB for accessfile switch.^/(^a)", 63 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, longinfo); 64 p_code = code; 65 go to BAIL_OUT; 66 end; 67 68 call iox_$attach_ptr (afs_ptr, attach_desc, (null ()), code); 69 if code ^= 0 70 then do; 71 call convert_status_code_ (code, shortinfo, longinfo); 72 call ioa_$rsnnl ("Tried to attach vfile_ to ^a^/(^a)", 73 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, accessfile_pathname, 74 longinfo); 75 p_code = code; 76 go to BAIL_OUT; 77 end; 78 79 call iox_$open (afs_ptr, Stream_output, "0"b, code); 80 if code ^= 0 81 then do; 82 call convert_status_code_ (code, shortinfo, longinfo); 83 call ioa_$rsnnl ("Tried to open accessfile_switch to ^a^/(^a)", 84 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, accessfile_pathname, 85 longinfo); 86 p_code = code; 87 go to BAIL_OUT; 88 end; 89 90 star_paths.value (1) = pathname_ ((imft_check_acl.dirname), rtrim (imft_check_acl.ename) || ">**"); 91 star_options.entry_type.links = ENTRY_DONT_RETURN; 92 star_options.entry_type.dirs = ENTRY_RETURN | ENTRY_LIST_SUBENTRIES; 93 94 COMMON: 95 call fs_star_$select (star_optionsP, star_dataP, code); 96 if code ^= 0 97 then do; 98 imft_check_acl.allow_transfer = "0"b; 99 call convert_status_code_ (code, shortinfo, longinfo); 100 call ioa_$rsnnl ("^a: Error while checking access to objects in subtree.^/(^a)", 101 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, ME, longinfo); 102 p_code = code; 103 go to BAIL_OUT; 104 end; 105 106 BAIL_OUT: 107 call CLEANUP (); 108 109 RETURN: 110 return; 111 112 /**** 113* This is called by fs_star_ for each object it was directed to find. 114**/ 115 116 check_fs_entry: 117 proc (P_star_data_ptr, Pdir, Pent, Pcomp, Paction); 118 119 dcl P_star_data_ptr pointer; 120 dcl Pdir char (*); 121 dcl Pent (*) char (32) parm; 122 dcl Pcomp char (*) parm; 123 dcl Paction fixed bin parm; 124 125 dcl access_error bit (1); 126 dcl code fixed bin (35); 127 dcl local_dirname char (168); 128 dcl local_ename char (32); 129 dcl local_pathname char (168); 130 dcl my_access_ok bit (1); 131 dcl user_access_ok bit (1); 132 133 star_dataP = P_star_data_ptr; 134 local_dirname = Pdir; 135 local_ename = Pent (1); 136 local_pathname = pathname_ (local_dirname, local_ename); 137 Paction = HANDLER_OK; /* unless a problem is found */ 138 139 general_acl.status_code = 0; 140 141 if ^checking_subtree /* let caller know what type object this is */ 142 then imft_check_acl.type = star_data.type; /* unless checking a subtree */ 143 144 /**** Check ring brackets. */ 145 146 if star_data.type = ENTRY_TYPE_DIRECTORY | star_data.type = ENTRY_TYPE_DM_FILE | star_data.type = ENTRY_TYPE_MSF 147 then do; 148 call hcs_$get_dir_ring_brackets (local_dirname, local_ename, dir_ring_brackets, code); 149 if code = 0 150 then do; 151 if ^checking_subtree 152 then imft_check_acl.object_ring = dir_ring_brackets (1); 153 154 if imft_check_acl.effective_ring > dir_ring_brackets (1) 155 then code = error_table_$lower_ring; 156 end; 157 end; /* if star_data.type in set of directories */ 158 159 else do; 160 call hcs_$get_ring_brackets (local_dirname, local_ename, seg_ring_brackets, code); 161 if code = 0 162 then do; 163 if ^checking_subtree 164 then imft_check_acl.object_ring = seg_ring_brackets (1); 165 166 if imft_check_acl.effective_ring > seg_ring_brackets (1) 167 then code = error_table_$lower_ring; 168 end; 169 end; /* if star_data.type not in set of directories */ 170 171 if code ^= 0 172 then do; 173 general_acl (imft_check_acl.bad_acl_idx).status_code = code; 174 call set_error_message (); 175 return; 176 end; 177 178 /**** Check ACL of object. */ 179 180 if star_data.type = ENTRY_TYPE_DIRECTORY 181 then do; 182 access_str = DIR_ACCESS_MODE_NAMES (bin (imft_check_acl.dir_access)); 183 test_access = imft_check_acl.dir_access; 184 end; 185 else do; 186 access_str = SEG_ACCESS_MODE_NAMES (bin (imft_check_acl.seg_access)); 187 test_access = imft_check_acl.seg_access; 188 end; 189 190 call fs_util_$list_acl (local_dirname, local_ename, GENERAL_ACL_VERSION_1, null (), imft_check_acl.gen_acl_ptr, 191 code); 192 if code ^= 0 193 then do; 194 imft_check_acl.error_code = code; 195 call set_error_message (); 196 return; 197 end; 198 199 access_error = "0"b; 200 do acl_idx = 1 to hbound (general_acl.mode, 1); 201 code = 0; 202 if general_acl (acl_idx).status_code ^= 0 /* Person.Project is not present */ 203 then code = general_acl (acl_idx).status_code; 204 205 else if (general_acl (acl_idx).mode & test_access) ^= test_access 206 /* explicitly denied access */ 207 then general_acl (acl_idx).status_code, code = error_table_$moderr; 208 imft_check_acl.bad_acl_idx = acl_idx; /* record current pass, it may be last one */ 209 if code ^= 0 210 then call set_error_message (); 211 end; /* loop on acl_idx */ 212 213 if access_error 214 then return; 215 216 /**** Check AIM of object. */ 217 218 if imft_check_acl.check_aim 219 then do; 220 221 call hcs_$get_access_class (local_dirname, local_ename, local_obj_access_class, code); 222 if code ^= 0 223 then do; 224 call convert_status_code_ (code, shortinfo, longinfo); 225 call ioa_$rsnnl ( 226 "^[^/^]Access error: ^a^/Attempting to determine access class of^[^/^2x^a^; object.^]", 227 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, 228 checking_subtree, longinfo, checking_subtree, local_pathname); 229 call process_error (); 230 end; 231 232 my_access_ok = aim_check_$greater_or_equal (imft_check_acl.sys_auth_ceiling, local_obj_access_class); 233 if my_access_ok 234 then my_access_ok = 235 aim_check_$greater_or_equal (local_obj_access_class, imft_check_acl.sys_auth_floor); 236 if ^my_access_ok 237 then do; /* access class exceeds maximum allowed for transfer */ 238 object_access_class_text, max_access_class_text = ""; 239 call convert_authorization_$to_string_short (local_obj_access_class, 240 object_access_class_text, ignore_code); 241 call convert_authorization_$to_string_short (imft_check_acl.sys_auth_ceiling, 242 max_access_class_text, ignore_code); 243 call convert_authorization_$to_string_short (imft_check_acl.sys_auth_floor, 244 min_access_class_text, ignore_code); 245 imft_check_acl.bad_acl_idx = DRIVER_ACL_IDX; 246 general_acl (DRIVER_ACL_IDX).status_code, code = error_table_$ai_restricted; 247 call convert_status_code_ (code, shortinfo, longinfo); 248 call ioa_$rsnnl ( 249 "^[^/^]Access error: ^a^/^2xAccess class of object (^[^a^;^ssystem_low^]) is not within the range permitted for transfer to ^a (^[^a^;^ssystem_low^]:^[^a^;^ssystem_low^])^[^/^2x^a^;^s.^]", 250 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, 251 checking_subtree, longinfo, (object_access_class_text ^= ""), object_access_class_text, 252 imft_check_acl.foreign_sys_name, (min_access_class_text ^= ""), min_access_class_text, 253 (max_access_class_text ^= ""), max_access_class_text, checking_subtree, local_pathname) 254 ; 255 call process_error (); 256 end; 257 258 /**** Check AIM of user with object. */ 259 260 user_access_ok = aim_check_$greater_or_equal (imft_check_acl.user_auth, local_obj_access_class); 261 if ^user_access_ok 262 then do; /* AIM strikes again */ 263 imft_check_acl.bad_acl_idx = USER_ACL_IDX; 264 general_acl (USER_ACL_IDX).status_code, code = error_table_$ai_restricted; 265 call convert_status_code_ (code, shortinfo, longinfo); 266 user_authorization_text = ""; 267 call convert_authorization_$to_string_short (imft_check_acl.user_auth, 268 user_authorization_text, ignore_code); 269 call ioa_$rsnnl ( 270 "^[^/^]Access error: ^a^/^2x^a (at authorization ^[^a^;^ssystem_low^]) can not ^[examine^;read^]^[^/^2x^a^;^s object.^]", 271 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, 272 checking_subtree, longinfo, general_acl (USER_ACL_IDX).access_name, 273 (user_authorization_text ^= ""), user_authorization_text, 274 (star_data.type = ENTRY_TYPE_DIRECTORY), checking_subtree, local_pathname); 275 call process_error (); 276 end; 277 278 if access_error 279 then return; 280 end; /* if imft_check_acl.check_aim */ 281 282 imft_check_acl.objects_to_transfer = "1"b; 283 return; 284 285 /**** 286* This is called by fs_star_ to indicate that some error occured in 287* accessing the indicated object. Any call to this routine is considered 288* an access failure and the IMFT request is not to be processed. 289**/ 290 291 analyze_fs_error: 292 entry (P_star_data_ptr, Pdir, Pent, Pcomp, Pcode, Pmessage, Paction); 293 294 dcl Pcode fixed bin (35) parameter; 295 dcl Pmessage char (*) parameter; 296 297 dcl local_path char (168); 298 299 Paction = ERROR_REJECT; 300 code = Pcode; 301 call convert_status_code_ (code, shortinfo, longinfo); 302 303 if Pent (1) = "" 304 then local_path = Pdir; 305 else local_path = pathname_ (Pdir, Pent (1)); 306 307 call ioa_$rsnnl ("^a: Error from fs_star_ ERROR handler while processing:^/^2x^a^/^2x^a^[^/^2x(^a)^]", 308 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, ME, local_path, longinfo, 309 (Pmessage ^= ""), Pmessage); 310 call process_error (); 311 return; 312 313 /**** 314* Internal routine to set up an appropriate error message. 315**/ 316 317 set_error_message: 318 proc; 319 320 call convert_status_code_ (code, shortinfo, longinfo); 321 bad_access_name = general_acl (imft_check_acl.bad_acl_idx).access_name; 322 323 if substr (star_data.type, 1, 1) = "-" 324 then object_type = substr (star_data.type, 2); 325 else object_type = star_data.type; 326 327 if code = error_table_$user_not_found 328 then call ioa_$rsnnl ( 329 "^[^/^]Access error: ^a^/^2xAn explicit ACL entry for ^[Driver^;User^] (^a)^[^/^2xmust appear on ^a^; must appear on object.^]", 330 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, checking_subtree, longinfo, 331 (imft_check_acl.bad_acl_idx = DRIVER_ACL_IDX), bad_access_name, checking_subtree, local_pathname); 332 else if code = error_table_$moderr 333 then call ioa_$rsnnl ( 334 "^[^/^]Access error: ^a^/^2xAccess mode ^a must be given in ACL entry for ^[Driver^;User^] (^a)^[^/^2xwhich appears on ^a^; which appears on object.^]", 335 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, checking_subtree, 336 longinfo, access_str, (imft_check_acl.bad_acl_idx = DRIVER_ACL_IDX), bad_access_name, 337 checking_subtree, local_pathname); 338 else if code = error_table_$lower_ring 339 then call ioa_$rsnnl ( 340 "^[^/^]Access error: ^a^/^2xThe ^a object cannot be transfered because ring brackets less than user execution ring.^[^/^2x^a^]", 341 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, checking_subtree, 342 longinfo, object_type, checking_subtree, local_pathname); 343 else call ioa_$rsnnl ( 344 "^[^/^]Access error: ^a^/^2xDetermining driver (^a) and user (^a)^[^/^2xaccess to: ^a^; access to object.^]", 345 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, checking_subtree, message_len, 346 longinfo, general_acl (DRIVER_ACL_IDX).access_name, general_acl (USER_ACL_IDX).access_name, 347 checking_subtree, local_pathname); 348 349 call process_error (); 350 351 end set_error_message; 352 353 /**** Internal routine to process error code and set up for return. */ 354 355 process_error: 356 proc; 357 358 dcl buffer character (512); 359 dcl iox_code fixed bin (35); 360 361 Paction = HANDLER_DONT_EXPAND; 362 access_error = "1"b; 363 364 if checking_subtree 365 then do; /* collect errors to send as mail */ 366 buffer = imft_check_acl (imft_check_acl.bad_acl_idx).error_message; 367 call iox_$put_chars (afs_ptr, addr (buffer), message_len, iox_code); 368 if iox_code ^= 0 369 then do; 370 call ioa_$rsnnl ("^a: Tried to write to ^a", 371 imft_check_acl (imft_check_acl.bad_acl_idx).error_message, message_len, ME, 372 imft_check_acl.accessfile_pathname); 373 p_code = iox_code; 374 go to BAIL_OUT; 375 end; 376 end; /* if checking_subtree */ 377 378 if code ^= 0 379 then if code = error_table_$lower_ring 380 then imft_check_acl.found_inner_ring_object = "1"b; 381 else imft_check_acl.allow_transfer = "0"b; 382 383 end process_error; 384 385 end check_fs_entry; 386 387 init_check_acl: 388 proc; 389 imft_check_acl_ptr = p_check_acl_ptr; 390 391 if imft_check_acl.version ^= IMFT_CHECK_ACL_VERSION_1 392 then do; /* cannot use this structure for error messages, etc */ 393 /* caller will have to special case */ 394 p_code = error_table_$unimplemented_version; 395 go to RETURN; 396 end; 397 398 code, p_code = 0; /* for now */ 399 400 call fs_star_$init (null (), ME, "", STAR_OPTIONS_VERSION_1, star_optionsP, code); 401 if code ^= 0 402 then do; 403 imft_check_acl.allow_transfer = "0"b; 404 call convert_status_code_ (code, shortinfo, longinfo); 405 call ioa_$rsnnl ("^a: Error from fs_star_$init: ^a", imft_check_acl.error_message, message_len, ME, 406 longinfo); 407 p_code = code; 408 go to BAIL_OUT; 409 end; 410 411 star_paths.version = STAR_PATHS_VERSION_1; 412 star_paths.count = 1; 413 star_options.entry_type.segs = ENTRY_RETURN; 414 star_options.entry_type.archives = ENTRY_RETURN; 415 star_options.entry_type.msfs = ENTRY_RETURN; 416 star_options.entry_type.msf_comps = ENTRY_DONT_RETURN; 417 star_options.entry_type.dm_files = ENTRY_RETURN | ENTRY_INASE; 418 star_options.entry_type.extended_entries = ENTRY_RETURN | ENTRY_INASE; 419 star_options.entry_type.arch_comps = ENTRY_DONT_RETURN; 420 star_options.extended_entry_typesP = null (); 421 star_options.match_namesP = null (); 422 star_options.exclude_namesP = null (); 423 star_options.sorting = SORT_OFF; 424 star_options.handler = check_fs_entry; 425 star_options.error = analyze_fs_error; 426 star_options.handler_dataP = null (); 427 imft_check_acl.allow_transfer = "1"b; 428 imft_check_acl.objects_to_transfer = "0"b; 429 imft_check_acl.found_inner_ring_object = "0"b; 430 imft_check_acl.error_code = 0; 431 imft_check_acl.error_message = ""; 432 acl_ptr = imft_check_acl.gen_acl_ptr; 433 434 end init_check_acl; 435 436 CLEANUP: 437 proc; 438 439 if star_optionsP ^= null () 440 then do; 441 call fs_star_$term (star_optionsP); 442 star_optionsP = null (); 443 end; 444 445 if afs_ptr ^= null () 446 then do; 447 call iox_$close (afs_ptr, ignore_code); 448 call iox_$detach_iocb (afs_ptr, ignore_code); 449 afs_ptr = null (); 450 end; 451 452 end CLEANUP; 453 454 455 dcl p_check_acl_ptr pointer parameter; 456 dcl p_code fixed bin (35) parameter; 457 458 dcl ME char (32); 459 dcl access_str character (4); 460 dcl accessfile_dname char (168) static; 461 dcl accessfile_ename char (32) static; 462 dcl acl_idx fixed bin; 463 dcl addr builtin; 464 dcl attach_desc char (80); 465 dcl afs_ptr pointer; 466 dcl bad_access_name character (32); 467 dcl bin builtin; 468 dcl checking_subtree bit (1); 469 dcl cleanup condition; 470 dcl code fixed binary (35); 471 dcl dir_ring_brackets (2) fixed bin (3); 472 dcl hbound builtin; 473 dcl ignore_code fixed bin (35); 474 dcl local_obj_access_class bit (72) aligned; 475 dcl longinfo char (100) aligned; 476 dcl max_access_class_text character (256); 477 dcl message_len fixed bin (21); 478 dcl min_access_class_text character (256); 479 dcl null builtin; 480 dcl object_access_class_text 481 character (256); 482 dcl object_type character (32); 483 dcl rtrim builtin; 484 dcl seg_ring_brackets (3) fixed bin (3); 485 dcl shortinfo character (8) aligned; 486 dcl substr builtin; 487 dcl test_access bit (3); 488 dcl user_authorization_text 489 character (256); 490 491 dcl error_table_$ai_restricted 492 fixed bin (35) ext static; 493 dcl error_table_$lower_ring 494 fixed bin (35) ext static; 495 dcl error_table_$moderr fixed bin (35) ext static; 496 dcl error_table_$unimplemented_version 497 fixed bin (35) ext static; 498 dcl error_table_$user_not_found 499 fixed bin (35) ext static; 500 501 dcl aim_check_$greater_or_equal 502 entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); 503 dcl convert_authorization_$to_string_short 504 entry (bit (72) aligned, char (*), fixed bin (35)); 505 dcl convert_status_code_ entry (fixed bin (35), char (8) aligned, char (100) aligned); 506 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 507 dcl fs_star_$init entry (ptr, char (*), char (*), char (8), ptr, fixed bin (35)); 508 dcl fs_star_$select entry (ptr, ptr, fixed bin (35)); 509 dcl fs_star_$term entry (ptr); 510 dcl fs_util_$list_acl entry (char (*), char (*), char (*), ptr, ptr, fixed bin (35)); 511 dcl hcs_$get_access_class entry (char (*), char (*), bit (72) aligned, fixed bin (35)); 512 dcl hcs_$get_dir_ring_brackets 513 entry (char (*), char (*), (2) fixed bin (3), fixed bin (35)); 514 dcl hcs_$get_ring_brackets entry (char (*), char (*), (3) fixed bin (3), fixed bin (35)); 515 dcl hcs_$set_bc entry (char (*), char (*), fixed bin (24), fixed bin (35)); 516 dcl hcs_$truncate_file entry (char (*), char (*), fixed bin (19), fixed bin (35)); 517 dcl ioa_$rsnnl entry () options (variable); 518 dcl iox_$attach_ptr entry (ptr, char (*), ptr, fixed bin (35)); 519 dcl iox_$close entry (ptr, fixed bin (35)); 520 dcl iox_$detach_iocb entry (ptr, fixed bin (35)); 521 dcl iox_$find_iocb entry (char (*), ptr, fixed bin (35)); 522 dcl iox_$open entry (ptr, fixed bin, bit (1) aligned, fixed bin (35)); 523 dcl iox_$put_chars entry (ptr, ptr, fixed bin (21), fixed bin (35)); 524 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 525 1 1 /* BEGIN INCLUDE FILE ... _imft_check_acl.incl.pl1 */ 1 2 1 3 /* format: style4 */ 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(88-09-21,Beattie), approve(88-08-01,MCR7948), 1 7* audit(88-10-14,Farley), install(88-10-14,MR12.2-1165): 1 8* Created to support IMFT ACL checking. 1 9* END HISTORY COMMENTS */ 1 10 1 11 dcl 1 imft_check_acl aligned based (imft_check_acl_ptr), 1 12 2 version character (8), /* version of this structure */ 1 13 2 flags, 1 14 3 allow_transfer bit (1) unaligned, /* indicates that transfer is allowed to start */ 1 15 3 objects_to_transfer bit (1) unaligned, /* indicates that objects were found in subtree that passed all checks */ 1 16 3 check_aim bit (1) unaligned, /* do aim checks */ 1 17 3 found_inner_ring_object bit (1) unaligned, /* an inner ring object was detected */ 1 18 3 pad bit (32) unaligned, 1 19 2 dirname character (168), /* containing directory of object */ 1 20 2 ename character (32), /* entry name of object */ 1 21 2 type character (32), /* type of object */ 1 22 2 object_ring fixed binary (3), /* first ring bracket of object */ 1 23 2 sys_auth_ceiling bit (72), /* system auth ceiling */ 1 24 2 sys_auth_floor bit (72), /* system auth floor */ 1 25 2 user_auth bit (72), /* user's authorization */ 1 26 2 foreign_sys_name character (32), /* for error message */ 1 27 2 gen_acl_ptr pointer, /* ptr to general ACL array */ 1 28 2 dir_access bit (3), /* desired ACL for directories */ 1 29 2 seg_access bit (3), /* desired ACL for segments */ 1 30 2 effective_ring, /* minimum ring for object to allow transfer */ 1 31 2 bad_acl_idx fixed bin, /* index in ACL array which failed ACL checks */ 1 32 2 error_code fixed bin (35), /* standard error code */ 1 33 2 error_message (2) character (512) varying, /* contains an error message */ 1 34 2 accessfile_pathname character (168); /* collect access error mesages here if subtree checking */ 1 35 1 36 dcl imft_check_acl_ptr pointer; 1 37 1 38 dcl DRIVER_ACL_IDX fixed binary int static options (constant) initial (1); 1 39 dcl USER_ACL_IDX fixed binary int static options (constant) initial (2); 1 40 1 41 dcl IMFT_CHECK_ACL_VERSION_1 character (8) init ("IMFTCA01") internal static options (constant); 1 42 1 43 /* END INCLUDE FILE ... _imft_check_acl.incl.pl1 */ 526 527 2 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 2 2* 2 3* Values for the "access mode" argument so often used in hardcore 2 4* James R. Davis 26 Jan 81 MCR 4844 2 5* Added constants for SM access 4/28/82 Jay Pattin 2 6* Added text strings 03/19/85 Chris Jones 2 7**/ 2 8 2 9 2 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 2 11 dcl ( 2 12 N_ACCESS init ("000"b), 2 13 R_ACCESS init ("100"b), 2 14 E_ACCESS init ("010"b), 2 15 W_ACCESS init ("001"b), 2 16 RE_ACCESS init ("110"b), 2 17 REW_ACCESS init ("111"b), 2 18 RW_ACCESS init ("101"b), 2 19 S_ACCESS init ("100"b), 2 20 M_ACCESS init ("010"b), 2 21 A_ACCESS init ("001"b), 2 22 SA_ACCESS init ("101"b), 2 23 SM_ACCESS init ("110"b), 2 24 SMA_ACCESS init ("111"b) 2 25 ) bit (3) internal static options (constant); 2 26 2 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 2 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 2 29 2 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 2 31 static options (constant); 2 32 2 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 2 34 static options (constant); 2 35 2 36 dcl ( 2 37 N_ACCESS_BIN init (00000b), 2 38 R_ACCESS_BIN init (01000b), 2 39 E_ACCESS_BIN init (00100b), 2 40 W_ACCESS_BIN init (00010b), 2 41 RW_ACCESS_BIN init (01010b), 2 42 RE_ACCESS_BIN init (01100b), 2 43 REW_ACCESS_BIN init (01110b), 2 44 S_ACCESS_BIN init (01000b), 2 45 M_ACCESS_BIN init (00010b), 2 46 A_ACCESS_BIN init (00001b), 2 47 SA_ACCESS_BIN init (01001b), 2 48 SM_ACCESS_BIN init (01010b), 2 49 SMA_ACCESS_BIN init (01011b) 2 50 ) fixed bin (5) internal static options (constant); 2 51 2 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 528 529 3 1 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 3 2 /* format: style3,indcomtxt,idind30 */ 3 3 3 4 declare acl_ptr pointer; 3 5 declare acl_count fixed bin; 3 6 3 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 3 8 2 version char (8) aligned, 3 9 2 count fixed bin, 3 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 3 11 3 12 declare 1 general_acl_entry based, 3 13 2 access_name character (32) unaligned, 3 14 2 mode bit (36) aligned, 3 15 2 status_code fixed bin (35); 3 16 3 17 3 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 3 19 2 version char (8) aligned, 3 20 2 count fixed bin, 3 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 3 22 3 23 declare 1 general_extended_acl_entry aligned based, 3 24 2 access_name character (32) unaligned, 3 25 2 mode bit (36) aligned, 3 26 2 extended_mode bit (36) aligned, 3 27 2 status_code fixed bin (35); 3 28 3 29 3 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 3 31 2 version char (8) aligned, 3 32 2 count fixed bin, 3 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 3 34 3 35 declare 1 general_delete_acl_entry aligned based, 3 36 2 access_name character (32) unaligned, 3 37 2 status_code fixed bin (35); 3 38 3 39 3 40 declare 1 segment_acl aligned based (acl_ptr), 3 41 2 version fixed bin, 3 42 2 count fixed bin, 3 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 3 44 3 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 3 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 3 47 3 48 3 49 declare 1 directory_acl aligned based (acl_ptr), 3 50 2 version fixed bin, 3 51 2 count fixed bin, 3 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 3 53 3 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 3 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 3 56 3 57 3 58 declare 1 delete_acl based (acl_ptr) aligned, 3 59 2 version fixed bin, 3 60 2 count fixed bin, 3 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 3 62 3 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 3 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 3 65 3 66 3 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 3 68 DIR_ACL_VERSION_1 init ("dra1"), 3 69 DELETE_ACL_VERSION_1 init ("dla1")) 3 70 char (4) int static options (constant); 3 71 3 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 3 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 3 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 3 75 char (8) internal static options (constant); 3 76 3 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 3 78 3 79 /* End include file acl_structures.incl.pl1 */ 530 531 4 1 /* BEGIN: fs_star_.incl.pl1 * * * * * * * * * * * * */ 4 2 4 3 /****^ HISTORY COMMENTS: 4 4* 1) change(88-07-15,GDixon), approve(88-09-20,MCR7987), 4 5* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 4 6* Initial version corresponding to MTB781-00. 4 7* 2) change(88-08-25,GDixon), approve(88-09-20,MCR7987), 4 8* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 4 9* Modifications corresponding to MTB781-01 correcting minor problems 4 10* found during the review of the earlier MTB. 4 11* 3) change(88-09-19,GDixon), approve(88-09-20,MCR8007), 4 12* audit(88-10-03,Beattie), install(88-10-06,MR12.2-1139): 4 13* Final changes reflecting MTB781-02. This is the MR12.2 version. 4 14* END HISTORY COMMENTS */ 4 15 4 16 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 17 /* */ 4 18 /* This include file declares structures and named constants used when calling the fs_star_ */ 4 19 /* subroutine. */ 4 20 /* */ 4 21 /* star_options: */ 4 22 /* defines star matching, selection and sorting criteria. */ 4 23 /* */ 4 24 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 25 4 26 dcl 1 star_options aligned based (star_optionsP), 4 27 2 version char(8), /* = STAR_OPTIONS_VERSION_1 */ 4 28 4 29 2 caller, 4 30 3 ssu_sciP ptr, /* subsystem sci_ptr, used to get */ 4 31 /* areas & temp segs, report errors. */ 4 32 /* null => use other elements as below */ 4 33 3 fs_star_dataP ptr, /* ptr to fs_star_ internal data. */ 4 34 4 35 2 selection, 4 36 3 star_pathsP ptr, /* ptr to input pathname array. */ 4 37 /* Starred paths select starting ents. */ 4 38 3 path_allow bit(36) aligned, /* type of paths allowed in star_paths */ 4 39 /* See PATH_ALLOW_xxx constants below. */ 4 40 3 entry_type, /* selection/expansion of standard */ 4 41 4 ( /* entry types. See ENTRY_xxx */ 4 42 links, /* constants below. */ 4 43 segs, 4 44 dirs, 4 45 msfs, 4 46 msf_comps, 4 47 dm_files, 4 48 archives, 4 49 arch_comps, 4 50 extended_entries) bit(36) aligned, 4 51 3 extended_entry_typesP ptr, /* ptr to entry type selection array. */ 4 52 /* ^=null => only paths matching one */ 4 53 /* extended entry type are */ 4 54 /* selected. */ 4 55 3 match_namesP ptr, /* ptr to added starname match array. */ 4 56 /* ^=null => only paths matching one */ 4 57 /* or more matchnames are */ 4 58 /* selected. */ 4 59 3 exclude_namesP ptr, /* ptr to starname exclusion array. */ 4 60 /* ^=null => selected paths matching */ 4 61 /* one or more excludenames */ 4 62 /* are de-selected. */ 4 63 4 64 2 per_entry, /* For each selected entry: */ 4 65 3 sorting (6), /* major/minor sort keys, by locator */ 4 66 4 ( /* within selected subtree. */ 4 67 dirs, /* Sorting of dirs in selected subtree */ 4 68 dir_ents, /* Sorting of ents in selected dirs. */ 4 69 comps) fixed bin, /* Sorting of archive and msf */ 4 70 /* components in selected ents. */ 4 71 /* Lower-numbered array elements are */ 4 72 /* major keys. See SORT_xxx */ 4 73 /* constants below. */ 4 74 3 handler /* call this proc to handle entry. */ 4 75 entry (ptr, char(*), (*)char(32), char(*), fixed bin), 4 76 /* call handler (star_dataP, dir, ent_names, comp_name, action); */ 4 77 3 error /* call this proc if error occurs. */ 4 78 entry (ptr, char(*), (*)char(32), char(*), 4 79 fixed bin(35), char(*), fixed bin), 4 80 /* call error (star_dataP, dir, ent_names, comp_name, */ 4 81 /* code, message, action); */ 4 82 /* =ssu_$null_entry => */ 4 83 /* use ssu_$print_error */ 4 84 3 handler_dataP ptr, /* ptr to caller-provided data passed */ 4 85 /* on to .handler and .error. */ 4 86 3 data_desired fixed bin, /* type of info to pass to .handler */ 4 87 /* for each selected entry. See */ 4 88 /* DATA_xxx constants below. */ 4 89 3 data_version char(8) unal, /* Version of star_data structure */ 4 90 /* that .handler expects to receive. */ 4 91 /* Only STAR_DATA_VERSION_1 allowed. */ 4 92 2 mbz bit(36) aligned, /* Reserved for future use. */ 4 93 star_optionsP ptr; /* ptr to star_options structure. */ 4 94 4 95 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 96 /* */ 4 97 /* Named Constant for star_options.version: */ 4 98 /* version of star_options the caller is prepared to deal with. */ 4 99 /* */ 4 100 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 101 4 102 dcl STAR_OPTIONS_VERSION_1 init("STAROPT1") char(8) int static options(constant); 4 103 4 104 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 105 /* */ 4 106 /* star_paths: */ 4 107 /* array of directory entry pathnames (or archive component pathnames) which does initial */ 4 108 /* pathname selection, based upon starnames in dir part (dir>**>ent), final entryname (dir>**), */ 4 109 /* and/or archive component part (dir>ent.archive::**) of pathname. These starnames select the */ 4 110 /* initial set of entries to which further selection criteria are applied. */ 4 111 /* star_options.path_allow setting controls which type of pathname (dir entry or archive */ 4 112 /* component) is allowed, and which parts may contain stars. */ 4 113 /* */ 4 114 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 115 4 116 dcl 1 star_paths aligned based (star_options.star_pathsP), 4 117 2 version char(8), /* = STAR_PATHS_VERSION_1 */ 4 118 2 max_count fixed bin, /* maximum size of value array for the */ 4 119 /* current allocation of star_paths. */ 4 120 2 count fixed bin, /* current size of value array. */ 4 121 2 value (star_paths_size refer (star_paths.max_count)) char(202) unal, 4 122 /* dir>**>ent>**::** */ 4 123 star_paths_size fixed bin auto, 4 124 STAR_PATHS_VERSION_1 init("STARPTH1") char(8) int static options(constant); 4 125 4 126 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 127 /* */ 4 128 /* Named Constants for star_options.path_allow: */ 4 129 /* select the types of pathnames are allowed, and which pathname components may contain stars. */ 4 130 /* */ 4 131 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 132 4 133 dcl (PATH_ALLOW_DIR_STAR_NAMES init("1"b), /* dir>**>ent */ 4 134 PATH_ALLOW_ENTRY_STAR_NAMES init("01"b), /* dir>** */ 4 135 PATH_ALLOW_ARCHIVE_COMPONENTS init("001"b), /* dir>ent::comp */ 4 136 PATH_ALLOW_ARCHIVE_STAR_NAMES init("0001"b), /* dir>ent::** */ 4 137 PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES init("0011"b), /* dir>ent::** or dir>ent::comp */ 4 138 PATH_ALLOW_NONDIR_STAR_NAMES init("0111"b), /* dir>**::** */ 4 139 PATH_ALLOW_BRANCH_STAR_NAMES init("1100"b), /* dir>**>** */ 4 140 PATH_ALLOW_ALL_STAR_NAMES init("1111"b)) /* dir>**>**::** */ 4 141 bit(36) aligned int static options(constant); 4 142 4 143 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 144 /* */ 4 145 /* Named Constants for star_options.selection.entry_type: */ 4 146 /* for entries matching the starname, selection by entry type, control expansion, etc. */ 4 147 /* One named constant from each group may be ORed together to form a value to be assigned to */ 4 148 /* each star_options.entry_type.XXX value (eg, star_options.entry_type.segs). */ 4 149 /* */ 4 150 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 151 4 152 dcl (ENTRY_DONT_RETURN init("1"b), /* Don't return entries of this type. */ 4 153 ENTRY_RETURN init("0"b), /* Return entries of this type. */ 4 154 4 155 ENTRY_LIST_SUBENTRIES init("01"b), /* List components of matching ents. */ 4 156 ENTRY_DONT_LIST_SUBENTRIES init("00"b), /* Don't list components of match ents. */ 4 157 /* Applies to: dirs, archives, msfs */ 4 158 4 159 ENTRY_INAEE init("001"b), /* Interpret as extended ent (-inaee). */ 4 160 ENTRY_INASE init("000"b), /* Interpret as standard ent (-inase). */ 4 161 /* Applies to: segs, dirs, msfs, & */ 4 162 /* dm_files. */ 4 163 4 164 ENTRY_DONT_SELECT_NULL init("0001"b), /* Select only nonnull entries. */ 4 165 ENTRY_DONT_SELECT_NONNULL init("00001"b), /* Select only null entries. */ 4 166 ENTRY_SELECT_NULL_NONNULL init("00000"b), /* Select both null and nonnull entries.*/ 4 167 /* Applies to: links, segs, msfs, */ 4 168 /* msf_comps, archives, arch_comps */ 4 169 4 170 ENTRY_CHASE_NONSTAR_LINKS init("000001"b), /* Chase links only if link was not */ 4 171 /* selected by a starname. */ 4 172 ENTRY_CHASE_ALL_LINKS init("0000001"b), /* Chase all links. (-chase) */ 4 173 ENTRY_DONT_CHASE_LINKS init("0000000"b), /* Don't chase links. (-no_chase) */ 4 174 /* Applies to: links */ 4 175 4 176 ENTRY_DONT_SELECT_OBJECTS init("00000001"b), /* Select only nonobject files. */ 4 177 ENTRY_DONT_SELECT_NONOBJECTS init("000000001"b), /* Select only object files. */ 4 178 ENTRY_SELECT_ALL_FILES init("000000000"b), /* Select both objects and nonobjects. */ 4 179 /* Applies to: segs, msfs, arch_comps */ 4 180 4 181 ENTRY_DONT_SELECT_MDIRS init("0000000001"b), /* Select only nonmaster dirs. */ 4 182 ENTRY_DONT_SELECT_NON_MDIRS init("00000000001"b),/* Select only master dirs. */ 4 183 ENTRY_SELECT_ALL_DIRS init("00000000000"b))/* Select both masters and nonmasters. */ 4 184 /* Applies to: dirs */ 4 185 bit(36) aligned int static options(constant); 4 186 4 187 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 188 /* */ 4 189 /* extended_entry_types: */ 4 190 /* array of extended entry types applied to entries selected from the star_paths array. If an */ 4 191 /* entry matches any of the given extended types, that entry is included for further selection. */ 4 192 /* */ 4 193 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 194 4 195 dcl 1 extended_entry_types aligned based (star_options.extended_entry_typesP), 4 196 2 version char(8), /* = STAR_EXTENDED_ENTRY_VERSION_1 */ 4 197 2 max_count fixed bin, /* maximum size of value array for the */ 4 198 /* current allocation of */ 4 199 /* extended_entry_types. */ 4 200 2 count fixed bin, /* current size of value array. */ 4 201 2 value (extended_entry_types_size refer (extended_entry_types.max_count)) char(32) unal, 4 202 /* -slet EXTENDED_TYPE */ 4 203 extended_entry_types_size fixed bin auto, 4 204 STAR_EXTENDED_ENTRY_VERSION_1 init("STARETP1") char(8) int static options(constant); 4 205 4 206 4 207 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 208 /* */ 4 209 /* match_names: */ 4 210 /* array of additional starnames which are applied to entries selected from the star_paths */ 4 211 /* and extended_entry_types arrays. If any name on an entry matches any match_name, that entry */ 4 212 /* is included for further selection. */ 4 213 /* */ 4 214 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 215 4 216 dcl 1 match_names aligned based (star_options.match_namesP), 4 217 2 version char(8), /* = STAR_MATCH_NAMES_VERSION_1 */ 4 218 2 max_count fixed bin, /* maximum size of value array for the */ 4 219 /* current allocation of match_names. */ 4 220 2 count fixed bin, /* current size of value array. */ 4 221 2 value (match_names_size refer (match_names.max_count)) char(32) unal, 4 222 /* -match ** */ 4 223 match_names_size fixed bin auto, 4 224 STAR_MATCH_NAMES_VERSION_1 init("STARMNM1") char(8) int static options(constant); 4 225 4 226 4 227 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 228 /* */ 4 229 /* exclude_names: */ 4 230 /* array of starnames which are applied to entries selected from star_paths, */ 4 231 /* extended_entry_types and match_names arrays. If any name on an entry matches an exclude */ 4 232 /* name, that entry is excluded from further selection. */ 4 233 /* */ 4 234 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 235 4 236 dcl 1 exclude_names aligned based (star_options.exclude_namesP), 4 237 2 version char(8), /* = STAR_EXCLUDE_NAMES_VERSION_1 */ 4 238 2 max_count fixed bin, /* maximum size of value array for the */ 4 239 /* current allocation of exclude_names */ 4 240 2 count fixed bin, /* current size of value array. */ 4 241 2 value (exclude_names_size refer (exclude_names.max_count)) char(32) unal, 4 242 /* -exclude ** */ 4 243 exclude_names_size fixed bin auto, 4 244 STAR_EXCLUDE_NAMES_VERSION_1 init("STARENM1") char(8) int static options(constant); 4 245 4 246 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 247 /* */ 4 248 /* Named Constants for star_options.handler: */ 4 249 /* handler procedure's action parameter to control the further progress of searching. */ 4 250 /* */ 4 251 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 252 4 253 dcl (HANDLER_OK init (0), /* no error when handling entry. */ 4 254 HANDLER_REJECT init (1), /* no error, but handler does not */ 4 255 /* accept entry; it should not be */ 4 256 /* counted, expanded, etc. */ 4 257 HANDLER_DONT_EXPAND init (2), /* no error, but handler does not want */ 4 258 /* dir/archive entry expanded. */ 4 259 HANDLER_EXPAND init (3), /* no error, but expand dir/archive */ 4 260 /* even if contrary to .entry_type. */ 4 261 HANDLER_EXPAND_DONT_COUNT init (4), /* no error, but handler does not accept */ 4 262 /* entry; it should not be counted, but */ 4 263 /* should be expanded. */ 4 264 HANDLER_DONT_COUNT init (5), /* no error, but handler does not accept */ 4 265 /* entry; it should not be counted. Its */ 4 266 /* expansion depends upon .entry_type */ 4 267 /* setting for this type of entry. */ 4 268 HANDLER_STOP init (6), /* no error, but the selection process */ 4 269 /* process terminates immediately. */ 4 270 /* Entry should be counted, then */ 4 271 /* fs_star_$select returns to caller. */ 4 272 HANDLER_ABORT init (7) /* error, entry not counted, selection */ 4 273 /* process terminates immediately, */ 4 274 /* handler reports any error, then */ 4 275 /* fs_star_$select returns to caller. */ 4 276 ) fixed bin internal static options(constant); 4 277 4 278 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 279 /* */ 4 280 /* Named Constants for star_options.error: */ 4 281 /* error procedure's action parameter. */ 4 282 /* */ 4 283 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 284 4 285 dcl (ERROR_OK init (0), /* error was processed successfully. */ 4 286 /* Entry causing error should be */ 4 287 /* counted as a match, but should not */ 4 288 /* be passed to handler for processing */ 4 289 /* nor expanded. */ 4 290 ERROR_REJECT init (1), /* error was processed successfully. */ 4 291 /* Entry causing error was rejected, */ 4 292 /* should not be counted as a match, */ 4 293 /* expanded, nor passed to handler. */ 4 294 ERROR_STOP init (6), /* error was processed successfully, */ 4 295 /* but error routine wants to stop the */ 4 296 /* selection process immediately. */ 4 297 /* Entry should be counted as a match, */ 4 298 /* but not expanded nor passed to the */ 4 299 /* handler routine for processing. */ 4 300 ERROR_ABORT init (7) /* error processing was unsuccessful. */ 4 301 /* Error routine wants to stop the */ 4 302 /* selection process immediately. */ 4 303 /* Entry should not be counted as a */ 4 304 /* match, expanded, nor passed to the */ 4 305 /* handler routine. */ 4 306 ) fixed bin internal static options(constant); 4 307 4 308 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 309 /* */ 4 310 /* Named Constants for star_options.sorting: */ 4 311 /* */ 4 312 /* fs_star_ can sort the selected entries before they are passed to the caller-provided handler */ 4 313 /* routine. Sorting of selected entries can be based upon three categories of sorting: */ 4 314 /* - the attributes of selected archive or MSF components (the component's name or its position */ 4 315 /* within the archive/msf); or */ 4 316 /* - the attributes of the selected directory entry (matching entryname, entry type or position */ 4 317 /* within the directory); or */ 4 318 /* - the selected entry's location within the selected subtree, or the matching entrynames in the */ 4 319 /* directory part of the pathname of a selected entry. */ 4 320 /* */ 4 321 /* To provide flexibility, any of the sorting categories above can be used singly, or in */ 4 322 /* combination. If used in combination, component sorting occurs before entry sorting, which occurs */ 4 323 /* before directory pathname sorting. Within a given category, several sorting operations are */ 4 324 /* possible. These include: */ 4 325 /* - sorting by name; */ 4 326 /* - sorting by (standard or extended) entry type; */ 4 327 /* - sorting of children entries with respect to their parent; */ 4 328 /* - sorting in ascending or descending sequence (forward or reverse); or */ 4 329 /* - sorting can be disabled for the category. */ 4 330 /* */ 4 331 /* Within a sort category, each sorting operation can be used singly, or in combinations of one to*/ 4 332 /* four sort operations in a caller-defined order. Order sort operations are specified by filling in*/ 4 333 /* the elements of the star_options.sorting arrays. For example: */ 4 334 /* star_options.selection.entry_type = ENTRY_RETURN; */ 4 335 /* star_options.sorting(*) = SORT_OFF; */ 4 336 /* star_options.sorting(1) = SORT_FORWARD; */ 4 337 /* star_options.sorting(1).comps = SORT_BY_NAME; */ 4 338 /* passes all directories and directory entries in the selected subtree to the handler routine in the*/ 4 339 /* order they were returned by hcs_$star_. Selected components of archives and MSFs are passed to */ 4 340 /* the handler routine, sorted by component name. */ 4 341 /* star_options.selection.entry_type = ENTRY_RETURN; */ 4 342 /* star_options.sorting(*) = SORT_OFF; */ 4 343 /* star_options.sorting(1) = SORT_FORWARD; */ 4 344 /* star_options.sorting(1).comps = SORT_REVERSE; */ 4 345 /* star_options.sorting(2).comps = SORT_BY_NAME; */ 4 346 /* passes the components to the handler sorted by component name, in reverse ASCII collating */ 4 347 /* sequence. */ 4 348 /* star_options.selection.entry_type = ENTRY_DONT_RETURN; */ 4 349 /* star_options.selection.entry_type.dirs = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ 4 350 /* star_options.selection.entry_type.archives = ENTRY_DONT_RETURN | ENTRY_LIST_SUBENTRIES; */ 4 351 /* star_options.selection.entry_type.arch_comps = ENTRY_RETURN; */ 4 352 /* star_options.sorting(*) = SORT_OFF; */ 4 353 /* star_options.sorting(1).comps = SORT_BY_NAME; */ 4 354 /* passes the archive components to the handler sorted by component name, irrespective of the archive*/ 4 355 /* the component resides in. That is, components in all archives selected from the subtree are found*/ 4 356 /* and sorted by name, and then passed to the handler in that order. */ 4 357 /* */ 4 358 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 359 4 360 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 361 /* */ 4 362 /* star_options.selection.entry_type = ENTRY_RETURN; */ 4 363 /* star_options.selection.entry_type.dirs = ENTRY_LIST_SUBENTRIES; */ 4 364 /* star_options.selection.entry_type.arch_comps = ENTRY_DONT_RETURN; */ 4 365 /* star_options.selection.entry_type.msf_comps = ENTRY_DONT_RETURN; */ 4 366 /* star_options.sorting(*) = SORT_OFF; */ 4 367 /* star_options.sorting(1).dirs = SORT_BY_NAME; */ 4 368 /* star_options.sorting(1).dir_ents = SORT_BY_STANDARD_TYPE */ 4 369 /* star_options.sorting(2).dir_ents = SORT_BY_NAME; */ 4 370 /* star_options.sorting(3).dir_ents = SORT_ENTRIES_BEFORE_SUBENTRIES; */ 4 371 /* passes selected entries to the handler routine sorted by directory, and within a directory sorted */ 4 372 /* by matching entryname within entry type groupings. For entries in a single directory, this is the*/ 4 373 /* type of grouping and sorting performed by the command: */ 4 374 /* list -sort name -all */ 4 375 /* */ 4 376 /* Sorting is based upon the location of the item within the selected subtree. If sorting by */ 4 377 /* dirs(*) is SORT_OFF, then the entire subtree must be selected and sorted before any data can be */ 4 378 /* passed to the handler. If sorting by dirs(*) is not SORT_OFF, then the contents of each dir is */ 4 379 /* sorted and passed to handler before processing subdirs. This provides more immediate response. */ 4 380 /* */ 4 381 /* Elements of the star_data.matched minor structure below are counts of the total entries found, */ 4 382 /* divided by entry type. If sorting.dirs(*) is SORT_OFF, then these counts represent the total of */ 4 383 /* all entries selected within the entire subtree. Otherwise, they represent only the entries */ 4 384 /* selected and sorted within the current node of the subtree and all previously handled nodes. */ 4 385 /* */ 4 386 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 387 4 388 dcl (SORT_OFF init(0), /* Don't sort by this subtree locator. */ 4 389 SORT_FORWARD init(1), /* Sort entries in order returned by */ 4 390 /* hcs_$star_ or archive_ subrs. */ 4 391 SORT_REVERSE init(2), /* Reverse ordering specified by */ 4 392 /* sort_sel elements with higher */ 4 393 /* index values. */ 4 394 SORT_BY_NAME init(3), /* Sort by primary matching ent name. */ 4 395 SORT_BY_STANDARD_ENTRY_TYPE init(4), /* Sort by standard entry type. */ 4 396 SORT_BY_EXTENDED_ENTRY_TYPE init(5), /* Sort by extended entry type. */ 4 397 SORT_ENTRIES_BEFORE_SUBENTRIES init(6)) /* Sort all entries in a directory before*/ 4 398 /* looking for any subentries. By */ 4 399 /* default, subentries below an entry */ 4 400 /* are expanded immediately after the */ 4 401 /* entry is encountered in the sorted */ 4 402 /* sequence of directory entries. */ 4 403 fixed bin int static options(constant); 4 404 4 405 4 406 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 407 /* */ 4 408 /* Named Constants for star_options.data_desired: */ 4 409 /* values control the amount of data returned to caller's entry handler routine in */ 4 410 /* star_data.entry_data. */ 4 411 /* */ 4 412 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 413 4 414 dcl (DATA_TYPE init (1), /* Entry type, only. */ 4 415 DATA_INITIATE init (2)) /* Entry type, length and count */ 4 416 fixed bin int static options(constant); 4 417 4 418 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 419 /* */ 4 420 /* Named constant for star_options.data_version: */ 4 421 /* caller-specified version of star_data he is willing to accept. */ 4 422 /* */ 4 423 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 424 4 425 dcl STAR_DATA_VERSION_1 init ("STARDAT1") char(8) int static options(constant); 4 426 /* star_data version 1 structure. */ 4 427 4 428 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 429 /* */ 4 430 /* star_data: */ 4 431 /* information provided to caller-supplied entry handler routine for each selected entry. */ 4 432 /* */ 4 433 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 434 4 435 dcl 1 star_data aligned based (star_dataP), 4 436 2 version char(8), /* = STAR_DATA_VERSION_1 */ 4 437 2 star_optionsP ptr, /* ptr to caller-supplied star_options */ 4 438 /* structure. This makes */ 4 439 /* star_options.handler_dataP */ 4 440 /* available to the handler routine. */ 4 441 2 matched, /* count of matching entries: */ 4 442 3 ( 4 443 current, /* index of current entry in sort list */ 4 444 total, /* count of total entries. */ 4 445 links, /* count of total links. */ 4 446 segs, /* count of total non-archive, */ 4 447 /* non-extended entry segments. */ 4 448 dirs, /* count of total directories. */ 4 449 msfs, /* count of total multisegment files. */ 4 450 msf_comps, /* count of total msf components. */ 4 451 dm_files, /* count of total data mgt files. */ 4 452 archives, /* count of total archives. */ 4 453 arch_comps, /* count of total archive components. */ 4 454 extended_entries) fixed bin, /* count of total extended entries. */ 4 455 /* See Named Constants for */ 4 456 /* sort_options.sorting above. */ 4 457 3 mbz_matched (4) fixed bin, /* reserved for future use. */ 4 458 4 459 2 entry_data, /* Beginning of DATA_xxx return items. */ 4 460 3 data_desired fixed bin, /* amount of data in entry_data minor */ 4 461 /* structure which is valid. */ 4 462 3 depth fixed bin, /* depth of this entry below its */ 4 463 /* corresponding parent in */ 4 464 /* star_paths.value. */ 4 465 3 type char(32) unal, /* extended entry type for matching */ 4 466 /* entry. See ENTRY_TYPE_xxx */ 4 467 /* constants below for standard entry */ 4 468 /* types. Extended types are given */ 4 469 /* by entry type suffix (eg, mbx). */ 4 470 /* Data above available when */ 4 471 /* data_desired set to DATA_TYPE. */ 4 472 4 473 3 length fixed bin(35), /* length of entry (by entry type): */ 4 474 /* link => 0 */ 4 475 /* seg => bit count */ 4 476 /* dir => 0 */ 4 477 /* msf => sum of comp bit counts */ 4 478 /* msf comp => msf comp bit count */ 4 479 /* dm_file => 0 */ 4 480 /* arch => bit count of archive */ 4 481 /* arch comp => bit count of component */ 4 482 /* ext entry => 0 */ 4 483 3 count fixed bin(35), /* length of entry (by entry type): */ 4 484 /* link => 0 */ 4 485 /* seg => 0 */ 4 486 /* dir => inferior entry count */ 4 487 /* msf => number of components */ 4 488 /* msf comp => total msf components */ 4 489 /* dm_file => 0 */ 4 490 /* arch => number of components */ 4 491 /* arch comp => total arch components */ 4 492 /* ext entry => 0 */ 4 493 3 entryP ptr, /* ptr to an entry: */ 4 494 /* link => null */ 4 495 /* seg => ptr to segment */ 4 496 /* dir => null */ 4 497 /* msf => ptr to msf_manager_ */ 4 498 /* fcb_ptr argument */ 4 499 /* msf comp => ptr to msf component */ 4 500 /* dm_file => null */ 4 501 /* arch => ptr to archive */ 4 502 /* arch comp => ptr to component */ 4 503 /* ext entry => null */ 4 504 /* Data above available when */ 4 505 /* data_desired set to DATA_INITIATE. */ 4 506 4 507 star_dataP ptr automatic; /* ptr to star_data structure. */ 4 508 4 509 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 510 /* */ 4 511 /* Named constants for star_data.type: */ 4 512 /* type values describing the type of entry passed to caller-supplied handler routine. Type */ 4 513 /* strings for file system standard entry types (links, segments, dirs, dm_files, msfs) agree */ 4 514 /* with those returned by fs_util_$get_type. */ 4 515 /* */ 4 516 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 517 4 518 dcl (ENTRY_TYPE_ARCHIVE init ("-archive"), 4 519 ENTRY_TYPE_ARCHIVE_COMP init ("-archive_component"), 4 520 ENTRY_TYPE_DIRECTORY init ("-directory"), 4 521 ENTRY_TYPE_DM_FILE init ("-dm_file"), 4 522 ENTRY_TYPE_LINK init ("-link"), 4 523 ENTRY_TYPE_MSF init ("-multisegment_file"), 4 524 ENTRY_TYPE_MSF_COMP init ("-msf_component"), 4 525 ENTRY_TYPE_SEGMENT init ("-segment"), 4 526 ENTRY_TYPE_UNKNOWN init ("-unknown"), 4 527 ENTRY_TYPE_UNSET init ("") 4 528 ) char (32) unaligned int static options (constant); 4 529 4 530 dcl STANDARD_ENTRY_TYPES (9) char (32) unal/* array of standard entry type values. */ 4 531 int static options(constant) init ( 4 532 "-link", 4 533 "-segment", 4 534 "-directory", 4 535 "-multisegment_file", 4 536 "-msf_component", 4 537 "-dm_file", 4 538 "-archive", 4 539 "-archive_component", 4 540 "-unknown"); 4 541 4 542 /* END OF: fs_star_.incl.pl1 * * * * * * * * * * * * */ 532 533 5 1 /* Begin include file ..... iox_modes.incl.pl1 */ 5 2 5 3 /* Written by C. D. Tavares, 03/17/75 */ 5 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 5 5 5 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 5 7 ("stream_input", "stream_output", "stream_input_output", 5 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 5 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 5 10 "direct_input", "direct_output", "direct_update"); 5 11 5 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 5 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 5 14 5 15 dcl (Stream_input initial (1), 5 16 Stream_output initial (2), 5 17 Stream_input_output initial (3), 5 18 Sequential_input initial (4), 5 19 Sequential_output initial (5), 5 20 Sequential_input_output initial (6), 5 21 Sequential_update initial (7), 5 22 Keyed_sequential_input initial (8), 5 23 Keyed_sequential_output initial (9), 5 24 Keyed_sequential_update initial (10), 5 25 Direct_input initial (11), 5 26 Direct_output initial (12), 5 27 Direct_update initial (13)) fixed bin int static options (constant); 5 28 5 29 /* End include file ..... iox_modes.incl.pl1 */ 534 535 end imft_util_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/04/00 1651.4 imft_util_.pl1 >udd>sm>ds>w>ml>imft_util_.pl1 526 1 10/18/88 1304.1 _imft_check_acl.incl.pl1 >ldd>incl>_imft_check_acl.incl.pl1 528 2 04/11/85 1552.6 access_mode_values.incl.pl1 >ldd>incl>access_mode_values.incl.pl1 530 3 10/14/83 1706.6 acl_structures.incl.pl1 >ldd>incl>acl_structures.incl.pl1 532 4 10/10/88 1009.4 fs_star_.incl.pl1 >ldd>incl>fs_star_.incl.pl1 534 5 02/02/78 1329.7 iox_modes.incl.pl1 >ldd>incl>iox_modes.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. DIR_ACCESS_MODE_NAMES 000036 constant char(4) initial array packed unaligned dcl 2-33 ref 182 DRIVER_ACL_IDX constant fixed bin(17,0) initial dcl 1-38 ref 245 246 327 332 343 ENTRY_CHASE_NONSTAR_LINKS constant bit(36) initial dcl 4-152 ref 36 ENTRY_DONT_LIST_SUBENTRIES constant bit(36) initial dcl 4-152 ref 37 ENTRY_DONT_RETURN constant bit(36) initial dcl 4-152 ref 91 416 419 ENTRY_INASE constant bit(36) initial dcl 4-152 ref 417 418 ENTRY_LIST_SUBENTRIES constant bit(36) initial dcl 4-152 ref 92 ENTRY_RETURN constant bit(36) initial dcl 4-152 ref 36 37 92 413 414 415 417 418 ENTRY_TYPE_DIRECTORY 000020 constant char(32) initial packed unaligned dcl 4-518 ref 146 180 269 ENTRY_TYPE_DM_FILE 000010 constant char(32) initial packed unaligned dcl 4-518 ref 146 ENTRY_TYPE_MSF 000000 constant char(32) initial packed unaligned dcl 4-518 ref 146 ERROR_REJECT constant fixed bin(17,0) initial dcl 4-285 ref 299 GENERAL_ACL_VERSION_1 000034 constant char(8) initial packed unaligned dcl 3-72 set ref 190* HANDLER_DONT_EXPAND constant fixed bin(17,0) initial dcl 4-253 ref 361 HANDLER_OK constant fixed bin(17,0) initial dcl 4-253 ref 137 IMFT_CHECK_ACL_VERSION_1 000056 constant char(8) initial packed unaligned dcl 1-41 ref 391 ME 000100 automatic char(32) packed unaligned dcl 458 set ref 26* 43* 100* 307* 370* 400* 405* P_star_data_ptr parameter pointer dcl 119 ref 116 133 291 Paction parameter fixed bin(17,0) dcl 123 set ref 116 137* 291 299* 361* Pcode parameter fixed bin(35,0) dcl 294 ref 291 300 Pcomp parameter char packed unaligned dcl 122 ref 116 291 Pdir parameter char packed unaligned dcl 120 set ref 116 134 291 303 305* Pent parameter char(32) array packed unaligned dcl 121 set ref 116 135 291 303 305* Pmessage parameter char packed unaligned dcl 295 set ref 291 307 307* SEG_ACCESS_MODE_NAMES 000046 constant char(4) initial array packed unaligned dcl 2-30 ref 186 SORT_OFF constant fixed bin(17,0) initial dcl 4-388 ref 423 STAR_OPTIONS_VERSION_1 000032 constant char(8) initial packed unaligned dcl 4-102 set ref 400* STAR_PATHS_VERSION_1 000030 constant char(8) initial packed unaligned dcl 4-116 ref 411 Stream_output 000122 constant fixed bin(17,0) initial dcl 5-15 set ref 79* USER_ACL_IDX constant fixed bin(17,0) initial dcl 1-39 ref 263 264 269 343 access_error 000100 automatic bit(1) packed unaligned dcl 125 set ref 199* 213 278 362* access_name 3 based char(32) array level 3 packed packed unaligned dcl 3-7 set ref 269* 321 343* 343* access_str 000110 automatic char(4) packed unaligned dcl 459 set ref 182* 186* 332* accessfile_dname 000010 internal static char(168) packed unaligned dcl 460 set ref 54* 55* 56* accessfile_ename 000062 internal static char(32) packed unaligned dcl 461 set ref 54* 55* 56* accessfile_pathname 525 based char(168) level 2 dcl 1-11 set ref 54 57* 72* 83* 370* acl_idx 000111 automatic fixed bin(17,0) dcl 462 set ref 200* 202 202 205 205 208* acl_ptr 000644 automatic pointer dcl 3-4 set ref 139 173 200 202 202 205 205 246 264 269 321 343 343 432* addr builtin function dcl 463 ref 367 367 afs_ptr 000136 automatic pointer dcl 465 set ref 29* 46* 58* 68* 79* 367* 445 447* 448* 449* aim_check_$greater_or_equal 000104 constant entry external dcl 501 ref 232 233 260 allow_transfer 2 based bit(1) level 3 packed packed unaligned dcl 1-11 set ref 98* 381* 403* 427* arch_comps 20 based bit(36) level 4 dcl 4-26 set ref 419* archives 17 based bit(36) level 4 dcl 4-26 set ref 414* attach_desc 000112 automatic char(80) packed unaligned dcl 464 set ref 57* 68* bad_access_name 000140 automatic char(32) packed unaligned dcl 466 set ref 321* 327* 332* bad_acl_idx 121 based fixed bin(17,0) level 2 dcl 1-11 set ref 62 72 83 100 173 208* 225 245* 248 263* 269 307 321 327 327 332 332 338 343 366 370 bin builtin function dcl 467 ref 182 186 buffer 000332 automatic char(512) packed unaligned dcl 358 set ref 366* 367 367 check_aim 2(02) based bit(1) level 3 packed packed unaligned dcl 1-11 ref 218 checking_subtree 000150 automatic bit(1) packed unaligned dcl 468 set ref 27* 44* 141 151 163 225* 225* 248* 248* 269* 269* 327* 327* 332* 332* 338* 338* 343* 343* 364 cleanup 000152 stack reference condition dcl 469 ref 31 48 code 000101 automatic fixed bin(35,0) dcl 126 in procedure "check_fs_entry" set ref 148* 149 154* 160* 161 166* 171 173 190* 192 194 201* 202* 205* 209 221* 222 224* 246* 247* 264* 265* 300* 301* 320* 327 332 338 378 378 code 000160 automatic fixed bin(35,0) dcl 470 in procedure "imft_util_" set ref 58* 59 61* 64 68* 69 71* 75 79* 80 82* 86 94* 96 99* 102 398* 400* 401 404* 407 convert_authorization_$to_string_short 000106 constant entry external dcl 503 ref 239 241 243 267 convert_status_code_ 000110 constant entry external dcl 505 ref 61 71 82 99 224 247 265 301 320 404 count 2 based fixed bin(17,0) level 2 in structure "general_acl" dcl 3-7 in procedure "imft_util_" ref 139 200 count 3 based fixed bin(17,0) level 2 in structure "star_paths" dcl 4-116 in procedure "imft_util_" set ref 412* delete_acl_entry based structure level 1 dcl 3-63 dir_access 116 based bit(3) level 2 dcl 1-11 ref 182 183 dir_ring_brackets 000162 automatic fixed bin(3,0) array dcl 471 set ref 148* 151 154 directory_acl_entry based structure level 1 dcl 3-54 dirname 3 based char(168) level 2 dcl 1-11 ref 35 90 dirs 13 based bit(36) level 4 dcl 4-26 set ref 37* 92* dm_files 16 based bit(36) level 4 dcl 4-26 set ref 417* effective_ring 120 based fixed bin(17,0) level 2 dcl 1-11 ref 154 166 ename 55 based char(32) level 2 dcl 1-11 ref 35 90 entries 3 based structure array level 2 dcl 3-7 entry_data 24 based structure level 2 dcl 4-435 entry_type 11 based structure level 3 dcl 4-26 error 56 based entry variable level 3 dcl 4-26 set ref 425* error_code 122 based fixed bin(35,0) level 2 dcl 1-11 set ref 194* 430* error_message 123 based varying char(512) array level 2 dcl 1-11 set ref 62* 72* 83* 100* 225* 248* 269* 307* 327* 332* 338* 343* 366 370* 405* 431* error_table_$ai_restricted 000072 external static fixed bin(35,0) dcl 491 ref 246 264 error_table_$lower_ring 000074 external static fixed bin(35,0) dcl 493 ref 154 166 338 378 error_table_$moderr 000076 external static fixed bin(35,0) dcl 495 ref 205 332 error_table_$unimplemented_version 000100 external static fixed bin(35,0) dcl 496 ref 394 error_table_$user_not_found 000102 external static fixed bin(35,0) dcl 498 ref 327 exclude_namesP 26 based pointer level 3 dcl 4-26 set ref 422* expand_pathname_ 000112 constant entry external dcl 506 ref 54 extended_entries 21 based bit(36) level 4 dcl 4-26 set ref 418* extended_entry_typesP 22 based pointer level 3 dcl 4-26 set ref 420* flags 2 based structure level 2 dcl 1-11 foreign_sys_name 104 based char(32) level 2 dcl 1-11 set ref 248* found_inner_ring_object 2(03) based bit(1) level 3 packed packed unaligned dcl 1-11 set ref 378* 429* fs_star_$init 000114 constant entry external dcl 507 ref 400 fs_star_$select 000116 constant entry external dcl 508 ref 94 fs_star_$term 000120 constant entry external dcl 509 ref 441 fs_util_$list_acl 000122 constant entry external dcl 510 ref 190 gen_acl_ptr 114 based pointer level 2 dcl 1-11 set ref 190* 432 general_acl based structure level 1 dcl 3-7 general_acl_entry based structure level 1 unaligned dcl 3-12 general_delete_acl_entry based structure level 1 dcl 3-35 general_extended_acl_entry based structure level 1 dcl 3-23 handler 52 based entry variable level 3 dcl 4-26 set ref 424* handler_dataP 62 based pointer level 3 dcl 4-26 set ref 426* hbound builtin function dcl 472 ref 200 hcs_$get_access_class 000124 constant entry external dcl 511 ref 221 hcs_$get_dir_ring_brackets 000126 constant entry external dcl 512 ref 148 hcs_$get_ring_brackets 000130 constant entry external dcl 514 ref 160 hcs_$set_bc 000132 constant entry external dcl 515 ref 56 hcs_$truncate_file 000134 constant entry external dcl 516 ref 55 ignore_code 000164 automatic fixed bin(35,0) dcl 473 set ref 54* 55* 56* 239* 241* 243* 267* 447* 448* imft_check_acl based structure level 1 dcl 1-11 imft_check_acl_ptr 000642 automatic pointer dcl 1-36 set ref 35 35 54 57 62 62 72 72 72 83 83 83 90 90 98 100 100 141 151 154 163 166 173 182 183 186 187 190 194 208 218 225 225 232 233 241 243 245 248 248 248 260 263 267 269 269 282 307 307 321 327 327 327 332 332 332 338 338 343 343 366 366 370 370 370 378 381 389* 391 403 405 427 428 429 430 431 432 ioa_$rsnnl 000136 constant entry external dcl 517 ref 57 62 72 83 100 225 248 269 307 327 332 338 343 370 405 iox_$attach_ptr 000140 constant entry external dcl 518 ref 68 iox_$close 000142 constant entry external dcl 519 ref 447 iox_$detach_iocb 000144 constant entry external dcl 520 ref 448 iox_$find_iocb 000146 constant entry external dcl 521 ref 58 iox_$open 000150 constant entry external dcl 522 ref 79 iox_$put_chars 000152 constant entry external dcl 523 ref 367 iox_code 000532 automatic fixed bin(35,0) dcl 359 set ref 367* 368 373 links 11 based bit(36) level 4 dcl 4-26 set ref 36* 91* local_dirname 000102 automatic char(168) packed unaligned dcl 127 set ref 134* 136* 148* 160* 190* 221* local_ename 000154 automatic char(32) packed unaligned dcl 128 set ref 135* 136* 148* 160* 190* 221* local_obj_access_class 000166 automatic bit(72) dcl 474 set ref 221* 232* 233* 239* 260* local_path 000240 automatic char(168) packed unaligned dcl 297 set ref 303* 305* 307* local_pathname 000164 automatic char(168) packed unaligned dcl 129 set ref 136* 225* 248* 269* 327* 332* 338* 343* longinfo 000170 automatic char(100) dcl 475 set ref 61* 62* 71* 72* 82* 83* 99* 100* 224* 225* 247* 248* 265* 269* 301* 307* 320* 327* 332* 338* 343* 404* 405* match_namesP 24 based pointer level 3 dcl 4-26 set ref 421* max_access_class_text 000221 automatic char(256) packed unaligned dcl 476 set ref 238* 241* 248 248* message_len 000321 automatic fixed bin(21,0) dcl 477 set ref 57* 62* 72* 83* 100* 225* 248* 269* 307* 327* 332* 338* 343* 367* 370* 405* min_access_class_text 000322 automatic char(256) packed unaligned dcl 478 set ref 243* 248 248* mode 13 based bit(36) array level 3 dcl 3-7 ref 200 205 msf_comps 15 based bit(36) level 4 dcl 4-26 set ref 416* msfs 14 based bit(36) level 4 dcl 4-26 set ref 415* my_access_ok 000236 automatic bit(1) packed unaligned dcl 130 set ref 232* 233 233* 236 null builtin function dcl 479 ref 29 30 46 47 68 190 190 400 400 420 421 422 426 439 442 445 449 object_access_class_text 000422 automatic char(256) packed unaligned dcl 480 set ref 238* 239* 248 248* object_ring 75 based fixed bin(3,0) level 2 dcl 1-11 set ref 151* 163* object_type 000522 automatic char(32) packed unaligned dcl 482 set ref 323* 325* 338* objects_to_transfer 2(01) based bit(1) level 3 packed packed unaligned dcl 1-11 set ref 282* 428* p_check_acl_ptr parameter pointer dcl 455 ref 23 40 389 p_code parameter fixed bin(35,0) dcl 456 set ref 23 40 64* 75* 86* 102* 373* 394* 398* 407* pathname_ 000154 constant entry external dcl 524 ref 35 90 136 305 per_entry 30 based structure level 2 dcl 4-26 rtrim builtin function dcl 483 ref 90 seg_access 117 based bit(3) level 2 dcl 1-11 ref 186 187 seg_ring_brackets 000532 automatic fixed bin(3,0) array dcl 484 set ref 160* 163 166 segment_acl_entry based structure level 1 dcl 3-45 segs 12 based bit(36) level 4 dcl 4-26 set ref 413* selection 6 based structure level 2 dcl 4-26 shortinfo 000536 automatic char(8) dcl 485 set ref 61* 71* 82* 99* 224* 247* 265* 301* 320* 404* sorting 30 based structure array level 3 dcl 4-26 set ref 423* star_data based structure level 1 dcl 4-435 star_dataP 000650 automatic pointer dcl 4-435 set ref 94* 133* 141 146 146 146 180 269 323 323 325 star_options based structure level 1 dcl 4-26 star_optionsP 000646 automatic pointer dcl 4-26 set ref 30* 35 36 37 47* 90 91 92 94* 400* 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 439 441* 442* star_paths based structure level 1 dcl 4-116 star_pathsP 6 based pointer level 3 dcl 4-26 ref 35 90 411 412 status_code 14 based fixed bin(35,0) array level 3 dcl 3-7 set ref 139* 173* 202 202 205* 246* 264* substr builtin function dcl 486 ref 323 323 sys_auth_ceiling 76 based bit(72) level 2 dcl 1-11 set ref 232* 241* sys_auth_floor 100 based bit(72) level 2 dcl 1-11 set ref 233* 243* test_access 000540 automatic bit(3) packed unaligned dcl 487 set ref 183* 187* 205 205 type 65 based char(32) level 2 in structure "imft_check_acl" dcl 1-11 in procedure "imft_util_" set ref 141* type 26 based char(32) level 3 in structure "star_data" packed packed unaligned dcl 4-435 in procedure "imft_util_" ref 141 146 146 146 180 269 323 323 325 user_access_ok 000237 automatic bit(1) packed unaligned dcl 131 set ref 260* 261 user_auth 102 based bit(72) level 2 dcl 1-11 set ref 260* 267* user_authorization_text 000541 automatic char(256) packed unaligned dcl 488 set ref 266* 267* 269 269* value 4 based char(202) array level 2 packed packed unaligned dcl 4-116 set ref 35* 90* version based char(8) level 2 in structure "star_paths" dcl 4-116 in procedure "imft_util_" set ref 411* version based char(8) level 2 in structure "imft_check_acl" dcl 1-11 in procedure "imft_util_" ref 391 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 3-77 A_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 DATA_INITIATE internal static fixed bin(17,0) initial dcl 4-414 DATA_TYPE internal static fixed bin(17,0) initial dcl 4-414 DELETE_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 3-67 DIR_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 3-67 Direct_input internal static fixed bin(17,0) initial dcl 5-15 Direct_output internal static fixed bin(17,0) initial dcl 5-15 Direct_update internal static fixed bin(17,0) initial dcl 5-15 ENTRY_CHASE_ALL_LINKS internal static bit(36) initial dcl 4-152 ENTRY_DONT_CHASE_LINKS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_MDIRS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NONNULL internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NONOBJECTS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NON_MDIRS internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_NULL internal static bit(36) initial dcl 4-152 ENTRY_DONT_SELECT_OBJECTS internal static bit(36) initial dcl 4-152 ENTRY_INAEE internal static bit(36) initial dcl 4-152 ENTRY_SELECT_ALL_DIRS internal static bit(36) initial dcl 4-152 ENTRY_SELECT_ALL_FILES internal static bit(36) initial dcl 4-152 ENTRY_SELECT_NULL_NONNULL internal static bit(36) initial dcl 4-152 ENTRY_TYPE_ARCHIVE internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_ARCHIVE_COMP internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_LINK internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_MSF_COMP internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_SEGMENT internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_UNKNOWN internal static char(32) initial packed unaligned dcl 4-518 ENTRY_TYPE_UNSET internal static char(32) initial packed unaligned dcl 4-518 ERROR_ABORT internal static fixed bin(17,0) initial dcl 4-285 ERROR_OK internal static fixed bin(17,0) initial dcl 4-285 ERROR_STOP internal static fixed bin(17,0) initial dcl 4-285 E_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 GENERAL_DELETE_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 3-72 GENERAL_EXTENDED_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 3-72 HANDLER_ABORT internal static fixed bin(17,0) initial dcl 4-253 HANDLER_DONT_COUNT internal static fixed bin(17,0) initial dcl 4-253 HANDLER_EXPAND internal static fixed bin(17,0) initial dcl 4-253 HANDLER_EXPAND_DONT_COUNT internal static fixed bin(17,0) initial dcl 4-253 HANDLER_REJECT internal static fixed bin(17,0) initial dcl 4-253 HANDLER_STOP internal static fixed bin(17,0) initial dcl 4-253 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 5-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 5-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 5-15 M_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 PATH_ALLOW_ALL_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_ARCHIVE_COMPONENTS internal static bit(36) initial dcl 4-133 PATH_ALLOW_ARCHIVE_COMP_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_ARCHIVE_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_BRANCH_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_DIR_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_ENTRY_STAR_NAMES internal static bit(36) initial dcl 4-133 PATH_ALLOW_NONDIR_STAR_NAMES internal static bit(36) initial dcl 4-133 REW_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RW_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 R_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SA_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SEG_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 3-67 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SORT_BY_EXTENDED_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 4-388 SORT_BY_NAME internal static fixed bin(17,0) initial dcl 4-388 SORT_BY_STANDARD_ENTRY_TYPE internal static fixed bin(17,0) initial dcl 4-388 SORT_ENTRIES_BEFORE_SUBENTRIES internal static fixed bin(17,0) initial dcl 4-388 SORT_FORWARD internal static fixed bin(17,0) initial dcl 4-388 SORT_REVERSE internal static fixed bin(17,0) initial dcl 4-388 STANDARD_ENTRY_TYPES internal static char(32) initial array packed unaligned dcl 4-530 STAR_DATA_VERSION_1 internal static char(8) initial packed unaligned dcl 4-425 STAR_EXCLUDE_NAMES_VERSION_1 internal static char(8) initial packed unaligned dcl 4-236 STAR_EXTENDED_ENTRY_VERSION_1 internal static char(8) initial packed unaligned dcl 4-195 STAR_MATCH_NAMES_VERSION_1 internal static char(8) initial packed unaligned dcl 4-216 S_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 Sequential_input internal static fixed bin(17,0) initial dcl 5-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 5-15 Sequential_output internal static fixed bin(17,0) initial dcl 5-15 Sequential_update internal static fixed bin(17,0) initial dcl 5-15 Stream_input internal static fixed bin(17,0) initial dcl 5-15 Stream_input_output internal static fixed bin(17,0) initial dcl 5-15 W_ACCESS internal static bit(3) initial packed unaligned dcl 2-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 acl_count automatic fixed bin(17,0) dcl 3-5 delete_acl based structure level 1 dcl 3-58 delete_acl_array based structure array level 1 dcl 3-64 directory_acl based structure level 1 dcl 3-49 directory_acl_array based structure array level 1 dcl 3-55 exclude_names based structure level 1 dcl 4-236 exclude_names_size automatic fixed bin(17,0) dcl 4-236 extended_entry_types based structure level 1 dcl 4-195 extended_entry_types_size automatic fixed bin(17,0) dcl 4-195 general_delete_acl based structure level 1 dcl 3-30 general_extended_acl based structure level 1 dcl 3-18 iox_modes internal static char(24) initial array dcl 5-6 match_names based structure level 1 dcl 4-216 match_names_size automatic fixed bin(17,0) dcl 4-216 segment_acl based structure level 1 dcl 3-40 segment_acl_array based structure array level 1 dcl 3-46 short_iox_modes internal static char(4) initial array dcl 5-12 star_paths_size automatic fixed bin(17,0) dcl 4-116 NAMES DECLARED BY EXPLICIT CONTEXT. BAIL_OUT 001702 constant label dcl 106 ref 65 76 87 103 374 408 CLEANUP 004362 constant entry internal dcl 436 ref 31 48 106 COMMON 001604 constant label dcl 94 ref 38 RETURN 001706 constant label dcl 109 ref 395 analyze_fs_error 003174 constant entry internal dcl 291 ref 425 check_fs_entry 001710 constant entry internal dcl 116 ref 424 check_object_acl 000704 constant entry external dcl 23 check_subtree_acl 001010 constant entry external dcl 40 imft_util_ 000672 constant entry external dcl 18 init_check_acl 004117 constant entry internal dcl 387 ref 33 50 process_error 003767 constant entry internal dcl 355 ref 229 255 275 310 349 set_error_message 003406 constant entry internal dcl 317 ref 174 195 209 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 5052 5230 4443 5062 Length 5600 4443 156 334 406 62 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME imft_util_ 596 external procedure is an external procedure. on unit on line 31 64 on unit on unit on line 48 64 on unit check_fs_entry 708 internal procedure is assigned to an entry variable. set_error_message internal procedure shares stack frame of internal procedure check_fs_entry. process_error internal procedure shares stack frame of internal procedure check_fs_entry. init_check_acl internal procedure shares stack frame of external procedure imft_util_. CLEANUP 74 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 accessfile_dname imft_util_ 000062 accessfile_ename imft_util_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME check_fs_entry 000100 access_error check_fs_entry 000101 code check_fs_entry 000102 local_dirname check_fs_entry 000154 local_ename check_fs_entry 000164 local_pathname check_fs_entry 000236 my_access_ok check_fs_entry 000237 user_access_ok check_fs_entry 000240 local_path check_fs_entry 000332 buffer process_error 000532 iox_code process_error imft_util_ 000100 ME imft_util_ 000110 access_str imft_util_ 000111 acl_idx imft_util_ 000112 attach_desc imft_util_ 000136 afs_ptr imft_util_ 000140 bad_access_name imft_util_ 000150 checking_subtree imft_util_ 000160 code imft_util_ 000162 dir_ring_brackets imft_util_ 000164 ignore_code imft_util_ 000166 local_obj_access_class imft_util_ 000170 longinfo imft_util_ 000221 max_access_class_text imft_util_ 000321 message_len imft_util_ 000322 min_access_class_text imft_util_ 000422 object_access_class_text imft_util_ 000522 object_type imft_util_ 000532 seg_ring_brackets imft_util_ 000536 shortinfo imft_util_ 000540 test_access imft_util_ 000541 user_authorization_text imft_util_ 000642 imft_check_acl_ptr imft_util_ 000644 acl_ptr imft_util_ 000646 star_optionsP imft_util_ 000650 star_dataP imft_util_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as alloc_char_temp call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry int_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. aim_check_$greater_or_equal convert_authorization_$to_string_short convert_status_code_ expand_pathname_ fs_star_$init fs_star_$select fs_star_$term fs_util_$list_acl hcs_$get_access_class hcs_$get_dir_ring_brackets hcs_$get_ring_brackets hcs_$set_bc hcs_$truncate_file ioa_$rsnnl iox_$attach_ptr iox_$close iox_$detach_iocb iox_$find_iocb iox_$open iox_$put_chars pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$ai_restricted error_table_$lower_ring error_table_$moderr error_table_$unimplemented_version error_table_$user_not_found LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000671 21 000677 23 000700 26 000711 27 000714 29 000715 30 000717 31 000720 33 000742 35 000743 36 001000 37 001003 38 001005 40 001006 43 001015 44 001020 46 001022 47 001024 48 001025 50 001047 54 001050 55 001101 56 001127 57 001155 58 001206 59 001235 61 001237 62 001252 64 001305 65 001310 68 001311 69 001337 71 001341 72 001354 75 001413 76 001416 79 001417 80 001436 82 001440 83 001453 86 001512 87 001515 90 001516 91 001576 92 001601 94 001604 96 001617 98 001621 99 001624 100 001637 102 001676 103 001701 106 001702 109 001706 116 001707 133 001733 134 001737 135 001744 136 001760 137 001777 139 002001 141 002015 146 002025 148 002042 149 002067 151 002071 154 002100 157 002107 160 002110 161 002135 163 002137 166 002146 171 002155 173 002157 174 002167 175 002170 180 002171 182 002177 183 002204 184 002206 186 002207 187 002214 190 002216 192 002254 194 002256 195 002261 196 002262 199 002263 200 002264 201 002276 202 002277 205 002306 208 002317 209 002322 211 002325 213 002330 218 002332 221 002336 222 002363 224 002365 225 002401 229 002450 232 002451 233 002471 236 002512 238 002513 239 002522 241 002543 243 002566 245 002611 246 002615 247 002626 248 002640 255 002756 260 002757 261 002777 263 003000 264 003004 265 003015 266 003027 267 003033 269 003055 275 003163 278 003164 282 003166 283 003172 291 003173 299 003224 300 003226 301 003231 303 003245 305 003272 307 003317 310 003404 311 003405 317 003406 320 003407 321 003423 323 003434 325 003445 327 003450 332 003536 338 003626 343 003701 349 003765 351 003766 355 003767 361 003770 362 003772 364 003774 366 004000 367 004010 368 004027 370 004031 373 004071 374 004075 378 004100 381 004112 383 004116 387 004117 389 004120 391 004124 394 004130 395 004133 398 004134 400 004136 401 004174 403 004176 404 004201 405 004214 407 004251 408 004254 411 004255 412 004262 413 004264 414 004265 415 004266 416 004267 417 004271 418 004273 419 004275 420 004277 421 004301 422 004303 423 004305 424 004324 425 004327 426 004332 427 004334 428 004337 429 004341 430 004343 431 004344 432 004356 434 004360 436 004361 439 004367 441 004374 442 004402 445 004405 447 004411 448 004422 449 004434 452 004437 ----------------------------------------------------------- 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